]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Change many things, mostly docs, for the switch from kdoc1 to kdoc2.
authorwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Thu, 22 Jun 2000 14:53:22 +0000 (14:53 +0000)
committerwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Thu, 22 Jun 2000 14:53:22 +0000 (14:53 +0000)
git-svn-id: https://svn.dealii.org/trunk@3064 0785d39b-7218-0410-832d-ea1e28bc413d

122 files changed:
deal.II/base/include/base/convergence_table.h
deal.II/base/include/base/data_out_base.h
deal.II/base/include/base/exceptions.h
deal.II/base/include/base/function.h
deal.II/base/include/base/function_time.h
deal.II/base/include/base/job_identifier.h
deal.II/base/include/base/logstream.h
deal.II/base/include/base/multithread_info.h
deal.II/base/include/base/parameter_handler.h
deal.II/base/include/base/point.h
deal.II/base/include/base/quadrature.h
deal.II/base/include/base/smartpointer.h
deal.II/base/include/base/subscriptor.h
deal.II/base/include/base/table_handler.h
deal.II/base/include/base/tensor.h
deal.II/base/include/base/tensor_base.h
deal.II/base/include/base/tensor_function.h
deal.II/base/include/base/thread_management.h
deal.II/base/include/base/timer.h
deal.II/base/source/data_out_base.cc
deal.II/base/source/parameter_handler.cc
deal.II/base/source/thread_management.cc
deal.II/deal.II/include/dofs/dof_accessor.h
deal.II/deal.II/include/dofs/dof_constraints.h
deal.II/deal.II/include/dofs/dof_constraints.templates.h
deal.II/deal.II/include/dofs/dof_handler.h
deal.II/deal.II/include/dofs/dof_levels.h
deal.II/deal.II/include/dofs/dof_tools.h
deal.II/deal.II/include/fe/fe.h
deal.II/deal.II/include/fe/fe_lib.criss_cross.h
deal.II/deal.II/include/fe/fe_lib.dg.h
deal.II/deal.II/include/fe/fe_lib.dgp.h
deal.II/deal.II/include/fe/fe_lib.lagrange.h
deal.II/deal.II/include/fe/fe_system.h
deal.II/deal.II/include/fe/fe_tools.h
deal.II/deal.II/include/fe/fe_update_flags.h
deal.II/deal.II/include/fe/fe_values.h
deal.II/deal.II/include/fe/q1_mapping.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/intergrid_map.h
deal.II/deal.II/include/grid/persistent_tria.h
deal.II/deal.II/include/grid/tria.h
deal.II/deal.II/include/grid/tria_accessor.h
deal.II/deal.II/include/grid/tria_accessor.templates.h
deal.II/deal.II/include/grid/tria_boundary.h
deal.II/deal.II/include/grid/tria_boundary_lib.h
deal.II/deal.II/include/grid/tria_hex.h
deal.II/deal.II/include/grid/tria_iterator.h
deal.II/deal.II/include/grid/tria_levels.h
deal.II/deal.II/include/grid/tria_line.h
deal.II/deal.II/include/grid/tria_quad.h
deal.II/deal.II/include/multigrid/mg_base.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/multigrid.h
deal.II/deal.II/include/numerics/assembler.h
deal.II/deal.II/include/numerics/base.h
deal.II/deal.II/include/numerics/data_io.h
deal.II/deal.II/include/numerics/data_out.h
deal.II/deal.II/include/numerics/data_out_stack.h
deal.II/deal.II/include/numerics/derivative_approximation.h
deal.II/deal.II/include/numerics/dof_print_solver_step.h
deal.II/deal.II/include/numerics/dof_renumbering.h
deal.II/deal.II/include/numerics/error_estimator.h
deal.II/deal.II/include/numerics/gradient_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/deal.II/source/dofs/dof_constraints.cc
deal.II/deal.II/source/dofs/dof_handler.cc
deal.II/deal.II/source/dofs/dof_tools.cc
deal.II/deal.II/source/fe/fe_system.cc
deal.II/deal.II/source/fe/fe_values.cc
deal.II/deal.II/source/grid/tria.all_dimensions.cc
deal.II/deal.II/source/grid/tria.cc
deal.II/deal.II/source/numerics/assembler.cc
deal.II/deal.II/source/numerics/data_io.cc
deal.II/deal.II/source/numerics/data_out_stack.cc
deal.II/deal.II/source/numerics/error_estimator.cc
deal.II/deal.II/source/numerics/matrices.cc
deal.II/deal.II/source/numerics/solution_transfer.cc
deal.II/deal.II/source/numerics/time_dependent.cc
deal.II/deal.II/source/numerics/vectors.cc
deal.II/doc/auto/kdoc/Makefile.in
deal.II/doc/development/writing-documentation.html
deal.II/examples/step-7/step-7.cc
deal.II/lac/include/lac/block_indices.h
deal.II/lac/include/lac/block_sparse_matrix.h
deal.II/lac/include/lac/block_sparsity_pattern.h
deal.II/lac/include/lac/block_vector.h
deal.II/lac/include/lac/full_matrix.h
deal.II/lac/include/lac/precondition.h
deal.II/lac/include/lac/precondition_block.h
deal.II/lac/include/lac/precondition_block.templates.h
deal.II/lac/include/lac/precondition_selector.h
deal.II/lac/include/lac/solver.h
deal.II/lac/include/lac/solver_bicgstab.h
deal.II/lac/include/lac/solver_cg.h
deal.II/lac/include/lac/solver_control.h
deal.II/lac/include/lac/solver_gmres.h
deal.II/lac/include/lac/solver_minres.h
deal.II/lac/include/lac/solver_qmrs.h
deal.II/lac/include/lac/solver_richardson.h
deal.II/lac/include/lac/solver_selector.h
deal.II/lac/include/lac/sparse_ilu.h
deal.II/lac/include/lac/sparse_ilu.templates.h
deal.II/lac/include/lac/sparse_matrix.h
deal.II/lac/include/lac/sparse_vanka.h
deal.II/lac/include/lac/sparse_vanka.templates.h
deal.II/lac/include/lac/sparsity_pattern.h
deal.II/lac/include/lac/swappable_vector.h
deal.II/lac/include/lac/swappable_vector.templates.h
deal.II/lac/include/lac/vector.h
deal.II/lac/include/lac/vector_memory.h
deal.II/lac/source/sparsity_pattern.cc

index d4c26aea1454c45b8f43843226ec16ccf7ef8736..6682431b27dab40dbe1eb802dc8db96b08e0e3e0 100644 (file)
 
 
 /**
- * The #ConvergenceTable# class is an application to the #TableHandler# class and
+ * The @p{ConvergenceTable} class is an application to the @p{TableHandler} class and
  * stores some convergence data, such as residuals of the cg-method, or some evaluated
  * $L^2$-errors of discrete solutions, etc, and evaluates convergence rates or orders.
  *
- * The already implemented #RateMode#s are #ConvergenceTable::reduction_rate#
+ * The already implemented @p{RateMode}s are @p{ConvergenceTable::reduction_rate}
  * where the convergence rate is the quotient of two following rows, and 
- * #ConvergenceTable::reduction_rate_log2#, that evaluates the order of convergence.
+ * @p{ConvergenceTable::reduction_rate_log2}, that evaluates the order of convergence.
  * These standard evaluations are useful for global refinement, for local refinement
  * this may not be an appropriate method, as the convergence rates should be
  * set in relation to the number of cells or the number of DoFs. The
  * implementations of these non-standard methods is left to a user.
  *
- * \subsection{Usage}
+ * @sect3{Usage}
  * The number of cells and the number of DoFs may be added to the table by
- * calling e.g.  #add_value("n cells", n_cells)#. The table
- * data is also added by calling #add_value(...)#.
- * Before the output of the table the functions #evaluate_convergence_rates(...)# and
- * #evaluate_all_convergence_rates(...)# may be (also multiply) called.
+ * calling e.g.  @p{add_value("n cells", n_cells)}. The table
+ * data is also added by calling @p{add_value(...)}.
+ * Before the output of the table the functions @p{evaluate_convergence_rates(...)} and
+ * @p{evaluate_all_convergence_rates(...)} may be (also multiply) called.
  *
  * There are two possibilities of how to evaluate the convergence rates of multiple 
- * columns in the same #RateMode#.
+ * columns in the same @p{RateMode}.
  * \begin{enumerate}
- * \item call #evaluate_convergence_rates(data_column_key, ...)# for all wanted columns
- * \item call #omit_column_from_convergence_rate_evaluation(data_column_key)# for all
+ * \item call @p{evaluate_convergence_rates(data_column_key, ...)} for all wanted columns
+ * \item call @p{omit_column_from_convergence_rate_evaluation(data_column_key)} for all
  * NOT wanted columns and then 
- * #evaluate_all_convergence_rates(...)# to evaluate the convergence rates of all columns
+ * @p{evaluate_all_convergence_rates(...)} to evaluate the convergence rates of all columns
  * that are not signed to be omitted.
  * \end{enumerate}
  *
@@ -62,9 +62,9 @@ class ConvergenceTable: public TableHandler
                                      * Rate in relation to the rows (without a
                                      * reference column).
                                      * 
-                                     * #reduction_rate#: $value(row-1)/value(row)$.
+                                     * @p{reduction_rate}: $value(row-1)/value(row)$.
                                      *
-                                     * #reduction_rate_log2#: the order $O(h^r)$ of 
+                                     * @p{reduction_rate_log2}: the order $O(h^r)$ of 
                                      * the reduction rate with the assumption
                                      * row-1: h, row: h/2. Hence the order 
                                      * is evaluated by
@@ -72,9 +72,9 @@ class ConvergenceTable: public TableHandler
                                      *
                                      * Rate in relation to a reference column:
                                      *
-                                     * #reduction_rate#: Not implemented.
+                                     * @p{reduction_rate}: Not implemented.
                                      *
-                                     * #reduction_rate_log2#: Not implemented.
+                                     * @p{reduction_rate_log2}: Not implemented.
                                      */
     enum RateMode {
          none,
@@ -84,9 +84,9 @@ class ConvergenceTable: public TableHandler
     
                                     /**
                                      * Evaluates the convergence rates of the
-                                     * data column #data_column_key# 
-                                     * due to the #RateMode# in relation to
-                                     * the reference column #reference_column_key#.
+                                     * data column @p{data_column_key} 
+                                     * due to the @p{RateMode} in relation to
+                                     * the reference column @p{reference_column_key}.
                                      * Be sure that the value types of the
                                      * table entries of the
                                      * data column and the reference data column
@@ -98,8 +98,8 @@ class ConvergenceTable: public TableHandler
                                      * tex caption of the supercolumn will be
                                      * (by default) the same as the one of the
                                      * data column. This may be changed by using
-                                     * the #set_tex_supercaption (...)# function
-                                     * of the base class #TableHandler#.
+                                     * the @p{set_tex_supercaption (...)} function
+                                     * of the base class @p{TableHandler}.
                                      *
                                      * Still not implemented.
                                      */
@@ -110,8 +110,8 @@ class ConvergenceTable: public TableHandler
 
                                     /**
                                      * Evaluates the convergence rates of the
-                                     * data column #data_column_key# 
-                                     * due to the #RateMode#.
+                                     * data column @p{data_column_key} 
+                                     * due to the @p{RateMode}.
                                      * Be sure that the value types of the
                                      * table entries of the data column
                                      * is a number, i.e. double, float,
@@ -122,14 +122,14 @@ class ConvergenceTable: public TableHandler
                                      * tex caption of the supercolumn will be
                                      * (by default) the same as the one of the
                                      * data column. This may be changed by using
-                                     * the #set_tex_supercaption (...)# function
-                                     * of the base class #TableHandler#.
+                                     * the @p{set_tex_supercaption (...)} function
+                                     * of the base class @p{TableHandler}.
                                      */
     void evaluate_convergence_rates (const string &data_column_key, 
                                     const RateMode rate_mode);
 
                                     /**
-                                     * Omit this column #key# 
+                                     * Omit this column @p{key} 
                                      * (not supercolumn!) from the
                                      * evaluation of the convergence rates
                                      * of `all' columns (see the following 
@@ -143,9 +143,9 @@ class ConvergenceTable: public TableHandler
 
                                     /**
                                      * Evaluates convergence rates
-                                     * due to the #rate_mode# in relation
+                                     * due to the @p{rate_mode} in relation
                                      * to the reference column 
-                                     * #reference_column_key#. This
+                                     * @p{reference_column_key}. This
                                      * function evaluates the rates of
                                      * ALL columns except of the 
                                      * columns that are to be omitted
@@ -156,23 +156,23 @@ class ConvergenceTable: public TableHandler
                                      * This function allows to evaluate
                                      * the convergence rate for almost all
                                      * columns of a table without calling
-                                     * #evaluate_convergence_rates(data_column, ...)#
+                                     * @p{evaluate_convergence_rates(data_column, ...)}
                                      * for each column separately.
                                      *
                                      * Example: 
-                                     * Columns like #n cells# or 
-                                     * #n dofs# columns may be wanted
+                                     * Columns like @p{n cells} or 
+                                     * @p{n dofs} columns may be wanted
                                      * to be omitted in the evaluation
                                      * of the convergence rates. Hence they
                                      * should omitted by calling the
-                                     * #omit_column_from_convergence_rate_evaluation(..)#.
+                                     * @p{omit_column_from_convergence_rate_evaluation(..)}.
                                      */
     void evaluate_all_convergence_rates(const string &reference_column_key,
                                        const RateMode rate_mode);
 
                                     /**
                                      * Evaluates convergence rates
-                                     * due to the #rate_mode#. This
+                                     * due to the @p{rate_mode}. This
                                      * function evaluates the rates of
                                      * ALL columns except of the 
                                      * columns that are to be omitted
@@ -183,16 +183,16 @@ class ConvergenceTable: public TableHandler
                                      * This function allows to evaluate
                                      * the convergence rate for almost all
                                      * columns of a table without calling
-                                     * #evaluate_convergence_rates(data_column, ...)#
+                                     * @p{evaluate_convergence_rates(data_column, ...)}
                                      * for each column seperately.
                                      *
                                      * Example: 
-                                     * Columns like #n cells# or 
-                                     * #n dofs# columns may be wanted
+                                     * Columns like @p{n cells} or 
+                                     * @p{n dofs} columns may be wanted
                                      * to be omitted in the evaluation
                                      * of the convergence rates. Hence they
                                      * should omitted by calling the
-                                     * #omit_column_from_convergence_rate_evaluation(..)#.
+                                     * @p{omit_column_from_convergence_rate_evaluation(..)}.
                                      */
     void evaluate_all_convergence_rates(const RateMode rate_mode);
 
index 32f0bd62e087daaa68f7d8e98e61f9f6a1f6afe8..90908defdca1812555c20dff2ea66ff3a4e63e90 100644 (file)
@@ -36,10 +36,10 @@ class ParameterHandler;
  * be provided by derived class which have a user callable interface then.
  *
  *
- * \subsection{Interface}
+ * @sect3{Interface}
  * This class has an interface that is not usually called by a user directly;
- * also, it consists of #static# functions only. Usually, derived classes will
- * inherit this class #protected# to hide this interface to the users of thes
+ * also, it consists of @p{static} functions only. Usually, derived classes will
+ * inherit this class @p{protected} to hide this interface to the users of thes
  * classes.
  *
  * The interface of this class basically consists of the declaration of a data
@@ -49,7 +49,7 @@ class ParameterHandler;
  * In addition to the list of patches, a name for each data set may be given.
  *
  *
- * \subsection{Patches}
+ * @sect3{Patches}
  * Grids can be thought of as a collection of cells; if you want to write out
  * data on such a grid, you can do so by writing them one cell at a time.
  * The functions in this class therefore take a list of objects describing the
@@ -61,32 +61,32 @@ class ParameterHandler;
  * example, you may have higher order elements and printing the values at
  * the vertices only is not enough. For this reason, we not only provide
  * writing the data on the vertices only, but the data is organizes as a
- * tensor product grid on each cell. The parameter #n_subdivision#, which is
+ * tensor product grid on each cell. The parameter @p{n_subdivision}, which is
  * given for each patch separately, denotes how often the cell is to be
- * divided for output; for example, #n_subdivisions==1# yields no subdivision
- * of the cell, #n_subdivisions==2# will produce a grid of 3 times 3 points
+ * divided for output; for example, @p{n_subdivisions==1} yields no subdivision
+ * of the cell, @p{n_subdivisions==2} will produce a grid of 3 times 3 points
  * in two spatial dimensions and 3 times 3 times 3 points in three dimensions,
- * #n_subdivisions==2# will yield 4 times 4 (times 4) points, etc. The actual
+ * @p{n_subdivisions==2} will yield 4 times 4 (times 4) points, etc. The actual
  * location of these points on the patch will be computed by a multilinear
  * transformation from the vertices given for this patch.
  *
  * Given these comments, the actual data to be printed on this patch of
  * points consists of several data sets each of which has a value at each
- * of the patch points. For example with #n_subdivisions==2# in two space
+ * of the patch points. For example with @p{n_subdivisions==2} in two space
  * dimensions, each data set has to provide nine values, and since the
  * patch is to be printed as a tensor product (or its transformation to the
  * real space cell), its values are to be ordered like
- * #(x0,y0) (x0,y1) (x0,y2) (x1,y0) (x1,y1) (x1,y2) (x2,y0) (x2,y1) (x2,y2)#,
+ * @p{(x0,y0) (x0,y1) (x0,y2) (x1,y0) (x1,y1) (x1,y2) (x2,y0) (x2,y1) (x2,y2)},
  * i.e. the z-coordinate runs fastest, then the y-coordinate, then x (if there
  * are that many space directions).
  *
- * The #Patch# class takes a template parameter denoting the space dimension
+ * The @p{Patch} class takes a template parameter denoting the space dimension
  * in which this patch operates.
  *
  *
- * \section{Supported output formats}
+ * @sect2{Supported output formats}
  *
- * \subsection{UCD format}
+ * @sect3{UCD format}
  *
  * The UCD format is described in the AVS developer's guide. Due to
  * limitations in the present format, only node based data can be output,
@@ -101,7 +101,7 @@ class ParameterHandler;
  * patch to the same value.
  *
  *
- * \subsection{GNUPLOT format}
+ * @sect3{GNUPLOT format}
  *
  * The GNUPLOT format is not able to handle data on unstructured grids
  * directly. Directly would mean that you only give the vertices and
@@ -135,19 +135,19 @@ class ParameterHandler;
  * This command plots data in x- and y-direction unbounded, but in z-direction
  * only those data points which are above the x-y-plane (we assume here a
  * positive solution, if it has negative values, you might want to decrease the
- * lower bound). Furthermore, it only takes the data points with z-values (#$3#)
- * equal to 0.5, i.e. a cut through the domain at #z=0.5#. For the data points
- * on this plane, the data values of the first data set (#$4#) are raised in
+ * lower bound). Furthermore, it only takes the data points with z-values (@p{$3})
+ * equal to 0.5, i.e. a cut through the domain at @p{z=0.5}. For the data points
+ * on this plane, the data values of the first data set (@p{$4}) are raised in
  * z-direction above the x-y-plane; all other points are denoted the value
- * #-1# instead of the value of the data vector and are not plotted due to
+ * @p{-1} instead of the value of the data vector and are not plotted due to
  * the lower bound in z plotting direction, given in the third pair of brackets.
  *
- * Of course, more complex cuts than #$3==.5# are possible, including nonlinear
+ * Of course, more complex cuts than @p{$3==.5} are possible, including nonlinear
  * ones. Note however, that only those points which are actually on the
  * cut-surface are plotted.
  *
  *
- * \subsection{POVRAY format}
+ * @sect3{POVRAY format}
  *
  * Output in this format creates a povray source file, include standard
  * camera and light source definition for rendering with povray 3.1
@@ -158,15 +158,15 @@ class ParameterHandler;
 
  * \begin{itemize}
  *
- * \item #BICUBIC_PATCH#
- * A #bicubic_patch# is a 3-dimensional Bezier patch. It consists of 16 Points
+ * \item @p{BICUBIC_PATCH}
+ * A @p{bicubic_patch} is a 3-dimensional Bezier patch. It consists of 16 Points
  * describing the surface. The 4 corner points are touched by the object,
  * while the other 12 points pull and stretch the patch into shape.
- * One #bicubic_patch# is generated on each patch. Therefor the number of 
+ * One @p{bicubic_patch} is generated on each patch. Therefor the number of 
  * subdivisions has to be 3 to provide the patch with 16 points.
  * A bicubic patch is not exact but generates very smooth images.
  *
- * \item #MESH#
+ * \item @p{MESH}
  * The mesh object is used to store large number of triangles.
  * Every square of the patch data is split into one upper-left and one 
  * lower-right triangle. If the number of subdivisions is three, 32 triangle
@@ -179,7 +179,7 @@ class ParameterHandler;
  * All objects get one texture definition called Tex. This texture has to be
  * declared somewhere before the object data. This may be in an external 
  * data file or at the beginning of the output file.
- * Setting the #external_data# flag to false, an standard camera, light and
+ * Setting the @p{external_data} flag to false, an standard camera, light and
  * texture (scaled to fit the scene) is added to the outputfile. Set to true
  * an include file "data.inc" is included. This file is not generated by deal
  * and has to include camera, light and the texture definition Tex.
@@ -192,7 +192,7 @@ class ParameterHandler;
  * If the external file "data.inc" is used, the path to this file has to be
  * included in the povray options.
  *
- * \subsection{EPS format}
+ * @sect3{EPS format}
  *
  * Output in this format circumvents the use of auxiliary graphic programs
  * converting some output format into a graphics format. This has the advantage
@@ -227,7 +227,7 @@ class ParameterHandler;
  * five digits, to keep picture size at a reasonable size.
  *
  * All parameters along with their default values are listed in the documentation
- * of the #EpsFlags# member class of this class. See there for more and detailed
+ * of the @p{EpsFlags} member class of this class. See there for more and detailed
  * information.
  *
  * Please note that due to the various transformations each patch has to undergo
@@ -235,9 +235,9 @@ class ParameterHandler;
  * of patches.
  *
  *
- * \subsection{GMV format}
+ * @sect3{GMV format}
  *
- * The #write_gmv# function and the #write# function through the #gmv# parameter
+ * The @p{write_gmv} function and the @p{write} function through the @p{gmv} parameter
  * write the data in a format understood by the GMV (general mesh viewer)
  * program. This program is able to generate 2d and 3d plots of almost
  * arbitrarily many data sets, along with shading, cuts through data sets and
@@ -250,10 +250,10 @@ class ParameterHandler;
  * (bi-,tri-)linear elements.
  *
  *
- * \section{Output parameters}
+ * @sect2{Output parameters}
  *
- * All functions take a parameter which is a structure of type #XFlags#, where
- * #X# is the name of the output format. To find out what flags are presently
+ * All functions take a parameter which is a structure of type @p{XFlags}, where
+ * @p{X} is the name of the output format. To find out what flags are presently
  * supported, read the documentation of the different structures.
  *
  * Note that usually the output formats used for scientific visualization
@@ -274,17 +274,17 @@ class DataOutBase
   public:
                                     /**
                                      * Data structure describing a
-                                     * patch of data in #dim# space
+                                     * patch of data in @p{dim} space
                                      * dimensions. See the general
                                      * documentation of the
-                                     * #DataOutBase# class for more
+                                     * @p{DataOutBase} class for more
                                      * information on its contents
                                      * and purposes.  In the case of
                                      * two dimensions, the next
                                      * picture ist an example of
-                                     * #n_subdivision# = 4 because
+                                     * @p{n_subdivision} = 4 because
                                      * the number of cells is
-                                     * equal to #2^dim#.
+                                     * equal to @p{2^dim}.
                                      * \begin{verbatim}
                                      *  __ __ __ __
                                      * |  |  |  |  |
@@ -320,9 +320,9 @@ class DataOutBase
                                         /**
                                          * Number of subdivisions with
                                          * which this patch is to be
-                                         * written. #1# means no
-                                         * subdivision, #2# means
-                                         * bisection, #3# trisection,
+                                         * written. @p{1} means no
+                                         * subdivision, @p{2} means
+                                         * bisection, @p{3} trisection,
                                          * etc.
                                          */
        unsigned int n_subdivisions;
@@ -330,38 +330,38 @@ class DataOutBase
                                         /**
                                          * Data vectors. The format is
                                          * as follows:
-                                         * #data(i,.)# denotes the data
-                                         * belonging to the #i#th data
-                                         * vector. #data.n()#
+                                         * @p{data(i,.)} denotes the data
+                                         * belonging to the @p{i}th data
+                                         * vector. @p{data.n()}
                                          * therefore equals the number
                                          * of output points; this
-                                         * number is #(subdivisions+1)^{dim}#.
-                                         * #data.m()# equals the number of
+                                         * number is @p{(subdivisions+1)^{dim}}.
+                                         * @p{data.m()} equals the number of
                                          * data vectors.
                                          *
                                          * Within each column,
-                                         * #data(.,j)# are the data
+                                         * @p{data(.,j)} are the data
                                          * values at the output point
-                                         * #j#, where #j# runs first
+                                         * @p{j}, where @p{j} runs first
                                          * over the last direction,
                                          * then over the second last
                                          * one etc, just as if it was
                                          * organized as an array
-                                         * #double[x][y][z]#. This is
+                                         * @p{double[x][y][z]}. This is
                                          * also the order of points
                                          * as provided by the
-                                         * #QIterated# class when
-                                         * used with the #QTrapez#
+                                         * @p{QIterated} class when
+                                         * used with the @p{QTrapez}
                                          * class as subquadrature.
                                          * Note that if
-                                         * #subdivisions==1#, the
-                                         * elements of #data[i]#
+                                         * @p{subdivisions==1}, the
+                                         * elements of @p{data[i]}
                                          * correspond to vertices
-                                         * #(0,1)# in 1d, #(0, 3, 1,
-                                         * 2)# in 2d, and #(0, 4, 3,
-                                         * 7, 1, 5, 2, 6)# in 3d as
-                                         * following:
-                                         \begin{verbatim}
+                                         * @p{(0,1)} in 1d, 
+                                         * @p{(0, 3, 1,2)} in 2d, and 
+                                         * @p{(0, 4, 3, 7, 1, 5, 2, 6)}
+                                         * in 3d as following:
+                                         \begin{verbatim}
                                          *  
                                          *      7________6
                                          *      /       /|
@@ -375,8 +375,8 @@ class DataOutBase
                                          * \end{verbatim}
                                          * 
                                          * For exemple in 2d: If
-                                         * #subdivisions==2# the
-                                         * elements of #data[i]# are
+                                         * @p{subdivisions==2} the
+                                         * elements of @p{data[i]} are
                                          * given by the following
                                          * numeration:
                                          *
@@ -394,7 +394,7 @@ class DataOutBase
                                          *
                                          * Since the number of data vectors
                                          * is usually the same for all
-                                         * patches to be printed, #data.size()#
+                                         * patches to be printed, @p{data.size()}
                                          * should yield the same value for all
                                          * patches provided.
                                          */
@@ -402,7 +402,7 @@ class DataOutBase
        
                                         /**
                                          * Default constructor. Sets
-                                         * #n_subdivisions# to one.
+                                         * @p{n_subdivisions} to one.
                                          */
        Patch () :
                        n_subdivisions(1) {};
@@ -425,7 +425,7 @@ class DataOutBase
                                          * by this, so you can switch it off
                                          * this way.
                                          *
-                                         * Default: #true#.
+                                         * Default: @p{true}.
                                          */
        bool write_preamble;
        
@@ -443,7 +443,7 @@ class DataOutBase
 
                                         /**
                                          * Read the parameters declared in
-                                         * #declare_parameters# and set the
+                                         * @p{declare_parameters} and set the
                                          * flags for this output format
                                          * accordingly.
                                          *
@@ -467,7 +467,7 @@ class DataOutBase
                                          * structure. Remove this member
                                          * when adding the first flag to
                                          * this structure (and remove the
-                                         * #private# as well).
+                                         * @p{private} as well).
                                          */
        int dummy;
 
@@ -481,7 +481,7 @@ class DataOutBase
 
                                         /**
                                          * Read the parameters declared in
-                                         * #declare_parameters# and set the
+                                         * @p{declare_parameters} and set the
                                          * flags for this output format
                                          * accordingly.
                                          *
@@ -542,7 +542,7 @@ class DataOutBase
 
                                         /**
                                          * Read the parameters declared in
-                                         * #declare_parameters# and set the
+                                         * @p{declare_parameters} and set the
                                          * flags for this output format
                                          * accordingly.
                                          *
@@ -566,7 +566,7 @@ class DataOutBase
                                          * for generating the height
                                          * information. By default, the
                                          * first data vector is taken,
-                                         * i.e. #height_vector==0#, if
+                                         * i.e. @p{height_vector==0}, if
                                          * there is any data vector. If there
                                          * is no data vector, no height
                                          * information is generated.
@@ -577,14 +577,14 @@ class DataOutBase
                                          * Number of the vector which is
                                          * to be taken to colorize cells.
                                          * The same applies as for
-                                         * #height_vector#.
+                                         * @p{height_vector}.
                                          */
        unsigned int color_vector;
        
                                         /**
                                          * Enum denoting the possibilities
                                          * whether the scaling should be done
-                                         * such that the given #size# equals
+                                         * such that the given @p{size} equals
                                          * the width or the height of
                                          * the resulting picture.
                                          */
@@ -593,7 +593,7 @@ class DataOutBase
        };
 
                                         /**
-                                         * See above. Default is #width#.
+                                         * See above. Default is @p{width}.
                                          */
        SizeType size_type;
        
@@ -604,7 +604,7 @@ class DataOutBase
                                          * strange unit 1/72 inch. Whether
                                          * this is height or width is
                                          * specified by the flag
-                                         * #size_type#.
+                                         * @p{size_type}.
                                          *
                                          * Default is 300, which represents
                                          * a size of roughly 10 cm.
@@ -672,7 +672,7 @@ class DataOutBase
                                          * mountainous area" in the opposite
                                          * case.
                                          *
-                                         * Default is #1.0#.
+                                         * Default is @p{1.0}.
                                          */
        double z_scaling;
 
@@ -682,7 +682,7 @@ class DataOutBase
                                          * parts of each patch) are to be
                                          * plotted.
                                          *
-                                         * Default: #true#.
+                                         * Default: @p{true}.
                                          */
        bool   draw_mesh;
 
@@ -697,31 +697,31 @@ class DataOutBase
                                          * the background by cells in the
                                          * foreground.
                                          *
-                                         * If this flag is #false# and #draw_mesh#
-                                         * is #false# as well, nothing will be
+                                         * If this flag is @p{false} and @p{draw_mesh}
+                                         * is @p{false} as well, nothing will be
                                          * printed.
                                          *
-                                         * If this flag is #true#, then the cells
+                                         * If this flag is @p{true}, then the cells
                                          * will be drawn either colored by one
-                                         * of the data sets (if #shade_cells# is
-                                         * #true#), or pure white (if
-                                         * #shade_cells# is false or if there are
+                                         * of the data sets (if @p{shade_cells} is
+                                         * @p{true}), or pure white (if
+                                         * @p{shade_cells} is false or if there are
                                          * no data sets).
                                          *
-                                         * Default is #true#.
+                                         * Default is @p{true}.
                                          */
        bool   draw_cells;
 
                                         /**
                                          * Flag to determine whether the cells
                                          * shall be colorized by one the data
-                                         * set denoted by #color_vector#, or
+                                         * set denoted by @p{color_vector}, or
                                          * simply be painted in white. This
                                          * flag only makes sense if
-                                         * #draw_cells==true#. Colorization is
-                                         * done through the #color_function#.
+                                         * @p{draw_cells==true}. Colorization is
+                                         * done through the @p{color_function}.
                                          *
-                                         * Default is #true#.
+                                         * Default is @p{true}.
                                          */
        bool   shade_cells;
 
@@ -755,7 +755,7 @@ class DataOutBase
                                          * This is a pointer to the function
                                          * which is used to colorize the cells.
                                          * By default, it points to the
-                                         * static function #default_color_function#
+                                         * static function @p{default_color_function}
                                          * which is a member of this class.
                                          */
        ColorFunction color_function;
@@ -783,7 +783,7 @@ class DataOutBase
                                          * between black (lowest values)
                                          * and white (highest values). You
                                          * may use it by setting the
-                                         * #color_function# variable to the
+                                         * @p{color_function} variable to the
                                          * address of this function.
                                          */
        static RgbValues grey_scale_color_function (const double value,
@@ -819,7 +819,7 @@ class DataOutBase
 
                                         /**
                                          * Read the parameters declared in
-                                         * #declare_parameters# and set the
+                                         * @p{declare_parameters} and set the
                                          * flags for this output format
                                          * accordingly.
                                          *
@@ -843,7 +843,7 @@ class DataOutBase
                                          * structure. Remove this member
                                          * when adding the first flag to
                                          * this structure (and remove the
-                                         * #private# as well).
+                                         * @p{private} as well).
                                          */
        int dummy;
 
@@ -857,7 +857,7 @@ class DataOutBase
 
                                         /**
                                          * Read the parameters declared in
-                                         * #declare_parameters# and set the
+                                         * @p{declare_parameters} and set the
                                          * flags for this output format
                                          * accordingly.
                                          *
@@ -994,7 +994,7 @@ class DataOutBase
                                          * Data value from which the actual
                                          * colors will be computed by
                                          * the colorization function stated
-                                         * in the #EpsFlags# class.
+                                         * in the @p{EpsFlags} class.
                                          */
        float color_value;
        
@@ -1017,14 +1017,14 @@ class DataOutBase
 
 
 /**
- * This class is the interface to the #DataOutBase# class, as already its name
+ * This class is the interface to the @p{DataOutBase} class, as already its name
  * might suggest. It does not offer much functionality apart from a way to
  * access the implemented formats and a way to dynamically dispatch what output
  * format to chose.
  *
  * This class is thought as a base class to classes actually
  * generating data for output. It has two abstract virtual functions,
- * #get_patches# and #get_dataset_names# which are to produce the data
+ * @p{get_patches} and @p{get_dataset_names} which are to produce the data
  * which is actually needed. These are the only functions that need to
  * be overloaded by a derived class.  In additional to that, it has a
  * function for each output format supported by the underlying base
@@ -1038,41 +1038,41 @@ class DataOutBase
  * the abstract interface to derived classes briefly discussed above.
  *
  *
- * \subsection{Output flags}
+ * @sect3{Output flags}
  *
  * The way we treat flags in this class is very similar to that used in
- * the #GridOut# class. For detailed information on the why's and how's,
+ * the @p{GridOut} class. For detailed information on the why's and how's,
  * as well as an example of programming, we refer to the documentation
  * of that class.
  *
  * In basics, this class stores a set of flags for each output format
- * supported by the underlying #DataOutBase# class. These are used
- * whenever one of the #write_*# functions is used. By default, the
+ * supported by the underlying @p{DataOutBase} class. These are used
+ * whenever one of the @p{write_*} functions is used. By default, the
  * values of these flags are set to reasonable start-ups, but in case
  * you want to change them, you can create a structure holding the flags
- * for one of the output formats and set it using the #set_flags# functions
+ * for one of the output formats and set it using the @p{set_flags} functions
  * of this class to determine all future output the object might produce
  * by that output format.
  *
  * For information on what parameters are supported by different output
- * functions, please see the documentation of the #DataOutBase# class and
+ * functions, please see the documentation of the @p{DataOutBase} class and
  * its member classes.
  *
  *
- * \section{Run time selection of output parameters}
+ * @sect2{Run time selection of output parameters}
  *
  * In the output flags classes, described above, many flags are
  * defined for output in the different formats. In order to make them
- * available to the input file handler class #ParameterHandler#, each
+ * available to the input file handler class @p{ParameterHandler}, each
  * of these has a function declaring these flags to the parameter
  * handler and to read them back from an actual input file. In order
  * to avoid that in user programs these functions have to be called
  * for each available output format and the respective flag class, the
- * present #DataOut_Interface# class offers a function
- * #declare_parameters# which calls the respective function of all
+ * present @p{DataOut_Interface} class offers a function
+ * @p{declare_parameters} which calls the respective function of all
  * known output format flags classes. The flags of each such format
  * are packed together in a subsection in the input file.
- * Likewise, there is a function #parse_parameters# which reads
+ * Likewise, there is a function @p{parse_parameters} which reads
  * these parameters and stores them in the flags associated with
  * this object (see above).
  * 
@@ -1097,23 +1097,23 @@ class DataOutBase
  *   prm.leave_subsection ();
  *   ...
  * \end{verbatim}
- * Note that in the present example, the class #DataOut# was used. However, any
- * other class derived from #DataOut_Interface# would work alike.
+ * Note that in the present example, the class @p{DataOut} was used. However, any
+ * other class derived from @p{DataOut_Interface} would work alike.
  *
  *
- * \subsection{Run time selection of formats}
+ * @sect3{Run time selection of formats}
  *
- * This class, much like the #GridOut# class, has a set of functions
- * providing a list of supported output formats, an #enum# denoting
+ * This class, much like the @p{GridOut} class, has a set of functions
+ * providing a list of supported output formats, an @p{enum} denoting
  * all these and a function to parse a string and return the respective
- * #enum# value if it is a valid output format's name. Finally, there
- * is a function #write#, which takes a value of this #enum# and
- * dispatches to one of the actual #write_*# functions depending on
+ * @p{enum} value if it is a valid output format's name. Finally, there
+ * is a function @p{write}, which takes a value of this @p{enum} and
+ * dispatches to one of the actual @p{write_*} functions depending on
  * the output format selected by this value. 
  *
  * The functions offering the different output format names are,
- * respectively, #default_suffix#, #parse_output_format#, and
- * #get_output_format_names#. They make the selection of ouput formats
+ * respectively, @p{default_suffix}, @p{parse_output_format}, and
+ * @p{get_output_format_names}. They make the selection of ouput formats
  * in parameter files much easier, and especially independent of
  * the formats presently implemented. User programs need therefore not
  * be changed whenever a new format is implemented.
@@ -1121,9 +1121,9 @@ class DataOutBase
  * Additionally, objects of this class have a default format, which
  * can be set by the parameter "Output format" of the parameter
  * file. Within a program, this can be changed by the member function
- * #set_default_format#. Using this default format, it is possible to leave
+ * @p{set_default_format}. Using this default format, it is possible to leave
  * the format selection completely to the parameter file. A suitable
- * suffix for the output file name can be obtained by #default_suffix#
+ * suffix for the output file name can be obtained by @p{default_suffix}
  * without arguments.
  *
  * @author Wolfgang Bangerth, 1999
@@ -1139,55 +1139,55 @@ class DataOutInterface : private DataOutBase
     enum OutputFormat { default_format, ucd, gnuplot, povray, eps, gmv };
 
                                     /**
-                                     * Obtain data through the #get_patches#
-                                     * function and write it to #out# in
+                                     * Obtain data through the @p{get_patches}
+                                     * function and write it to @p{out} in
                                      * UCD format.
                                      */
     void write_ucd (ostream &out) const;
 
                                     /**
-                                     * Obtain data through the #get_patches#
-                                     * function and write it to #out# in
+                                     * Obtain data through the @p{get_patches}
+                                     * function and write it to @p{out} in
                                      * GNUPLOT format.
                                      */
     void write_gnuplot (ostream &out) const;
 
                                     /**
-                                     * Obtain data through the #get_patches#
-                                     * function and write it to #out# in
+                                     * Obtain data through the @p{get_patches}
+                                     * function and write it to @p{out} in
                                      * POVRAY format.
                                      */
     void write_povray (ostream &out) const;
 
                                     /**
-                                     * Obtain data through the #get_patches#
-                                     * function and write it to #out# in
+                                     * Obtain data through the @p{get_patches}
+                                     * function and write it to @p{out} in
                                      * EPS format.
                                      */
     void write_eps (ostream &out) const;
 
                                     /**
-                                     * Obtain data through the #get_patches#
-                                     * function and write it to #out# in
+                                     * Obtain data through the @p{get_patches}
+                                     * function and write it to @p{out} in
                                      * GMV format.
                                      */
     void write_gmv (ostream &out) const;
 
                                     /**
-                                     * Write data and grid to #out# according
+                                     * Write data and grid to @p{out} according
                                      * to the given data format. This function
                                      * simply calls the appropriate
-                                     * #write_*# function. If no output format is
-                                     * requested, the #default_format# is written.
+                                     * @p{write_*} function. If no output format is
+                                     * requested, the @p{default_format} is written.
                                      *
                                      * An error occurs if no format is provided and
-                                     * the default format is #default_format#.
+                                     * the default format is @p{default_format}.
                                      */
     void write (ostream &out, const OutputFormat output_format = default_format) const;
 
                                     /**
                                      * Set the default format. The value set here
-                                     * is used anytime, output for format #default_format# is
+                                     * is used anytime, output for format @p{default_format} is
                                      * requested.
                                      */
     void set_default_format(const OutputFormat default_format);
@@ -1229,22 +1229,22 @@ class DataOutInterface : private DataOutBase
                                      * usually has. At present the following
                                      * formats are defined:
                                      * \begin{itemize}
-                                     * \item #ucd#: #.inp#
-                                     * \item #gnuplot#: #.gnuplot#
-                                     * \item #povray#: #.pov#
-                                     * \item #eps#: #.eps#
-                                     * \item #gmv#: #.gmv#.
+                                     * \item @p{ucd}: @p{.inp}
+                                     * \item @p{gnuplot}: @p{.gnuplot}
+                                     * \item @p{povray}: @p{.pov}
+                                     * \item @p{eps}: @p{.eps}
+                                     * \item @p{gmv}: @p{.gmv}.
                                      * \end{itemize}
                                      *
                                      * If this function is called
-                                     * with no argument or #default_format#, the
+                                     * with no argument or @p{default_format}, the
                                      * suffix for the
-                                     * #default_format# is returned.
+                                     * @p{default_format} is returned.
                                      */
     string default_suffix (const OutputFormat output_format = default_format) const;
 
                                     /**
-                                     * Return the #OutputFormat# value
+                                     * Return the @p{OutputFormat} value
                                      * corresponding to the given string. If
                                      * the string does not match any known
                                      * format, an exception is thrown.
@@ -1260,16 +1260,16 @@ class DataOutInterface : private DataOutBase
                                      *
                                      * To get a list of presently available
                                      * format names, e.g. to give it to the
-                                     * #ParameterHandler# class, use the
-                                     * function #get_output_format_names ()#.
+                                     * @p{ParameterHandler} class, use the
+                                     * function @p{get_output_format_names ()}.
                                      */
     static OutputFormat parse_output_format (const string &format_name);
 
                                     /**
                                      * Return a list of implemented output
                                      * formats. The different names are
-                                     * separated by vertical bar signs (#`|'#)
-                                     * as used by the #ParameterHandler#
+                                     * separated by vertical bar signs (@p{`|'})
+                                     * as used by the @p{ParameterHandler}
                                      * classes.
                                      */
     static string get_output_format_names ();
@@ -1279,7 +1279,7 @@ class DataOutInterface : private DataOutBase
                                      * formats by declaring subsections
                                      * within the parameter file for each
                                      * output format and call the
-                                     * respective #declare_parameters#
+                                     * respective @p{declare_parameters}
                                      * functions of the flag classes for
                                      * each output format.
                                      *
@@ -1301,14 +1301,14 @@ class DataOutInterface : private DataOutBase
 
                                     /**
                                      * Read the parameters declared in
-                                     * #declare_parameters# and set the
+                                     * @p{declare_parameters} and set the
                                      * flags for the output formats
                                      * accordingly.
                                      *
                                      * The flags thus obtained overwrite
                                      * all previous contents of the flag
                                      * objects as default-constructed or
-                                     * set by the #set_flags# function.
+                                     * set by the @p{set_flags} function.
                                      */
     void parse_parameters (ParameterHandler &prm);
     
@@ -1322,8 +1322,8 @@ class DataOutInterface : private DataOutBase
                                      * This is the abstract function through
                                      * which derived classes propagate
                                      * preprocessed data in the form of
-                                     * #Patch# structures (declared in
-                                     * the base class #DataOutBase#) to
+                                     * @p{Patch} structures (declared in
+                                     * the base class @p{DataOutBase}) to
                                      * the actual output function. You
                                      * need to overload this function to
                                      * allow the output functions to
@@ -1343,7 +1343,7 @@ class DataOutInterface : private DataOutBase
                                     /**
                                      * Standard output format.
                                      * Use this format, if output format default_format is
-                                     * requested. It can be changed by the #set_format#
+                                     * requested. It can be changed by the @p{set_format}
                                      * function or in a parameter file.
                                      */
     OutputFormat default_fmt;
@@ -1351,28 +1351,28 @@ class DataOutInterface : private DataOutBase
                                     /**
                                      * Flags to be used upon output of UCD
                                      * data. Can be changed by using the
-                                     * #set_flags# function.
+                                     * @p{set_flags} function.
                                      */
     UcdFlags     ucd_flags;
 
                                     /**
                                      * Flags to be used upon output of GNUPLOT
                                      * data. Can be changed by using the
-                                     * #set_flags# function.
+                                     * @p{set_flags} function.
                                      */
     GnuplotFlags gnuplot_flags;
 
                                     /**
                                      * Flags to be used upon output of POVRAY
                                      * data. Can be changed by using the
-                                     * #set_flags# function.
+                                     * @p{set_flags} function.
                                      */
     PovrayFlags povray_flags;
 
                                     /**
                                      * Flags to be used upon output of EPS
                                      * data in one space dimension. Can be
-                                     * changed by using the #set_flags#
+                                     * changed by using the @p{set_flags}
                                      * function.
                                      */
     EpsFlags     eps_flags;    
@@ -1380,7 +1380,7 @@ class DataOutInterface : private DataOutBase
                                     /**
                                      * Flags to be used upon output of gmv
                                      * data in one space dimension. Can be
-                                     * changed by using the #set_flags#
+                                     * changed by using the @p{set_flags}
                                      * function.
                                      */
     GmvFlags     gmv_flags;    
index 276fd3fa65c8f21e1b7ab26139b456da27cfcd0c..86518c706433a6eec10a986e6810c5125a855600 100644 (file)
  *  and variables directly since the interface
  *  and mechanism may be subject to change. Rather
  *  create new exception classes using the
- *  #DeclException# macro family.
+ *  @p{DeclException} macro family.
  *
  *
- *  \section{General overview of the exception handling mechanism in #deal.II#}
+ *  @sect2{General overview of the exception handling mechanism in @p{deal.II}}
  *
- *  The error handling mechanism in #deal.II# is generally used in two ways.
+ *  The error handling mechanism in @p{deal.II} is generally used in two ways.
  *  The first uses error checking in debug mode only and is useful for programs
  *  which are not fully tested. When the program shows no error anymore, one may
  *  switch off error handling and get better performance by this, since checks
@@ -49,7 +49,7 @@
  *  I/O errors, failing memory requests and the like. It does not make much
  *  sense to turn this mode off, since this kind of errors may happen in tested
  *  and untested programs likewise. Exceptions of this kind do not terminate the
- *  program, rather they throw exceptions in the #C++# manner, allowing the
+ *  program, rather they throw exceptions in the @p{C++} manner, allowing the
  *  program to catch them and eventually do something about it. As it may be
  *  useful to have some information printed out if an exception could not be
  *  handled properly, additional information is passed along as for the first
  *  this.
  *
  *  Both modes use exception classes, which need to have special features
- *  additionally to the #C++# standard's #exception# class. Such a class
+ *  additionally to the @p{C++} standard's @p{exception} class. Such a class
  *  is declared by the following lines of code:
  *   \begin{verbatim}
  *     DeclException2 (ExcDomain, int, int,
  *                     << "Index= " << arg1 << "Upper Bound= " << arg2);
  *  \end{verbatim}
- *  This declares an exception class named #ExcDomain#, which
+ *  This declares an exception class named @p{ExcDomain}, which
  *  has two variables as additional information (named
- *  #arg1# and #arg2# by default) and which outputs the
- *  given sequence (which is appended to an #ostream#
+ *  @p{arg1} and @p{arg2} by default) and which outputs the
+ *  given sequence (which is appended to an @p{ostream}
  *  variable's name, thus the weird syntax). There are
- *  other #DeclExceptionN# macros for exception classes
+ *  other @p{DeclExceptionN} macros for exception classes
  *  with more or no parameters. It is proposed to let start
- *  the name of all exceptions by #Exc...# and to declare them locally to
+ *  the name of all exceptions by @p{Exc...} and to declare them locally to
  *  the class it is to be used in. Declaring exceptions globally is possible
  *  but pollutes the global namespace, is less readable and thus unnecessary.
  *
  *  Since exception classes are declared the same way for both modes of error
  *  checking, it is possible to use an exception declared through the
- *  #DeclExceptionN(...)# macro family in both modes; there is no need to
+ *  @p{DeclExceptionN(...)} macro family in both modes; there is no need to
  *  declare different classes for each of these.
  *
  *
- *  \section{Use of the debug mode exceptions}
+ *  @sect2{Use of the debug mode exceptions}
  *
  *  To use the exception mechanism for debug mode error checking, write lines
  *  like the following in your source code:
  *    #endif
  *  \end{verbatim}
  *  i.e. it issues an error only if the preprocessor variable
- *  #DEBUG# is set and if the given condition (in this case
- *  #n<dim# is violated.
+ *  @p{DEBUG} is set and if the given condition (in this case
+ *  @p{n<dim} is violated.
  *
- *  If the exception was declared using the #DeclException0 (...)#
+ *  If the exception was declared using the @p{DeclException0 (...)}
  *  macro, i.e. without any additional parameters, its name has
  *  nonetheless to be given with parentheses:
- *  #Assert (i>m, ExcSomewhat());#
+ *  @p{Assert (i>m, ExcSomewhat());}
  *
- *  \subsection{How it works internally}
- *  If the #DEBUG# preprocessor directive is set, the call #Assert (cond, exc);#
+ *  @sect3{How it works internally}
+ *  If the @p{DEBUG} preprocessor directive is set, the call @p{Assert (cond, exc);}
  *  is converted by the preprocessor into the sequence
  *  \begin{verbatim}
  *    if (!(cond))
  *  line in which the exception occured as well as
  *  the condition itself and the call sequence of the
  *  exception object is transferred. Additionally an object
- *  of the form given by #exc# is created (this is normally an
- *  unnamed object like in #ExcDomain (n, dim)# of class
- *  #ExcDomain#) and transferred to the #__IssueError_Assert#
+ *  of the form given by @p{exc} is created (this is normally an
+ *  unnamed object like in @p{ExcDomain (n, dim)} of class
+ *  @p{ExcDomain}) and transferred to the @p{__IssueError_Assert}
  *  function.
  *
- *  #__PRETTY__FUNCTION__# is a macro defined only by the GNU CC
+ *  @p{__PRETTY__FUNCTION__} is a macro defined only by the GNU CC
  *  compiler and gives the name of the function. If another compiler
- *  is used, we set #__PRETTY_FUNCTION__ = "(unknown)"#.
- *
- *  In #__IssueError# the given data
- *  is transferred into the #exc# object by calling the
- *  #SetFields# function; after that, the general error info
- *  is printed onto #cerr# using the #PrintError# function of
- *  #exc# and finally the exception specific data is printed
- *  using the user defined function #PrintError# (which is
- *  normally created using the #DeclException (...)# macro
+ *  is used, we set @p{__PRETTY_FUNCTION__ = "(unknown)"}.
+ *
+ *  In @p{__IssueError} the given data
+ *  is transferred into the @p{exc} object by calling the
+ *  @p{SetFields} function; after that, the general error info
+ *  is printed onto @p{cerr} using the @p{PrintError} function of
+ *  @p{exc} and finally the exception specific data is printed
+ *  using the user defined function @p{PrintError} (which is
+ *  normally created using the @p{DeclException (...)} macro
  *  family.
  *
- *  After printing all this information, #abort()# is called.
+ *  After printing all this information, @p{abort()} is called.
  *  This terminates the program, which is the right thing to do for
  *  this kind of error checking since it is used to detect programming
  *  errors rather than run-time errors; a program can, by definition,
  *  not recover from programming errors.
  *
- *  If the preprocessor variable #DEBUG# is not set, then nothing
- *  happens, i.e. the #Assert# macro is expanded to #{}#.
+ *  If the preprocessor variable @p{DEBUG} is not set, then nothing
+ *  happens, i.e. the @p{Assert} macro is expanded to @p{{}}.
  *
  *  Sometimes, there is no useful condition for an exception other
  *  than that the program flow should not have reached a certain point,
- *  e.g. a #default# section of a #switch# statement. In this case,
+ *  e.g. a @p{default} section of a @p{switch} statement. In this case,
  *  raise the exception by the following construct:
  *  \begin{verbatim}
  *    Assert (false, ExcInternalError());
  *  \end{verbatim}
  *
  *
- *  \section{Use of run-time exceptions}
+ *  @sect2{Use of run-time exceptions}
  *
- *  For this mode, the standard #C++# #throw# and #catch# concept exists. We
+ *  For this mode, the standard @p{C++} @p{throw} and @p{catch} concept exists. We
  *  want to keep to this, but want to extend it a bit. In general, the
  *  structure is the same, i.e. you normally raise and exception by
  *  \begin{verbatim}
  *      do_something_to_reciver ();
  *    };
  *  \end{verbatim}
- *  #exception# is a standard #C++# class providing basic functionality for
- *  exceptions, such as the virtual function #what()# which returns some
+ *  @p{exception} is a standard @p{C++} class providing basic functionality for
+ *  exceptions, such as the virtual function @p{what()} which returns some
  *  information on the exception itself. This information is useful if an
  *  exception can't be handled properly, in which case as precise a description
  *  as possible should be printed.
  *
  *  The problem here is that to get significant and useful information out
- *  of #what()#, it is necessary to overload this function in out exception
- *  class and call the #throw# operator with additional arguments to the
- *  exception class. The first thing, overloading the #what# function is
- *  done using the #DeclExceptionN# macros, but putting the right information,
- *  which is the same as explained above for the #Assert# expansion, requires
+ *  of @p{what()}, it is necessary to overload this function in out exception
+ *  class and call the @p{throw} operator with additional arguments to the
+ *  exception class. The first thing, overloading the @p{what} function is
+ *  done using the @p{DeclExceptionN} macros, but putting the right information,
+ *  which is the same as explained above for the @p{Assert} expansion, requires
  *  some work if one would want to write it down each time:
  *  \begin{verbatim}
  *    if (!cond)
  *      };
  *  \end{verbatim}
  *
- *  For this purpose, the macro #AssertThrow# was invented. It does mainly
- *  the same job as does the #Assert# macro, but it does not kill the
+ *  For this purpose, the macro @p{AssertThrow} was invented. It does mainly
+ *  the same job as does the @p{Assert} macro, but it does not kill the
  *  program, it rather throws an exception as shown above. The mode of usage
  *  is
  *  \begin{verbatim}
  *  \end{verbatim}
  *  The condition to be checked is incorporated into the macro in order to
  *  allow passing the violated condition as a string. The expansion of the
- *  #AssertThrow# macro is not affected by the #DEBUG# preprocessor variable.
+ *  @p{AssertThrow} macro is not affected by the @p{DEBUG} preprocessor variable.
  *
  *
- *  \section{Description of the #DeclExceptionN# macro family}
+ *  @sect2{Description of the @p{DeclExceptionN} macro family}
  *
  *  Declare an exception class without any additional parameters.
- *  There is a whole family of #DeclException?# macros
- *  where #?# is to be replaced by the number of additional
+ *  There is a whole family of @p{DeclException?} macros
+ *  where @p{?} is to be replaced by the number of additional
  *  parameters (0 to 5 presently).
  *  
  *  The syntax is as follows:
  *    --------------------------------------------------------
  *  \end{verbatim}
  *  
- *  Obviously for the #DeclException0(name)# macro, no types and
+ *  Obviously for the @p{DeclException0(name)} macro, no types and
  *  also no output sequence is allowed.
  *
  *
@@ -289,7 +289,7 @@ class ExceptionBase : public exception {
                                      *  The constructor takes the file in which the
                                      *  error happened, the line and the violated
                                      *  condition as well as the name of the
-                                     *  exception class as a #char*# as arguments.
+                                     *  exception class as a @p{char*} as arguments.
                                      */
     ExceptionBase (const char* f, const int l, const char *func,
                   const char* c, const char *e);
@@ -329,8 +329,8 @@ class ExceptionBase : public exception {
                                      *
                                      *  This function is mainly used when using
                                      *  exceptions declared by the
-                                     *  #DeclException*# macros with the #throw#
-                                     *  mechanism or the #AssertThrow# macro.
+                                     *  @p{DeclException*} macros with the @p{throw}
+                                     *  mechanism or the @p{AssertThrow} macro.
                                      */
     virtual const char * what () const;
 
@@ -365,7 +365,7 @@ class ExceptionBase : public exception {
 /**
  *  This routine does the main work for the
  *  exception generation mechanism used in the
- *  #Assert# macro.
+ *  @p{Assert} macro.
  *
  *  @see ExceptionBase
  */
@@ -394,7 +394,7 @@ void __IssueError_Assert (const char *file,
 /**
  *  This routine does the main work for the
  *  exception generation mechanism used in the
- *  #AssertThrow# macro.
+ *  @p{AssertThrow} macro.
  *
  *  @see ExceptionBase
  */
@@ -416,7 +416,7 @@ void __IssueError_Throw (const char *file,
 /**
  *  This is the main routine in the exception mechanism for debug mode
  *  error checking. See the
- *  #ExceptionBase# class for more information.
+ *  @p{ExceptionBase} class for more information.
  *
  *  @memo Assert that a certain condition is fulfilled, otherwise
  *   issue an error and abort the program.
@@ -442,7 +442,7 @@ void __IssueError_Throw (const char *file,
 /**
  *  This is the main routine in the exception mechanism for run-time mode
  *  error checking. See the
- *  #ExceptionBase# class for more information.
+ *  @p{ExceptionBase} class for more information.
  *
  *  @memo Assert that a certain condition is fulfilled, otherwise
  *   throw an exception
@@ -467,7 +467,7 @@ void __IssueError_Throw (const char *file,
 #endif
 
 /**
- * See the #ExceptionBase# class for a detailed description.
+ * See the @p{ExceptionBase} class for a detailed description.
  *
  * @see ExceptionBase
  * @author Wolfgang Bangerth, November 1997
index 2be2230aee39bdbc9ac8ece09c3fe44751218110..6f801d2709069fa917c13ca6e5901bcedfab06f0 100644 (file)
@@ -62,15 +62,15 @@ template<typename number> class Vector;
  * function at one or several points.
  *
  * You will usually only overload those functions you need; the
- * functions returning several values at a time (#value_list#,
- * #vector_value_list#, and gradient analoga) will call those
- * returning only one value (#value#, #vector_value#, and gradient
+ * functions returning several values at a time (@p{value_list},
+ * @p{vector_value_list}, and gradient analoga) will call those
+ * returning only one value (@p{value}, @p{vector_value}, and gradient
  * analoga), while those ones will throw an exception when called but
  * not overloaded.
  *
  * Note however, that the functions returning all components of the
- * function at one or several points (i.e. #vector_value#,
- * #vector_value_list#), will not call the function returning one
+ * function at one or several points (i.e. @p{vector_value},
+ * @p{vector_value_list}), will not call the function returning one
  * component at one point repeatedly, once for each point and
  * component. The reason is efficiency: this would amount to too many
  * virtual function calls. If you have vector-valued functions, you
@@ -85,11 +85,11 @@ template<typename number> class Vector;
  *
  *
  * Support for time dependant functions can be found in the base
- * class #FunctionTime#.
+ * class @p{FunctionTime}.
  *
  * {\bf Note}: if the functions you are dealing with have sizes which
- * are a priori known (for example, #dim# elements), you might
- * consider using the #TensorFunction# class instead.
+ * are a priori known (for example, @p{dim} elements), you might
+ * consider using the @p{TensorFunction} class instead.
  *
  * @author Wolfgang Bangerth, 1998, 1999
  */
@@ -142,37 +142,37 @@ class Function : public FunctionTime,
                                      *
                                      * Be default, this function
                                      * repeatedly calls the other
-                                     * #operator()# for each
+                                     * @p{operator()} for each
                                      * component separately, to fill
                                      * the output array.
                                      *
-                                     * #values# shall have the right
+                                     * @p{values} shall have the right
                                      * size beforehand,
-                                     * i.e. #n_components#.
+                                     * i.e. @p{n_components}.
                                      */
     virtual void   vector_value (const Point<dim>   &p,
                                 Vector<double>     &values) const;
     
                                     /**
-                                     * Set #values# to the point
+                                     * Set @p{values} to the point
                                      * values of the specified
                                      * component of the function at
-                                     * the #points#.  It is assumed
-                                     * that #values# already has the
+                                     * the @p{points}.  It is assumed
+                                     * that @p{values} already has the
                                      * right size, i.e.  the same
-                                     * size as the #points# array.
+                                     * size as the @p{points} array.
                                      */
     virtual void value_list (const vector<Point<dim> > &points,
                             vector<double>            &values,
                             const unsigned int         component = 0) const;
 
                                     /**
-                                     * Set #values# to the point
+                                     * Set @p{values} to the point
                                      * values of the function at the
-                                     * #points#.  It is assumed that
-                                     * #values# already has the right
+                                     * @p{points}.  It is assumed that
+                                     * @p{values} already has the right
                                      * size, i.e.  the same size as
-                                     * the #points# array, and that
+                                     * the @p{points} array, and that
                                      * all elements be vectors with
                                      * the same number of components
                                      * as this function has.
@@ -197,28 +197,28 @@ class Function : public FunctionTime,
                                           vector<Tensor<1,dim> > &gradients) const;
     
                                     /**
-                                     * Set #gradients# to the
+                                     * Set @p{gradients} to the
                                      * gradients of the specified
                                      * component of the function at
-                                     * the #points#.  It is assumed
-                                     * that #gradients# already has the
+                                     * the @p{points}.  It is assumed
+                                     * that @p{gradients} already has the
                                      * right size, i.e.  the same
-                                     * size as the #points# array.
+                                     * size as the @p{points} array.
                                      */
     virtual void gradient_list (const vector<Point<dim> > &points,
                                vector<Tensor<1,dim> >    &gradients,
                                const unsigned int         component = 0) const;
     
                                     /**
-                                     * Set #gradients# to the gradients of
-                                     * the function at the #points#,
+                                     * Set @p{gradients} to the gradients of
+                                     * the function at the @p{points},
                                      * for all components.
-                                     * It is assumed that #gradients# 
+                                     * It is assumed that @p{gradients} 
                                      * already has the right size, i.e.
-                                     * the same size as the #points# array.
+                                     * the same size as the @p{points} array.
                                      *
                                      * The outer loop over
-                                     * #gradients# is over the points
+                                     * @p{gradients} is over the points
                                      * in the list, the inner loop
                                      * over the different components
                                      * of the function.
@@ -228,15 +228,15 @@ class Function : public FunctionTime,
 
                                     /**
                                      * Compute the Laplacian of a
-                                     * given component at point #p#.
+                                     * given component at point @p{p}.
                                      */
     virtual double laplacian (const Point<dim>   &p,
                              const unsigned int  component = 0) const;
 
                                     /**
                                      * Compute the Laplacian of all
-                                     * components at point #p# and
-                                     * store them in #values#.
+                                     * components at point @p{p} and
+                                     * store them in @p{values}.
                                      */
     virtual void vector_laplacian (const Point<dim>   &p,
                                     Vector<double>     &values) const;
@@ -303,12 +303,12 @@ class ZeroFunction : public Function<dim>
                                 Vector<double>   &return_value) const;
 
                                     /**
-                                     * Set #values# to the point values
-                                     * of the function at the #points#,
+                                     * Set @p{values} to the point values
+                                     * of the function at the @p{points},
                                      * for the given component.
-                                     * It is assumed that #values#
+                                     * It is assumed that @p{values}
                                      * already has the right size, i.e.
-                                     * the same size as the #points#
+                                     * the same size as the @p{points}
                                      * array.
                                      */
     virtual void value_list (const vector<Point<dim> > &points,
@@ -316,12 +316,12 @@ class ZeroFunction : public Function<dim>
                             const unsigned int         component = 0) const;
 
                                     /**
-                                     * Set #values# to the point values
-                                     * of the function at the #points#,
+                                     * Set @p{values} to the point values
+                                     * of the function at the @p{points},
                                      * for all components.
-                                     * It is assumed that #values#
+                                     * It is assumed that @p{values}
                                      * already has the right size, i.e.
-                                     * the same size as the #points#
+                                     * the same size as the @p{points}
                                      * array.
                                      */
     virtual void vector_value_list (const vector<Point<dim> > &points,
@@ -345,27 +345,27 @@ class ZeroFunction : public Function<dim>
                                           vector<Tensor<1,dim> > &gradients) const;
     
                                     /**
-                                     * Set #gradients# to the gradients of
-                                     * the function at the #points#,
+                                     * Set @p{gradients} to the gradients of
+                                     * the function at the @p{points},
                                      * for the given component.
-                                     * It is assumed that #values#
+                                     * It is assumed that @p{values}
                                      * already has the right size, i.e.
-                                     * the same size as the #points# array.
+                                     * the same size as the @p{points} array.
                                      */
     virtual void gradient_list (const vector<Point<dim> > &points,
                                vector<Tensor<1,dim> >    &gradients,
                                const unsigned int         component = 0) const;
     
                                     /**
-                                     * Set #gradients# to the gradients of
-                                     * the function at the #points#,
+                                     * Set @p{gradients} to the gradients of
+                                     * the function at the @p{points},
                                      * for all components.
-                                     * It is assumed that #gradients# 
+                                     * It is assumed that @p{gradients} 
                                      * already has the right size, i.e.
-                                     * the same size as the #points# array.
+                                     * the same size as the @p{points} array.
                                      *
                                      * The outer loop over
-                                     * #gradients# is over the points
+                                     * @p{gradients} is over the points
                                      * in the list, the inner loop
                                      * over the different components
                                      * of the function.
@@ -379,12 +379,12 @@ class ZeroFunction : public Function<dim>
  * Provide a function which always returns a constant value, which is
  * delivered upon construction. Obviously, the derivates of this
  * function are zero, which is why we derive this class from
- * #ZeroFunction#: we then only have to overload th value functions,
+ * @p{ZeroFunction}: we then only have to overload th value functions,
  * not all the derivatives. In some way, it would be more obvious to
  * do the derivation in the opposite direction, i.e. let
- * #ZeroFunction# be a more specialized version of #ConstantFunction#;
+ * @p{ZeroFunction} be a more specialized version of @p{ConstantFunction};
  * however, this would be more inefficient, since we could not make
- * use of the fact that the function value of the #ZeroFunction# is
+ * use of the fact that the function value of the @p{ZeroFunction} is
  * known at compile time and need not be looked up somewhere in
  * memory.
  *
@@ -431,12 +431,12 @@ class ConstantFunction : public ZeroFunction<dim>
                                 Vector<double>   &return_value) const;
 
                                     /**
-                                     * Set #values# to the point values
-                                     * of the function at the #points#,
+                                     * Set @p{values} to the point values
+                                     * of the function at the @p{points},
                                      * for the given component.
-                                     * It is assumed that #values#
+                                     * It is assumed that @p{values}
                                      * already has the right size, i.e.
-                                     * the same size as the #points#
+                                     * the same size as the @p{points}
                                      * array.
                                      */
     virtual void value_list (const vector<Point<dim> > &points,
@@ -444,12 +444,12 @@ class ConstantFunction : public ZeroFunction<dim>
                             const unsigned int         component = 0) const;
 
                                     /**
-                                     * Set #values# to the point values
-                                     * of the function at the #points#,
+                                     * Set @p{values} to the point values
+                                     * of the function at the @p{points},
                                      * for all components.
-                                     * It is assumed that #values#
+                                     * It is assumed that @p{values}
                                      * already has the right size, i.e.
-                                     * the same size as the #points#
+                                     * the same size as the @p{points}
                                      * array.
                                      */
     virtual void vector_value_list (const vector<Point<dim> > &points,
@@ -494,12 +494,12 @@ class ComponentSelectFunction : public ConstantFunction<dim>
                                 Vector<double>   &return_value) const;
 
                                     /**
-                                     * Set #values# to the point values
-                                     * of the function at the #points#,
+                                     * Set @p{values} to the point values
+                                     * of the function at the @p{points},
                                      * for all components.
-                                     * It is assumed that #values#
+                                     * It is assumed that @p{values}
                                      * already has the right size, i.e.
-                                     * the same size as the #points#
+                                     * the same size as the @p{points}
                                      * array.
                                      */
     virtual void vector_value_list (const vector<Point<dim> > &points,
index 8a8e8b13bab2369058cb8bb23fb2f1f62ad44a98..0e1254c9a1b58c9ff83ca39e12d86e7f41d8f1c8 100644 (file)
  *  normally does not create thousands of function objects, the gain in
  *  generality weighs out the fact that we need not store the time value
  *  for not time dependent problems. The second advantage is that the derived
- *  standard classes like #ZeroFunction#, #ConstantFunction# etc also work
+ *  standard classes like @p{ZeroFunction}, @p{ConstantFunction} etc also work
  *  for time dependent problems.
  *
  *  Access to the time goes through the following functions:
  *  \begin{verbatim}
- *  \item #get_time#: return the present value of the time variable.
- *  \item #set_time#: set the time value to a specific value.
- *  \item #advance_time#: increase the time by a certain time step.
+ *  \item @p{get_time}: return the present value of the time variable.
+ *  \item @p{set_time}: set the time value to a specific value.
+ *  \item @p{advance_time}: increase the time by a certain time step.
  *  \end{verbatim}
  *  The latter two functions are virtual, so that derived classes can
  *  perform computations which need only be done once for every new time.
- *  For example, if a time dependent function had a factor #sin(t)#, then
+ *  For example, if a time dependent function had a factor @p{sin(t)}, then
  *  it may be a reasonable choice to calculate this factor in a derived
- *  version of #set_time#, store it in a member variable and use that one
- *  rather than computing it every time #operator()#, #value_list# or one
+ *  version of @p{set_time}, store it in a member variable and use that one
+ *  rather than computing it every time @p{operator()}, @p{value_list} or one
  *  of the other functions is called.
  *
- *  By default, the #advance_time# function calls the #set_time# function
+ *  By default, the @p{advance_time} function calls the @p{set_time} function
  *  with the new time, so it is sufficient in most cases to overload only
- *  #set_time# for computations as sketched out above.
+ *  @p{set_time} for computations as sketched out above.
  *
  *  The constructor of this class takes an initial value for the time
  *  variable, which defaults to zero. Because a default value is given,
  *  none of the derived classes needs to take an initial value for the
  *  time variable if not needed.
  *
- *  Once again the warning: do not use the #time# variable for any other
+ *  Once again the warning: do not use the @p{time} variable for any other
  *  purpose than the intended one! This will inevitably lead to confusion.
  *
  *
@@ -78,14 +78,14 @@ class FunctionTime
     double get_time () const;
 
                                     /**
-                                     * Set the time to #new_time#, overwriting
+                                     * Set the time to @p{new_time}, overwriting
                                      * the old value.
                                      */
     virtual void set_time (const double new_time);
 
                                     /**
                                      * Advance the time by the given
-                                     * time step #delta_t#.
+                                     * time step @p{delta_t}.
                                      */
     virtual void advance_time (const double delta_t);
 
index 3aa60ce7a082b24496d71d838c66ff96d791b90c..72babfc1751e28de4b646ae2cba2282c5101a686 100644 (file)
@@ -17,9 +17,9 @@
 #include <string>
 
 /**
- * Identification of a program run. #JobIdentifier# determines the
+ * Identification of a program run. @p{JobIdentifier} determines the
  * start time of a program run and stores it as a program
- * identifier. There exists a library object #dealjobid# of this
+ * identifier. There exists a library object @p{dealjobid} of this
  * class. This object can be accessed by all output functions to
  * provide an id for the current job.
  */
index 7b4ce1a9ad4c4dd4935a6929237b49ff25073549..31dd87ca0ab1b9136e0eff6b24e5a2b55d8a243c 100644 (file)
  * \end{itemize}
  *
  * The usual usage of this class is through the pregenerated object
- * #deallog#. Typical steps are
+ * @p{deallog}. Typical steps are
  * <OL>
- * <LI> #deallog.attach(ostream)#: write logging information into a file.
- * <LI> #deallog.depth_console(n)#: restrict output on screen to outer loops.
+ * <LI> @p{deallog.attach(ostream)}: write logging information into a file.
+ * <LI> @p{deallog.depth_console(n)}: restrict output on screen to outer loops.
  * <LI> Before entering a new phase of your program, e.g. a new loop,
- * #deallog.push("loopname")#.
- * <LI> #deallog << anything << endl;# to write logging information
- * (Usage of #endl# is mandatory!).
- * <LI> #deallog.pop()# when leaving that stage entered with #push#.
+ * @p{deallog.push("loopname")}.
+ * <LI> @p{deallog << anything << endl;} to write logging information
+ * (Usage of @p{endl} is mandatory!).
+ * <LI> @p{deallog.pop()} when leaving that stage entered with @p{push}.
  * </OL>
  *
  * @author Guido Kanschat, Wolfgang Bangerth, 1999
@@ -59,7 +59,7 @@ class LogStream
                                     /**
                                      * Default stream, where the output
                                      * is to go to. This stream defaults
-                                     * to #cerr#, but can be set to another
+                                     * to @p{cerr}, but can be set to another
                                      * stream through the constructor.
                                      */
     ostream  *std_out;
@@ -70,7 +70,7 @@ class LogStream
                                      * will be a file stream.
                                      *
                                      * You can set and reset this stream
-                                     * by the #attach# function.
+                                     * by the @p{attach} function.
                                      */
     ostream  *file;
 
@@ -112,27 +112,27 @@ class LogStream
                                     /**
                                      * Standard constructor, since we
                                      * intend to provide an object
-                                     * #deallog# in the library. Set the
-                                     * standard output stream to #cerr#.
+                                     * @p{deallog} in the library. Set the
+                                     * standard output stream to @p{cerr}.
                                      */
     LogStream();
     
                                     /**
                                      * Enable output to a second
-                                     * stream #o#.
+                                     * stream @p{o}.
                                      */
     void attach(ostream& o);
     
                                     /**
                                      * Disable output to the second
                                      * stream. You may want to call
-                                     * #close# on the stream that was
+                                     * @p{close} on the stream that was
                                      * previously attached to this object.
                                      */
     void detach();
 
                                     /**
-                                     * Gives the default stream (#std_out#).
+                                     * Gives the default stream (@p{std_out}).
                                      */
     ostream& get_console();
 
@@ -161,9 +161,9 @@ class LogStream
                                      * function allows to restrict
                                      * console output to the upmost
                                      * levels of iterations. Only
-                                     * output with less than #n#
+                                     * output with less than @p{n}
                                      * prefixes is printed. By calling
-                                     * this function with #n=0#, no
+                                     * this function with @p{n=0}, no
                                      * console output will be written.
                                      */
     void depth_console (unsigned int n);
@@ -172,7 +172,7 @@ class LogStream
                                      * Maximum number of levels to be
                                      * written to the log file. The
                                      * functionality is the same as
-                                     * #depth_console#, nevertheless,
+                                     * @p{depth_console}, nevertheless,
                                      * this function should be used
                                      * with care, since it may spoile
                                      * the value of a log file.
@@ -200,15 +200,15 @@ class LogStream
                                      * function on the present object. It
                                      * works the same way as it is possible
                                      * to output the stream manipulators
-                                     * (like #endl#, etc) work on standard
-                                     * streams: #stream << endl;#. We need
+                                     * (like @p{endl}, etc) work on standard
+                                     * streams: @p{stream << endl;}. We need
                                      * to overload this function in order
                                      * to know when we have to print the
                                      * prefixes, since a user may use several
-                                     * calls to #operator <<# before the
+                                     * calls to @p{operator <<} before the
                                      * line is complete. The overloaded
-                                     * function #void endl(LogStream &)#
-                                     * tells the #LogStream# that the end of
+                                     * function @p{void endl(LogStream &)}
+                                     * tells the @p{LogStream} that the end of
                                      * the line is reached.
                                      */
     LogStream & operator << (void (f)(LogStream &));
@@ -242,7 +242,7 @@ LogStream &
 LogStream::operator<< (const T& t)
 {
                                   // if the previous command was an
-                                  // #endl#, print the topmost prefix
+                                  // @p{endl}, print the topmost prefix
                                   // and a colon
   if (was_endl)
     {
@@ -262,10 +262,10 @@ LogStream::operator<< (const T& t)
 
 
 /**
- * Replacement of #endl# for #LogStream#.
+ * Replacement of @p{endl} for @p{LogStream}.
  *
- * Overloaded version of the stream manipulator function #endl# which
- * results in calling the original version of #endl# for each of the
+ * Overloaded version of the stream manipulator function @p{endl} which
+ * results in calling the original version of @p{endl} for each of the
  * two streams, if the present prefix number does not exceed the
  * specified maximal number.
  *
index 6fe02600cd6dc4e456050147a6c0f132a5bf48bb..c9f5a54d066614c969c2b749f99ec332d5ba5fd3 100644 (file)
@@ -23,9 +23,9 @@
  * use in multithreaded programs.  At the moment this is just the
  * number of cpus. If deal.II is compiled with multithreading support,
  * some functions will use multiple threads for their action, and will
- * use the member variable #n_default_threads# of this class as the
+ * use the member variable @p{n_default_threads} of this class as the
  * default number of threads to start.  This variable
- * #n_default_threads# is set to the number of CPUs by default, but
+ * @p{n_default_threads} is set to the number of CPUs by default, but
  * can be adjusted by the user to fit the requirements.
  *
  * @author Thomas Richter, 2000
@@ -59,7 +59,7 @@ class MultithreadInfo
                                      * The number of threads to use as
                                      * a default value for all functions
                                      * that support multithreading.
-                                     * At start time this is #n_cpus# or
+                                     * At start time this is @p{n_cpus} or
                                      * one, if detection of the number
                                      * of CPUs is not possible.
                                      */
@@ -88,7 +88,7 @@ class MultithreadInfo
 
 
 /**
- * Global variable of type #MultithreadInfo# which you may ask for the
+ * Global variable of type @p{MultithreadInfo} which you may ask for the
  * number of CPUs in you system, as well as for the default number of
  * threads that multithreaded functions shall use.
  */
index 3c1de8e8ddf083d8aa8ebec20db46de49b1e2ce0..f4ae625853d386fbb46aea0186a21ffb9761d0ef 100644 (file)
@@ -102,8 +102,8 @@ struct Patterns {
                                      * a sequence of values given like a
                                      * regular expression. For example, if
                                      * the string given to the constructor
-                                     * is "red|blue|black", then the #match#
-                                     * function returns #true# exactly if
+                                     * is "red|blue|black", then the @p{match}
+                                     * function returns @p{true} exactly if
                                      * the string is either "red" or "blue"
                                      * or "black". Spaces around the pipe
                                      * signs do not matter and are
@@ -121,14 +121,14 @@ struct Patterns {
 
 
                                     /**
-                                     * This class is much like the #Selection#
+                                     * This class is much like the @p{Selection}
                                      * class, but it allows the input to be
                                      * a comma-separated list of values which
                                      * each have to be given in the constructor
                                      * argument. For example, if the string to
-                                     * the constructor was #"ucd|gmv|eps"#, then
+                                     * the constructor was @p{"ucd|gmv|eps"}, then
                                      * the following would be legal input:
-                                     * #eps, gmv#. You may give an arbitrarily
+                                     * @p{eps, gmv}. You may give an arbitrarily
                                      * long list of values, where there may be
                                      * as many spaces around commas as you like.
                                      * However, commas are not allowed inside
@@ -153,7 +153,7 @@ struct Patterns {
                                     /**
                                      * Test for the string being either
                                      * "true" or "false". This is mapped
-                                     * to the #Selection# class.
+                                     * to the @p{Selection} class.
                                      */
     class Bool : public Selection {
       public:
@@ -182,7 +182,7 @@ struct Patterns {
 
 
 /**
- *   The #ParameterHandler# class provides a standard interface to an input file
+ *   The @p{ParameterHandler} class provides a standard interface to an input file
  *   which provides at run-time for program parameters such as time step sizes,
  *   geometries, right hand sides etc. The input for the program is given in files,
  *   streams or strings in memory using text like
@@ -194,9 +194,9 @@ struct Patterns {
  *   structure.
  *
  *   
- *   \subsection{Declaration of entries}
+ *   @sect3{Declaration of entries}
  *   
- *   In order to use the facilities of a #ParameterHandler# object, one first has
+ *   In order to use the facilities of a @p{ParameterHandler} object, one first has
  *   to make known the different entries the input file may or may not contain. This
  *   is done in the following way:
  *   \begin{verbatim}
@@ -210,15 +210,15 @@ struct Patterns {
  *                       Patterns::Anything());
  *     ...
  *   \end{verbatim}
- *   Each entry is declared using the function #declare_entry#. The first parameter is
+ *   Each entry is declared using the function @p{declare_entry}. The first parameter is
  *   the name of the entry (in short: the entry). The second is the default answer to
  *   be taken in case the entry is not specified in the input file. The third parameter
  *   is a regular expression which the input (and the default answer) has to match.
- *   Several such regular expressions are defined in #Patterns#.
+ *   Several such regular expressions are defined in @p{Patterns}.
  *
  *   Entries may be located in subsections which form a kind of input tree. For example
  *   input parameters for linear solver routines should be classified in a subsection
- *   named #Linear solver# or any other suitable name. This is accomplished in the
+ *   named @p{Linear solver} or any other suitable name. This is accomplished in the
  *   following way:
  *   \begin{verbatim}
  *     ...
@@ -241,7 +241,7 @@ struct Patterns {
  *
  *   Subsections may be nested. For example a nonlinear solver may have a linear solver
  *   as member object. Then the function call tree would be something like (if the class
- *   #NonLinEq# has a member variables #eq# of type #LinEq#):
+ *   @p{NonLinEq} has a member variables @p{eq} of type @p{LinEq}):
  *   \begin{verbatim}
  *     void NonLinEq::declare_parameters (ParameterHandler &prm) {
  *       prm.enter_subsection ("Nonlinear solver");
@@ -254,11 +254,11 @@ struct Patterns {
  *   \end{verbatim}
  *
  *   For class member functions which declare the different entries we propose to use the
- *   common name #declare_parameters#. In normal cases this method can be #static# since the
+ *   common name @p{declare_parameters}. In normal cases this method can be @p{static} since the
  *   entries will not depend on any previous knowledge. Classes for which entries should
  *   logically be grouped into subsections should declare these subsections themselves. If
  *   a class has two or more member variables of the same type both of which should have
- *   their own parameters, this parent class' method #declare_parameters# is responsible to
+ *   their own parameters, this parent class' method @p{declare_parameters} is responsible to
  *   group them into different subsections:
  *   \begin{verbatim}
  *     void NonLinEq::declare_parameters (ParameterHandler &prm) {
@@ -275,7 +275,7 @@ struct Patterns {
  *   \end{verbatim}
  *
  *
- *   \subsection{Input files and special characters}
+ *   @sect3{Input files and special characters}
  *
  *   For the first example above the input file would look like the following:
  *   \begin{verbatim}
@@ -289,27 +289,27 @@ struct Patterns {
  *     end
  *     ...                       # other stuff
  *   \end{verbatim}
- *   The words #subsection#, #set# and #end# may be either written in lowercase or uppercase
+ *   The words @p{subsection}, @p{set} and @p{end} may be either written in lowercase or uppercase
  *   letters. Leading and trailing whitespace is removed, multiple whitespace is condensed into
  *   only one. Since the latter applies also to the name of an entry, an entry name will not
  *   be recognised if in the declaration multiple whitespace is used.
  *
- *   In entry names and values the following characters are not allowed: \#, #{#, #}#, #|#.
- *   Their use is reserved for the \ref{MultipleParameterLoop} class.
+ *   In entry names and values the following characters are not allowed: @p{#}, @p{\{}, 
+ *   @p{\}}, @p{|}. Their use is reserved for the \ref{MultipleParameterLoop} class.
  *   
  *   Comments starting with \# are skipped.
  *   
  *   We propose to use the following
  *   scheme to name entries: start the first word with a capital letter and use lowercase
  *   letters further on. The same applies to the possible entry values to the right of the
- *   #=# sign.
+ *   @p{=} sign.
  *
  *   
- *   \subsection{Reading data from input sources}
+ *   @sect3{Reading data from input sources}
  *   
- *   In order to read input you can use three possibilities: reading from an #istream# object,
+ *   In order to read input you can use three possibilities: reading from an @p{istream} object,
  *   reading from a file of which the name is given and reading from a string in memory in
- *   which the lines are separated by #\n# characters. These possibilites are used as follows:
+ *   which the lines are separated by @p{\n} characters. These possibilites are used as follows:
  *   \begin{verbatim}
  *     ParameterHandler prm;
  *     ...
@@ -325,18 +325,18 @@ struct Patterns {
  *   \end{verbatim}
  *   You can use several sources of input successively. Entries which are changed more than
  *   once will be overwritten everytime they are used. It is suggested to let the name of
- *   parameter input end in #.prm#.
+ *   parameter input end in @p{.prm}.
  *
- *   You should not try to declare entries using #declare_entry# and #enter_subsection# with as
- *   yet unknown subsection names after using #read_input#. The results in this case are
+ *   You should not try to declare entries using @p{declare_entry} and @p{enter_subsection} with as
+ *   yet unknown subsection names after using @p{read_input}. The results in this case are
  *   unspecified.
  *
- *   If an error occurs upon reading the input, error messages are written to #cerr#.
+ *   If an error occurs upon reading the input, error messages are written to @p{cerr}.
  *
  *   
- *   \subsection{Getting entry values out of a #ParameterHandler# object}
+ *   @sect3{Getting entry values out of a @p{ParameterHandler} object}
  *   
- *   Each class gets its data out of a #ParameterHandler# object by calling the #get (...)#
+ *   Each class gets its data out of a @p{ParameterHandler} object by calling the @p{get (...)}
  *   member functions like this:
  *   \begin{verbatim}
  *      void NonLinEq::get_parameters (ParameterHandler &prm) {
@@ -346,7 +346,7 @@ struct Patterns {
  *       prm.leave_subsection ();
  *     };
  *   \end{verbatim}
- *   #get()# returns the value of the given entry. If the entry was not specified in the input
+ *   @p{get()} returns the value of the given entry. If the entry was not specified in the input
  *   source(s), the default value is returned. You have to enter and leave subsections
  *   exactly as you did when declaring subsection. You may chose the order in which to
  *   transverse the subsection tree.
@@ -354,17 +354,17 @@ struct Patterns {
  *   It is guaranteed that only entries matching the given regular expression are returned,
  *   i.e. an input entry value which does not match the regular expression is not stored.
  *
- *   You can use #get# to retrieve the parameter in text form, #get_integer# to get an integer
- *   or #get_double# to get a double. You can also use #get_bool#.
+ *   You can use @p{get} to retrieve the parameter in text form, @p{get_integer} to get an integer
+ *   or @p{get_double} to get a double. You can also use @p{get_bool}.
  *   It will cause an internal error if the string could not be 
  *   converted to an integer, double or a bool. This should, though, not
  *   happen if you correctly specified the regular expression for this entry; you should not
  *   try to get out an integer or a double from an entry for which no according regular
- *   expression was set. The internal error is raised through the #Assert()# macro family
+ *   expression was set. The internal error is raised through the @p{Assert()} macro family
  *   which only works in debug mode.
  *
  *   If you want to print out all user selectable features, use the
- *   #print_parameters# function. It is generally a good idea to print all parameters
+ *   @p{print_parameters} function. It is generally a good idea to print all parameters
  *   at the beginning of a log file, since this way input and output are together in
  *   one file which makes matching at a later time easier. Additionally, the function
  *   also print those entries which have not been modified in the input file und are
@@ -373,14 +373,14 @@ struct Patterns {
  *   input file.
  *   
  *   
- *   \subsection{Style guide for data retrieval}
+ *   @sect3{Style guide for data retrieval}
  *   
- *   We propose that every class which gets data out of a #ParameterHandler# object provides
- *   a function named #get_parameters#. This should be declared #virtual#. #get_parameters#
- *   functions in derived classes should call the #BaseClass::get_parameters# function.
+ *   We propose that every class which gets data out of a @p{ParameterHandler} object provides
+ *   a function named @p{get_parameters}. This should be declared @p{virtual}. @p{get_parameters}
+ *   functions in derived classes should call the @p{BaseClass::get_parameters} function.
  *
  *
- *   \subsection{Experience with large parameter lists}
+ *   @sect3{Experience with large parameter lists}
  *  
  *   Experience has shown that in programs defining larger numbers of parameters (more than,
  *   say, fifty) it is advantageous to define an additional class holding these parameters.
@@ -394,18 +394,18 @@ struct Patterns {
  *   up your main class with dozens or more variables denoting the parameters.
  *
  *
- *   \subsection{Possible future extensions}
+ *   @sect3{Possible future extensions}
  *   
  *   \begin{itemize}
  *   \item Allow long input lines to be broken by appending a backslash character
  *     (just like C macros and shell input).
- *   \item Provide an #input filename# command for the input file to enable users to put the
+ *   \item Provide an @p{input filename} command for the input file to enable users to put the
  *     most common parameters into separate files.
  *   \end{itemize}  
  *
  *
  *   
- *   \subsection{Worked Example}
+ *   @sect3{Worked Example}
  *
  *   This is the code:
  *   \begin{verbatim}
@@ -606,9 +606,9 @@ struct Patterns {
  *   \end{verbatim}
  *
  *   
- *   \subsection{References}
+ *   @sect3{References}
  *
- *   This class is inspired by the #MenuSystem# class of #DiffPack#.
+ *   This class is inspired by the @p{MenuSystem} class of @p{DiffPack}.
  *
  *   @memo  This class provides a standard interface to an input file
  *   which provides at run-time for program parameters such as time step sizes,
@@ -635,7 +635,7 @@ class ParameterHandler
     
                                     /**
                                      * Read input from a stream until stream
-                                     * returns #eof# condition or error.
+                                     * returns @p{eof} condition or error.
                                      *
                                      * Return whether the read was successful.
                                      */
@@ -656,7 +656,7 @@ class ParameterHandler
                                     /**
                                      * Read input from a string in memory. The
                                      * lines in memory have to be separated by
-                                     * #\n# characters.
+                                     * @p{\n} characters.
                                      *
                                      * Return whether the read was successful.
                                      */
@@ -664,7 +664,7 @@ class ParameterHandler
 
                                     /**
                                      * Return status of this object:
-                                     * #true#=clean or #false#=error occured.
+                                     * @p{true}=clean or @p{false}=error occured.
                                      */
     bool ok() const;
 
@@ -675,13 +675,13 @@ class ParameterHandler
 
 
                                     /**
-                                     * Declare a new entry with name #entry#,
+                                     * Declare a new entry with name @p{entry},
                                      * default and for which
-                                     * any input has to match the #pattern#
+                                     * any input has to match the @p{pattern}
                                      * (default: any pattern).
-                                     * @return #false# if entry already exists or
+                                     * @return @p{false} if entry already exists or
                                      * default value does not match the regular
-                                     * expression; #true# otherwise.
+                                     * expression; @p{true} otherwise.
                                      */
     bool declare_entry    (const string &entry,
                           const string &default_value,
@@ -696,47 +696,47 @@ class ParameterHandler
     
                                     /**
                                      * Leave present subsection.
-                                     * @return #false# if there is no subsection
+                                     * @return @p{false} if there is no subsection
                                      * to leave; true otherwise.
                                      */
     bool leave_subsection ();
 
                                     /**
-                                     * Return value of entry #entry_string#.
+                                     * Return value of entry @p{entry_string}.
                                      * If the entry was changed, then the changed
                                      * value is returned, otherwise the default
                                      * value. If the value of an undeclared entry
                                      * is required, an empty string is returned and
-                                     * #assert# is used to check whether this entry
+                                     * @p{assert} is used to check whether this entry
                                      * was declared (therefore an exception may be
                                      * thrown).
                                      */
     const string & get (const string &entry_string) const;
     
                                     /**
-                                     * Return value of entry #entry_string# as
-                                     * #long int#.
+                                     * Return value of entry @p{entry_string} as
+                                     * @p{long int}.
                                      */
     long int       get_integer (const string &entry_string) const;
     
                                     /**
-                                     * Return value of entry #entry_string# as
-                                     * #double#.
+                                     * Return value of entry @p{entry_string} as
+                                     * @p{double}.
                                      */
     double         get_double (const string &entry_string) const;
 
                                     /**
-                                     * Return value of entry #entry_string# as
-                                     * #bool#.
+                                     * Return value of entry @p{entry_string} as
+                                     * @p{bool}.
                                      */
     bool           get_bool (const string &entry_string) const;
 
                                     /**
                                      * Print all parameters with the given style
-                                     * to #out#. Presently only #Text# and #LaTeX#
+                                     * to @p{out}. Presently only @p{Text} and @p{LaTeX}
                                      * are implemented.
                                      *
-                                     * In #Text# format, the output is formatted
+                                     * In @p{Text} format, the output is formatted
                                      * in such a way that it is possible to
                                      * use it for later input again. This is most
                                      * useful to record the parameters set for
@@ -750,7 +750,7 @@ class ParameterHandler
 
                                     /**
                                      * Print out the parameters of the subsection
-                                     * given by the #subsection_path# member
+                                     * given by the @p{subsection_path} member
                                      * variable.
                                      */
     void print_parameters_section (ostream &out,
@@ -837,47 +837,47 @@ class ParameterHandler
                                      * Analogue list of changed entries. The
                                      * tree of subsections is there even if there
                                      * are no changed entry values in a
-                                     * subsection; therefore #enter_subsection#
-                                     * has to create the tree in both #Defaults#
-                                     * and #changed_entries#.
+                                     * subsection; therefore @p{enter_subsection}
+                                     * has to create the tree in both @p{Defaults}
+                                     * and @p{changed_entries}.
                                      */
     Section changed_entries;
 
                                     /**
                                      * Scan one line of input.
-                                     * #lineno# is the number of the line presently
+                                     * @p{lineno} is the number of the line presently
                                      * scanned (for the logs if there are messages).
-                                     * @return #false# if line contained stuff
+                                     * @return @p{false} if line contained stuff
                                      * that could not be understood, the uppermost
-                                     * subsection was to be left by an #END# or
-                                     * #end# statement, a value for a non-declared
+                                     * subsection was to be left by an @p{END} or
+                                     * @p{end} statement, a value for a non-declared
                                      * entry was given or teh entry value did not
-                                     * match the regular expression. #true#
+                                     * match the regular expression. @p{true}
                                      * otherwise
                                      */
     bool scan_line (string line, const unsigned int lineno);
 
                                     /**
-                                     * Get a pointer to the #Section# structure
-                                     * in the #Defaults# tree
+                                     * Get a pointer to the @p{Section} structure
+                                     * in the @p{Defaults} tree
                                      * for the subsection we are presently in.
                                      */
     Section*       get_present_defaults_subsection ();
     
                                     /**
-                                     * Same, #const# version.
+                                     * Same, @p{const} version.
                                      */ 
     const Section* get_present_defaults_subsection () const;
 
                                     /**
-                                     * Get a pointer to the #Section# structure
-                                     * in the #changed_entries# tree
+                                     * Get a pointer to the @p{Section} structure
+                                     * in the @p{changed_entries} tree
                                      * for the subsection we are presently in.
                                      */
     Section* get_present_changed_subsection ();
     
                                     /**
-                                     * Same, #const# version.
+                                     * Same, @p{const} version.
                                      */
     const Section* get_present_changed_subsection () const;
 
@@ -886,9 +886,9 @@ class ParameterHandler
 
 
 /**
- *   The class #MultipleParameterLoop# offers an easy possibility to test several
+ *   The class @p{MultipleParameterLoop} offers an easy possibility to test several
  *   parameter sets during one run of the program. For this it uses the
- *   #ParameterHandler# class to read in data in a standardized form, searches for
+ *   @p{ParameterHandler} class to read in data in a standardized form, searches for
  *   variant entry values and performs a loop over all combinations of parameters.
  *
  *   Variant entry values are given like this:
@@ -896,7 +896,7 @@ class ParameterHandler
  *     set Time step size = { 0.1 | 0.2 | 0.3 }
  *   \end{verbatim}
  *   The loop will then perform three runs of the program, one for each value
- *   of #Time step size#, while all other parameters are as specified or with their
+ *   of @p{Time step size}, while all other parameters are as specified or with their
  *   default value. If there are several variant entry values in the input a loop is
  *   performed for each combination of variant values:
  *   \begin{verbatim}
@@ -911,10 +911,10 @@ class ParameterHandler
  *     set Output file = ofile.{{ 1 | 2 | 3 | 4 }}
  *   \end{verbatim}
  *   This indicates that if there are variant entries producing a total of four
- *   different runs will write their results to the files #ofile.1#, #ofile.2#,
- *   #ofile.3# and #ofile.4#, respectively. Array entries do not generate multiple
+ *   different runs will write their results to the files @p{ofile.1}, @p{ofile.2},
+ *   @p{ofile.3} and @p{ofile.4}, respectively. Array entries do not generate multiple
  *   runs of the main loop themselves, but if there are variant entries, then in
- *   the #n#th run of the main loop, also the #n#th value of an array is returned.
+ *   the @p{n}th run of the main loop, also the @p{n}th value of an array is returned.
  *
  *   Since the different variants are constructed in the order of declaration, not in
  *   the order in which the variat entries appear in the input file, it may be
@@ -930,13 +930,13 @@ class ParameterHandler
  *   program.
  *
  *   
- *   \subsection{Usage}
+ *   @sect3{Usage}
  *   
- *   The usage of this class is similar to the #ParameterHandler# class. First the
+ *   The usage of this class is similar to the @p{ParameterHandler} class. First the
  *   entries and subsections have to be declared, then a loop is performed in which
  *   the different parameter sets are set, a new instance of a user class is created
  *   which is then called. Taking the classes of the example for the
- *   #ParameterHandler# class, the extended program would look like this:
+ *   @p{ParameterHandler} class, the extended program would look like this:
  *   \begin{verbatim}
  *     class HelperClass : public MultipleParameterLoop::UserClass {
  *       public:
@@ -987,23 +987,23 @@ class ParameterHandler
  *         
  *   As can be seen, first a new helper class has to be set up. This must contain
  *   a virtual constructor for a problem class. You can also derive your problem
- *   class from #MultipleParameterLoop::UserClass# and let #create_new# clear all
+ *   class from @p{MultipleParameterLoop::UserClass} and let @p{create_new} clear all
  *   member variables. If you have access to all inherited member variables in
  *   some way this is the recommended procedure. A third possibility is to use
  *   multiple inheritance and derive a helper class from both the
- *   #MultipleParameterLoop::UserClass# and the problem class. In any case,
- *   #create_new# has to provide a clean problem object which is the problem in
+ *   @p{MultipleParameterLoop::UserClass} and the problem class. In any case,
+ *   @p{create_new} has to provide a clean problem object which is the problem in
  *   the second and third possibility. However, if possible, the second way should
  *   be chosen.
  *
  *   The derived class also
  *   has to provide for member functions which declare the entries and which run
  *   the program. Running the program includes getting the parameters out of the
- *   #ParameterHandler# object.
+ *   @p{ParameterHandler} object.
  *
  *   After defining an object of this helper class and an object of the
- *   #MultipleParameterLoop# class, the entries have to be declared in the same way
- *   as for the #ParameterHandler# class. Then the input has to be read. Finally
+ *   @p{MultipleParameterLoop} class, the entries have to be declared in the same way
+ *   as for the @p{ParameterHandler} class. Then the input has to be read. Finally
  *   the loop is called. This executes the following steps:
  *   \begin{verbatim}
  *     for each combination
@@ -1015,27 +1015,27 @@ class ParameterHandler
  *         UserObject.run (*this);
  *       };
  *   \end{verbatim}
- *   #UserObject# is the parameter to the #loop# function. #create_new# is given the number
+ *   @p{UserObject} is the parameter to the @p{loop} function. @p{create_new} is given the number
  *   of the run (starting from one) to enable naming output files differently for each
  *   run.
  *
  *   
- *   \subsection{Syntax for variant and array entry values}
+ *   @sect3{Syntax for variant and array entry values}
  *   
- *   Variant values are specified like #prefix{ v1 | v2 | v3 | ... }postfix#. Whitespace
- *   to the right of the opening brace #{# is ignored as well as to the left of the
- *   closing brace #}# while whitespace on the respectively other side is not ignored.
- *   Whitespace around the mid symbols #|# is also ignored. The empty selection
- *   #prefix{ v1 | }postfix# is also allowed and produces the strings #prefixv1postfix# and
- *   #prefixpostfix#.
+ *   Variant values are specified like @p{prefix{ v1 | v2 | v3 | ... }postfix}. Whitespace
+ *   to the right of the opening brace @p{{} is ignored as well as to the left of the
+ *   closing brace @p{}} while whitespace on the respectively other side is not ignored.
+ *   Whitespace around the mid symbols @p{|} is also ignored. The empty selection
+ *   @p{prefix{ v1 | }postfix} is also allowed and produces the strings @p{prefixv1postfix} and
+ *   @p{prefixpostfix}.
  *
  *   The syntax for array values is equal, apart from the double braces:
- *   #prefix{{ v1 | v2 | v3 }}postfix#.
+ *   @p{prefix{{ v1 | v2 | v3 }}postfix}.
  *   
  *
- *   \subsection{Worked example}
+ *   @sect3{Worked example}
  *   
- *   Given the above extensions to the example program for the #ParameterHandler# and the
+ *   Given the above extensions to the example program for the @p{ParameterHandler} and the
  *   following input file
  *   \begin{verbatim}
  *     set Equation 1 = Poisson
@@ -1091,12 +1091,12 @@ class ParameterHandler
  *              eq1=Poisson, eq2=Navier-Stokes
  *              Matrix1=Sparse, Matrix2=Full
  *   \end{verbatim}
- *   Since #create_new# gets the number of the run it would also be possible to output
+ *   Since @p{create_new} gets the number of the run it would also be possible to output
  *   the number of the run.
  *   
  *   
- *   \subsection{References}
- *   This class is inspired by the #Multipleloop# class of #DiffPack#.
+ *   @sect3{References}
+ *   This class is inspired by the @p{Multipleloop} class of @p{DiffPack}.
  *
  *   @memo  This class provides an interface to an input file which provides at
  *   run-time for multiple program parameters sets. The class performs a loop over
@@ -1115,7 +1115,7 @@ class MultipleParameterLoop : public ParameterHandler {
     class UserClass {
       public:
                                         /**
-                                         * #create_new# must provide a clean
+                                         * @p{create_new} must provide a clean
                                          * object, either by creating a new one
                                          * or by cleaning an old one.
                                          */
@@ -1123,7 +1123,7 @@ class MultipleParameterLoop : public ParameterHandler {
        
                                         /**
                                          * This should declare parameters and call
-                                         * the #declare_parameters# function of the
+                                         * the @p{declare_parameters} function of the
                                          * problem class.
                                          */
        virtual void declare_parameters (ParameterHandler &prm) = 0;
@@ -1150,7 +1150,7 @@ class MultipleParameterLoop : public ParameterHandler {
 
                                     /**
                                      * Read input from a stream until stream
-                                     * returns #eof# condition or error.
+                                     * returns @p{eof} condition or error.
                                      */
     virtual bool read_input (istream &Input);
     
@@ -1163,7 +1163,7 @@ class MultipleParameterLoop : public ParameterHandler {
                                     /**
                                      * Read input from a string in memory. The
                                      *  lines in memory have to be separated by
-                                     *  #\n# characters.
+                                     *  @p{\n} characters.
                                      */
     virtual bool read_input_from_string (const char *s);
 
@@ -1175,8 +1175,8 @@ class MultipleParameterLoop : public ParameterHandler {
   private:
                                     /**
                                      * Declare what a multiple entry is: a variant
-                                     * entry (in curly braces #{}#) or an
-                                     * array (in double curly braces #{{}}#).
+                                     * entry (in curly braces @p{{}}) or an
+                                     * array (in double curly braces @p{{{}}}).
                                      */
     enum MultipleEntryType {
          variant, array
@@ -1197,7 +1197,7 @@ class MultipleParameterLoop : public ParameterHandler {
                                          * Construct an object with given subsection
                                          * path, name and value. The splitting up
                                          * into the different variants is done
-                                         * later by #split_different_values#.
+                                         * later by @p{split_different_values}.
                                          */
        Entry (const vector<string> &Path, const string &Name, const string &Value);
 
@@ -1225,7 +1225,7 @@ class MultipleParameterLoop : public ParameterHandler {
                                         /**
                                          * List of entry values constructed out of
                                          * what was given in the input file (that
-                                         * is stored in #EntryValue#.
+                                         * is stored in @p{EntryValue}.
                                          */
        vector<string> different_values;
 
index 309a43e919f14c82cb192abc2a3c5851c85bfe13..a5f09cba674fb6e53c74fc1242f8bed449060a38 100644 (file)
 
 
 /**
- * The #Point# class provides for a point or vector in a space with arbitrary
- * dimension #dim#.
+ * The @p{Point} class provides for a point or vector in a space with arbitrary
+ * dimension @p{dim}.
  *
  * It is the preferred object to be passed to functions which
  * operate on points in spaces of a priori unknown dimension: rather than
- * using functions like #double f(double x)# and #double f(double x, double y)#,
- * you use double #f(Point<dim> &p)#.
+ * using functions like @p{double f(double x)} and @p{double f(double x, double y)},
+ * you use double @p{f(Point<dim> &p)}.
  *
- * #Point# also serves as a starting point for the implementation of the
- * geometrical primitives like #Polyhedron#, #Triangle#, etc.
+ * @p{Point} also serves as a starting point for the implementation of the
+ * geometrical primitives like @p{Polyhedron}, @p{Triangle}, etc.
  *
- * #Point#s can also be thought of as vectors, i.e. points in a vector space
+ * @p{Point}s can also be thought of as vectors, i.e. points in a vector space
  * without an obvious meaning. For instance, it may be suitable to let the
- * gradient of a function be a #point# vector:
- * #Point<dim> gradient_of_f (const Point<dim> &x)#. #Point#s have all
+ * gradient of a function be a @p{point} vector:
+ * @p{Point<dim> gradient_of_f (const Point<dim> &x)}. @p{Point}s have all
  * functionality for this, e.g. scalar products, addition etc. However, you
- * should also consider using the simpler #Tensor<1,dim># class, which seems
+ * should also consider using the simpler @p{Tensor<1,dim>} class, which seems
  * more suited to gradients.
  *
  * @author Wolfgang Bangerth, 1997
@@ -46,7 +46,7 @@ class Point : public Tensor<1,dim>
   public:
                                     /**
                                      * Constructor. Initialize all entries
-                                     * to zero if #initialize==true#; this
+                                     * to zero if @p{initialize==true}; this
                                      * is the default behaviour.
                                      */
     explicit Point (const bool initialize = true);
@@ -60,56 +60,56 @@ class Point : public Tensor<1,dim>
     
                                     /**
                                      *  Constructor for one dimensional points. This
-                                     *  function is only implemented for #dim==1#
+                                     *  function is only implemented for @p{dim==1}
                                      *  since the usage is considered unsafe
-                                     *  for points with #dim!=1#.
+                                     *  for points with @p{dim!=1}.
                                      */
     explicit Point (const double x);
 
                                     /**
                                      *  Constructor for two dimensional points. This
-                                     *  function is only implemented for #dim==2#
+                                     *  function is only implemented for @p{dim==2}
                                      *  since the usage is considered unsafe
-                                     *  for points with #dim!=2#.
+                                     *  for points with @p{dim!=2}.
                                      */
     Point (const double x, const double y);
     
                                     /**
                                      *  Constructor for three dimensional points. This
-                                     *  function is only implemented for #dim==3#
+                                     *  function is only implemented for @p{dim==3}
                                      *  since the usage is considered unsafe
-                                     *  for points with #dim!=3#.
+                                     *  for points with @p{dim!=3}.
                                      */
     Point (const double x, const double y, const double z);
 
                                     /**
-                                     *  Read access to the #index#th coordinate.
+                                     *  Read access to the @p{index}th coordinate.
                                      */
     double   operator () (const unsigned int index) const;
 
                                     /**
-                                     *  Read and write access to the #index#th
+                                     *  Read and write access to the @p{index}th
                                      *  coordinate.
                                      */
     double & operator () (const unsigned int index);
 
                                     /**
                                      *  Add two point vectors. If possible, use
-                                     *  #operator +=# instead since this does not
+                                     *  @p{operator +=} instead since this does not
                                      *  need to copy a point at least once.
                                      */
     Point<dim>   operator + (const Point<dim> &) const;
 
                                     /**
                                      *  Subtract two point vectors. If possible, use
-                                     *  #operator +=# instead since this does not
+                                     *  @p{operator +=} instead since this does not
                                      *  need to copy a point at least once.
                                      */
     Point<dim>   operator - (const Point<dim> &) const;
 
                                     /**
                                      *  Multiply by a factor. If possible, use
-                                     *  #operator *=# instead since this does not
+                                     *  @p{operator *=} instead since this does not
                                      *  need to copy a point at least once.
                                      *
                                      * There is a commutative complement to this
@@ -124,7 +124,7 @@ class Point : public Tensor<1,dim>
 
                                     /**
                                      *  Divide by a factor. If possible, use
-                                     *  #operator /=# instead since this does not
+                                     *  @p{operator /=} instead since this does not
                                      *  need to copy a point at least once.
                                      */
     Point<dim>   operator / (const double) const;
index 92dc1529a3a38928d3acd0ece57787682bb2f16c..63d4bca1decbc01a816c4a5fed64077c7a9a6963 100644 (file)
@@ -24,7 +24,7 @@
  * square [0,1]x[0,1], etc.
  *
  * There are a number of derived classes, denoting concrete
- * integration formulae. Their names names prefixed by #Q#. By now,
+ * integration formulae. Their names names prefixed by @p{Q}. By now,
  * there are several Newton-Cotes formulae, @ref{QMidpoint},
  * @ref{QTrapez} and @ref{QSimpson}, as well as N-point Gauss formulae
  * @p{QGaussN}. The names refer to the one-dimensional formulae. The
  * these. Therefore, a three-dimensional @ref{QGauss5} formula has 125
  * quadrature points.
  *
- * For each quadrature formula we denote by #m#, the maximal degree of
+ * For each quadrature formula we denote by @p{m}, the maximal degree of
  * polynomials integrated exactly. This number is given in the
  * documentation of each formula. The order of the integration error
- * is #m+1#, that is, the error is the size of the cell two the #m+1#
- * by the Bramble-Hilbert Lemma. The number #m# is to be found in the
+ * is @p{m+1}, that is, the error is the size of the cell two the @p{m+1}
+ * by the Bramble-Hilbert Lemma. The number @p{m} is to be found in the
  * documentation of each concrete formula. For the optimal formulae
  * @p{QGaussN} we have $m = 2N-1$. The tensor product formulae are
- * exact on tensor product polynomials of degree #m# in each space
- * direction, but they are still only of #m+1#st order.
+ * exact on tensor product polynomials of degree @p{m} in each space
+ * direction, but they are still only of @p{m+1}st order.
  *
  * Most integration formulae in more than one space dimension are
  * tensor products of quadrature formulae in one space dimension, or
- * more generally the tensor product of a formula in #(dim-1)#
+ * more generally the tensor product of a formula in @p{(dim-1)}
  * dimensions and one in one dimension. There is a special constructor
  * to generate a quadrature formula from two others.  For example, the
- * #QGauss2<dim># formulae includes $2^dim$ quadrature points in #dim#
+ * @p{QGauss2<dim>} formulae includes $2^dim$ quadrature points in @p{dim}
  * dimensions but is still exact for polynomials of degree 3 and its
  * order of integration is 4.
  *
  * faces.  These programs fail to link if compiled for only one space
  * dimension, since there quadrature rules for faces just don't make
  * no sense. In order to allow these programs to be linked anyway, for
- * class #Quadrature<0># all functions are provided in the
- * #quadrature.cc# file, but they will throw exceptions if actually
+ * class @p{Quadrature<0>} all functions are provided in the
+ * @p{quadrature.cc} file, but they will throw exceptions if actually
  * called. The only function which is allowed to be called is the
  * constructor taking one integer, which in this case ignores its
  * parameter, and of course the destructor. Besides this, it is
- * necessary to provide a class #Point<0># to make the compiler
+ * necessary to provide a class @p{Point<0>} to make the compiler
  * happy. This class also does nothing.
  *
  * @author Wolfgang Bangerth, 1998, 1999, 2000
@@ -100,7 +100,7 @@ class Quadrature
     virtual ~Quadrature ();
     
                                     /**
-                                     * Return the #i#th quadrature point.
+                                     * Return the @p{i}th quadrature point.
                                      */
     const Point<dim> & point (const unsigned int i) const;
 
@@ -111,7 +111,7 @@ class Quadrature
     const vector<Point<dim> > & get_points () const;
     
                                     /**
-                                     * Return the weight of the #i#th
+                                     * Return the weight of the @p{i}th
                                      * quadrature point.
                                      */
     double weight (const unsigned int i) const;
@@ -145,16 +145,16 @@ class Quadrature
  * the respective iterated quadrature formula in one space dimension.
  *
  * In one space dimension, the given base formula is copied and scaled onto
- * a given number of subintervals of length #1/n_copies#. If the quadrature
+ * a given number of subintervals of length @p{1/n_copies}. If the quadrature
  * formula uses both end points of the unit interval, then in the interior
  * of the iterated quadrature formula there would be quadrature points which
  * are used twice; we merge them into one with a weight which is the sum
  * of the weights of the left- and the rightmost quadrature point.
  *
  * Since all dimensions higher than one are built up by tensor products of
- * one dimensional and #dim-1# dimensional quadrature formulae, the
+ * one dimensional and @p{dim-1} dimensional quadrature formulae, the
  * argument given to the constructor needs to be a quadrature formula in
- * one space dimension, rather than in #dim# dimensions.
+ * one space dimension, rather than in @p{dim} dimensions.
  *
  * The aim of this class is to provide a
  * low order formula, where the error constant can be tuned by
@@ -169,7 +169,7 @@ class QIterated : public Quadrature<dim>
   public:
                                     /**
                                      * Constructor. Iterate the given
-                                     * quadrature formula #n_copies# times in
+                                     * quadrature formula @p{n_copies} times in
                                      * each direction.
                                      */
     QIterated (const Quadrature<1> &base_quadrature,
@@ -201,7 +201,7 @@ class QIterated : public Quadrature<dim>
  *  points on the unit cell from a quadrature object for a mannifold of
  *  one dimension less than that of the cell and the number of the face.
  *  For example, giving the Simpson rule in one dimension and using the
- *  #project_to_face# function with face number 1, the returned points will
+ *  @p{project_to_face} function with face number 1, the returned points will
  *  be $(1,0)$, $(1,0.5)$ and $(1,1)$. Note that faces have an orientation,
  *  so when projecting to face 3, you will get $(0,0)$, $(0,0.5)$ and $(0,1)$,
  *  which is in clockwise sense, while for face 1 the points were in
@@ -216,13 +216,13 @@ class QIterated : public Quadrature<dim>
  *  them into global namespace (and to make documentation easier, since
  *  presently the documentation tool can only handle classes, not global
  *  functions). However, since they have no local data, all functions are
- *  declared #static# and can be called without creating an object of this
+ *  declared @p{static} and can be called without creating an object of this
  *  class.
  *
  *  For the 3d case, you should note that the orientation of faces is even
  *  more intricate than for two dimensions. Quadrature formulae are projected
  *  upon the faces in their standard orientation, not to the inside or outside
- *  of the hexahedron! Refer to the documentation of the #Triangulation# class
+ *  of the hexahedron! Refer to the documentation of the @p{Triangulation} class
  *  for a description of the orientation of the different faces.
  */
 template <int dim>
@@ -232,7 +232,7 @@ class QProjector
                                     /**
                                      * Compute the quadrature points on the
                                      * cell if the given quadrature formula
-                                     * is used on face #face_no#. For further
+                                     * is used on face @p{face_no}. For further
                                      * details, see the general doc for
                                      * this class.
                                      */
@@ -251,8 +251,8 @@ class QProjector
                                     /**
                                      * Compute the quadrature points on the
                                      * cell if the given quadrature formula
-                                     * is used on face #face_no#, subface
-                                     * number #subface_no#. For further
+                                     * is used on face @p{face_no}, subface
+                                     * number @p{subface_no}. For further
                                      * details, see the general doc for
                                      * this class.
                                      */
index ff1fdc638349de8628c9c31602e5dc6eca0e5fc0..4f2a5d68e5b16673c3b3ea84c9720042eee0cdb5 100644 (file)
 
 /**
  * Smart pointers avoid destruction of an object in use. They can be used just
- * like a pointer (i.e. using the #*# and #-># operators and through casting)
+ * like a pointer (i.e. using the @p{*} and @p{->} operators and through casting)
  * but make sure that the object pointed to is not deleted in the course of
  * use of the pointer by signalling the pointee its use.
  *
- * Objects pointed to should inherit #Subscriptor# or must implement
+ * Objects pointed to should inherit @p{Subscriptor} or must implement
  * the same functionality. Null pointers are an exception from this
  * rule and are allowed, too.
  *
- * #SmartPointer# does NOT implement any memory handling! Especially,
- * deleting a #SmartPointer# does not delete the object. Writing
+ * @p{SmartPointer} does NOT implement any memory handling! Especially,
+ * deleting a @p{SmartPointer} does not delete the object. Writing
  * \begin{verbatim}
  * SmartPointer<T> t = new T;
  * \end{verbatim}
  * delete p;
  * \end{verbatim}
  *
- * Note that a smart pointer can handle #const#ness of an object, i.e.
- * a #SmartPointer<const ABC># really behaves as if it were a pointer to
+ * Note that a smart pointer can handle @p{const}ness of an object, i.e.
+ * a @p{SmartPointer<const ABC>} really behaves as if it were a pointer to
  * a constant object (disallowing write access when dereferenced), while
- * #SmartPointer<ABC># is a mutable pointer.
+ * @p{SmartPointer<ABC>} is a mutable pointer.
  */
 template<typename T>
 class SmartPointer
@@ -59,8 +59,8 @@ class SmartPointer
 
                                     /*
                                      * Copy constructor for
-                                     * #SmartPointer#. We copy the object
-                                     * subscribed to from #tt#, but subscribe
+                                     * @p{SmartPointer}. We copy the object
+                                     * subscribed to from @p{tt}, but subscribe
                                      * ourselves to it again.
                                      */
     SmartPointer (const SmartPointer<T> &tt);
@@ -95,7 +95,7 @@ class SmartPointer
 
                                     /**
                                      *Assignment operator for
-                                     * #SmartPointer#.  The pointer
+                                     * @p{SmartPointer}.  The pointer
                                      * subscribes to the new object
                                      * automatically and unsubscribes
                                      * to an old one if it exists.
index 2a799718bcafe704f55f03ece0548f761533b256..5e2a8295495afbd972d55d5058f86c83512344f1 100644 (file)
@@ -27,8 +27,8 @@
  * constructor by reference, is stored. Then, the original object may
  * not be deleted before the dependent object is deleted. You can assert
  * this constraint by letting the object passed be derived from this class
- * and let the user #subscribe# to this object. The destructor the used
- * object inherits from the #Subscriptor# class then will lead to an error
+ * and let the user @p{subscribe} to this object. The destructor the used
+ * object inherits from the @p{Subscriptor} class then will lead to an error
  * when destruction is attempted while there are still subscriptions.
  */
 class Subscriptor
@@ -61,7 +61,7 @@ class Subscriptor
                                      * care, too, because the counter
                                      * has to remain the same. It therefore
                                      * does nothing more than returning
-                                     * #*this#.
+                                     * @p{*this}.
                                      */
     Subscriptor& operator = (const Subscriptor&);
         
@@ -98,7 +98,7 @@ class Subscriptor
 
                                     /**
                                      * Exception: object should be used
-                                     * when #unsubscribe# is called.
+                                     * when @p{unsubscribe} is called.
                                      */
     DeclException0(ExcNotUsed);
 
@@ -115,7 +115,7 @@ class Subscriptor
                                      * The creator (and owner) of an object
                                      * is not counted.
                                      *
-                                     * We use the #mutable# keyword in order
+                                     * We use the @p{mutable} keyword in order
                                      * to allow subscription to constant
                                      * objects also.
                                      */
index fb62247815f1709058777ce0a62cc48d50143daa..481e3c4ee85c10bdb746847c148577fac215b86b 100644 (file)
@@ -25,7 +25,7 @@
 
 
 /**
- * Abstract base class for the #TableEntry# class. See there.
+ * Abstract base class for the @p{TableEntry} class. See there.
  * This class is not to be used by the user.
  *
  * @author Ralf Hartmann, 1999
@@ -55,13 +55,13 @@ class TableEntryBase
 
 
 /**
- * A #TableEntry# stores the value of a table entry.
+ * A @p{TableEntry} stores the value of a table entry.
  * The value type of this table entry is arbitrary. For
- * a #TableEntry<typename value_type># with a non-common value
+ * a @p{TableEntry<typename value_type>} with a non-common value
  * type you may want to specialize the output functions in order
  * to get nicer output. This class is not to be used by the user.
  *
- * For more detail see the #TableHandler# class.
+ * For more detail see the @p{TableHandler} class.
  *
  * @author Ralf Hartmann, 1999
  */
@@ -104,33 +104,33 @@ class TableEntry : public TableEntryBase
 
 
 /**
- * The #TableHandler# stores #TableEntries# of arbitrary value type and 
+ * The @p{TableHandler} stores @p{TableEntries} of arbitrary value type and 
  * writes the table as text or in tex format to an output stream. The value
  * type actually may vary from column to column and from row to row. 
  *
- * \subsection{Usage}
+ * @sect3{Usage}
  *
  * The most important function is the templatized function 
- * #add_value(const string &key, const value_type value)#, that adds a column
- * with the name #key# to the table if this column does not yet exist and adds the 
- * value of #value_type# (e.g. #unsigned int#, #double#, #string#, ...) to this column.
+ * @p{add_value(const string &key, const value_type value)}, that adds a column
+ * with the name @p{key} to the table if this column does not yet exist and adds the 
+ * value of @p{value_type} (e.g. @p{unsigned int}, @p{double}, @p{string}, ...) to this column.
  * After the table is complete there are different possibilities of output, e.g.
- * into a tex file with #write_tex(ofstream &file)# or as text with 
- * #write_text (ostream &out)#
+ * into a tex file with @p{write_tex(ofstream &file)} or as text with 
+ * @p{write_text (ostream &out)}
  *
  * Two (or more) columns may be merged into a "supercolumn" by twice
- * (or multiple) calling #add_column_to_supercolumn(...)#, see
+ * (or multiple) calling @p{add_column_to_supercolumn(...)}, see
  * there. Additionally there is a function to set for each column the
  * precision of the output of numbers, and there are several functions
  * to prescribe the format and the captions the columns are written
  * with in tex mode.
  *
- * \subsection{Example}
+ * @sect3{Example}
  * This is a simple example demonstrating the usage of this class. The first column
- * includes the numbers #i=1..n#, the second $1^2$...$n^2$, the third $sqrt(1)...sqrt(n)$,
+ * includes the numbers @p{i=1..n}, the second $1^2$...$n^2$, the third $sqrt(1)...sqrt(n)$,
  * where the second and third columns are merged into one supercolumn 
- * with the superkey #squares and roots#. Additionally the first column is
- * aligned to the right (the default was #centered#) and the precision of
+ * with the superkey @p{squares and roots}. Additionally the first column is
+ * aligned to the right (the default was @p{centered}) and the precision of
  * the square roots are set to be 6 (instead of 4 as default).
  *
  * \begin{verbatim}
@@ -169,8 +169,8 @@ class TableHandler
     
                                     /**
                                      * Adds a column (if not yet existent) with
-                                     * the key #key#
-                                     * and adds the value of #value_type#
+                                     * the key @p{key}
+                                     * and adds the value of @p{value_type}
                                      * to the column.
                                      */
     template <typename value_type>
@@ -181,11 +181,11 @@ class TableHandler
                                      * Creates a sypercolumn (if not yet
                                      * existent) and includes column to it.
                                      * The keys of the column and the supercolumn
-                                     * are #key# and #superkey#, respectively.
-                                     * To merge two columns #c1# and #c2# to
-                                     * a supercolumn #sc# hence call
-                                     * #add_column_to_supercolumn(c1,sc)# and
-                                     * #add_column_to_supercolumn(c2,sc)#.
+                                     * are @p{key} and @p{superkey}, respectively.
+                                     * To merge two columns @p{c1} and @p{c2} to
+                                     * a supercolumn @p{sc} hence call
+                                     * @p{add_column_to_supercolumn(c1,sc)} and
+                                     * @p{add_column_to_supercolumn(c2,sc)}.
                                      *
                                      * Concerning the order of the columns,
                                      * the supercolumn replaces the first
@@ -201,7 +201,7 @@ class TableHandler
                                      * Change the order of columns and
                                      * supercolumns in the table.
                                      *
-                                     * #new_order# includes the keys and
+                                     * @p{new_order} includes the keys and
                                      * superkeys of the columns and
                                      * supercolumns in the order the user like to.
                                      * If a superkey is included the keys
@@ -215,24 +215,24 @@ class TableHandler
                                      * This function may also be used to break
                                      * big tables with to many columns into smaller
                                      * ones. Call this function with
-                                     * the first e.g. five columns and then #write_*#.
+                                     * the first e.g. five columns and then @p{write_*}.
                                      * Afterwards call this function with the 
-                                     * next e.g. five columns and again #write_*#,
+                                     * next e.g. five columns and again @p{write_*},
                                      * and so on.
                                      */
     void set_column_order (const vector<string> &new_order);
     
                                     /**
-                                     * Sets the #precision# e.g. double or float
-                                     * variables are written with. #precision# is
+                                     * Sets the @p{precision} e.g. double or float
+                                     * variables are written with. @p{precision} is
                                      * the same as in calling
-                                     * #out << setprecision(precision)#.
+                                     * @p{out << setprecision(precision)}.
                                      */
     void set_precision (const string &key,
                        const unsigned int precision);
 
                                     /**
-                                     * Sets the #scientific_flag#. True means
+                                     * Sets the @p{scientific_flag}. True means
                                      * scientific, false means fixed point
                                      * notation.
                                      */
@@ -240,9 +240,9 @@ class TableHandler
                         bool scientific);
 
                                     /**
-                                     * Sets the caption of the column #key#
+                                     * Sets the caption of the column @p{key}
                                      * for tex output. You may want to chose
-                                     * this different from #key#, if it 
+                                     * this different from @p{key}, if it 
                                      * contains formulas or similar constructs.
                                      */
     void set_tex_caption (const string &key,
@@ -250,8 +250,8 @@ class TableHandler
 
                                     /**
                                      * Sets the caption the the supercolumn
-                                     * #superkey# for tex output. You may want
-                                     * to chose this different from #superkey#,
+                                     * @p{superkey} for tex output. You may want
+                                     * to chose this different from @p{superkey},
                                      * if it contains formulas or similar
                                      * constructs.
                                      */
@@ -260,10 +260,10 @@ class TableHandler
 
                                     /**
                                      * Sets the tex output format of a column.
-                                     * e.g. #c#, #r#, #l#, or #p{3cm}#. The
-                                     * default is #c#. Also if this function
+                                     * e.g. @p{c}, @p{r}, @p{l}, or @p{p{3cm}}. The
+                                     * default is @p{c}. Also if this function
                                      * is not called for a column, the default
-                                     * is preset to be #c#.
+                                     * is preset to be @p{c}.
                                      */
     void set_tex_format (const string &key,
                         const string &format="c");
@@ -343,30 +343,30 @@ class TableHandler
                                          * List of entries within this column.
                                          * They may actually be of very 
                                          * different type, since we use the
-                                         * templated #TableEntry<T># class
+                                         * templated @p{TableEntry<T>} class
                                          * for actual values, which is only
-                                         * a wrapper for #T#, but is derived
-                                         * from #TableEntryBase#.
+                                         * a wrapper for @p{T}, but is derived
+                                         * from @p{TableEntryBase}.
                                          */
        vector<TableEntryBase *> entries;
        
                                         /**
                                          * The caption of the column in tex output.
                                          * By default, this is the key string that
-                                         * is given to the #TableHandler# by
-                                         * #TableHandler::add_value(...)#. This may
+                                         * is given to the @p{TableHandler} by
+                                         * @p{TableHandler::add_value(...)}. This may
                                          * be changed by calling
-                                         * #TableHandler::set_tex_caption(...)#.
+                                         * @p{TableHandler::set_tex_caption(...)}.
                                          */
        string tex_caption;
 
                                         /**
                                          * The column format in tex output.
-                                         * By default, this is #"c"#, meaning
+                                         * By default, this is @p{"c"}, meaning
                                          * `centered'. This may
                                          * be changed by calling
-                                         * #TableHandler::set_tex_format(...)#
-                                         * with #"c", "r", "l"# for centered,
+                                         * @p{TableHandler::set_tex_format(...)}
+                                         * with @p{"c", "r", "l"} for centered,
                                          * right or left.
                                          */
        
@@ -380,7 +380,7 @@ class TableHandler
        unsigned int precision;
 
                                         /**
-                                         * #scientific#=false means fixed
+                                         * @p{scientific}=false means fixed
                                          * point notation.
                                          */
        bool scientific;
@@ -395,12 +395,12 @@ class TableHandler
                                     /**
                                      * Help function that gives a vector of
                                      * the keys of all columns that are mentioned
-                                     * in #column_order#, where each supercolumn key
+                                     * in @p{column_order}, where each supercolumn key
                                      * is replaced by its subcolumn keys.
                                      *
                                      * This function implicitly checks the
                                      * consistency of the data. The result is
-                                     * returned in #sel_columns#.
+                                     * returned in @p{sel_columns}.
                                      */
     void get_selected_columns (vector<string> &sel_columns) const;
     
@@ -420,7 +420,7 @@ class TableHandler
                                      * by the user.
                                      * By default this is the order of
                                      * adding the columns. This order may be
-                                     * changed by #set_column_order(...)#.
+                                     * changed by @p{set_column_order(...)}.
                                      */
     vector<string> column_order;
 
@@ -436,7 +436,7 @@ class TableHandler
                                      * It is allowed that a supercolumn has got
                                      * the same key as a column.
                                      *
-                                     * Note that we do not use a #multimap#
+                                     * Note that we do not use a @p{multimap}
                                      * here since the order of column
                                      * keys for each supercolumn key is
                                      * relevant.
@@ -450,7 +450,7 @@ class TableHandler
                                      *
                                      * By default these are just the
                                      * supercolumn keys but they may be changed
-                                     * by #set_tex_supercaptions(...)#.
+                                     * by @p{set_tex_supercaptions(...)}.
                                      */
     map<string, string> tex_supercaptions;
 };
index 83ddcba199f1421b5a053c79ff51628ad7e15e20..7541b23d55dde9c270921dbb65f87dc171fb4478 100644 (file)
@@ -23,7 +23,7 @@ template <int rank_, int dim> class Tensor;
  * an arbitrary number of indices. The Tensor class provides an
  * indexing operator and a bit of infrastructure, but most
  * functionality is recursively handed down to tensors of rank 1 or
- * put into external templated functions, e.g. the #contract# family.
+ * put into external templated functions, e.g. the @p{contract} family.
  *
  * Using this tensor class for objects of rank 2 has advantages over
  * matrices in many cases since the dimension is known to the compiler
@@ -41,7 +41,7 @@ class Tensor
                                      * explicit knowledge of it's
                                      * data type. Implementation is
                                      * this way instead of providing
-                                     * a function #dimension()#
+                                     * a function @p{dimension()}
                                      * because now it is possible to
                                      * get the dimension at compile
                                      * time without the expansion and
@@ -116,26 +116,26 @@ class Tensor
     Tensor<rank_,dim> & operator -= (const Tensor<rank_,dim> &);
 
                                     /**
-                                     *  Scale the tensor by #factor#, i.e. multiply
-                                     *  all coordinates by #factor#.
+                                     *  Scale the tensor by @p{factor}, i.e. multiply
+                                     *  all coordinates by @p{factor}.
                                      */
     Tensor<rank_,dim> & operator *= (const double &factor);
 
                                     /**
-                                     *  Scale the vector by #1/factor#.
+                                     *  Scale the vector by @p{1/factor}.
                                      */
     Tensor<rank_,dim> & operator /= (const double &factor);
 
                                     /**
                                      *  Add two tensors. If possible, use
-                                     *  #operator +=# instead since this does not
+                                     *  @p{operator +=} instead since this does not
                                      *  need to copy a point at least once.
                                      */
     Tensor<rank_,dim>   operator + (const Tensor<rank_,dim> &) const;
 
                                     /**
                                      *  Subtract two tensors. If possible, use
-                                     *  #operator +=# instead since this does not
+                                     *  @p{operator +=} instead since this does not
                                      *  need to copy a point at least once.
                                      */
     Tensor<rank_,dim>   operator - (const Tensor<rank_,dim> &) const;
@@ -364,7 +364,7 @@ DeclException1 (ExcInvalidTensorIndex,
 
 /**
  * Contract a tensor of rank 2 with a tensor of rank 1. The result is
- * #dest[i] = sum_j src1[i][j] src2[j]#.
+ * @p{dest[i] = sum_j src1[i][j] src2[j]}.
  *
  * @author Wolfgang Bangerth, 1998
  */
@@ -384,7 +384,7 @@ void contract (Tensor<1,dim>       &dest,
 
 /**
  * Contract a tensor of rank 2 with a tensor of rank 2. The result is
- * #dest[i][k] = sum_j src1[i][j] src2[j][k]#.
+ * @p{dest[i][k] = sum_j src1[i][j] src2[j][k]}.
  *
  * @author Wolfgang Bangerth, 1998
  */
@@ -405,11 +405,11 @@ void contract (Tensor<2,dim>       &dest,
 
 /**
  * Contract a tensor of rank 2 with a tensor of rank 2. The
- * contraction is performed over index #index1# of the first tensor,
- * and #index2# of the second tensor. Thus, if #index1==2#,
- * #index2==1#, the result is the usual contraction, but if for
- * example #index1==1#, #index2==2#, then the result is
- * #dest[i][k] = sum_j src1[j][i] src2[k][j]#.
+ * contraction is performed over index @p{index1} of the first tensor,
+ * and @p{index2} of the second tensor. Thus, if @p{index1==2},
+ * @p{index2==1}, the result is the usual contraction, but if for
+ * example @p{index1==1}, @p{index2==2}, then the result is
+ * @p{dest[i][k] = sum_j src1[j][i] src2[k][j]}.
  *
  * Note that the number of the index is counted from 1 on, not from
  * zero as usual.
@@ -476,7 +476,7 @@ void contract (Tensor<2,dim>       &dest,
 
 /**
  * Contract a tensor of rank 3 with a tensor of rank 1. The
- * contraction is performed over index #index1# of the first
+ * contraction is performed over index @p{index1} of the first
  * tensor.
  *
  * Note that the number of the index is counted from 1 on, not from
@@ -524,7 +524,7 @@ void contract (Tensor<2,dim>       &dest,
 
 /**
  * Contract a tensor of rank 3 with a tensor of rank 2. The result is
- * #dest[i][j][l] = sum_k src1[i][j][k] src2[k][l]#.
+ * @p{dest[i][j][l] = sum_k src1[i][j][k] src2[k][l]}.
  *
  * @author Wolfgang Bangerth, 1998
  */
@@ -546,7 +546,7 @@ void contract (Tensor<3,dim>       &dest,
 
 /**
  * Contract a tensor of rank 2 with a tensor of rank 3. The result is
- * #dest[i][j][l] = sum_k src1[i][k] src2[k][j][l]#.
+ * @p{dest[i][j][l] = sum_k src1[i][k] src2[k][j][l]}.
  *
  * @author Wolfgang Bangerth, 1998
  */
@@ -567,7 +567,7 @@ void contract (Tensor<3,dim>       &dest,
 
 /**
  * Contract a tensor of rank 3 with a tensor of rank 3. The result is
- * #dest[i][j][k][l] = sum_m src1[i][j][m] src2[m][k][l]#.
+ * @p{dest[i][j][k][l] = sum_m src1[i][j][m] src2[m][k][l]}.
  *
  * @author Wolfgang Bangerth, 1998
  */
@@ -603,7 +603,7 @@ double determinant (const Tensor<rank,1> &t)
                                   // can be computed by recursion. we
                                   // need therefore not try to access
                                   // the number itself, which is
-                                  // difficult since it needs #rank#
+                                  // difficult since it needs @p{rank}
                                   // indirections, which is not
                                   // computable in the general
                                   // template
@@ -628,7 +628,7 @@ double determinant (const Tensor<1,1> &t)
 
 
 /**
- * Compute the determinant of a tensor or rank 2, here for #dim==2#.
+ * Compute the determinant of a tensor or rank 2, here for @p{dim==2}.
  *
  * @author Wolfgang Bangerth, 1998
  */
@@ -643,7 +643,7 @@ double determinant (const Tensor<2,2> &t)
 
 
 /**
- * Compute the determinant of a tensor or rank 2, here for #dim==3#.
+ * Compute the determinant of a tensor or rank 2, here for @p{dim==3}.
  *
  * @author Wolfgang Bangerth, 1998
  */
index 934fcd98b5bc36bf7691b51f317a2d4c67e095c7..d34c4f3f5a0a069a30772090646ececc07e0714f 100644 (file)
@@ -32,11 +32,11 @@ template <int rank, int dim> class Tensor;
 
 
 /**
- * This class is a specialized version of the #Tensor<rank,dim># class.
+ * This class is a specialized version of the @p{Tensor<rank,dim>} class.
  * It handles tensors with one index, i.e. vectors, of fixed dimension
  * and offers the functionality needed for tensors of higher rank.
  *
- * In many cases, you will want to use the more specialized #Point# class
+ * In many cases, you will want to use the more specialized @p{Point} class
  * which acts as a tensor of rank one but has more functionality.
  */
 template <int dim>
@@ -48,7 +48,7 @@ class Tensor<1,dim> {
                                      * explicit knowledge of it's
                                      * data type. Implementation is
                                      * this way instead of providing
-                                     * a function #dimension()#
+                                     * a function @p{dimension()}
                                      * because now it is possible to
                                      * get the dimension at compile
                                      * time without the expansion and
@@ -70,7 +70,7 @@ class Tensor<1,dim> {
 #if (__GNUC__==2) && (__GNUC_MINOR__ < 95)  
                                     /**
                                      * Unnecessary variable, only used in
-                                     * the declaration of #array_type#.
+                                     * the declaration of @p{array_type}.
                                      * This variable should be omitted,
                                      * but egcs1.1.2 chokes on that so
                                      * we need it presently.
@@ -82,8 +82,8 @@ class Tensor<1,dim> {
                                      * be used to initialize statically
                                      * an object of this type.
                                      *
-                                     * Use the same condition for #dim==0#
-                                     * as in the #TensorBase<1,dim># class.
+                                     * Use the same condition for @p{dim==0}
+                                     * as in the @p{TensorBase<1,dim>} class.
                                      */
     typedef double array_type[array_size];
 #else
@@ -93,15 +93,15 @@ class Tensor<1,dim> {
                                      * be used to initialize statically
                                      * an object of this type.
                                      *
-                                     * Use the same condition for #dim==0#
-                                     * as in the #TensorBase<1,dim># class.
+                                     * Use the same condition for @p{dim==0}
+                                     * as in the @p{TensorBase<1,dim>} class.
                                      */
     typedef double array_type[(dim!=0) ? dim : 1];
 #endif
     
                                     /**
                                      * Constructor. Initialize all entries
-                                     * to zero if #initialize==true#; this
+                                     * to zero if @p{initialize==true}; this
                                      * is the default behaviour.
                                      */
     explicit Tensor (const bool initialize = true);
@@ -118,20 +118,20 @@ class Tensor<1,dim> {
     Tensor (const Tensor<1,dim> &);
 
                                     /**
-                                     *  Read access to the #index#th coordinate.
+                                     *  Read access to the @p{index}th coordinate.
                                      *
-                                     * Note that the derived #Point# class also
-                                     * provides access through the #()#
+                                     * Note that the derived @p{Point} class also
+                                     * provides access through the @p{()}
                                      * operator for backcompatibility.
                                      */
     double   operator [] (const unsigned int index) const;
 
                                     /**
-                                     *  Read and write access to the #index#th
+                                     *  Read and write access to the @p{index}th
                                      *  coordinate.
                                      *
-                                     * Note that the derived #Point# class also
-                                     * provides access through the #()#
+                                     * Note that the derived @p{Point} class also
+                                     * provides access through the @p{()}
                                      * operator for backcompatibility.
                                      */
     double & operator [] (const unsigned int index);
@@ -162,13 +162,13 @@ class Tensor<1,dim> {
     Tensor<1,dim> & operator -= (const Tensor<1,dim> &);
 
                                     /**
-                                     *  Scale the vector by #factor#, i.e. multiply
-                                     *  all coordinates by #factor#.
+                                     *  Scale the vector by @p{factor}, i.e. multiply
+                                     *  all coordinates by @p{factor}.
                                      */
     Tensor<1,dim> & operator *= (const double &factor);
 
                                     /**
-                                     *  Scale the vector by #1/factor#.
+                                     *  Scale the vector by @p{1/factor}.
                                      */
     Tensor<1,dim> & operator /= (const double &factor);
 
@@ -179,14 +179,14 @@ class Tensor<1,dim> {
 
                                     /**
                                      *  Add two tensors. If possible, use
-                                     *  #operator +=# instead since this does not
+                                     *  @p{operator +=} instead since this does not
                                      *  need to copy a point at least once.
                                      */
     Tensor<1,dim>   operator + (const Tensor<1,dim> &) const;
 
                                     /**
                                      *  Subtract two tensors. If possible, use
-                                     *  #operator +=# instead since this does not
+                                     *  @p{operator +=} instead since this does not
                                      *  need to copy a point at least once.
                                      */
     Tensor<1,dim>   operator - (const Tensor<1,dim> &) const;
@@ -210,7 +210,7 @@ class Tensor<1,dim> {
   protected:
                                     /**
                                      * Store the values in a simple array.
-                                     * For #dim==0# store one element, because
+                                     * For @p{dim==0} store one element, because
                                      * otherways the compiler would choke.
                                      * We catch this case in the constructor
                                      * to disallow the creation of such
@@ -249,7 +249,7 @@ DeclException1 (ExcDimTooSmall,
 
                                 /**
                                  *  Prints the values of this point in the
-                                 *  form #x1 x2 x3 etc#.
+                                 *  form @p{x1 x2 x3 etc}.
                                  */
 template <int dim>
 ostream & operator << (ostream &out, const Tensor<1,dim> &p);
index b98a1285d621188189b7e15fb8f498727bb0a12b..50ae2d13e5913b445dcf59e288dbe36671a63fcf 100644 (file)
@@ -26,7 +26,7 @@
 /**
  *  This class is a model for a tensor valued function.
  *  It returns the value
- *  at a given point through the #operator ()# member functions,
+ *  at a given point through the @p{operator ()} member functions,
  *  which are virtual. It also has a function to return a whole list of
  *  values at different points to reduce the overhead of the virtual function
  *  calls; this function is preset to successively call the function returning
@@ -68,11 +68,11 @@ class TensorFunction : public FunctionTime,
     virtual Tensor<rank, dim> value (const Point<dim> &p) const;
 
                                     /**
-                                     * Set #values# to the point values
-                                     * of the function at the #points#.
-                                     * It is assumed that #values#
+                                     * Set @p{values} to the point values
+                                     * of the function at the @p{points}.
+                                     * It is assumed that @p{values}
                                      * already has the right size, i.e.
-                                     * the same size as the #points#
+                                     * the same size as the @p{points}
                                      * array.
                                      */
     virtual void value_list (const vector<Point<dim> > &points,
@@ -85,11 +85,11 @@ class TensorFunction : public FunctionTime,
     virtual Tensor<rank+1,dim> gradient (const Point<dim> &p) const;
 
                                     /**
-                                     * Set #gradients# to the gradients of
-                                     * the function at the #points#.
-                                     * It is assumed that #values# 
+                                     * Set @p{gradients} to the gradients of
+                                     * the function at the @p{points}.
+                                     * It is assumed that @p{values} 
                                      * already has the right size, i.e.
-                                     * the same size as the #points# array.
+                                     * the same size as the @p{points} array.
                                      */
     virtual void gradient_list (const vector<Point<dim> > &points,
                                vector<Tensor<rank+1,dim> > &gradients) const;
index c1e099b24a3ab50c0491ebe68a3e2ab49059ed45..7a0d984ab21983decb2694a6c11f32f63debd721 100644 (file)
@@ -38,7 +38,7 @@ namespace Threads
  * multithreading. It allows to write programs such that they start
  * new threads and/or lock objects in multithreading mode, and use
  * dummy thread management and synchronisation classes instead when
- * running in single-thread mode. Specifically, the #spawn# functions
+ * running in single-thread mode. Specifically, the @p{spawn} functions
  * only call the function but wait for it to return instead of running
  * in on another thread, and the mutices do nothing really. The only
  * reason to provide such a function is that the program can be
@@ -74,7 +74,7 @@ namespace Threads
  * using multithreading. It allows to write programs such that they
  * start new threads and/or lock objects in multithreading mode, and
  * use dummy thread management and synchronisation classes instead
- * when running in single-thread mode. Specifically, the #spawn#
+ * when running in single-thread mode. Specifically, the @p{spawn}
  * functions only call the function but wait for it to return instead
  * of running in on another thread, and the mutices do nothing
  * really. The only reason to provide such a function is that the
@@ -145,7 +145,7 @@ namespace Threads
 /**
  * Class used to store a pointer temporarily and delete the object
  * pointed to upon destruction of this object. For more information on
- * use and internals of this class see the report on this subject.
+ * use and internals of this class see the report on multithreading.
  *
  * @author Wolfgang Bangerth, 2000
  */
@@ -155,10 +155,10 @@ namespace Threads
                                       /**
                                        * Default constructor. Construct
                                        * the object empty, i.e. set
-                                       * #data==0#. Since this is not
+                                       * @p{data==0}. Since this is not
                                        * very useful, disallow it by
                                        * declaring this constructor
-                                       * #private#.
+                                       * @p{private}.
                                        */
       FunEncapsulation ();
 
@@ -166,28 +166,28 @@ namespace Threads
                                       /**
                                        * Copy constructor. Clone the
                                        * object pointed to by
-                                       * #fun_data.fun_data_base#.
+                                       * @p{fun_data.fun_data_base}.
                                        */
       FunEncapsulation (const FunEncapsulation &fun_encapsulation);
 
                                       /**
                                        * This is the usual
-                                       * constructor. Set #fun_data_base# to
-                                       * #fun_data_base#. This is what
-                                       * the #fun_data_*# functions
+                                       * constructor. Set @p{fun_data_base} to
+                                       * @p{fun_data_base}. This is what
+                                       * the @p{fun_data_*} functions
                                        * use.
                                        */
       FunEncapsulation (FunDataBase *fun_data_base);
 
                                       /**
                                        * Destructor. Delete the object
-                                       * pointed to by #fun_data_base#.
+                                       * pointed to by @p{fun_data_base}.
                                        */
       ~FunEncapsulation ();
 
                                       /**
                                        * Copy another object of this
-                                       * type by cloning its #fun_data_base#
+                                       * type by cloning its @p{fun_data_base}
                                        * object.
                                        */
       const FunEncapsulation & operator = (const FunEncapsulation &fun_encapsulation);
@@ -204,7 +204,7 @@ namespace Threads
 /**
  * Abstract base class for those classes that actually store
  * parameters of functions. For more information on use and internals
- * of this class see the report on this subject.
+ * of this class see the report on multithreading.
  *
  * @author Wolfgang Bangerth, 2000
  */
@@ -275,7 +275,7 @@ namespace Threads
                                        * Make the thread starter
                                        * function a friend, since it
                                        * needs to have access to the
-                                       * #thread_entry_point# variable.
+                                       * @p{thread_entry_point} variable.
                                        */
       friend void spawn (ThreadManager          &thread_manager,
                         const FunEncapsulation &fun_data);
@@ -286,7 +286,7 @@ namespace Threads
 /**
  * Class to store the parameters of a void function. For more
  * information on use and internals of this class see the report on
- * this subject.
+ * multithreading.
  *
  * @author Wolfgang Bangerth, 2000
  */
@@ -390,7 +390,7 @@ namespace Threads
 /**
  * Class to store the parameters of a unary function. For more
  * information on use and internals of this class see the report on
- * this subject.
+ * multithreading.
  *
  * @author Wolfgang Bangerth, 2000
  */
@@ -492,7 +492,7 @@ namespace Threads
 /**
  * Class to store the parameters of a binary function. For more
  * information on use and internals of this class see the report on
- * this subject.
+ * multithreading.
  *
  * @author Wolfgang Bangerth, 2000
  */
@@ -596,7 +596,7 @@ namespace Threads
 /**
  * Class to store the parameters of a ternary function. For more
  * information on use and internals of this class see the report on
- * this subject.
+ * multithreading.
  *
  * @author Wolfgang Bangerth, 2000
  */
@@ -703,7 +703,7 @@ namespace Threads
 /**
  * Class to store the parameters of a quaternary function. For more
  * information on use and internals of this class see the report on
- * this subject.
+ * multithreading.
  *
  * @author Wolfgang Bangerth, 2000
  */
@@ -814,7 +814,7 @@ namespace Threads
 /**
  * Class to store the parameters of a quintary function. For more
  * information on use and internals of this class see the report on
- * this subject.
+ * multithreading.
  *
  * @author Wolfgang Bangerth, 2000
  */
@@ -927,7 +927,7 @@ namespace Threads
 /**
  * Class to store the parameters of a function with 6 arguments. For more
  * information on use and internals of this class see the report on
- * this subject.
+ * multithreading.
  *
  * @author Wolfgang Bangerth, Ralf Hartmann, 2000
  */
@@ -1043,7 +1043,7 @@ namespace Threads
 /**
  * Class to store the parameters of a void function. For more
  * information on use and internals of this class see the report on
- * this subject.
+ * multithreading.
  *
  * @author Wolfgang Bangerth, 2000
  */
@@ -1145,7 +1145,7 @@ namespace Threads
 /**
  * Class to store the parameters of a unary function. For more
  * information on use and internals of this class see the report on
- * this subject.
+ * multithreading.
  *
  * @author Wolfgang Bangerth, 2000
  */
@@ -1255,7 +1255,7 @@ namespace Threads
 /**
  * Class to store the parameters of a binary function. For more
  * information on use and internals of this class see the report on
- * this subject.
+ * multithreading.
  *
  * @author Wolfgang Bangerth, 2000
  */
@@ -1367,7 +1367,7 @@ namespace Threads
 /**
  * Class to store the parameters of a ternary function. For more
  * information on use and internals of this class see the report on
- * this subject.
+ * multithreading.
  *
  * @author Wolfgang Bangerth, 2000
  */
@@ -1483,7 +1483,7 @@ namespace Threads
 /**
  * Class to store the parameters of a quaternary function. For more
  * information on use and internals of this class see the report on
- * this subject.
+ * multithreading.
  *
  * @author Wolfgang Bangerth, 2000
  */
@@ -1602,7 +1602,7 @@ namespace Threads
 /**
  * Class to store the parameters of a quintary function. For more
  * information on use and internals of this class see the report on
- * this subject.
+ * multithreading.
  *
  * @author Wolfgang Bangerth, 2000
  */
@@ -1851,7 +1851,7 @@ namespace Threads
                                    * thread can later be spawned.
                                    * For more information on use and
                                    * internals of this class see the
-                                   * report on this subject.
+                                   * report on multithreading.
                                    *
                                    * This function exists once for
                                    * each number of parameters.
@@ -1865,7 +1865,7 @@ namespace Threads
                                    * thread can later be spawned.
                                    * For more information on use and
                                    * internals of this class see the
-                                   * report on this subject.
+                                   * report on multithreading.
                                    *
                                    * This function exists once for
                                    * each number of parameters.
@@ -1881,7 +1881,7 @@ namespace Threads
                                    * thread can later be spawned.
                                    * For more information on use and
                                    * internals of this class see the
-                                   * report on this subject.
+                                   * report on multithreading.
                                    *
                                    * This function exists once for
                                    * each number of parameters.
@@ -1897,7 +1897,7 @@ namespace Threads
                                    * thread can later be spawned.
                                    * For more information on use and
                                    * internals of this class see the
-                                   * report on this subject.
+                                   * report on multithreading.
                                    *
                                    * This function exists once for
                                    * each number of parameters.
@@ -1913,7 +1913,7 @@ namespace Threads
                                    * thread can later be spawned.
                                    * For more information on use and
                                    * internals of this class see the
-                                   * report on this subject.
+                                   * report on multithreading.
                                    *
                                    * This function exists once for
                                    * each number of parameters.
@@ -1930,7 +1930,7 @@ namespace Threads
                                    * thread can later be spawned.
                                    * For more information on use and
                                    * internals of this class see the
-                                   * report on this subject.
+                                   * report on multithreading.
                                    *
                                    * This function exists once for
                                    * each number of parameters.
@@ -1946,7 +1946,7 @@ namespace Threads
                                    * thread can later be spawned.
                                    * For more information on use and
                                    * internals of this class see the
-                                   * report on this subject.
+                                   * report on multithreading.
                                    *
                                    * This function exists once for
                                    * each number of parameters.
@@ -2077,7 +2077,7 @@ namespace Threads
                                   /**
                                    * Spawn a new thread using the
                                    * function and parameters
-                                   * encapsulated in #fun_data#, and
+                                   * encapsulated in @p{fun_data}, and
                                    * using the given thread manager
                                    * object.
                                    */
@@ -2096,17 +2096,17 @@ namespace Threads
 
 
                                   /**
-                                   * Split the range #[begin,end)#
-                                   * into #n_intervals# subintervals
+                                   * Split the range @p{[begin,end)}
+                                   * into @p{n_intervals} subintervals
                                    * of equal size. The last interval
                                    * will be a little bit larger, if
                                    * the number of elements in the
                                    * whole range is not exactly
-                                   * divisible by #n_intervals#. The
+                                   * divisible by @p{n_intervals}. The
                                    * type of the iterators has to
                                    * fulfill the requirements of a
                                    * forward iterator,
-                                   * i.e. #operator++# must be
+                                   * i.e. @p{operator++} must be
                                    * available, and of course it must
                                    * be assignable.
                                    *
@@ -2114,7 +2114,7 @@ namespace Threads
                                    * returned as a vector of pairs of
                                    * iterators, where each pair
                                    * denotes the range
-                                   * #[begin[i],end[i])#.
+                                   * @p{[begin[i],end[i])}.
                                    */
   template <typename ForwardIterator>
   vector<pair<ForwardIterator,ForwardIterator> >
@@ -2123,7 +2123,7 @@ namespace Threads
               const unsigned int n_intervals);
 
                                   /**
-                                   * Split the interval #[begin,end)#
+                                   * Split the interval @p{[begin,end)}
                                    * into subintervals of (almost)
                                    * equal size. This function works
                                    * mostly as the one before, with
@@ -2142,7 +2142,7 @@ namespace Threads
  * This class is used to make some sanity checks on the numbers of
  * objects of some types related with thread spawning, which are
  * created and deleted. This is a helpful thing when trying to
- * implement the data copying using #clone# functions etc, in order to
+ * implement the data copying using @p{clone} functions etc, in order to
  * avoid that there are some objects which are copied but not deleted.
  *
  * It basically only monitors the number of objects which is alive at
@@ -2249,7 +2249,7 @@ namespace Threads
 
                                   // copying of parameters is done,
                                   // now we can release the lock on
-                                  // #fun_data#
+                                  // @p{fun_data}
     fun_data->lock.release ();
 
                                     // call the function
@@ -2327,7 +2327,7 @@ namespace Threads
 
                                   // copying of parameters is done,
                                   // now we can release the lock on
-                                  // #fun_data#
+                                  // @p{fun_data}
     fun_data->lock.release ();
 
                                     // call the function
@@ -2409,7 +2409,7 @@ namespace Threads
 
                                   // copying of parameters is done,
                                   // now we can release the lock on
-                                  // #fun_data#
+                                  // @p{fun_data}
     fun_data->lock.release ();
 
                                     // call the function
@@ -2497,7 +2497,7 @@ namespace Threads
 
                                   // copying of parameters is done,
                                   // now we can release the lock on
-                                  // #fun_data#
+                                  // @p{fun_data}
     fun_data->lock.release ();
 
                                     // call the function
@@ -2590,7 +2590,7 @@ namespace Threads
 
                                   // copying of parameters is done,
                                   // now we can release the lock on
-                                  // #fun_data#
+                                  // @p{fun_data}
     fun_data->lock.release ();
 
                                     // call the function
@@ -2688,7 +2688,7 @@ namespace Threads
 
                                   // copying of parameters is done,
                                   // now we can release the lock on
-                                  // #fun_data#
+                                  // @p{fun_data}
     fun_data->lock.release ();
 
                                     // call the function
@@ -2792,7 +2792,7 @@ namespace Threads
 
                                   // copying of parameters is done,
                                   // now we can release the lock on
-                                  // #fun_data#
+                                  // @p{fun_data}
     fun_data->lock.release ();
 
                                     // call the function
@@ -2877,7 +2877,7 @@ namespace Threads
 
                                   // copying of parameters is done,
                                   // now we can release the lock on
-                                  // #fun_data#
+                                  // @p{fun_data}
     fun_data->lock.release ();
 
                                     // call the function
@@ -2959,7 +2959,7 @@ namespace Threads
 
                                   // copying of parameters is done,
                                   // now we can release the lock on
-                                  // #fun_data#
+                                  // @p{fun_data}
     fun_data->lock.release ();
 
                                     // call the function
@@ -3046,7 +3046,7 @@ namespace Threads
 
                                   // copying of parameters is done,
                                   // now we can release the lock on
-                                  // #fun_data#
+                                  // @p{fun_data}
     fun_data->lock.release ();
 
                                     // call the function
@@ -3139,7 +3139,7 @@ namespace Threads
 
                                   // copying of parameters is done,
                                   // now we can release the lock on
-                                  // #fun_data#
+                                  // @p{fun_data}
     fun_data->lock.release ();
 
                                     // call the function
@@ -3238,7 +3238,7 @@ namespace Threads
 
                                   // copying of parameters is done,
                                   // now we can release the lock on
-                                  // #fun_data#
+                                  // @p{fun_data}
     fun_data->lock.release ();
 
                                     // call the function
@@ -3342,7 +3342,7 @@ namespace Threads
 
                                   // copying of parameters is done,
                                   // now we can release the lock on
-                                  // #fun_data#
+                                  // @p{fun_data}
     fun_data->lock.release ();
 
                                     // call the function
@@ -3451,7 +3451,7 @@ namespace Threads
 
                                   // copying of parameters is done,
                                   // now we can release the lock on
-                                  // #fun_data#
+                                  // @p{fun_data}
     fun_data->lock.release ();
 
                                     // call the function
index 2476258816795acf78218efb1d8a19a6e39f3d2e..a160d1c5767509b20e854507a715edb05f6a1ffb 100644 (file)
@@ -22,7 +22,7 @@
  * microsecond. 
  *
  *
- * \subsection{Usage}
+ * @sect3{Usage}
  *
  * Use of this class is as you might expect by looking at the member
  * functions:
@@ -42,7 +42,7 @@
  * \end{verbatim}
  *
  * Alternatively, you can also restart the timer instead of resetting
- * it. The times between successive calls to #start/stop# will then be
+ * it. The times between successive calls to @p{start/stop} will then be
  * accumulated.
  *
  * Note: the implementation of this class is system dependent.
@@ -89,16 +89,16 @@ class Timer
   private:
 
                                     /**
-                                     * Value of the user time when #start#
+                                     * Value of the user time when @p{start}
                                      * was called the last time or when the
-                                     * object was created and no #stop# was
+                                     * object was created and no @p{stop} was
                                      * issued in between.
                                      */
     double              start_time;
 
                                     /**
                                      * Accumulated time for all previous
-                                     * #start#/#stop# cycles. The time for
+                                     * @p{start}/@p{stop} cycles. The time for
                                      * the present cycle is not included.
                                      */
     double              cumulative_time;
index 8828de0e1a729487bcbb16acf9b0a46014d01143..058441847b42045924243f0de659c16563cd695e 100644 (file)
@@ -1652,7 +1652,7 @@ void DataOutBase::write_gmv (const vector<Patch<dim> > &patches,
            };
        };
 
-                                      // now write the data vectors to #out#
+                                      // now write the data vectors to @p{out}
                                       // the '1' means: node data (as opposed
                                       // to cell data, which we do not
                                       // support explicitely here)
index 7d7c3edd090dda8f97d98552c3f4dbd3c34c8cde..a7daf6b6fc702c58a9cc702b17cb2b01b5a9f02c 100644 (file)
@@ -757,7 +757,7 @@ ParameterHandler::Section* ParameterHandler::get_present_defaults_subsection ()
 
 const ParameterHandler::Section* ParameterHandler::get_present_defaults_subsection () const {
   Section* sec = const_cast<Section*>(&defaults); // not nice, but needs to be and
-                                  // after all: we do not change #sec#
+                                  // after all: we do not change @p{sec}
   vector<string>::const_iterator SecName = subsection_path.begin();
     
   while (SecName != subsection_path.end()) 
index 9d50b6a4e42124926604a2722644cba93004648e..0ce3df3d1898666f7333dd5bb0dc4edd1735510e 100644 (file)
@@ -145,7 +145,7 @@ namespace Threads
   void spawn (ThreadManager          &thread_manager,
              const FunEncapsulation &fun_data)
   {
-                                    // lock the #fun_data_base# object
+                                    // lock the @p{fun_data_base} object
                                     // to avoid destruction while its
                                     // data is still accessed. the lock
                                     // is released by the new thread
index 95cdffd9c15a7641b0736d9b86addf098475599f..9cff7b36815adc090745d4258421526e8a211732 100644 (file)
@@ -37,14 +37,14 @@ template <int dim> class DoFHandler;
  * Define the basis for accessors to the degrees of freedom.
  *
  * Note that it is allowed to construct an object of which the
- * #dof_handler# pointer is a Null pointer. Such an object would
+ * @p{dof_handler} pointer is a Null pointer. Such an object would
  * result in a strange kind of behaviour, though every reasonable
  * operating system should disallow access through that pointer.
  * The reason we do not check for the null pointer in the
- * constructor which gets passed the #DoFHandler# pointer is that
+ * constructor which gets passed the @p{DoFHandler} pointer is that
  * if we did we could not make dof iterators member of other classes
- * (like in the #FEValues# class) if we did not know about the
- * #DoFHandler# object to be used upon construction of that object.
+ * (like in the @p{FEValues} class) if we did not know about the
+ * @p{DoFHandler} object to be used upon construction of that object.
  * Through the way this class is implemented here, we allow the
  * creation of a kind of virgin object which only gets useful if
  * assigned to from another object before first usage.
@@ -53,7 +53,7 @@ template <int dim> class DoFHandler;
  * which has an invalid dof handler pointer. This is to guarantee
  * that every iterator which is once assigned to is a valid
  * object. However, this assertion only holds in debug mode, when
- * the #Assert# macro is switched on.
+ * the @p{Assert} macro is switched on.
  *
  * @author Wolfgang Bangerth, 1998
  */
@@ -68,7 +68,7 @@ class DoFAccessor
 
                                     /**
                                      * This should be the default constructor.
-                                     * We cast away the #const#ness of the
+                                     * We cast away the @p{const}ness of the
                                      * pointer which clearly is EVIL but
                                      * we can't help without making all
                                      * functions which could somehow use
@@ -85,7 +85,7 @@ class DoFAccessor
 
                                     /**
                                      * Return a handle on the
-                                     * #DoFHandler# object which we
+                                     * @p{DoFHandler} object which we
                                      * are using.
                                      */
     const DoFHandler<dim> &
@@ -120,7 +120,7 @@ class DoFAccessor
 
   protected:
                                     /**
-                                     * Store the address of the #DoFHandler# object
+                                     * Store the address of the @p{DoFHandler} object
                                      * to be accessed.
                                      */
     DoFHandler<dim> *dof_handler;  
@@ -130,14 +130,14 @@ class DoFAccessor
 /* -------------------------------------------------------------------------- */
 
 /**
- * This is a switch class which only declares a #typedef#. It is meant to
- * determine which class a #DoFObjectAccessor# class is to be derived
- * from. By default, #DoFObjectAccessor<celldim,dim># derives from
- * the #typedef# in the general #DoFObjectAccessor_Inheritance<celldim,dim>#
- * class, which is #TriaObjectAccessor<celldim,dim>#,
- * but if #celldim==dim#, then the specialization #DoFObjectAccessor_Inheritance<dim,dim>#
- * is used which declares its local type to be #CellAccessor<dim>#. Therefore,
- * the inheritance is automatically chosen to be from #CellAccessor# if the
+ * This is a switch class which only declares a @p{typedef}. It is meant to
+ * determine which class a @p{DoFObjectAccessor} class is to be derived
+ * 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,
+ * the inheritance is automatically chosen to be from @p{CellAccessor} if the
  * object under consideration has full dimension, i.e. constitutes a cell.
  *
  * @author Wolfgang Bangerth, 1999
@@ -146,7 +146,7 @@ template <int celldim, int dim>
 class DoFObjectAccessor_Inheritance 
 {
                                     /**
-                                     * Declaration of the #typedef#.
+                                     * Declaration of the @p{typedef}.
                                      * See the full documentation for
                                      * more information.
                                      */
@@ -155,14 +155,14 @@ class DoFObjectAccessor_Inheritance
 
 
 /**
- * This is a switch class which only declares a #typedef#. It is meant to
- * determine which class a #DoFObjectAccessor# class is to be derived
- * from. By default, #DoFObjectAccessor<celldim,dim># derives from
- * the #typedef# in the general #DoFObjectAccessor_Inheritance<celldim,dim>#
- * class, which is #TriaObjectAccessor<celldim,dim>#,
- * but if #celldim==dim#, then the specialization #DoFObjectAccessor_Inheritance<dim,dim>#
- * is used which declares its local type to be #CellAccessor<dim>#. Therefore,
- * the inheritance is automatically chosen to be from #CellAccessor# if the
+ * This is a switch class which only declares a @p{typedef}. It is meant to
+ * determine which class a @p{DoFObjectAccessor} class is to be derived
+ * 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,
+ * the inheritance is automatically chosen to be from @p{CellAccessor} if the
  * object under consideration has full dimension, i.e. constitutes a cell.
  *
  * @author Wolfgang Bangerth, 1999
@@ -171,7 +171,7 @@ template <int dim>
 class DoFObjectAccessor_Inheritance<dim,dim>
 {
                                     /**
-                                     * Declaration of the #typedef#.
+                                     * Declaration of the @p{typedef}.
                                      * See the full documentation for
                                      * more information.
                                      */
@@ -189,7 +189,7 @@ class DoFObjectAccessor_Inheritance<dim,dim>
  * parameters. In this class here, we only collect all functions which
  * are in the specialized classes for simpler reference. Some
  * functions, however, might be missing in the specialized classes,
- * such as #quad# in the accessors for lines and quads, etc.
+ * such as @p{quad} in the accessors for lines and quads, etc.
  *
  * This class follows mainly the route laid out by the accessor library
  * declared in the triangulation library (\Ref{TriaAccessor}). It enables
@@ -199,7 +199,7 @@ class DoFObjectAccessor_Inheritance<dim,dim>
  * lines in 1D-, 2D-, etc dimensions).
  *
  *
- * \subsection{Usage}
+ * @sect3{Usage}
  *
  * The \Ref{DoFDimensionInfo} classes inherited by the \Ref{DoFHandler} classes
  * declare typedefs to iterators using the accessors declared in this class
@@ -208,7 +208,7 @@ class DoFObjectAccessor_Inheritance<dim,dim>
  * as they provide easier typing (much less complicated names!).
  * 
  * 
- * \subsection{Notes about the class hierarchy structure}
+ * @sect3{Notes about the class hierarchy structure}
  *
  * See the report on this subject, which is available from the general
  * documentation directory.
@@ -241,9 +241,9 @@ class DoFObjectAccessor : public DoFAccessor<dim>,
     DoFObjectAccessor ();
 
                                     /**
-                                     * Constructor. The #local_data#
+                                     * Constructor. The @p{local_data}
                                      * argument is assumed to be a pointer
-                                     * to a #DoFHandler<dim># object.
+                                     * to a @p{DoFHandler<dim>} object.
                                      */
     DoFObjectAccessor (Triangulation<dim> *tria,
                    const int           level,
@@ -253,28 +253,28 @@ class DoFObjectAccessor : public DoFAccessor<dim>,
                    DoFObjectAccessor_Inheritance<celldim,dim>::BaseClass (tria,level,index) {};
     
                                     /**
-                                     * Index of the #i#th degree
+                                     * Index of the @p{i}th degree
                                      * of freedom of this object.
                                      */
     unsigned int dof_index (const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the #i#th degree
-                                     * of freedom of this object to #index#.
+                                     * Set the index of the @p{i}th degree
+                                     * of freedom of this object to @p{index}.
                                      */
     void set_dof_index (const unsigned int i,
                        const int index) const;
 
                                     /**
-                                     * Index of the #i#th degree
-                                     * on the #vertex#th vertex.
+                                     * Index of the @p{i}th degree
+                                     * on the @p{vertex}th vertex.
                                      */
     unsigned int vertex_dof_index (const unsigned int vertex,
                                   const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the #i#th degree
-                                     * on the #vertex#th vertex to #index#.
+                                     * Set the index of the @p{i}th degree
+                                     * on the @p{vertex}th vertex to @p{index}.
                                      */
     void set_vertex_dof_index (const unsigned int vertex,
                               const unsigned int i,
@@ -308,9 +308,9 @@ class DoFObjectAccessor : public DoFAccessor<dim>,
                                      * active cells.
                                      *
                                      * The input vector may be either
-                                     * a #Vector<float>#,
-                                     * #Vector<double>#, or a
-                                     * #BlockVector<...,double>#. It
+                                     * a @p{Vector<float>},
+                                     * @p{Vector<double>}, or a
+                                     * @p{BlockVector<...,double>}. It
                                      * is in the responsibility of
                                      * the caller to assure that the
                                      * types of the numbers stored in
@@ -324,11 +324,11 @@ class DoFObjectAccessor : public DoFAccessor<dim>,
 
                                     /**
                                      * This function is the counterpart to
-                                     * #get_dof_values#: it takes a vector
+                                     * @p{get_dof_values}: it takes a vector
                                      * of values for the degrees of freedom
                                      * of the cell pointed to by this iterator
                                      * and writes these values into the global
-                                     * data vector #values#. This function
+                                     * data vector @p{values}. This function
                                      * is only callable for active cells.
                                      *
                                      * Note that for continuous finite
@@ -346,9 +346,9 @@ class DoFObjectAccessor : public DoFAccessor<dim>,
                                      * to this function.
                                      *
                                      * The output vector may be either
-                                     * a #Vector<float>#,
-                                     * #Vector<double>#, or a
-                                     * #BlockVector<...,double>#. It
+                                     * a @p{Vector<float>},
+                                     * @p{Vector<double>}, or a
+                                     * @p{BlockVector<...,double>}. It
                                      * is in the responsibility of
                                      * the caller to assure that the
                                      * types of the numbers stored in
@@ -361,21 +361,21 @@ class DoFObjectAccessor : public DoFAccessor<dim>,
                         OutputVector         &values) const;
 
                                     /**
-                                     *  Pointer to the #i#th line
+                                     *  Pointer to the @p{i}th line
                                      *  bounding this Object.
                                      */
     TriaIterator<dim,DoFObjectAccessor<1, dim> >
     line (const unsigned int i) const;
 
                                     /**
-                                     *  Pointer to the #i#th quad
+                                     *  Pointer to the @p{i}th quad
                                      *  bounding this Object.
                                      */
     TriaIterator<dim,DoFObjectAccessor<2, dim> >
     quad (const unsigned int i) const;
     
                                     /**
-                                     * #i#th child as a #DoFObjectAccessor#
+                                     * @p{i}th child as a @p{DoFObjectAccessor}
                                      * iterator. This function is needed since
                                      * the child function of the base
                                      * class returns a hex accessor without
@@ -390,7 +390,7 @@ class DoFObjectAccessor : public DoFAccessor<dim>,
                                      * to the global one and entering the
                                      * local values into the global vector.
                                      *
-                                     * The elements are {\it added} up to
+                                     * The elements are @em{added} up to
                                      * the elements in the global vector,
                                      * rather than just set, since this is
                                      * usually what one wants.
@@ -400,7 +400,7 @@ class DoFObjectAccessor : public DoFAccessor<dim>,
 
                                     /**
                                      * This function does much the same as the
-                                     * #distribute_local_to_global(dVector,dVector)#
+                                     * @p{distribute_local_to_global(dVector,dVector)}
                                      * function, but operates on matrices
                                      * instead of vectors. The sparse matrix
                                      * is supposed to have non-zero entry
@@ -451,7 +451,7 @@ class DoFObjectAccessor<0, dim> : public DoFAccessor<dim>,
  * lines in 1D-, 2D-, etc dimensions).
  *
  *
- * \subsection{Usage}
+ * @sect3{Usage}
  *
  * The \Ref{DoFDimensionInfo} classes inherited by the \Ref{DoFHandler} classes
  * declare typedefs to iterators using the accessors declared in this class
@@ -460,11 +460,11 @@ class DoFObjectAccessor<0, dim> : public DoFAccessor<dim>,
  * as they provide easier typing (much less complicated names!).
  * 
  * 
- * \subsection{Notes about the class hierarchy structure}
+ * @sect3{Notes about the class hierarchy structure}
  *
- * Inheritance from #DoFObjectAccessor_Inheritance<1,dim>::BaseClass# yields
- * inheritance from #CellAccessor<1># if #dim==1# and from
- * #TriaObjectAccessor<1,dim># for all other #dim# values. Thus, an object
+ * 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
  * of this class shares all features of cells in one dimension, but behaves
  * like an ordinary line in all other cases.
  *
@@ -495,9 +495,9 @@ class DoFObjectAccessor<1, dim> :  public DoFAccessor<dim>,
     DoFObjectAccessor ();
     
                                     /**
-                                     * Constructor. The #local_data#
+                                     * Constructor. The @p{local_data}
                                      * argument is assumed to be a pointer
-                                     * to a #DoFHandler<dim># object.
+                                     * to a @p{DoFHandler<dim>} object.
                                      */
     DoFObjectAccessor (Triangulation<dim> *tria,
                       const int           level,
@@ -507,28 +507,28 @@ class DoFObjectAccessor<1, dim> :  public DoFAccessor<dim>,
                    DoFObjectAccessor_Inheritance<1,dim>::BaseClass (tria,level,index) {};
     
                                     /**
-                                     * Return the index of the #i#th degree
+                                     * Return the index of the @p{i}th degree
                                      * of freedom of this line.
                                      */
     unsigned int dof_index (const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the #i#th degree
-                                     * of freedom of this line to #index#.
+                                     * Set the index of the @p{i}th degree
+                                     * of freedom of this line to @p{index}.
                                      */
     void set_dof_index (const unsigned int i,
                        const unsigned int index) const;
 
                                     /**
-                                     * Return the index of the #i#th degree
-                                     * on the #vertex#th vertex.
+                                     * Return the index of the @p{i}th degree
+                                     * on the @p{vertex}th vertex.
                                      */
     unsigned int vertex_dof_index (const unsigned int vertex,
                                   const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the #i#th degree
-                                     * on the #vertex#th vertex to #index#.
+                                     * Set the index of the @p{i}th degree
+                                     * on the @p{vertex}th vertex to @p{index}.
                                      */
     void set_vertex_dof_index (const unsigned int vertex,
                               const unsigned int i,
@@ -559,9 +559,9 @@ class DoFObjectAccessor<1, dim> :  public DoFAccessor<dim>,
                                      * cells.
                                      *
                                      * The input vector may be either
-                                     * a #Vector<float>#,
-                                     * #Vector<double>#, or a
-                                     * #BlockVector<...,double>#. It
+                                     * a @p{Vector<float>},
+                                     * @p{Vector<double>}, or a
+                                     * @p{BlockVector<...,double>}. It
                                      * is in the responsibility of
                                      * the caller to assure that the
                                      * types of the numbers stored in
@@ -575,11 +575,11 @@ class DoFObjectAccessor<1, dim> :  public DoFAccessor<dim>,
 
                                     /**
                                      * This function is the counterpart to
-                                     * #get_dof_values#: it takes a vector
+                                     * @p{get_dof_values}: it takes a vector
                                      * of values for the degrees of freedom
                                      * of the cell pointed to by this iterator
                                      * and writes these values into the global
-                                     * data vector #values#. This function
+                                     * data vector @p{values}. This function
                                      * is only callable for active cells.
                                      *
                                      * Note that for continuous finite
@@ -596,9 +596,9 @@ class DoFObjectAccessor<1, dim> :  public DoFAccessor<dim>,
                                      * have the right size beforehand.
                                      *
                                      * The output vector may be either
-                                     * a #Vector<float>#,
-                                     * #Vector<double>#, or a
-                                     * #BlockVector<...,double>#. It
+                                     * a @p{Vector<float>},
+                                     * @p{Vector<double>}, or a
+                                     * @p{BlockVector<...,double>}. It
                                      * is in the responsibility of
                                      * the caller to assure that the
                                      * types of the numbers stored in
@@ -611,7 +611,7 @@ class DoFObjectAccessor<1, dim> :  public DoFAccessor<dim>,
                         OutputVector         &values) const;
 
                                     /**
-                                     * Return the #i#th child as a DoF line
+                                     * Return the @p{i}th child as a DoF line
                                      * iterator. This function is needed since
                                      * the child function of the base
                                      * class returns a line accessor without
@@ -626,7 +626,7 @@ class DoFObjectAccessor<1, dim> :  public DoFAccessor<dim>,
                                      * to the global one and entering the
                                      * local values into the global vector.
                                      *
-                                     * The elements are {\it added} up to
+                                     * The elements are @em{added} up to
                                      * the elements in the global vector,
                                      * rather than just set, since this is
                                      * usually what one wants.
@@ -636,7 +636,7 @@ class DoFObjectAccessor<1, dim> :  public DoFAccessor<dim>,
 
                                     /**
                                      * This function does much the same as the
-                                     * #distribute_local_to_global(dVector,dVector)#
+                                     * @p{distribute_local_to_global(dVector,dVector)}
                                      * function, but operates on matrices
                                      * instead of vectors. The sparse matrix
                                      * is supposed to have non-zero entry
@@ -683,9 +683,9 @@ class DoFObjectAccessor<2, dim> :  public DoFAccessor<dim>,
     DoFObjectAccessor ();
 
                                     /**
-                                     * Constructor. The #local_data#
+                                     * Constructor. The @p{local_data}
                                      * argument is assumed to be a pointer
-                                     * to a #DoFHandler<dim># object.
+                                     * to a @p{DoFHandler<dim>} object.
                                      */
     DoFObjectAccessor (Triangulation<dim> *tria,
                     const int           level,
@@ -695,28 +695,28 @@ class DoFObjectAccessor<2, dim> :  public DoFAccessor<dim>,
                    DoFObjectAccessor_Inheritance<2,dim>::BaseClass (tria,level,index) {};
     
                                     /**
-                                     * Return the index of the #i#th degree
+                                     * Return the index of the @p{i}th degree
                                      * of freedom of this quad.
                                      */
     unsigned int dof_index (const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the #i#th degree
-                                     * of freedom of this quad to #index#.
+                                     * Set the index of the @p{i}th degree
+                                     * of freedom of this quad to @p{index}.
                                      */
     void set_dof_index (const unsigned int i,
                        const unsigned int index) const;
 
                                     /**
-                                     * Return the index of the #i#th degree
-                                     * on the #vertex#th vertex.
+                                     * Return the index of the @p{i}th degree
+                                     * on the @p{vertex}th vertex.
                                      */
     unsigned int vertex_dof_index (const unsigned int vertex,
                                   const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the #i#th degree
-                                     * on the #vertex#th vertex to #index#.
+                                     * Set the index of the @p{i}th degree
+                                     * on the @p{vertex}th vertex to @p{index}.
                                      */
     void set_vertex_dof_index (const unsigned int vertex,
                               const unsigned int i,
@@ -748,9 +748,9 @@ class DoFObjectAccessor<2, dim> :  public DoFAccessor<dim>,
                                      * cells.
                                      *
                                      * The input vector may be either
-                                     * a #Vector<float>#,
-                                     * #Vector<double>#, or a
-                                     * #BlockVector<...,double>#. It
+                                     * a @p{Vector<float>},
+                                     * @p{Vector<double>}, or a
+                                     * @p{BlockVector<...,double>}. It
                                      * is in the responsibility of
                                      * the caller to assure that the
                                      * types of the numbers stored in
@@ -764,11 +764,11 @@ class DoFObjectAccessor<2, dim> :  public DoFAccessor<dim>,
 
                                     /**
                                      * This function is the counterpart to
-                                     * #get_dof_values#: it takes a vector
+                                     * @p{get_dof_values}: it takes a vector
                                      * of values for the degrees of freedom
                                      * of the cell pointed to by this iterator
                                      * and writes these values into the global
-                                     * data vector #values#. This function
+                                     * data vector @p{values}. This function
                                      * is only callable for active cells.
                                      *
                                      * Note that for continuous finite
@@ -785,9 +785,9 @@ class DoFObjectAccessor<2, dim> :  public DoFAccessor<dim>,
                                      * have the right size beforehand.
                                      *
                                      * The output vector may be either
-                                     * a #Vector<float>#,
-                                     * #Vector<double>#, or a
-                                     * #BlockVector<...,double>#. It
+                                     * a @p{Vector<float>},
+                                     * @p{Vector<double>}, or a
+                                     * @p{BlockVector<...,double>}. It
                                      * is in the responsibility of
                                      * the caller to assure that the
                                      * types of the numbers stored in
@@ -800,14 +800,14 @@ class DoFObjectAccessor<2, dim> :  public DoFAccessor<dim>,
                         OutputVector         &values) const;
 
                                     /**
-                                     *  Return a pointer to the #i#th line
-                                     *  bounding this #Quad#.
+                                     *  Return a pointer to the @p{i}th line
+                                     *  bounding this @p{Quad}.
                                      */
     TriaIterator<dim,DoFObjectAccessor<1, dim> >
     line (const unsigned int i) const;
     
                                     /**
-                                     * Return the #i#th child as a DoF quad
+                                     * Return the @p{i}th child as a DoF quad
                                      * iterator. This function is needed since
                                      * the child function of the base
                                      * class returns a quad accessor without
@@ -823,7 +823,7 @@ class DoFObjectAccessor<2, dim> :  public DoFAccessor<dim>,
                                      * to the global one and entering the
                                      * local values into the global vector.
                                      *
-                                     * The elements are {\it added} up to
+                                     * The elements are @em{added} up to
                                      * the elements in the global vector,
                                      * rather than just set, since this is
                                      * usually what one wants.
@@ -833,7 +833,7 @@ class DoFObjectAccessor<2, dim> :  public DoFAccessor<dim>,
 
                                     /**
                                      * This function does much the same as the
-                                     * #distribute_local_to_global(dVector,dVector)#
+                                     * @p{distribute_local_to_global(dVector,dVector)}
                                      * function, but operates on matrices
                                      * instead of vectors. The sparse matrix
                                      * is supposed to have non-zero entry
@@ -880,9 +880,9 @@ class DoFObjectAccessor<3, dim> :  public DoFAccessor<dim>,
     DoFObjectAccessor ();
 
                                     /**
-                                     * Constructor. The #local_data#
+                                     * Constructor. The @p{local_data}
                                      * argument is assumed to be a pointer
-                                     * to a #DoFHandler<dim># object.
+                                     * to a @p{DoFHandler<dim>} object.
                                      */
     DoFObjectAccessor (Triangulation<dim> *tria,
                    const int           level,
@@ -892,28 +892,28 @@ class DoFObjectAccessor<3, dim> :  public DoFAccessor<dim>,
                    DoFObjectAccessor_Inheritance<3,dim>::BaseClass (tria,level,index) {};
     
                                     /**
-                                     * Return the index of the #i#th degree
+                                     * Return the index of the @p{i}th degree
                                      * of freedom of this hex.
                                      */
     unsigned int dof_index (const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the #i#th degree
-                                     * of freedom of this hex to #index#.
+                                     * Set the index of the @p{i}th degree
+                                     * of freedom of this hex to @p{index}.
                                      */
     void set_dof_index (const unsigned int i,
                        const unsigned int index) const;
 
                                     /**
-                                     * Return the index of the #i#th degree
-                                     * on the #vertex#th vertex.
+                                     * Return the index of the @p{i}th degree
+                                     * on the @p{vertex}th vertex.
                                      */
     unsigned int vertex_dof_index (const unsigned int vertex,
                                   const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the #i#th degree
-                                     * on the #vertex#th vertex to #index#.
+                                     * Set the index of the @p{i}th degree
+                                     * on the @p{vertex}th vertex to @p{index}.
                                      */
     void set_vertex_dof_index (const unsigned int vertex,
                               const unsigned int i,
@@ -945,9 +945,9 @@ class DoFObjectAccessor<3, dim> :  public DoFAccessor<dim>,
                                      * cells.
                                      *
                                      * The input vector may be either
-                                     * a #Vector<float>#,
-                                     * #Vector<double>#, or a
-                                     * #BlockVector<...,double>#. It
+                                     * a @p{Vector<float>},
+                                     * @p{Vector<double>}, or a
+                                     * @p{BlockVector<...,double>}. It
                                      * is in the responsibility of
                                      * the caller to assure that the
                                      * types of the numbers stored in
@@ -961,11 +961,11 @@ class DoFObjectAccessor<3, dim> :  public DoFAccessor<dim>,
 
                                     /**
                                      * This function is the counterpart to
-                                     * #get_dof_values#: it takes a vector
+                                     * @p{get_dof_values}: it takes a vector
                                      * of values for the degrees of freedom
                                      * of the cell pointed to by this iterator
                                      * and writes these values into the global
-                                     * data vector #values#. This function
+                                     * data vector @p{values}. This function
                                      * is only callable for active cells.
                                      *
                                      * Note that for continuous finite
@@ -982,9 +982,9 @@ class DoFObjectAccessor<3, dim> :  public DoFAccessor<dim>,
                                      * have the right size beforehand.
                                      *
                                      * The output vector may be either
-                                     * a #Vector<float>#,
-                                     * #Vector<double>#, or a
-                                     * #BlockVector<...,double>#. It
+                                     * a @p{Vector<float>},
+                                     * @p{Vector<double>}, or a
+                                     * @p{BlockVector<...,double>}. It
                                      * is in the responsibility of
                                      * the caller to assure that the
                                      * types of the numbers stored in
@@ -997,21 +997,21 @@ class DoFObjectAccessor<3, dim> :  public DoFAccessor<dim>,
                         OutputVector         &values) const;
 
                                     /**
-                                     *  Return a pointer to the #i#th line
-                                     *  bounding this #Hex#.
+                                     *  Return a pointer to the @p{i}th line
+                                     *  bounding this @p{Hex}.
                                      */
     TriaIterator<dim,DoFObjectAccessor<1, dim> >
     line (const unsigned int i) const;
 
                                     /**
-                                     *  Return a pointer to the #i#th quad
-                                     *  bounding this #Hex#.
+                                     *  Return a pointer to the @p{i}th quad
+                                     *  bounding this @p{Hex}.
                                      */
     TriaIterator<dim,DoFObjectAccessor<2, dim> >
     quad (const unsigned int i) const;
     
                                     /**
-                                     * Return the #i#th child as a DoF hex
+                                     * Return the @p{i}th child as a DoF hex
                                      * iterator. This function is needed since
                                      * the child function of the base
                                      * class returns a hex accessor without
@@ -1026,7 +1026,7 @@ class DoFObjectAccessor<3, dim> :  public DoFAccessor<dim>,
                                      * to the global one and entering the
                                      * local values into the global vector.
                                      *
-                                     * The elements are {\it added} up to
+                                     * The elements are @em{added} up to
                                      * the elements in the global vector,
                                      * rather than just set, since this is
                                      * usually what one wants.
@@ -1036,7 +1036,7 @@ class DoFObjectAccessor<3, dim> :  public DoFAccessor<dim>,
 
                                     /**
                                      * This function does much the same as the
-                                     * #distribute_local_to_global(dVector,dVector)#
+                                     * @p{distribute_local_to_global(dVector,dVector)}
                                      * function, but operates on matrices
                                      * instead of vectors. The sparse matrix
                                      * is supposed to have non-zero entry
@@ -1056,18 +1056,18 @@ 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
- * #DoFObjectAccessor<1, 1># and #DoFObjectAccessor<2, 2># for the space dimension
+ * @p{DoFObjectAccessor<1, 1>} and @p{DoFObjectAccessor<2, 2>} for the space dimension
  * one and two, respectively, this class only collects the pieces
- * together by deriving from the appropriate #DoF*Accessor# and the
- * right #CellAccessor<dim># 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 #CellAccessor<dim># class).
+ * together by deriving from the appropriate @p{DoF*Accessor} and the
+ * right @p{CellAccessor<dim>} and finally adding two functions which give
+ * access to the neighbors and children as @p{DoFCellAccessor} objects
+ * rather than @p{CellAccessor} objects (the latter function was inherited
+ * from the @p{CellAccessor<dim>} class).
  *
- * Note that since for the class we derive from, i.e. #DoFObjectAccessor<dim,dim>#,
+ * Note that since for the class we derive from, i.e. @p{DoFObjectAccessor<dim,dim>},
  * the two template parameters are equal, the base class is actually derived from
- * #CellAccessor#, which makes the functions of this class available to the
- * #DoFCellAccessor# class as well.
+ * @p{CellAccessor}, which makes the functions of this class available to the
+ * @p{DoFCellAccessor} class as well.
  *
  * @author Wolfgang Bangerth, 1998
  */
@@ -1092,7 +1092,7 @@ class DoFCellAccessor :  public DoFObjectAccessor<dim, dim>
                     DoFObjectAccessor<dim, dim> (tria,level,index,local_data) {};
 
                                     /**
-                                     * Return the #i#th neighbor as a DoF cell
+                                     * Return the @p{i}th neighbor as a DoF cell
                                      * iterator. This function is needed since
                                      * the neighbor function of the base
                                      * class returns a cell accessor without
@@ -1101,7 +1101,7 @@ class DoFCellAccessor :  public DoFObjectAccessor<dim, dim>
     TriaIterator<dim,DoFCellAccessor<dim> > neighbor (const unsigned int) const;
 
                                     /**
-                                     * Return the #i#th child as a DoF cell
+                                     * Return the @p{i}th child as a DoF cell
                                      * iterator. This function is needed since
                                      * the child function of the base
                                      * class returns a cell accessor without
@@ -1110,7 +1110,7 @@ class DoFCellAccessor :  public DoFObjectAccessor<dim, dim>
     TriaIterator<dim,DoFCellAccessor<dim> > child (const unsigned int) const;
 
                                     /**
-                                     * Return an iterator to the #i#th face
+                                     * Return an iterator to the @p{i}th face
                                      * of this cell.
                                      *
                                      * This function is not implemented in 1D,
@@ -1126,7 +1126,7 @@ class DoFCellAccessor :  public DoFObjectAccessor<dim, dim>
                                      * then, the returned value is the vector
                                      * of nodal values on that cell. You could
                                      * then as well get the desired values
-                                     * through the #get_dof_values# function
+                                     * through the @p{get_dof_values} function
                                      * In the other case, when the cell has
                                      * children, we use the restriction
                                      * matrices provided by the finite element
@@ -1157,7 +1157,7 @@ class DoFCellAccessor :  public DoFObjectAccessor<dim, dim>
                                      * what the this function does in these
                                      * cases.
                                      *
-                                     * Unlike the #get_dof_values#
+                                     * Unlike the @p{get_dof_values}
                                      * function, this function is
                                      * associated to cells rather
                                      * than to lines, quads, and
@@ -1172,7 +1172,7 @@ class DoFCellAccessor :  public DoFObjectAccessor<dim, dim>
 
                                     /**
                                      * This, again, is the counterpart to
-                                     * #get_interpolated_dof_values#: you
+                                     * @p{get_interpolated_dof_values}: you
                                      * specify the dof values on a cell and
                                      * these are interpolated to the children
                                      * of the present cell and set on the
@@ -1182,12 +1182,12 @@ class DoFCellAccessor :  public DoFObjectAccessor<dim, dim>
                                      * the cell pointed to by this object is
                                      * terminal, then the dof values are set
                                      * in the global data vector by calling
-                                     * the #set_dof_values# function;
+                                     * the @p{set_dof_values} function;
                                      * otherwise, the values are prolonged
                                      * to each of the children and this
                                      * function is called for each of them.
                                      *
-                                     * Using the #get_interpolated_dof_values#
+                                     * Using the @p{get_interpolated_dof_values}
                                      * and this function, you can compute the
                                      * interpolation of a finite element
                                      * function to a coarser grid by first
@@ -1223,7 +1223,7 @@ class DoFCellAccessor :  public DoFObjectAccessor<dim, dim>
                                      * the prolongation matrices represent in
                                      * this case.
                                      *
-                                     * Unlike the #set_dof_values#
+                                     * Unlike the @p{set_dof_values}
                                      * function, this function is
                                      * associated to cells rather
                                      * than to lines, quads, and
@@ -1233,9 +1233,9 @@ class DoFCellAccessor :  public DoFObjectAccessor<dim, dim>
                                      * objects.
                                      *
                                      * The output vector may be either
-                                     * a #Vector<float>#,
-                                     * #Vector<double>#, or a
-                                     * #BlockVector<...,double>#. It
+                                     * a @p{Vector<float>},
+                                     * @p{Vector<double>}, or a
+                                     * @p{BlockVector<...,double>}. It
                                      * is in the responsibility of
                                      * the caller to assure that the
                                      * types of the numbers stored in
index 71ec847299a73f5bcb52dd87e3ec1aeb48b79a7d..3707e11c22b50dcc9bdd36b0117456439b63d70c 100644 (file)
@@ -44,7 +44,7 @@ template <int n_blocks> class BlockIndices;
  * operation.
  *
  * Condensation is done in four steps: first the large matrix sparsity pattern
- * is created (e.g. using #DoFHandler::create_sparsity_pattern#), then the
+ * is created (e.g. using @p{DoFHandler::create_sparsity_pattern}), then the
  * sparsity pattern of the condensed matrix is made out of the large sparsity
  * pattern and the constraints. After that the global matrix is assembled and
  * finally condensed. To do these steps, you have (at least) two possibilities:
@@ -58,7 +58,7 @@ template <int n_blocks> class BlockIndices;
  *   two major drawbacks: keeping two matrices at the same time can be quite
  *   unacceptable in many cases, since these matrices may be several 10 or even
  *   100 MB large. Secondly, the condensation process is quite expensive, since
- *   {\it all} entries of the matrix have to be copied, not only those which are
+ *   @em{all} entries of the matrix have to be copied, not only those which are
  *   subject to constraints.
  *
  * \item Use only one sparsity pattern and one matrix: doing it this way, the
@@ -89,14 +89,14 @@ template <int n_blocks> class BlockIndices;
  * Usually, the second way is chosen since memory consumption upon construction
  * of a second matrix rules out the first possibility.
  *
- * This class provides two sets of #condense# functions: those taking two
+ * This class provides two sets of @p{condense} functions: those taking two
  * arguments refer to the first possibility above, those taking only one do
  * their job in-place and refer to the second possibility.
  *
  * Condensing vectors works exactly as described above for matrices.
  *
  * After solving the condensed system of equations, the solution vector has to
- * be redistributed. This is done by the two #distribute# function, one working
+ * be redistributed. This is done by the two @p{distribute} function, one working
  * with two vectors, one working in-place. The operation of distribution undoes
  * the condensation process in some sense, but it should be noted that it is not
  * the inverse operation.
@@ -167,17 +167,17 @@ class ConstraintMatrix : public Subscriptor
 
                                     /**
                                      * Return whether the degree of
-                                     * freedom with number #index# is
+                                     * freedom with number @p{index} is
                                      * a constrained one.
                                      *
-                                     * Note that if #close# was
+                                     * Note that if @p{close} was
                                      * called before, then this
                                      * function is significantly
                                      * faster, since then the
                                      * constrained degrees of freedom
                                      * are sorted and we can do a
                                      * binary search, while before
-                                     * #close# was called, we have to
+                                     * @p{close} was called, we have to
                                      * perform a linear search
                                      * through all entries.
                                      */
@@ -190,7 +190,7 @@ class ConstraintMatrix : public Subscriptor
                                      * in 2d a hanging node is
                                      * constrained only to its two
                                      * neighbors, so the returned
-                                     * value would be #2#. However,
+                                     * value would be @p{2}. However,
                                      * for higher order elements
                                      * and/or higher dimensions, or
                                      * other types of constraints,
@@ -251,7 +251,7 @@ class ConstraintMatrix : public Subscriptor
                                      * matrix struct should be condensed and
                                      * compressed. It is the user's
                                      * responsibility to guarantee that all
-                                     * entries in the #condensed# matrix be
+                                     * entries in the @p{condensed} matrix be
                                      * zero!
                                      *
                                      * The constraint matrix object must be
@@ -280,15 +280,15 @@ class ConstraintMatrix : public Subscriptor
     void condense (BlockSparseMatrix<number,blocks,blocks> &sparsity) const;
     
                                     /**
-                                     * Condense the given vector #uncondensed#
-                                     * into #condensed#. It is the user's
+                                     * Condense the given vector @p{uncondensed}
+                                     * into @p{condensed}. It is the user's
                                      * responsibility to guarantee that all
-                                     * entries of #condensed# be zero!
+                                     * entries of @p{condensed} be zero!
                                      *
-                                     * The #VectorType# may be a
-                                     * #Vector<float>#,
-                                     * #Vector<double>#,
-                                     * #BlockVector<...>#, or any
+                                     * The @p{VectorType} may be a
+                                     * @p{Vector<float>},
+                                     * @p{Vector<double>},
+                                     * @p{BlockVector<...>}, or any
                                      * other type having the same
                                      * interface.
                                      */
@@ -298,10 +298,10 @@ class ConstraintMatrix : public Subscriptor
 
                                     /**
                                      * Condense the given vector
-                                     * in-place. The #VectorType# may
-                                     * be a #Vector<float>#,
-                                     * #Vector<double>#,
-                                     * #BlockVector<...>#, or any
+                                     * in-place. The @p{VectorType} may
+                                     * be a @p{Vector<float>},
+                                     * @p{Vector<double>},
+                                     * @p{BlockVector<...>}, or any
                                      * other type having the same
                                      * interface.
                                      */
@@ -310,22 +310,22 @@ class ConstraintMatrix : public Subscriptor
 
                                     /**
                                      * Re-distribute the elements of
-                                     * the vector #condensed# to
-                                     * #uncondensed#. It is the
+                                     * the vector @p{condensed} to
+                                     * @p{uncondensed}. It is the
                                      * user's responsibility to
                                      * guarantee that all entries of
-                                     * #uncondensed# be zero!
+                                     * @p{uncondensed} be zero!
                                      *
                                      * This function undoes the
-                                     * action of #condense# somehow,
+                                     * action of @p{condense} somehow,
                                      * but it should be noted that it
                                      * is not the inverse of
-                                     * #condense#.
+                                     * @p{condense}.
                                      *
-                                     * The #VectorType# may be a
-                                     * #Vector<float>#,
-                                     * #Vector<double>#,
-                                     * #BlockVector<...>#, or any
+                                     * The @p{VectorType} may be a
+                                     * @p{Vector<float>},
+                                     * @p{Vector<double>},
+                                     * @p{BlockVector<...>}, or any
                                      * other type having the same
                                      * interface.
                                      */
@@ -336,10 +336,10 @@ class ConstraintMatrix : public Subscriptor
                                     /**
                                      * Re-distribute the elements of
                                      * the vector in-place. The
-                                     * #VectorType# may be a
-                                     * #Vector<float>#,
-                                     * #Vector<double>#,
-                                     * #BlockVector<...>#, or any
+                                     * @p{VectorType} may be a
+                                     * @p{Vector<float>},
+                                     * @p{Vector<double>},
+                                     * @p{BlockVector<...>}, or any
                                      * other type having the same
                                      * interface.
                                      */
@@ -350,10 +350,10 @@ class ConstraintMatrix : public Subscriptor
                                      * Delete hanging nodes in a
                                      * vector.  Sets all hanging node
                                      * values to zero. The
-                                     * #VectorType# may be a
-                                     * #Vector<float>#,
-                                     * #Vector<double>#,
-                                     * #BlockVector<...>#, or any
+                                     * @p{VectorType} may be a
+                                     * @p{Vector<float>},
+                                     * @p{Vector<double>},
+                                     * @p{BlockVector<...>}, or any
                                      * other type having the same
                                      * interface.
                                      */
@@ -368,7 +368,7 @@ class ConstraintMatrix : public Subscriptor
                                      * This function writes out all entries
                                      * in the constraint matrix lines with
                                      * their value in the form
-                                     * #row col : value#. Unconstrained lines
+                                     * @p{row col : value}. Unconstrained lines
                                      * containing only one identity entry are
                                      * not stored in this object and are not
                                      * printed.
@@ -443,7 +443,7 @@ class ConstraintMatrix : public Subscriptor
                                          * For the reason why we use a vector
                                          * instead of a map and the consequences
                                          * thereof, the same applies as what is
-                                         * said for #ConstraintMatrix::lines#.
+                                         * said for @p{ConstraintMatrix::lines}.
                                          */
        vector<pair<unsigned int,double> > entries;
 
@@ -472,7 +472,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 #close()# function.
+                                     * place when calling the @p{close()} function.
                                      *
                                      * We could, instead of using a vector, use
                                      * an associative array, like a map to
index f39cb8877eaf4cd109ece5c607ae5e9bcca3b9cd..129fbcd98dd1542ed24c50a8c4f8fe0577ba1186 100644 (file)
@@ -88,7 +88,7 @@ void ConstraintMatrix::condense (BlockSparsityPattern<blocks,blocks> &sparsity)
                    
                    if (distribute[global_col] != -1)
                                                       // distribute entry at regular
-                                                      // row #row# and irregular column
+                                                      // row @p{row} and irregular column
                                                       // global_col
                      {
                        for (unsigned int q=0;
@@ -131,7 +131,7 @@ void ConstraintMatrix::condense (BlockSparsityPattern<blocks,blocks> &sparsity)
                    
                    if (distribute[global_col] == -1)
                                                       // distribute entry at irregular
-                                                      // row #row# and regular column
+                                                      // row @p{row} and regular column
                                                       // global_col.
                      {
                        for (unsigned int q=0; q!=lines[distribute[row]].entries.size(); ++q) 
@@ -140,8 +140,8 @@ void ConstraintMatrix::condense (BlockSparsityPattern<blocks,blocks> &sparsity)
                      }
                    else
                                                       // distribute entry at irregular
-                                                      // row #row# and irregular column
-                                                      // #global_col#
+                                                      // row @p{row} and irregular column
+                                                      // @p{global_col}
                      {
                        for (unsigned int p=0; p!=lines[distribute[row]].entries.size(); ++p)
                          for (unsigned int q=0; q!=lines[distribute[global_col]].entries.size(); ++q)
@@ -197,7 +197,7 @@ ConstraintMatrix::condense (const SparseMatrix<number> &uncondensed,
        {
                                           // this line is constrained
          new_line.push_back (-1);
-                                          // note that #lines# is ordered
+                                          // note that @p{lines} is ordered
          ++shift;
          ++next_constraint;
          if (next_constraint == lines.end())
@@ -215,8 +215,8 @@ ConstraintMatrix::condense (const SparseMatrix<number> &uncondensed,
 
   next_constraint = lines.begin();
                                   // note: in this loop we need not check
-                                  // whether #next_constraint# is a valid
-                                  // iterator, since #next_constraint# is
+                                  // whether @p{next_constraint} is a valid
+                                  // iterator, since @p{next_constraint} is
                                   // only evaluated so often as there are
                                   // entries in new_line[*] which tells us
                                   // which constraints exist
@@ -326,7 +326,7 @@ ConstraintMatrix::condense (SparseMatrix<number> &uncondensed) const
            {
              if (distribute[sparsity.get_column_numbers()[j]] != -1)
                                                 // distribute entry at regular
-                                                // row #row# and irregular column
+                                                // row @p{row} and irregular column
                                                 // sparsity.get_column_numbers()[j]; set old
                                                 // entry to zero
                {
@@ -360,7 +360,7 @@ ConstraintMatrix::condense (SparseMatrix<number> &uncondensed) const
            {
              if (distribute[sparsity.get_column_numbers()[j]] == -1)
                                                 // distribute entry at irregular
-                                                // row #row# and regular column
+                                                // row @p{row} and regular column
                                                 // sparsity.get_column_numbers()[j]. set old
                                                 // entry to zero
                {
@@ -375,7 +375,7 @@ ConstraintMatrix::condense (SparseMatrix<number> &uncondensed) const
                }
              else
                                                 // distribute entry at irregular
-                                                // row #row# and irregular column
+                                                // row @p{row} and irregular column
                                                 // sparsity.get_column_numbers()[j]
                                                 // set old entry to one if on main
                                                 // diagonal, zero otherwise
@@ -477,7 +477,7 @@ ConstraintMatrix::condense (BlockSparseMatrix<number,blocks,blocks> &uncondensed
                    
                    if (distribute[global_col] != -1)
                                                       // distribute entry at regular
-                                                      // row #row# and irregular column
+                                                      // row @p{row} and irregular column
                                                       // global_col;
                                                       // set old entry to zero
                      {
@@ -532,7 +532,7 @@ ConstraintMatrix::condense (BlockSparseMatrix<number,blocks,blocks> &uncondensed
                    
                    if (distribute[global_col] == -1)
                                                       // distribute entry at irregular
-                                                      // row #row# and regular column
+                                                      // row @p{row} and regular column
                                                       // global_col. set old
                                                       // entry to zero
                      {
@@ -550,8 +550,8 @@ ConstraintMatrix::condense (BlockSparseMatrix<number,blocks,blocks> &uncondensed
                      }
                    else
                                                       // distribute entry at irregular
-                                                      // row #row# and irregular column
-                                                      // #global_col#
+                                                      // row @p{row} and irregular column
+                                                      // @p{global_col}
                                                       // set old entry to one if on main
                                                       // diagonal, zero otherwise
                      {
@@ -608,7 +608,7 @@ ConstraintMatrix::condense (const VectorType &uncondensed,
        {
                                           // this line is constrained
          new_line.push_back (-1);
-                                          // note that #lines# is ordered
+                                          // note that @p{lines} is ordered
          ++shift;
          ++next_constraint;
          if (next_constraint == lines.end())
@@ -626,8 +626,8 @@ ConstraintMatrix::condense (const VectorType &uncondensed,
 
   next_constraint = lines.begin();
                                   // note: in this loop we need not check
-                                  // whether #next_constraint# is a valid
-                                  // iterator, since #next_constraint# is
+                                  // whether @p{next_constraint} is a valid
+                                  // iterator, since @p{next_constraint} is
                                   // only evaluated so often as there are
                                   // entries in new_line[*] which tells us
                                   // which constraints exist
@@ -739,7 +739,7 @@ ConstraintMatrix::distribute (const VectorType &condensed,
        {
                                           // this line is constrained
          old_line.push_back (-1);
-                                          // note that #lines# is ordered
+                                          // note that @p{lines} is ordered
          ++shift;
          ++next_constraint;
          if (next_constraint == lines.end())
@@ -757,8 +757,8 @@ ConstraintMatrix::distribute (const VectorType &condensed,
 
   next_constraint = lines.begin();
                                   // note: in this loop we need not check
-                                  // whether #next_constraint# is a valid
-                                  // iterator, since #next_constraint# is
+                                  // whether @p{next_constraint} is a valid
+                                  // iterator, since @p{next_constraint} is
                                   // only evaluated so often as there are
                                   // entries in new_line[*] which tells us
                                   // which constraints exist
index 5aa4eddf704e9edc06774e1e91f0c3f369f23246..b3273c782dc925fe458bc8d605fc9c50463ab20b 100644 (file)
@@ -146,22 +146,22 @@ class DoFDimensionInfo<3> {
  * is described in the \Ref{DoFLevel} class documentation.
  *
  * Finally it offers a starting point for the assemblage of the matrices
- * by offering #begin()# and #end()# functions which return iterators
+ * by offering @p{begin()} and @p{end()} functions which return iterators
  * to walk on the DoF structures as well as the triangulation data.
  * These iterators work much like those described in the documentation
- * of the #Triangulation# class and of the iterator classes themselved,
+ * of the @p{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 #++# and #--# operators
+ * order in which dof iterators are presented by the @p{++} and @p{--} operators
  * is the same as that for the alike triangulation iterators.
  *
  * This class also provides functions to create the sparsity patterns of
  * global matrices as well as matrices living on (parts of) the boundary.
  * 
  * 
- * \subsection{Distribution of indices for degrees of freedom}
+ * @sect3{Distribution of indices for degrees of freedom}
  *
  * The degrees of freedom (`dofs') are distributed on the given triangulation
- * by the function #distribute_dofs()#. It gets passed a finite element object
+ * by the function @p{distribute_dofs()}. 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
@@ -175,18 +175,18 @@ class DoFDimensionInfo<3> {
  *
  * This numbering implies very large bandwiths of the resulting matrices and
  * is thus vastly suboptimal for some solution algorithms. For this reason,
- * the #DoFRenumbering# class offers the function #renumber_dofs# which reorders
+ * the @p{DoFRenumbering} class offers the function @p{renumber_dofs} which reorders
  * the dof numbering according to some scheme. See there for a discussion of
  * the implemented algorithms.
  *
  *
- * \subsection{User defined renumbering schemes}
+ * @sect3{User defined renumbering schemes}
  *
- * The #DoFRenumbering# class offers a fixed number of renumbering
+ * The @p{DoFRenumbering} class offers a fixed number of renumbering
  * schemes like the Cuthill-McKey scheme. Basically, the function sets
  * up an array in which for each degree of freedom the index is stored
  * which is to be assigned by the renumbering. Using this array, the
- * #renumber_dofs(vector<unsigned int>)# function is called, which actually
+ * @p{renumber_dofs(vector<unsigned int>)} 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
@@ -194,20 +194,20 @@ 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
- * #renumber_dofs(vector<unsigned int>)# with the array, which converts old
+ * @p{renumber_dofs(vector<unsigned int>)} with the array, which converts old
  * into new degree of freedom indices.
  *
  *
- * \subsection{Boundaries}
+ * @sect3{Boundaries}
  *
  * When projecting the traces of functions to the boundary or parts thereof, one
  * needs to built matrices and vectors with the degrees of freedom on the
  * boundary. What is needed in this case is a numbering of the boundary degrees
  * of freedom, starting from zero on and not considering the degrees of freedom
- * in the interior. The #map_dof_to_boundary_indices# function does exactly
+ * in the interior. The @p{map_dof_to_boundary_indices} function does exactly
  * this, by providing a vector with as many entries as there are degrees of
  * freedom on the whole domain, with each entry being the number in the
- * numbering of the boundary or #-1# if the dof is not on the boundary. You
+ * numbering of the boundary or @p{-1} if the dof is not on the boundary. You
  * should always use this function to get the mapping between local (boundary)
  * and the global numbers, for example to build the mass matrix on the
  * boundary, or to get the global index of a degree of freedom if we want to
@@ -223,7 +223,7 @@ class DoFDimensionInfo<3> {
  * internal knowledge about the used algorithm, you are better off if you
  * just accept the mapping `as is'.
  *
- * Actually, there are two #map_dof_to_boundary_indices# functions, one
+ * Actually, there are two @p{map_dof_to_boundary_indices} functions, one
  * producing a numbering for all boundary degrees of freedom and one producing
  * a numbering for only parts of the boundary, namely those parts for which
  * the boundary indicator is listed in a set of indicators given to the
@@ -237,20 +237,20 @@ class DoFDimensionInfo<3> {
  * different parts may be intermixed.
  *
  * Degrees of freedom on the boundary but not on one of the specified
- * boundary parts are given the index #invalid_dof_index#, as if they
+ * boundary parts are given the index @p{invalid_dof_index}, as if they
  * were in the interior. If no boundary indicator was given or if no
  * face of a cell has a boundary indicator contained in the given
- * list, the vector of new indices consists solely of #invalid_dof_index#s.
+ * list, the vector of new indices consists solely of @p{invalid_dof_index}s.
  *
  * The question what a degree of freedom on the boundary is, is not so easy.
  * It should really be a degree of freedom of which the respective basis
  * function has nonzero values on the boundary. At least for Lagrange elements
  * this definition is equal to the statement that the off-point of the trial
  * function, i.e. the point where the function assumes its nominal value (for
- * Lagrange elements this is the point where it has the function value #1#), is
+ * Lagrange elements this is the point where it has the function value @p{1}), is
  * located on the boundary. We do not check this directly, the criterion is
  * rather defined through the information the finite element class gives: the
- * #FiniteElementBase# class defines the numbers of basis functions per vertex,
+ * @p{FiniteElementBase} class defines the numbers of basis functions per vertex,
  * per line, and so on and the basis functions are numbered after this
  * information; a basis function is to be considered to be on the face of a
  * cell (and thus on the boundary if the cell is at the boundary) according
@@ -296,7 +296,7 @@ class DoFHandler  :  public Subscriptor,
                                      * values on this part of the boundary.
                                      * Only one boundary function may be given
                                      * for each boundary indicator, which is
-                                     * guaranteed by the #map# data type.
+                                     * guaranteed by the @p{map} data type.
                                      */
     typedef map<unsigned char,const Function<dim>*> FunctionMap;
 
@@ -318,7 +318,7 @@ class DoFHandler  :  public Subscriptor,
     static const unsigned int invalid_dof_index = static_cast<unsigned int>(-1);
     
                                     /**
-                                     * Constructor. Take #tria# as the
+                                     * Constructor. Take @p{tria} as the
                                      * triangulation to work on.
                                      */
     DoFHandler (Triangulation<dim> &tria);
@@ -336,7 +336,7 @@ class DoFHandler  :  public Subscriptor,
                                      * method.
                                      *
                                      * The additional optional
-                                     * parameter #offset# allows you
+                                     * parameter @p{offset} allows you
                                      * to reserve space for a finite
                                      * number of additional vector
                                      * entries in the beginning of
@@ -354,7 +354,7 @@ class DoFHandler  :  public Subscriptor,
                                      * object shall be longer than
                                      * that of this object. If you
                                      * don't want this behaviour, you
-                                     * may want to call the #clear#
+                                     * may want to call the @p{clear}
                                      * member function which also
                                      * releases the lock of this
                                      * object to the finite element.
@@ -372,7 +372,7 @@ class DoFHandler  :  public Subscriptor,
                                      * Clear all data of this object and
                                      * especially delete the lock this object
                                      * has to the finite element used the last
-                                     * time when #distribute_dofs# was called.
+                                     * time when @p{distribute_dofs} was called.
                                      */
     virtual void clear ();
     
@@ -381,14 +381,14 @@ class DoFHandler  :  public Subscriptor,
                                      * a list of new dof numbers for all the
                                      * dofs.
                                      *
-                                     * #new_numbers# is an array of integers
+                                     * @p{new_numbers} is an array of integers
                                      * with size equal to the number of dofs
                                      * on the present grid. It stores the new
                                      * indices after renumbering in the
                                      * order of the old indices.
                                      *
                                      * This function is called by the
-                                     * #renumber_dofs# function after computing
+                                     * @p{renumber_dofs} function after computing
                                      * the ordering of the degrees of freedom.
                                      * However, you can call this function
                                      * yourself, which is necessary if a user
@@ -405,7 +405,7 @@ class DoFHandler  :  public Subscriptor,
                                      * This is the maximum number of entries
                                      * per line in the system matrix; this
                                      * information can therefore be used upon
-                                     * construction of the #SparsityPattern#
+                                     * construction of the @p{SparsityPattern}
                                      * object.
                                      *
                                      * The returned number is not really the
@@ -429,7 +429,7 @@ class DoFHandler  :  public Subscriptor,
                                      * the boundary can couple with.
                                      *
                                      * The number is the same as for
-                                     * #max_coupling_between_dofs# in one
+                                     * @p{max_coupling_between_dofs} in one
                                      * dimension less.
                                      */
     unsigned int max_couplings_between_boundary_dofs () const;
@@ -439,16 +439,16 @@ class DoFHandler  :  public Subscriptor,
                                      * of freedom indices to the
                                      * index of that degree of
                                      * freedom on the boundary. After
-                                     * this operation, #mapping[dof]#
+                                     * this operation, @p{mapping[dof]}
                                      * gives the index of the the
                                      * degree of freedom with global
-                                     * number #dof# in the list of
+                                     * number @p{dof} in the list of
                                      * degrees of freedom on the
                                      * boundary.  If the degree of
                                      * freedom requested is not on
                                      * the boundary, the value of
-                                     * #mapping[dof]# is
-                                     * #invalid_dof_index#. This
+                                     * @p{mapping[dof]} is
+                                     * @p{invalid_dof_index}. This
                                      * function is mainly used when
                                      * setting up matrices and
                                      * vectors on the boundary from
@@ -458,7 +458,7 @@ class DoFHandler  :  public Subscriptor,
                                      * numbers of the trial functions
                                      * local to the boundary.
                                      *
-                                     * Prior content of #mapping# is deleted.
+                                     * Prior content of @p{mapping} is deleted.
                                      *
                                      * This function is not implemented for
                                      * one dimension. See the general doc
@@ -484,30 +484,30 @@ class DoFHandler  :  public Subscriptor,
                                     /*@{*/
                                     /**
                                      *  Iterator to the first cell, used
-                                     *  or not, on level #level#. If a level
+                                     *  or not, on level @p{level}. If a level
                                      *  has no cells, a past-the-end iterator
                                      *  is returned.
                                      *
-                                     *  This function calls #begin_raw_line#
-                                     *  in 1D and #begin_raw_quad# in 2D.
+                                     *  This function calls @p{begin_raw_line}
+                                     *  in 1D and @p{begin_raw_quad} in 2D.
                                      */
     raw_cell_iterator    begin_raw   (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first used cell
-                                     *  on level #level#.
+                                     *  on level @p{level}.
                                      *
-                                     *  This function calls #begin_line#
-                                     *  in 1D and #begin_quad# in 2D.
+                                     *  This function calls @p{begin_line}
+                                     *  in 1D and @p{begin_quad} in 2D.
                                      */
     cell_iterator        begin       (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first active
-                                     *  cell on level #level#.
+                                     *  cell on level @p{level}.
                                      *
-                                     *  This function calls #begin_active_line#
-                                     *  in 1D and #begin_active_quad# in 2D.
+                                     *  This function calls @p{begin_active_line}
+                                     *  in 1D and @p{begin_active_quad} in 2D.
                                      */
     active_cell_iterator begin_active(const unsigned int level = 0) const;
 
@@ -517,32 +517,32 @@ class DoFHandler  :  public Subscriptor,
                                      *  iterators with past-the-end or
                                      *  before-the-beginning states.
                                      *
-                                     *  This function calls #end_line#
-                                     *  in 1D and #end_quad# in 2D.
+                                     *  This function calls @p{end_line}
+                                     *  in 1D and @p{end_quad} in 2D.
                                      */
     raw_cell_iterator    end () const;
 
                                     /**
                                      * Return an iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     cell_iterator        end (const unsigned int level) const;
     
                                     /**
                                      * Return a raw iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     raw_cell_iterator    end_raw (const unsigned int level) const;
 
                                     /**
                                      * Return an active iterator which is the
-                                     * first iterator not on level. If #level#
+                                     * first iterator not on level. If @p{level}
                                      * is the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     active_cell_iterator end_active (const unsigned int level) const;
 
@@ -550,17 +550,17 @@ class DoFHandler  :  public Subscriptor,
                                      *  Return an iterator pointing to the
                                      *  last cell, used or not.
                                      *
-                                     *  This function calls #last_raw_line#
-                                     *  in 1D and #last_raw_quad# in 2D.
+                                     *  This function calls @p{last_raw_line}
+                                     *  in 1D and @p{last_raw_quad} in 2D.
                                      */
     raw_cell_iterator    last_raw () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  cell of the level #level#, used or not.
+                                     *  cell of the level @p{level}, used or not.
                                      *
-                                     *  This function calls #last_raw_line#
-                                     *  in 1D and #last_raw_quad# in 2D.
+                                     *  This function calls @p{last_raw_line}
+                                     *  in 1D and @p{last_raw_quad} in 2D.
                                      */
     raw_cell_iterator    last_raw (const unsigned int level) const;
 
@@ -568,17 +568,17 @@ class DoFHandler  :  public Subscriptor,
                                      *  Return an iterator pointing to the last
                                      *  used cell.
                                      *
-                                     *  This function calls #last_line#
-                                     *  in 1D and #last_quad# in 2D.
+                                     *  This function calls @p{last_line}
+                                     *  in 1D and @p{last_quad} in 2D.
                                      */
     cell_iterator        last () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  used cell on level #level#.
+                                     *  used cell on level @p{level}.
                                      *
-                                     *  This function calls #last_line#
-                                     *  in 1D and #last_quad# in 2D.
+                                     *  This function calls @p{last_line}
+                                     *  in 1D and @p{last_quad} in 2D.
                                      */
     cell_iterator        last (const unsigned int level) const;
 
@@ -586,17 +586,17 @@ class DoFHandler  :  public Subscriptor,
                                      *  Return an iterator pointing to the last
                                      *  active cell.
                                      *
-                                     *  This function calls #last_active_line#
-                                     *  in 1D and #last_active_quad# in 2D.
+                                     *  This function calls @p{last_active_line}
+                                     *  in 1D and @p{last_active_quad} in 2D.
                                      */
     active_cell_iterator last_active () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  active cell on level #level#.
+                                     *  active cell on level @p{level}.
                                      *
-                                     *  This function calls #last_active_line#
-                                     *  in 1D and #last_active_quad# in 2D.
+                                     *  This function calls @p{last_active_line}
+                                     *  in 1D and @p{last_active_quad} in 2D.
                                      */
     active_cell_iterator last_active (const unsigned int level) const;
                                     //@}
@@ -609,30 +609,30 @@ class DoFHandler  :  public Subscriptor,
                                     /*@{*/
                                     /**
                                      *  Iterator to the first face, used
-                                     *  or not, on level #level#. If a level
+                                     *  or not, on level @p{level}. If a level
                                      *  has no faces, a past-the-end iterator
                                      *  is returned.
                                      *
-                                     *  This function calls #begin_raw_line#
-                                     *  in 2D and #begin_raw_quad# in 3D.
+                                     *  This function calls @p{begin_raw_line}
+                                     *  in 2D and @p{begin_raw_quad} in 3D.
                                      */
     raw_face_iterator    begin_raw_face   (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first used face
-                                     *  on level #level#.
+                                     *  on level @p{level}.
                                      *
-                                     *  This function calls #begin_line#
-                                     *  in 2D and #begin_quad# in 3D.
+                                     *  This function calls @p{begin_line}
+                                     *  in 2D and @p{begin_quad} in 3D.
                                      */
     face_iterator        begin_face       (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first active
-                                     *  face on level #level#.
+                                     *  face on level @p{level}.
                                      *
-                                     *  This function calls #begin_active_line#
-                                     *  in 2D and #begin_active_quad# in 3D.
+                                     *  This function calls @p{begin_active_line}
+                                     *  in 2D and @p{begin_active_quad} in 3D.
                                      */
     active_face_iterator begin_active_face(const unsigned int level = 0) const;
 
@@ -642,32 +642,32 @@ class DoFHandler  :  public Subscriptor,
                                      *  iterators with past-the-end or
                                      *  before-the-beginning states.
                                      *
-                                     *  This function calls #end_line#
-                                     *  in 2D and #end_quad# in 3D.
+                                     *  This function calls @p{end_line}
+                                     *  in 2D and @p{end_quad} in 3D.
                                      */
     raw_face_iterator    end_face () const;
 
                                     /**
                                      * Return an iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     face_iterator        end_face (const unsigned int level) const;
     
                                     /**
                                      * Return a raw iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     raw_face_iterator    end_raw_face (const unsigned int level) const;
 
                                     /**
                                      * Return an active iterator which is the
-                                     * first iterator not on level. If #level#
+                                     * first iterator not on level. If @p{level}
                                      * is the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     active_face_iterator end_active_face (const unsigned int level) const;
 
@@ -675,17 +675,17 @@ class DoFHandler  :  public Subscriptor,
                                      *  Return an iterator pointing to the
                                      *  last face, used or not.
                                      *
-                                     *  This function calls #last_raw_line#
-                                     *  in 2D and #last_raw_quad# in 3D.
+                                     *  This function calls @p{last_raw_line}
+                                     *  in 2D and @p{last_raw_quad} in 3D.
                                      */
     raw_face_iterator    last_raw_face () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  face of the level #level#, used or not.
+                                     *  face of the level @p{level}, used or not.
                                      *
-                                     *  This function calls #last_raw_line#
-                                     *  in 2D and #last_raw_quad# in 3D.
+                                     *  This function calls @p{last_raw_line}
+                                     *  in 2D and @p{last_raw_quad} in 3D.
                                      */
     raw_face_iterator    last_raw_face (const unsigned int level) const;
 
@@ -693,17 +693,17 @@ class DoFHandler  :  public Subscriptor,
                                      *  Return an iterator pointing to the last
                                      *  used face.
                                      *
-                                     *  This function calls #last_line#
-                                     *  in 2D and #last_quad# in 3D.
+                                     *  This function calls @p{last_line}
+                                     *  in 2D and @p{last_quad} in 3D.
                                      */
     face_iterator        last_face () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  used face on level #level#.
+                                     *  used face on level @p{level}.
                                      *
-                                     *  This function calls #last_line#
-                                     *  in 2D and #last_quad# in 3D.
+                                     *  This function calls @p{last_line}
+                                     *  in 2D and @p{last_quad} in 3D.
                                      */
     face_iterator        last_face (const unsigned int level) const;
 
@@ -711,17 +711,17 @@ class DoFHandler  :  public Subscriptor,
                                      *  Return an iterator pointing to the last
                                      *  active face.
                                      *
-                                     *  This function calls #last_active_line#
-                                     *  in 2D and #last_active_quad# in 3D.
+                                     *  This function calls @p{last_active_line}
+                                     *  in 2D and @p{last_active_quad} in 3D.
                                      */
     active_face_iterator last_active_face () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  active face on level #level#.
+                                     *  active face on level @p{level}.
                                      *
-                                     *  This function calls #last_active_line#
-                                     *  in 2D and #last_active_quad# in 3D.
+                                     *  This function calls @p{last_active_line}
+                                     *  in 2D and @p{last_active_quad} in 3D.
                                      */
     active_face_iterator last_active_face (const unsigned int level) const;
                                     //@}
@@ -735,7 +735,7 @@ class DoFHandler  :  public Subscriptor,
                                     /*@{*/
                                     /**
                                      *  Iterator to the first line, used
-                                     *  or not, on level #level#. If a level
+                                     *  or not, on level @p{level}. If a level
                                      *  has no lines, a past-the-end iterator
                                      *  is returned.
                                      */
@@ -743,13 +743,13 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      *  Iterator to the first used line
-                                     *  on level #level#.
+                                     *  on level @p{level}.
                                      */
     line_iterator        begin_line       (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first active
-                                     *  line on level #level#.
+                                     *  line on level @p{level}.
                                      */
     active_line_iterator begin_active_line(const unsigned int level = 0) const;
 
@@ -763,25 +763,25 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      * Return an iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     line_iterator        end_line (const unsigned int level) const;
     
                                     /**
                                      * Return a raw iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     raw_line_iterator    end_raw_line (const unsigned int level) const;
 
                                     /**
                                      * Return an active iterator which is the
-                                     * first iterator not on level. If #level#
+                                     * first iterator not on level. If @p{level}
                                      * is the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     active_line_iterator end_active_line (const unsigned int level) const;
 
@@ -794,7 +794,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  line of the level #level#, used or not.
+                                     *  line of the level @p{level}, used or not.
 
                                      */
     raw_line_iterator    last_raw_line (const unsigned int level) const;
@@ -807,7 +807,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  used line on level #level#.
+                                     *  used line on level @p{level}.
                                      */
     line_iterator        last_line (const unsigned int level) const;
 
@@ -819,7 +819,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  active line on level #level#.
+                                     *  active line on level @p{level}.
                                      */
     active_line_iterator last_active_line (const unsigned int level) const;
                                     /*@}*/       
@@ -832,7 +832,7 @@ class DoFHandler  :  public Subscriptor,
                                      */
                                     /**
                                      *  Iterator to the first quad, used
-                                     *  or not, on level #level#. If a level
+                                     *  or not, on level @p{level}. If a level
                                      *  has no quads, a past-the-end iterator
                                      *  is returned.
                                      */
@@ -840,13 +840,13 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      *  Iterator to the first used quad
-                                     *  on level #level#.
+                                     *  on level @p{level}.
                                      */
     quad_iterator        begin_quad       (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first active
-                                     *  quad on level #level#.
+                                     *  quad on level @p{level}.
                                      */
     active_quad_iterator begin_active_quad(const unsigned int level = 0) const;
 
@@ -860,25 +860,25 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      * Return an iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     quad_iterator        end_quad (const unsigned int level) const;
     
                                     /**
                                      * Return a raw iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     raw_quad_iterator    end_raw_quad (const unsigned int level) const;
 
                                     /**
                                      * Return an active iterator which is the
-                                     * first iterator not on level. If #level#
+                                     * first iterator not on level. If @p{level}
                                      * is the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     active_quad_iterator end_active_quad (const unsigned int level) const;
 
@@ -891,7 +891,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  quad of the level #level#, used or not.
+                                     *  quad of the level @p{level}, used or not.
 
                                      */
     raw_quad_iterator    last_raw_quad (const unsigned int level) const;
@@ -904,7 +904,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  used quad on level #level#.
+                                     *  used quad on level @p{level}.
                                      */
     quad_iterator        last_quad (const unsigned int level) const;
 
@@ -916,7 +916,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  active quad on level #level#.
+                                     *  active quad on level @p{level}.
                                      */
     active_quad_iterator last_active_quad (const unsigned int level) const;
                                     /*@}*/
@@ -929,7 +929,7 @@ class DoFHandler  :  public Subscriptor,
                                      */
                                     /**
                                      *  Iterator to the first hex, used
-                                     *  or not, on level #level#. If a level
+                                     *  or not, on level @p{level}. If a level
                                      *  has no hexs, a past-the-end iterator
                                      *  is returned.
                                      */
@@ -938,14 +938,14 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      *  Iterator to the first used hex
-                                     *  on level #level#.
+                                     *  on level @p{level}.
                                      */
     hex_iterator
     begin_hex       (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first active
-                                     *  hex on level #level#.
+                                     *  hex on level @p{level}.
                                      */
     active_hex_iterator
     begin_active_hex(const unsigned int level = 0) const;
@@ -961,25 +961,25 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      * Return an iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     hex_iterator        end_hex (const unsigned int level) const;
     
                                     /**
                                      * Return a raw iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     raw_hex_iterator    end_raw_hex (const unsigned int level) const;
 
                                     /**
                                      * Return an active iterator which is the
-                                     * first iterator not on level. If #level#
+                                     * first iterator not on level. If @p{level}
                                      * is the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     active_hex_iterator end_active_hex (const unsigned int level) const;
 
@@ -992,7 +992,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  hex of the level #level#, used or not.
+                                     *  hex of the level @p{level}, used or not.
 
                                      */
     raw_hex_iterator
@@ -1007,7 +1007,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  used hex on level #level#.
+                                     *  used hex on level @p{level}.
                                      */
     hex_iterator
     last_hex (const unsigned int level) const;
@@ -1021,7 +1021,7 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  active hex on level #level#.
+                                     *  active hex on level @p{level}.
                                      */
     active_hex_iterator
     last_active_hex (const unsigned int level) const;
@@ -1049,9 +1049,9 @@ class DoFHandler  :  public Subscriptor,
                                      * located on those parts of the boundary
                                      * which have a boundary indicator listed
                                      * in the given set. The reason that a
-                                     * #map# rather than a #set# is used is the
+                                     * @p{map} rather than a @p{set} is used is the
                                      * same as descibed in the section on the
-                                     * #make_boundary_sparsity_pattern# function.
+                                     * @p{make_boundary_sparsity_pattern} function.
                                      */
     unsigned int n_boundary_dofs (const FunctionMap &boundary_indicators) const;
 
@@ -1123,7 +1123,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 #clear()#
+                                     * of this DoF handler, use the @p{clear()}
                                      * function (this clears all data of
                                      * this object as well, though).
                                      */
@@ -1155,12 +1155,12 @@ class DoFHandler  :  public Subscriptor,
 
                                     /**
                                      * Reserve enough space in the 
-                                     * #levels[]# objects to store the
+                                     * @p{levels[]} objects to store the
                                      * numbers of the degrees of freedom
                                      * needed for the given element. The
                                      * given element is that one which
                                      * was selected when calling
-                                     * #distribute_dofs# the last time.
+                                     * @p{distribute_dofs} the last time.
                                      */
     void reserve_space ();
 
@@ -1172,14 +1172,14 @@ class DoFHandler  :  public Subscriptor,
                                     /**
                                      * Distribute dofs on the given cell,
                                      * with new dofs starting with index
-                                     * #next_free_dof#. Return the next
+                                     * @p{next_free_dof}. Return the next
                                      * unused index number. The finite
                                      * element used is the one given to
-                                     * #distribute_dofs#, which is copied
-                                     * to #selected_fe#.
+                                     * @p{distribute_dofs}, which is copied
+                                     * to @p{selected_fe}.
                                      *
                                      * This function is excluded from the
-                                     * #distribute_dofs# function since
+                                     * @p{distribute_dofs} function since
                                      * it can not be implemented dimension
                                      * independent.
                                      */
@@ -1189,7 +1189,7 @@ class DoFHandler  :  public Subscriptor,
                                     /**
                                      * Space to store the DoF numbers for the
                                      * different levels. Analogous to the
-                                     * #levels[]# tree of the \Ref{Triangulation}
+                                     * @p{levels[]} tree of the \Ref{Triangulation}
                                      * objects.
                                      */
     vector<DoFLevel<dim>*>    levels;
index 4bbdab445c507e0e44f16fbff311634be1d4520d..2f6439efe820d0417210dd1f25346aa6f7e559fd 100644 (file)
@@ -37,9 +37,9 @@ class DoFLevel
 /**
  * Store the indices of the degrees of freedom which are located on the lines.
  *
- * \subsection{Information for all #DoFLevel# classes}
+ * @sect3{Information for all @p{DoFLevel} classes}
  *
- * The #DoFLevel<N># classes 
+ * The @p{DoFLevel<N>} classes 
  * store the global indices of the degrees of freedom for each cell on a
  * certain level. The index or number of a degree of freedom is the zero-based
  * index of the according value in the solution vector and the row and column
@@ -57,25 +57,25 @@ 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::make_hanging_node_constraints ()#
+ * constraint matrix returned by @p{DoFHandler::make_hanging_node_constraints ()}
  * is then
  * to be understood as a block matrix.
  *
  * The storage format of the degrees of freedom indices (short: DoF indices) is
  * somewhat like a mirror of the data structures of the triangulation classes.
- * There is a hierarchy of #DoFLevel<dim># classes for the different dimensions
- * which have objects named #line_dofs#, #quad_dofs# and so on, in which the
+ * There is a hierarchy of @p{DoFLevel<dim>} classes for the different dimensions
+ * which have objects named @p{line_dofs}, @p{quad_dofs} and so on, in which the
  * indices of DoFs located on lines and quads, respectively, are stored. The
  * indices are stored levelwise. The layout in
  * these arrays is as follows: if for a selected finite element (use
- * #DoFHandler::distribute_dofs()# to select a finite element) the number of
- * DoFs on each line (without those in the vertices) is #N#, then the length
- * of the #line_dofs# array is #N# times the number of lines on this level. The
- * DoF indices for the #i#th line are at the positions #N*i...(N+1)*i-1#.
+ * @p{DoFHandler::distribute_dofs()} to select a finite element) the number of
+ * DoFs on each line (without those in the vertices) is @p{N}, then the length
+ * of the @p{line_dofs} array is @p{N} times the number of lines on this level. The
+ * DoF indices for the @p{i}th line are at the positions @p{N*i...(N+1)*i-1}.
  *
  * The DoF indices for vertices are not stored this way, since they need
  * different treatment in multigrid environments. If no multigrid is used, the
- * indices are stored in the #vertex_dofs# array of the #DoFHandler# class.
+ * indices are stored in the @p{vertex_dofs} array of the @p{DoFHandler} class.
  */
 class DoFLevel<1>
 {
index 2a0fa4cfcd0981623d24693cebd9d86e0b9a15ed..362bdc1dbd1c3385a3b142c2b99d3477f400a9d7 100644 (file)
@@ -33,9 +33,9 @@ template <template <int> class GridClass, int dim> class InterGridMap;
  * documentation stating some commonalities.
  *
  * All member functions are static, so there is no need to create an
- * object of class #DoFTools#.
+ * object of class @p{DoFTools}.
  *
- * \subsection{Setting up sparsity patterns}
+ * @sect3{Setting up sparsity patterns}
  *
  * When assembling system matrices, the entries are usually of the form
  * $a_{ij} = a(\phi_i, \phi_j)$, where $a$ is a bilinear functional, often an
@@ -82,7 +82,7 @@ class DoFTools
                                      * correspond to degrees of
                                      * freedom of at least one common
                                      * cell. Therefore,
-                                     * #make_sparsity_pattern# just
+                                     * @p{make_sparsity_pattern} just
                                      * loops over all cells and
                                      * enters all couplings local to
                                      * that cell. As the generation
@@ -99,17 +99,17 @@ class DoFTools
                                      * of hanging nodes.  They have
                                      * to be taken care of by a call
                                      * to
-                                     * #ConstraintMatrix::condense()#
+                                     * @p{ConstraintMatrix::condense()}
                                      * afterwards.
                                      *
                                      * Remember using
-                                     * #SparsityPattern::compress()#
+                                     * @p{SparsityPattern::compress()}
                                      * after generating the pattern.
                                      *
                                      * The actual type of the
                                      * sparsity pattern may be
-                                     * #SparsityPattern#,
-                                     * #BlockSparsityPattern#, or any
+                                     * @p{SparsityPattern},
+                                     * @p{BlockSparsityPattern}, or any
                                      * other class that satisfies
                                      * similar requirements.
                                      */
@@ -121,7 +121,7 @@ class DoFTools
                                      * Locate non-zero entries for
                                      * mixed methods.  This function
                                      * does mostly the same as the
-                                     * other #make_sparsity_pattern#,
+                                     * other @p{make_sparsity_pattern},
                                      * but it is specialized for
                                      * mixed finite elements and
                                      * allows to specify which
@@ -138,7 +138,7 @@ class DoFTools
                                      *
                                      * in two space dimensions,
                                      * using stable Q2/Q1 mixed
-                                     * elements (using the #FESystem#
+                                     * elements (using the @p{FESystem}
                                      * class), then you don't want
                                      * all degrees of freedom to
                                      * couple in each equation. You
@@ -153,21 +153,21 @@ class DoFTools
                                      * \end{verbatim}
                                      * where "1" indicates that two
                                      * variables (i.e. components of
-                                     * the #FESystem#) couple in the
+                                     * the @p{FESystem}) couple in the
                                      * respective equation, and a "0"
                                      * means no coupling, in which
                                      * case it is not necessary to
                                      * allocate space in the matrix
                                      * structure. Obviously, the mask
                                      * refers to components of the
-                                     * composed #FESystem#, rather
+                                     * composed @p{FESystem}, rather
                                      * than to the degrees of freedom
                                      * contained in there.
                                      *
                                      * This function is designed to
                                      * accept a mask, like the one
                                      * shown above, through the
-                                     * #mask# parameter, which
+                                     * @p{mask} parameter, which
                                      * contains boolean values. It
                                      * builds the matrix structure
                                      * just like the previous
@@ -179,8 +179,8 @@ class DoFTools
                                      *
                                      * The actual type of the
                                      * sparsity pattern may be
-                                     * #SparsityPattern#,
-                                     * #BlockSparsityPattern#, or any
+                                     * @p{SparsityPattern},
+                                     * @p{BlockSparsityPattern}, or any
                                      * other class that satisfies
                                      * similar requirements.
                                      */
@@ -201,14 +201,14 @@ class DoFTools
                                      * nodes.  The sparsity pattern
                                      * is not compressed, since if
                                      * you want to call
-                                     * #ConstraintMatrix::condense(1)#
+                                     * @p{ConstraintMatrix::condense(1)}
                                      * afterwards, new entries have
                                      * to be added. However, if you
                                      * don't want to call
-                                     * #ConstraintMatrix::condense(1)#,
+                                     * @p{ConstraintMatrix::condense(1)},
                                      * you have to compress the
                                      * matrix yourself, using
-                                     * #SparsityPattern::compress()#.
+                                     * @p{SparsityPattern::compress()}.
                                      *
                                      * Since this function is
                                      * obviously useless in one
@@ -231,9 +231,9 @@ class DoFTools
                                      * the boundary indicator is listed in the
                                      * set of numbers passed to this function.
                                      *
-                                     * In fact, rather than a #set#
+                                     * In fact, rather than a @p{set}
                                      * of boundary indicators, a
-                                     * #map# needs to be passed,
+                                     * @p{map} needs to be passed,
                                      * since most of the functions
                                      * handling with boundary
                                      * indicators take a mapping of
@@ -267,7 +267,7 @@ class DoFTools
                                      * couple across faces of cells.
                                      * This is a replacement of the
                                      * function
-                                     * #make_sparsity_pattern# for
+                                     * @p{make_sparsity_pattern} for
                                      * discontinuous methods. Since
                                      * the fluxes include couplings
                                      * between neighboring elements,
@@ -323,11 +323,11 @@ class DoFTools
                                      * immediately. The object is not cleared
                                      * before use, so you should make sure
                                      * it containts only constraints you still
-                                     * want; otherwise call the #clear#
+                                     * want; otherwise call the @p{clear}
                                      * function.
                                      *
                                      * To condense a given sparsity pattern,
-                                     * use #ConstraintMatrix::condense#.
+                                     * use @p{ConstraintMatrix::condense}.
                                      * Before doing so, you need to close
                                      * the constraint object, which must be
                                      * done after all constraints are entered.
@@ -350,22 +350,22 @@ class DoFTools
                                      * the resulting field will not be
                                      * continuous at hanging nodes. This can,
                                      * however, easily be arranged by calling
-                                     * the appropraite #distribute# function
-                                     * of a #ConstraintMatrix# object created
-                                     * for this #DoFHandler# object.
+                                     * the appropraite @p{distribute} function
+                                     * of a @p{ConstraintMatrix} object created
+                                     * for this @p{DoFHandler} object.
                                      *
                                      * It is assumed that the number of
-                                     * elements in #cell_data# equals the
+                                     * elements in @p{cell_data} equals the
                                      * number of active cells. The size of
-                                     * #dof_data# is adjusted to the right
+                                     * @p{dof_data} is adjusted to the right
                                      * size.
                                      *
                                      * Note that the input vector may be
                                      * a vector of any data type as long
-                                     * as it is convertible to #double#.
+                                     * as it is convertible to @p{double}.
                                      * The output vector, being a data
                                      * vector on the grid, always consists
-                                     * of elements of type #double#.
+                                     * of elements of type @p{double}.
                                      *
                                      * In case the finite element used by
                                      * this DoFHandler consists of more than
@@ -380,8 +380,8 @@ class DoFTools
                                      * not changed.
                                      *
                                      * It is assumed that the output vector
-                                     * #dof_data# already has the right size,
-                                     * i.e. #n_dofs()# elements.
+                                     * @p{dof_data} already has the right size,
+                                     * i.e. @p{n_dofs()} elements.
                                      */
     template <int dim, typename Number>
     static void
@@ -393,21 +393,21 @@ class DoFTools
                                     /**
                                      * Extract the indices of the degrees
                                      * of freedom belonging to certain
-                                     * components. The bit vector #select#
+                                     * components. The bit vector @p{select}
                                      * defines, which components of an
-                                     * #FESystem# are to be extracted
-                                     * from the DoFHandler #dof#. The
-                                     * respective entries in #selected_dofs#
-                                     * are then flagged #true#, while all
-                                     * others are set to #false#.
+                                     * @p{FESystem} are to be extracted
+                                     * from the DoFHandler @p{dof}. The
+                                     * respective entries in @p{selected_dofs}
+                                     * are then flagged @p{true}, while all
+                                     * others are set to @p{false}.
                                      *
-                                     * The size of #component_select#
+                                     * The size of @p{component_select}
                                      * shall equal the number of
                                      * components in the finite
-                                     * element used by #dof#. The
-                                     * size of #selected_dofs# shall
+                                     * element used by @p{dof}. The
+                                     * size of @p{selected_dofs} shall
                                      * equal
-                                     * #dof_handler.n_dofs()#. Previous
+                                     * @p{dof_handler.n_dofs()}. Previous
                                      * contents of this array or
                                      * overwritten.
                                      */
@@ -419,7 +419,7 @@ class DoFTools
 
                                     /**
                                      * Do the same thing as
-                                     * #extract_dofs# for one level
+                                     * @p{extract_dofs} for one level
                                      * of a multi-grid DoF numbering.
                                      */
     template <int dim>
@@ -436,19 +436,19 @@ class DoFTools
                                      * of the solution. The function
                                      * returns its results in the
                                      * last parameter which contains
-                                     * #true# is a degree of freedom
+                                     * @p{true} is a degree of freedom
                                      * is at the boundary and belongs
                                      * to one of the selected
-                                     * components, and #false#
+                                     * components, and @p{false}
                                      * otherwise.
                                      *
-                                     * The size of #component_select#
+                                     * The size of @p{component_select}
                                      * shall equal the number of
                                      * components in the finite
-                                     * element used by #dof#. The
-                                     * size of #selected_dofs# shall
+                                     * element used by @p{dof}. The
+                                     * size of @p{selected_dofs} shall
                                      * equal
-                                     * #dof_handler.n_dofs()#. Previous
+                                     * @p{dof_handler.n_dofs()}. Previous
                                      * contents of this array or
                                      * overwritten.
                                      */
@@ -464,9 +464,9 @@ class DoFTools
                                      * constraints, i.e. all hanging
                                      * nodes.
                                      *
-                                     * The size of #selected_dofs#
+                                     * The size of @p{selected_dofs}
                                      * shall equal
-                                     * #dof_handler.n_dofs()#. Previous
+                                     * @p{dof_handler.n_dofs()}. Previous
                                      * contents of this array or
                                      * overwritten.
                                      */
@@ -668,7 +668,7 @@ class DoFTools
                                      * to the variable ``q''; zero
                                      * would be ``u'', two would be
                                      * ``lambda''). Furthermore, an
-                                     * object of type #IntergridMap#
+                                     * object of type @p{IntergridMap}
                                      * is needed; this could in
                                      * principle be generated by the
                                      * function itself from the two
@@ -680,7 +680,7 @@ class DoFTools
                                      * it. Finally, the computed
                                      * constraints are entered into a
                                      * variable of type
-                                     * #ConstraintMatrix#; the
+                                     * @p{ConstraintMatrix}; the
                                      * constraints are added,
                                      * i.e. previous contents which
                                      * may have, for example, be
index e1ed7b6bb2b86022a7b7bc9479281bd7fbdb9ee1..79a80f779255aec0a90dc0e6238f50fc63eff565 100644 (file)
@@ -24,7 +24,7 @@
 
 
 /**
- * Dimension independent data for finite elements. See the #FiniteElementBase#
+ * Dimension independent data for finite elements. See the @p{FiniteElementBase}
  * class for more information.
  */
 template<int dim>
@@ -116,7 +116,7 @@ class FiniteElementData
                                      * Default constructor. Constructs
                                      * an element
                                      * which is not so useful. Checking
-                                     * #dofs_per_cell# is therefore a good way to
+                                     * @p{dofs_per_cell} is therefore a good way to
                                      * check if something went wrong. 
                                      */
     FiniteElementData ();
@@ -159,42 +159,42 @@ class FiniteElementData
     virtual ~FiniteElementData ();
 
                                     /**
-                                     * Return the #dofs_per_vertex#.
+                                     * Return the @p{dofs_per_vertex}.
                                      */
     unsigned int n_dofs_per_vertex () const;
 
                                     /**
-                                     * Return the #dofs_per_line#.
+                                     * Return the @p{dofs_per_line}.
                                      */
     unsigned int n_dofs_per_line () const;
 
                                     /**
-                                     * Return the #dofs_per_quad#.
+                                     * Return the @p{dofs_per_quad}.
                                      */
     unsigned int n_dofs_per_quad () const;
 
                                     /**
-                                     * Return the #dofs_per_hex#.
+                                     * Return the @p{dofs_per_hex}.
                                      */
     unsigned int n_dofs_per_hex () const;
 
                                     /**
-                                     * Return the #dofs_per_face#.
+                                     * Return the @p{dofs_per_face}.
                                      */
     unsigned int n_dofs_per_face () const;
 
                                     /**
-                                     * Return the #dofs_per_cell#.
+                                     * Return the @p{dofs_per_cell}.
                                      */
     unsigned int n_dofs_per_cell () const;
 
                                     /**
-                                     * Return the #components#.
+                                     * Return the @p{components}.
                                      */
     unsigned int n_components () const;
 
                                     /**
-                                     * Return the #transform_functions#.
+                                     * Return the @p{transform_functions}.
                                      */
     unsigned int n_transform_functions () const;
 
@@ -224,8 +224,8 @@ class FiniteElementData
  * of the actual type (linear, quadratic, etc).
  *
  * The implementation of this base class is split into two parts: those fields
- * which are not common to all dimensions (#dofs_per_quad# for example are only
- * useful for #dim>=2#) are put into the #FiniteElementData<dim># class which
+ * which are not common to all dimensions (@p{dofs_per_quad} for example are only
+ * useful for @p{dim>=2}) are put into the @p{FiniteElementData<dim>} class which
  * is explicitely specialized for all used dimensions, while those fields which
  * may be formulated in a dimension-independent way are put into the present
  * class.
@@ -254,7 +254,7 @@ class FiniteElementBase : public Subscriptor,
                                      * Return a readonly reference to the
                                      * matrix which describes the transfer of a
                                      * child with the given number to the
-                                     * mother cell. See the #restriction# array
+                                     * mother cell. See the @p{restriction} array
                                      * for more information.
                                      */
     const FullMatrix<double> & restrict (const unsigned int child) const;
@@ -290,8 +290,8 @@ class FiniteElementBase : public Subscriptor,
                                      * Since this function is not that important,
                                      * we avoid an implementational question
                                      * about comparing arrays and do not compare
-                                     * the matrix arrays #restriction# and
-                                     * #prolongation#.
+                                     * the matrix arrays @p{restriction} and
+                                     * @p{prolongation}.
                                      */
     bool operator == (const FiniteElementBase<dim> &) const;
 
@@ -333,7 +333,7 @@ class FiniteElementBase : public Subscriptor,
                                      *
                                      * This table converts a
                                      * component number to the
-                                     * #base_element# number. While
+                                     * @p{base_element} number. While
                                      * component information contains
                                      * multiplicity of base elements,
                                      * the result allows access to
@@ -343,7 +343,7 @@ class FiniteElementBase : public Subscriptor,
     unsigned int component_to_base(unsigned int index) const;
 
                                     /**
-                                     * Access the #restriction_is_additive_flag#
+                                     * Access the @p{restriction_is_additive_flag}
                                      * field. See there for more information on 
                                      * its contents.
                                      */
@@ -364,9 +364,9 @@ class FiniteElementBase : public Subscriptor,
     
   protected:
                                     /**
-                                     * Have #N=2^dim# matrices keeping the
+                                     * Have @p{N=2^dim} matrices keeping the
                                      * restriction constants for the transfer
-                                     * of the #i#th child to the mother cell.
+                                     * of the @p{i}th child to the mother cell.
                                      * The numbering conventions for the
                                      * degree of freedom indices are descibed
                                      * in the derived classes.
@@ -390,7 +390,7 @@ class FiniteElementBase : public Subscriptor,
                                      * the respective restriction matrix and
                                      * clobber these contributions together.
                                      * However, you must take care not to
-                                     * #add# these together, since nodes which
+                                     * @p{add} these together, since nodes which
                                      * belong to more than one child would then
                                      * be counted more than once; rather, you
                                      * have to overwrite the nonzero
@@ -452,7 +452,7 @@ class FiniteElementBase : public Subscriptor,
                                      * 
                                      * At least for the first case
                                      * (the DG(r) elements), the
-                                     * #restriction_is_additive_flags# was
+                                     * @p{restriction_is_additive_flags} was
                                      * introduced, see there for more
                                      * information. For the latter
                                      * case, NO SOLUTION HAS BEEN
@@ -460,8 +460,8 @@ class FiniteElementBase : public Subscriptor,
                                      *
                                      * To compute the interpolation of a
                                      * finite element field to a cell, you
-                                     * may use the #get_interpolated_dof_values#
-                                     * function of the #DoFCellAccessor# class.
+                                     * may use the @p{get_interpolated_dof_values}
+                                     * function of the @p{DoFCellAccessor} class.
                                      * See there for more information.
                                      *
                                      * Upon assembling the transfer matrix
@@ -477,9 +477,9 @@ class FiniteElementBase : public Subscriptor,
 #endif
 
                                     /**
-                                     * Have #N=2^dim# matrices keeping the
+                                     * Have @p{N=2^dim} matrices keeping the
                                      * prolongation constants for the transfer
-                                     * of the mother cell to the #i#th child.
+                                     * of the mother cell to the @p{i}th child.
                                      * The numbering conventions for the
                                      * degree of freedom indices are descibed
                                      * in the derived classes.
@@ -487,11 +487,11 @@ class FiniteElementBase : public Subscriptor,
                                      * to the destination cell, i.e. the
                                      * refined one, while the column indices
                                      * are for the unrefined cell's degrees of
-                                     * freedom. Thus, if #u0# is the vector
+                                     * freedom. Thus, if @p{u0} is the vector
                                      * of values of degrees of freedom on the
-                                     * coarse cell, #prolongation[i]*u0#
+                                     * coarse cell, @p{prolongation[i]*u0}
                                      * yields the vector of values of the
-                                     * degrees of freedom on the #i#th child
+                                     * degrees of freedom on the @p{i}th child
                                      * cell.
                                      *
                                      * On the other hand, for finite elements
@@ -565,7 +565,7 @@ class FiniteElementBase : public Subscriptor,
                                      *
                                      * This table converts a
                                      * component number to the
-                                     * #base_element# number. While
+                                     * @p{base_element} number. While
                                      * component information contains
                                      * multiplicity of base elements,
                                      * the result allows access to
@@ -713,17 +713,17 @@ class FiniteElementBase : public Subscriptor,
                                      * hard coded and the summation
                                      * over all child cells is
                                      * switched on by setting the
-                                     * #restriction_is_additive_flags#
-                                     * to #true#.
+                                     * @p{restriction_is_additive_flags}
+                                     * to @p{true}.
                                      *
                                      * Given these notes, the flag
                                      * under consideration has to be
-                                     * set to #false# for the usual
+                                     * set to @p{false} for the usual
                                      * continuous Lagrange elements,
-                                     * and #true# for the other cases
+                                     * and @p{true} for the other cases
                                      * mentioned above. The main
                                      * function where it is used is
-                                     * #DoFAccessor::get_interpolated_dof_values#.
+                                     * @p{DoFAccessor::get_interpolated_dof_values}.
                                      * There is one flag per
                                      * component.
                                      */
@@ -735,7 +735,7 @@ class FiniteElementBase : public Subscriptor,
 
 /**
  * Finite Element in any dimension. This class declares the
- * functionality to fill the fields of the #FiniteElementBase#
+ * functionality to fill the fields of the @p{FiniteElementBase}
  * class. Since this is something that depends on the actual finite
  * element, the functions are declared virtual if it is not possible
  * to provide a reasonable standard implementation. Note that you will
@@ -743,26 +743,26 @@ class FiniteElementBase : public Subscriptor,
  * programs, as you will normally be interested in the values and
  * derivatives of shape functions on cells in physical space, rather
  * than on the unit cell. In that case, you will have to use the
- * #FEValues# class and its siblings.
+ * @p{FEValues} class and its siblings.
  *
  *
- * \subsection{Finite elements in one dimension}
+ * @sect3{Finite elements in one dimension}
  *
- * Finite elements in one dimension need only set the #restriction# and
- * #prolongation# matrices in #FiniteElementBase<1>#. The constructor of
- * this class in one dimension presets the #interface_constraints# matrix
+ * Finite elements in one dimension need only set the @p{restriction} and
+ * @p{prolongation} matrices in @p{FiniteElementBase<1>}. The constructor of
+ * this class in one dimension presets the @p{interface_constraints} matrix
  * by the unit matrix with dimension one. Changing this behaviour in
  * derived classes is generally not a reasonable idea and you risk getting
  * in terrible trouble.
  * 
  * 
- * \subsection{Finite elements in two dimensions}
+ * @sect3{Finite elements in two dimensions}
  * 
  * In addition to the fields already present in 1D, a constraint matrix
  * is needed in case two quads meet at a common line of which one is refined
  * once more than the other one. Then there are constraints referring to the
  * hanging nodes on that side of the line which is refined. These constraints
- * are represented by a $m\times n$-matrix #interface_constraints#, where $n$ is the
+ * are represented by a $m\times n$-matrix @p{interface_constraints}, where $n$ is the
  * number of degrees of freedom on the refined side (those dofs on the middle
  * vertex plus those on the two lines), and $m$ is that of the unrefined side
  * (those dofs on the two vertices plus those on the line). The matrix is thus
@@ -788,7 +788,7 @@ class FiniteElementBase : public Subscriptor,
  * at the time of this writing whether this is a constraint itself.
  *
  *
- * \subsection{Finite elements in three dimensions}
+ * @sect3{Finite elements in three dimensions}
  *
  * For the interface constraints, almost the same holds as for the 2D case.
  * The numbering for the indices $m$ on the mother face is obvious and keeps
@@ -842,7 +842,7 @@ class FiniteElementBase : public Subscriptor,
  *
  * The faces of a hexahedron are arranged in a way such that
  * some must be viewed from the inside and some from the outside of the cell to
- * show this order; refer to the documentation of the #Triangulation# class for
+ * show this order; refer to the documentation of the @p{Triangulation} class for
  * the definition of this.
  *
  * If of the cells adjacent to one line more than one is refined and there is
@@ -859,12 +859,12 @@ class FiniteElementBase : public Subscriptor,
  * degrees of freedom on a face.
  *
  * Since the handling of constraints on degrees of freedom is mostly done
- * by the #ConstraintMatrix# class, this class checks whether the constraints
+ * by the @p{ConstraintMatrix} class, this class checks whether the constraints
  * introduced from the two sides are unique; it is able to handle the fact
  * that the constraints for some of the dofs are entered more than once.
  *
  *
- * \subsection{Notes on three space dimensions}
+ * @sect3{Notes on three space dimensions}
  *
  * In three space dimensions, using locally refined elements involves
  * a difficulty not found in one or two spatial dimensions: the common
@@ -931,7 +931,7 @@ class FiniteElementBase : public Subscriptor,
  *
  * A second, but related problem comes into play when trying to
  * compute integrals over faces which are refined from one side. For
- * this problem, the #FESubfaceValues# class exists, and it evaluates
+ * this problem, the @p{FESubfaceValues} class exists, and it evaluates
  * certain functions of the finite element class involving the
  * Jacobian determinant of the mapping of unit face to real face,
  * restricted to a subface, and the normal vectors to the subfaces. We
@@ -960,9 +960,9 @@ class FiniteElementBase : public Subscriptor,
  * Within this library, the present implementation uses the second way.
  *
  *
- * \subsection{Notes on extending the finite element library}
+ * @sect3{Notes on extending the finite element library}
  *
- * The #deal.II# library was mainly made to use lagrange elements of arbitrary
+ * The @p{deal.II} library was mainly made to use lagrange elements of arbitrary
  * order. For this reason, there may be places in the library where it uses
  * features of finite elements which may not be as general as desirable as may
  * be. Most of these restrictions don't come to mind and may cause problems
@@ -986,15 +986,15 @@ class FiniteElementBase : public Subscriptor,
  *   Both these assumptions are used when interpolation of a continuous
  *   function to the finite element space is applied. At present, only few
  *   places where this is used in the library come to mind to the author,
- *   namely the treating of boundary values in the #ProblemBase# class and
- *   the interpolation in the #VectorTools# collection. You should also
+ *   namely the treating of boundary values in the @p{ProblemBase} class and
+ *   the interpolation in the @p{VectorTools} collection. You should also
  *   look out for other places where explicit use of the support points is
  *   made if you want to use elements of other classes. A hint may be the
- *   use of the #get_support_points# and #get_face_support_points# functions
+ *   use of the @p{get_support_points} and @p{get_face_support_points} functions
  *   of this class.
  *
  *   This also is used in some sense in the
- *   #DoFHandler::distribute_cell_to_dof_vector# where it is assumed that
+ *   @p{DoFHandler::distribute_cell_to_dof_vector} where it is assumed that
  *   the degrees of freedom denote function values and not derivatives or
  *   the like.
  *
@@ -1004,13 +1004,13 @@ class FiniteElementBase : public Subscriptor,
  *   on the boundary face itself. For Lagrange elements this is true, but it
  *   may or may not be true in other cases.
  *
- *   This assumption is used in the #VectorTools::project_boundary_values#,
- *   #MatrixCreator::create_boundary_mass_matrix#,
- *   #DoFHandler::make_boundary_sparsity_pattern#,
- *   #DoFHandler::map_dof_to_boundary_indices# and may be a few other places.
- *   The places in the #DoFHandler# class are probably not that dangerous,
+ *   This assumption is used in the @p{VectorTools::project_boundary_values},
+ *   @p{MatrixCreator::create_boundary_mass_matrix},
+ *   @p{DoFHandler::make_boundary_sparsity_pattern},
+ *   @p{DoFHandler::map_dof_to_boundary_indices} and may be a few other places.
+ *   The places in the @p{DoFHandler} class are probably not that dangerous,
  *   since wrong results will most likely lead to internal errors through
- *   the #Assert# mechanism, but the first places will lead to undiscovered
+ *   the @p{Assert} mechanism, but the first places will lead to undiscovered
  *   errors if not thought of properly.
  *
  *   This assumption also comes into play when computing the constraints of
@@ -1019,7 +1019,7 @@ class FiniteElementBase : public Subscriptor,
  *   constrained nodes happens with the face nodes on the large call. If
  *   the assumption does not hold, then the distribution has to happen
  *   with all nodes on the small and the large cells. This is not
- *   implemented in the #DoFHandler# class as of now.
+ *   implemented in the @p{DoFHandler} class as of now.
  * \end{itemize}
  *
  * @author Wolfgang Bangerth, 1998
@@ -1042,17 +1042,17 @@ class FiniteElement : public FiniteElementBase<dim>
     virtual ~FiniteElement () {};
     
                                     /**
-                                     * Return the value of the #i#th shape
-                                     * function at the point #p#.
-                                     * #p# is a point on the reference element.
+                                     * Return the value of the @p{i}th shape
+                                     * function at the point @p{p}.
+                                     * @p{p} is a point on the reference element.
                                      */
     virtual double shape_value (const unsigned int i,
                                const Point<dim> &p) const = 0;
 
                                     /**
                                      * Return the gradient of the
-                                     * #i#th shape function at the
-                                     * point #p#.  #p# is a point on
+                                     * @p{i}th shape function at the
+                                     * point @p{p}.  @p{p} is a point on
                                      * the reference element, and
                                      * likewise the gradient is the
                                      * gradient on the unit cell with
@@ -1064,8 +1064,8 @@ class FiniteElement : public FiniteElementBase<dim>
 
                                     /**
                                      * Return the tensor of second
-                                     * derivatives of the #i#th shape
-                                     * function at point #p# on the
+                                     * derivatives of the @p{i}th shape
+                                     * function at point @p{p} on the
                                      * unit cell. The derivatives are
                                      * derivatives on the unit cell
                                      * with respect to unit cell
@@ -1075,7 +1075,7 @@ class FiniteElement : public FiniteElementBase<dim>
                                           const Point<dim>   &p) const = 0;
 
                                     /**
-                                     * Return the value of the #i#th
+                                     * Return the value of the @p{i}th
                                      * shape function of the
                                      * transformation mapping from
                                      * unit cell to real cell. For
@@ -1090,7 +1090,7 @@ class FiniteElement : public FiniteElementBase<dim>
 
                                     /**
                                      * Same as above: return gradient
-                                     * of the #i#th shape function
+                                     * of the @p{i}th shape function
                                      * for the mapping from unit to
                                      * real cell.
                                      */
@@ -1140,7 +1140,7 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * more complicated.
                                      *
                                      * The
-                                     * #shape_values/grads_transform#
+                                     * @p{shape_values/grads_transform}
                                      * arrays store the values and
                                      * gradients of the
                                      * transformation basis
@@ -1165,7 +1165,7 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * the correct values beforehand.
                                      *
                                      * This function is more or less an
-                                     * interface to the #FEValues# class and
+                                     * interface to the @p{FEValues} class and
                                      * should not be used by users unless
                                      * absolutely needed.
                                      */
@@ -1184,9 +1184,9 @@ class FiniteElement : public FiniteElementBase<dim>
 
                                     /**
                                      * Do the same thing that the other
-                                     * #fill_fe_values# function does,
+                                     * @p{fill_fe_values} function does,
                                      * exception that a face rather than
-                                     * a cell is considered. The #face_no#
+                                     * a cell is considered. The @p{face_no}
                                      * parameter denotes the number of the
                                      * face to the given cell to be
                                      * considered.
@@ -1195,14 +1195,14 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * formula are given on the unit face
                                      * which is a mannifold of dimension
                                      * one less than the dimension of the
-                                     * cell. The #global_unit_points# 
+                                     * cell. The @p{global_unit_points} 
                                      * denote the position of the unit points
                                      * on the selected face on the unit cell.
                                      * This additional information is passed
-                                     * since the #FEFaceValues# class can
+                                     * since the @p{FEFaceValues} class can
                                      * compute them once and for all,
                                      * eliminating the need to recompute it
-                                     * each time #FEFaceValues::reinit# is
+                                     * each time @p{FEFaceValues::reinit} is
                                      * called.
                                      *
                                      * The jacobian matrix is evaluated at
@@ -1222,13 +1222,13 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * along faces. Note that we here return
                                      * the inverse of the determinant of the
                                      * jacobi matrices as explained in the
-                                     * documentation of the #FEValues# class.
+                                     * documentation of the @p{FEValues} class.
                                      * 
                                      * The support points are the
                                      * off-points of those trial functions
                                      * located on the given face; this
                                      * information is taken over from the
-                                     * #get_face_support_points# function.
+                                     * @p{get_face_support_points} function.
                                      *
                                      * The order of trial functions is the
                                      * same as if it were a cell of dimension
@@ -1240,11 +1240,11 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * The same applies for the quadrature
                                      * points which also use the standard
                                      * direction of faces as laid down by
-                                     * the #Triangulation# class.
+                                     * the @p{Triangulation} class.
                                      *
                                      * There is a standard implementation for
                                      * dimensions greater than one. It
-                                     * uses the #fill_fe_values()#
+                                     * uses the @p{fill_fe_values()}
                                      * function to retrieve the wanted
                                      * information. Since this operation acts
                                      * only on unit faces and cells it does
@@ -1263,9 +1263,9 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * real face, the support points
                                      * and the outward normal vectors. For
                                      * these fields, there exist pure
-                                     * virtual functions, #get_face_jacobians#,
-                                     * #get_face_support_points# and
-                                     * #get_normal_vectors#.
+                                     * virtual functions, @p{get_face_jacobians},
+                                     * @p{get_face_support_points} and
+                                     * @p{get_normal_vectors}.
                                      *
                                      * Though there is a standard
                                      * implementation, there
@@ -1275,14 +1275,14 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * Since any implementation for one
                                      * dimension would be senseless, all
                                      * derived classes should throw an error
-                                     * when called with #dim==1#.
+                                     * when called with @p{dim==1}.
                                      *
                                      * The function assumes that the fields
                                      * already have the right number of
                                      * elements.
                                      *
                                      * This function is more or less an
-                                     * interface to the #FEFaceValues# class
+                                     * interface to the @p{FEFaceValues} class
                                      * and should not be used by users unless
                                      * absolutely needed.
                                      */
@@ -1312,24 +1312,24 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * element to a subface (the child of a
                                      * face) rather than to a face. The number
                                      * of the subface in the face is given by
-                                     * the #subface_no# parameter. The meaning
+                                     * the @p{subface_no} parameter. The meaning
                                      * of the other parameters is the same as
-                                     * for the #fill_fe_face_values# function.
+                                     * for the @p{fill_fe_face_values} function.
                                      *
                                      * Since the usage of support points on
                                      * subfaces is not useful, it is excluded
                                      * from the interface to this function.
                                      *
-                                     * Like for the #fill_fe_face_values#
+                                     * Like for the @p{fill_fe_face_values}
                                      * function, there is a default
                                      * implementation, using the
-                                     * #fill_fe_values# function. There may
+                                     * @p{fill_fe_values} function. There may
                                      * be better and more efficient solutions
                                      * for a special finite element, which is
                                      * why this function is made virtual.
                                      *
                                      * This function is more or less an
-                                     * interface to the #FESubfaceValues# class
+                                     * interface to the @p{FESubfaceValues} class
                                      * and should not be used by users unless
                                      * absolutely needed.
                                      */                                       
@@ -1356,10 +1356,10 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * trial functions on the unit cell.
                                      *
                                      * The function assumes that the
-                                     * #unit_points# array already has the
+                                     * @p{unit_points} array already has the
                                      * right size. The order of points in
                                      * the array matches that returned by
-                                     * the #cell->get_dof_indices# function.
+                                     * the @p{cell->get_dof_indices} function.
                                      *
                                      * For one space dimension there is a
                                      * standard implementation assuming
@@ -1376,20 +1376,20 @@ class FiniteElement : public FiniteElementBase<dim>
                                      *
                                      * This function implements a subset of
                                      * the information delivered by the
-                                     * #fill_fe_values# function to the
-                                     * #FEValues# class. However, since it
+                                     * @p{fill_fe_values} function to the
+                                     * @p{FEValues} class. However, since it
                                      * is useful to use information about
-                                     * off-points without using #FEValues#
+                                     * off-points without using @p{FEValues}
                                      * objects (e.g. in interpolating functions
                                      * to the finite element space), this
                                      * function is excluded from the
                                      * abovementioned one.
                                      *
                                      * The function assumes that the
-                                     * #support_points# array already has the
+                                     * @p{support_points} array already has the
                                      * right size. The order of points in
                                      * the array matches that returned by
-                                     * the #cell->get_dof_indices# function.
+                                     * the @p{cell->get_dof_indices} function.
                                      *
                                      * For one space dimension there is a
                                      * standard implementation assuming
@@ -1417,11 +1417,11 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * of the trial functions which are
                                      * located on the face, rather than of
                                      * all basis functions, which is done by
-                                     * the #get_support_points# function.
+                                     * the @p{get_support_points} function.
                                      *
                                      * This function produces a subset of
                                      * the information provided by the
-                                     * #fill_fe_face_values()# function.
+                                     * @p{fill_fe_face_values()} function.
                                      * However, you should not try
                                      * to implement this function using the
                                      * abovementioned function, since usually
@@ -1437,24 +1437,24 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * to interpolate boundary values to the
                                      * finite element functions. If integration
                                      * along faces is needed, we still need
-                                     * the #fill_fe_face_values# function.
+                                     * the @p{fill_fe_face_values} function.
                                      *
                                      * The function assumes that the
-                                     * #support_points# array already has the
+                                     * @p{support_points} array already has the
                                      * right size. The order of points in
                                      * the array matches that returned by
-                                     * the #face->get_dof_indices# function.
+                                     * the @p{face->get_dof_indices} function.
                                      *
                                      * Since any implementation for one
                                      * dimension would be senseless, all
                                      * derived classes should throw an error
-                                     * when called with #dim==1#.
+                                     * when called with @p{dim==1}.
                                      *
                                      * Regarding information about the
                                      * boundary, which is necessary for
                                      * higher order transformations than
                                      * the usual (bi-, tri-)linear ones,
-                                     * refer to the #get_support_points#
+                                     * refer to the @p{get_support_points}
                                      * function.
                                      */
     virtual void get_face_support_points (const DoFHandler<dim>::face_iterator &face,
@@ -1463,7 +1463,7 @@ class FiniteElement : public FiniteElementBase<dim>
                                     /**
                                      * This is the second separated function
                                      * described in the documentation of the
-                                     * #fill_fe_face_values# function. It
+                                     * @p{fill_fe_face_values} function. It
                                      * returns the determinants of the
                                      * transformation from the unit face to the
                                      * real face at the
@@ -1471,13 +1471,13 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * Since any implementation for one
                                      * dimension would be senseless, all
                                      * derived classes should throw an error
-                                     * when called with #dim==1#.
+                                     * when called with @p{dim==1}.
                                      *
                                      * Regarding information about the
                                      * boundary, which is necessary for
                                      * higher order transformations than
                                      * the usual (bi-, tri-)linear ones,
-                                     * refer to the #get_support_points#
+                                     * refer to the @p{get_support_points}
                                      * function.
                                      */
     virtual void get_face_jacobians (const DoFHandler<dim>::face_iterator &face,
@@ -1488,8 +1488,8 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * Does the same as the above function,
                                      * except that it computes the Jacobi
                                      * determinant of the transformation from
-                                     * the unit face to the subface of #face#
-                                     * with number #subface_no#.
+                                     * the unit face to the subface of @p{face}
+                                     * with number @p{subface_no}.
                                      *
                                      * The function needs not take special care
                                      * about boundary approximation, since it
@@ -1504,7 +1504,7 @@ class FiniteElement : public FiniteElementBase<dim>
                                     /**
                                      * Compute the normal vectors to the cell
                                      * at the quadrature points. See the
-                                     * documentation for the #fill_fe_face_values#
+                                     * documentation for the @p{fill_fe_face_values}
                                      * function for more details. The function
                                      * must guarantee that the length of the
                                      * vectors be one.
@@ -1512,13 +1512,13 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * Since any implementation for one
                                      * dimension would be senseless, all
                                      * derived classes should throw an error
-                                     * when called with #dim==1#.
+                                     * when called with @p{dim==1}.
                                      *
                                      * Regarding information about the
                                      * boundary, which is necessary for
                                      * higher order transformations than
                                      * the usual (bi-, tri-)linear ones,
-                                     * refer to the #get_support_points#
+                                     * refer to the @p{get_support_points}
                                      * function.
                                      */
     virtual void get_normal_vectors (const DoFHandler<dim>::cell_iterator &cell,
@@ -1529,7 +1529,7 @@ class FiniteElement : public FiniteElementBase<dim>
                                     /**
                                      * Does the same as the above function,
                                      * except that it refers to the
-                                     * subface #subface_no# of the given face.
+                                     * subface @p{subface_no} of the given face.
                                      *
                                      * The function needs not take special care
                                      * about boundary approximation, since it
@@ -1549,7 +1549,7 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * quadrature, which may be done using
                                      * an equation object and an assembler,
                                      * as is done for the Laplace matrix
-                                     * in the #MatrixTools# class for example.
+                                     * in the @p{MatrixTools} class for example.
                                      *
                                      * The exact integration is possible since
                                      * an exact representation for the Jacobi
@@ -1595,16 +1595,16 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * documentation, but should check for
                                      * them in debug mode. For that purpose,
                                      * an exception with the longish name
-                                     * #ExcJacobiDeterminantHasWrongSign#
+                                     * @p{ExcJacobiDeterminantHasWrongSign}
                                      * is declared.
                                      *
-                                     * The function takes a #DoFHandler#
+                                     * The function takes a @p{DoFHandler}
                                      * iterator, which provides a superset
                                      * of information to the geometrical
                                      * information needed for the computations.
                                      * The additional data should not be
-                                     * used, however a #DoFHandler# iterator
-                                     * was preferred over a #Triangulation#
+                                     * used, however a @p{DoFHandler} iterator
+                                     * was preferred over a @p{Triangulation}
                                      * iterator since this is what usually
                                      * is available in places where this
                                      * function is called.
@@ -1625,7 +1625,7 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * of the matrix as well as for the
                                      * setting up using a script. For
                                      * example, the size of the generated
-                                     * #C++# code for the local mass
+                                     * @p{C++} code for the local mass
                                      * matrix in 3d is 4.383.656 bytes
                                      * already for the trilinear element.
                                      * Higher order elements would
@@ -1635,9 +1635,9 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * not to implement the functionality of
                                      * this function, that function is supposed
                                      * to throw an exception of class
-                                     * #ExcComputationNotUseful# declared
+                                     * @p{ExcComputationNotUseful} declared
                                      * in this class, for example through the
-                                     * #AssertThrow# mechanism; you can catch
+                                     * @p{AssertThrow} mechanism; you can catch
                                      * this exception and compute the mass matrix
                                      * by quadrature instead. Finite element
                                      * classes not implementing this function
@@ -1648,7 +1648,7 @@ class FiniteElement : public FiniteElementBase<dim>
                                      * boundary, which is necessary for
                                      * higher order transformations than
                                      * the usual (bi-, tri-)linear ones,
-                                     * refer to the #get_support_points#
+                                     * refer to the @p{get_support_points}
                                      * function.
                                      */
     virtual void get_local_mass_matrix (const DoFHandler<dim>::cell_iterator &cell,
@@ -1664,7 +1664,7 @@ class FiniteElement : public FiniteElementBase<dim>
                                     /**
                                      * Access to base element
                                      * objects.  By default,
-                                     * #base_element(0)# is #this#.
+                                     * @p{base_element(0)} is @p{this}.
                                      * This function is overloaded by
                                      * system elements to allow
                                      * access to the different
index 185971125ed4d3152f0f60561b09ff592f7c2c5a..bb50d277712faa7d11aa653e0cf352057d2a12bf 100644 (file)
  * decomposition of a domain using quadrilaterals is easier.
  *
  *
- * \section{Hanging nodes}
+ * @sect2{Hanging nodes}
  *
  * Hanging nodes are handled exactly like for any other element. It should
  * however be noted that the support of basis functions get quite
  *   *-----------------o--------*-----
  * \end{verbatim}
  * The dotted area is the support of the basis function associated with the
- * bottom middle vertex (denoted by #o#) after the hanging node in the center
+ * bottom middle vertex (denoted by @p{o}) after the hanging node in the center
  * of the `picture' was eliminated. This strange structure of the support
  * should not pose too many problems in practice, it is only note here for
  * completeness and for curiosity.
  *
  *
- * \section{Experience with the criss-cross element}
+ * @sect2{Experience with the criss-cross element}
  *
  * Experience is that the error for the criss cross element shows
  * the same convergence rate as the linear Lagrange element ($h^2$ for the
  * values on the unit disk (resp. a triangulation of that) and hanging nodes.
  *
  *
- * \section{Using quadrature formulae for this element}
+ * @sect2{Using quadrature formulae for this element}
  *
  * When using one of the usual quadrature formulae, a common problem is
  * that some of the quadrature points lie on the interfaces of the
@@ -180,23 +180,23 @@ class FECrissCross : public FiniteElement<dim> {
     FECrissCross ();
     
                                     /**
-                                     * Return the value of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the value of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      */
     virtual double shape_value(const unsigned int i,
                               const Point<dim>& p) const;
 
                                     /**
-                                     * Return the gradient of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the gradient of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      */
     virtual Tensor<1,dim> shape_grad(const unsigned int i,
                                     const Point<dim>& p) const;
 
                                     /**
                                      * Return the tensor of second derivatives
-                                     * of the #i#th shape function at
-                                     * point #p# on the unit cell.
+                                     * of the @p{i}th shape function at
+                                     * point @p{p} on the unit cell.
                                      *
                                      * The second derivatives are zero almost
                                      * everywhere for this element; however,
@@ -236,8 +236,8 @@ class FECrissCross : public FiniteElement<dim> {
                                        FullMatrix<double> &local_mass_matrix) const;
 
                                     /**
-                                     * Return the value of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the value of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      * Here, the (bi-)linear basis functions
                                      * are meant, which are used for the
                                      * computation of the transformation from
@@ -247,8 +247,8 @@ class FECrissCross : public FiniteElement<dim> {
                                          const Point<dim> &p) const;
 
                                     /**
-                                     * Return the gradient of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the gradient of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      * Here, the (bi-)linear basis functions
                                      * are meant, which are used for the
                                      * computation of the transformation from
@@ -283,7 +283,7 @@ class FECrissCross : public FiniteElement<dim> {
 
                                     /**
                                      * Return the normal vectors to the
-                                     * face with number #face_no# of #cell#.
+                                     * face with number @p{face_no} of @p{cell}.
                                      *
                                      * For linear finite elements, this function
                                      * is particularly simple since all normal
@@ -302,8 +302,8 @@ class FECrissCross : public FiniteElement<dim> {
 
                                     /**
                                      * Return the normal vectors to the
-                                     * subface with number #subface_no# of
-                                     * the face with number #face_no# of #cell#.
+                                     * subface with number @p{subface_no} of
+                                     * the face with number @p{face_no} of @p{cell}.
                                      *
                                      * For linear finite elements, this function
                                      * is particularly simple since all normal
index 7a212b972bc3bb7ee308ee2ce3cfa47be117c67f..045ad261dec4d956f10c69f4016137b522f8fa55 100644 (file)
@@ -23,7 +23,7 @@
 #define FEDGQuarticSub FEDG_Q4
 
 /**
- * Define a constant discontinuous finite element in #dim#
+ * Define a constant discontinuous finite element in @p{dim}
  * space dimensions, along with (bi-, tri-)linear
  * transforms from the unit cell to the real cell.
  * @author Ralf Hartmann, 1998
@@ -38,23 +38,23 @@ class FEDG_Q0 : public FEQ1Mapping<dim>
     FEDG_Q0 ();
     
                                     /**
-                                     * Return the value of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the value of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      */
     virtual double shape_value(const unsigned int i,
                               const Point<dim>& p) const;
     
                                     /**
-                                     * Return the gradient of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the gradient of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      */
     virtual Tensor<1,dim> shape_grad(const unsigned int i,
                                     const Point<dim>& p) const;
 
                                     /**
                                      * Return the tensor of second derivatives
-                                     * of the #i#th shape function at
-                                     * point #p# on the unit cell.
+                                     * of the @p{i}th shape function at
+                                     * point @p{p} on the unit cell.
                                      *
                                      * For linear elements, all second
                                      * derivatives on the unit cell are zero.
@@ -92,15 +92,15 @@ class FEDG_Q0 : public FEQ1Mapping<dim>
 
 
 /**
- * Define a (bi-, tri-, etc)linear finite element in #dim# space dimensions,
+ * Define a (bi-, tri-, etc)linear finite element in @p{dim} space dimensions,
  * along with (bi-, tri-)linear (therefore isoparametric) transforms from the
  * unit cell to the real cell allowing discontinuous Galerkin methods.
  *
  * 
  * This class is derived from and provides substantially the same 
- * as the #FEQ1# class. The only difference is the new constructor that
- * calls #FEQ1::FEQ1(const int)#, the protected constructor of the
- * #FEQ1# class using a #FiniteElement# with no dofs in the vertices and 
+ * as the @p{FEQ1} class. The only difference is the new constructor that
+ * calls @p{FEQ1::FEQ1(const int)}, the protected constructor of the
+ * @p{FEQ1} class using a @p{FiniteElement} with no dofs in the vertices and 
  * $2^d$ dofs per cell. As now the cells do not share any vertex-dof with
  * a neighboring cell the $2^d$ dofs per cell can be choosen independently not
  * needing any constraints and allowing the use of discontinuous Galerkin
@@ -130,14 +130,14 @@ class FEDG_Q1 : public FEQ1<dim>
 
 
 /**
- * Define a (bi-, tri-, etc)quadratic finite element in #dim# space dimensions,
+ * Define a (bi-, tri-, etc)quadratic finite element in @p{dim} space dimensions,
  * along with (bi-, tri-)linear transforms from the
  * unit cell to the real cell allowing discontinuous Galerkin methods.
  * 
  * This class is derived from and provides substantially the same 
- * as the #FEQ2# class. The only difference is the new constructor that
- * calls #FEQ2::FEQ2(const int)#, the protected constructor of the
- * #FEQ2# class using a #FiniteElement# with no dofs in the vertices, no dofs on the lines and 
+ * as the @p{FEQ2} class. The only difference is the new constructor that
+ * calls @p{FEQ2::FEQ2(const int)}, the protected constructor of the
+ * @p{FEQ2} class using a @p{FiniteElement} with no dofs in the vertices, no dofs on the lines and 
  * $3^d$ dofs per cell. As now the cells do not share any vertex-dof with
  * a neighboring cell the $3^d$ dofs per cell can be choosen independently not
  * needing any constraints and allowing the use of discontinuous Galerkin
@@ -167,14 +167,14 @@ class FEDG_Q2 : public FEQ2<dim>
 
 
 /**
- * Define a (bi-, tri-, etc)cubic finite element in #dim# space dimensions,
+ * Define a (bi-, tri-, etc)cubic finite element in @p{dim} space dimensions,
  * along with (bi-, tri-)linear transforms from the
  * unit cell to the real cell allowing discontinuous Galerkin methods.
  * 
  * This class is derived from and provides substantially the same 
- * as the #FEQ3# class. The only difference is the new constructor that
- * calls #FEQ3::FEQ3(const int)#, the protected constructor of the
- * #FEQ3# class using a #FiniteElement# with no dofs in the vertices, no dofs on the lines and 
+ * as the @p{FEQ3} class. The only difference is the new constructor that
+ * calls @p{FEQ3::FEQ3(const int)}, the protected constructor of the
+ * @p{FEQ3} class using a @p{FiniteElement} with no dofs in the vertices, no dofs on the lines and 
  * $4^d$ dofs per cell. As now the cells do not share any vertex-dof with
  * a neighboring cell the $4^d$ dofs per cell can be choosen independently not
  * needing any constraints and allowing the use of discontinuous Galerkin
@@ -204,14 +204,14 @@ class FEDG_Q3 : public FEQ3<dim>
 
 
 /**
- * Define a (bi-, tri-, etc)quartic finite element in #dim# space dimensions,
+ * Define a (bi-, tri-, etc)quartic finite element in @p{dim} space dimensions,
  * along with (bi-, tri-)linear transforms from the
  * unit cell to the real cell allowing discontinuous Galerkin methods.
  * 
  * This class is derived from and provides substantially the same 
- * as the #FEQ4# class. The only difference is the new constructor that
- * calls #FEQ4::FEQ4(const int)#, the protected constructor of the
- * #FEQ4# class using a #FiniteElement# with no dofs in the vertices, no dofs on the lines and 
+ * as the @p{FEQ4} class. The only difference is the new constructor that
+ * calls @p{FEQ4::FEQ4(const int)}, the protected constructor of the
+ * @p{FEQ4} class using a @p{FiniteElement} with no dofs in the vertices, no dofs on the lines and 
  * $5^d$ dofs per cell. As now the cells do not share any vertex-dof with
  * a neighboring cell the $5^d$ dofs per cell can be choosen independently not
  * needing any constraints and allowing the use of discontinuous Galerkin
index ea0346e4a3128e8833e3b765ecb517aa7707a6cb..bb0f2a77fc5e7220eec967de085d81ef96251727 100644 (file)
@@ -40,23 +40,23 @@ class FEDG_P1 : public FEQ1Mapping<dim>
     FEDG_P1 ();
 
                                     /**
-                                     * Return the value of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the value of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      */
     virtual double shape_value(const unsigned int i,
                               const Point<dim>& p) const;
 
                                     /**
-                                     * Return the gradient of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the gradient of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      */
     virtual Tensor<1,dim> shape_grad(const unsigned int i,
                                     const Point<dim>& p) const;
 
                                     /**
                                      * Return the tensor of second derivatives
-                                     * of the #i#th shape function at
-                                     * point #p# on the unit cell.
+                                     * of the @p{i}th shape function at
+                                     * point @p{p} on the unit cell.
                                      *
                                      * For linear elements, all second
                                      * derivatives on the unit cell are zero.
@@ -105,7 +105,7 @@ class FEDG_P1 : public FEQ1Mapping<dim>
                                     /**
                                      * This function is simply singled out of
                                      * the constructor; it sets up the
-                                     * #restriction# and #prolongation#
+                                     * @p{restriction} and @p{prolongation}
                                      * matrices. Since we have two constructors
                                      * which need this functionality, we
                                      * provide a single function for this.
@@ -137,23 +137,23 @@ class FEDG_P2 : public FEQ1Mapping<dim>
     FEDG_P2 ();
 
                                     /**
-                                     * Return the value of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the value of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      */
     virtual double shape_value(const unsigned int i,
                               const Point<dim>& p) const;
 
                                     /**
-                                     * Return the gradient of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the gradient of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      */
     virtual Tensor<1,dim> shape_grad(const unsigned int i,
                                     const Point<dim>& p) const;
 
                                     /**
                                      * Return the tensor of second derivatives
-                                     * of the #i#th shape function at
-                                     * point #p# on the unit cell.
+                                     * of the @p{i}th shape function at
+                                     * point @p{p} on the unit cell.
                                      */
     virtual Tensor<2,dim> shape_grad_grad (const unsigned int  i,
                                           const Point<dim>   &p) const;
@@ -199,7 +199,7 @@ class FEDG_P2 : public FEQ1Mapping<dim>
                                     /**
                                      * This function is simply singled out of
                                      * the constructor; it sets up the
-                                     * #restriction# and #prolongation#
+                                     * @p{restriction} and @p{prolongation}
                                      * matrices. Since we have two constructors
                                      * which need this functionality, we
                                      * provide a single function for this.
@@ -231,23 +231,23 @@ class FEDG_P3 : public FEQ1Mapping<dim>
     FEDG_P3 ();
 
                                     /**
-                                     * Return the value of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the value of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      */
     virtual double shape_value(const unsigned int i,
                               const Point<dim>& p) const;
 
                                     /**
-                                     * Return the gradient of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the gradient of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      */
     virtual Tensor<1,dim> shape_grad(const unsigned int i,
                                     const Point<dim>& p) const;
 
                                     /**
                                      * Return the tensor of second derivatives
-                                     * of the #i#th shape function at
-                                     * point #p# on the unit cell.
+                                     * of the @p{i}th shape function at
+                                     * point @p{p} on the unit cell.
                                      */
     virtual Tensor<2,dim> shape_grad_grad (const unsigned int  i,
                                           const Point<dim>   &p) const;
@@ -293,7 +293,7 @@ class FEDG_P3 : public FEQ1Mapping<dim>
                                     /**
                                      * This function is simply singled out of
                                      * the constructor; it sets up the
-                                     * #restriction# and #prolongation#
+                                     * @p{restriction} and @p{prolongation}
                                      * matrices. Since we have two constructors
                                      * which need this functionality, we
                                      * provide a single function for this.
@@ -325,23 +325,23 @@ class FEDG_P4 : public FEQ1Mapping<dim>
     FEDG_P4 ();
 
                                     /**
-                                     * Return the value of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the value of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      */
     virtual double shape_value(const unsigned int i,
                               const Point<dim>& p) const;
 
                                     /**
-                                     * Return the gradient of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the gradient of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      */
     virtual Tensor<1,dim> shape_grad(const unsigned int i,
                                     const Point<dim>& p) const;
 
                                     /**
                                      * Return the tensor of second derivatives
-                                     * of the #i#th shape function at
-                                     * point #p# on the unit cell.
+                                     * of the @p{i}th shape function at
+                                     * point @p{p} on the unit cell.
                                      */
     virtual Tensor<2,dim> shape_grad_grad (const unsigned int  i,
                                           const Point<dim>   &p) const;
@@ -387,7 +387,7 @@ class FEDG_P4 : public FEQ1Mapping<dim>
                                     /**
                                      * This function is simply singled out of
                                      * the constructor; it sets up the
-                                     * #restriction# and #prolongation#
+                                     * @p{restriction} and @p{prolongation}
                                      * matrices. Since we have two constructors
                                      * which need this functionality, we
                                      * provide a single function for this.
index b9c51060f5051d7c5277f211bafead3368324a57..e07607c30943bbcdd7d5ccc2b7d8c356eb1e6392 100644 (file)
@@ -20,7 +20,7 @@
 #include <fe/q1_mapping.h>
 
 /**
- * Isoparametric Q1 finite element in #dim# space dimensions.
+ * Isoparametric Q1 finite element in @p{dim} space dimensions.
  *
  * The linear, isoparametric mapping from a point $\vec \xi$ on the unit cell
  * to a point $\vec x$ on the real cell is defined as
@@ -47,33 +47,33 @@ class FEQ1 : public FEQ1Mapping<dim>
                                     /**
                                      * Constructor that is called by the
                                      * constructor of the derived
-                                     * #FEDG_Q1# class.
+                                     * @p{FEDG_Q1} class.
                                      * It uses  no dofs in the vertices and 
                                      * $2^d$ dofs per cell. No constraint
                                      * matrices are build.
-                                     * For more detail see class #FEDGLinear#.
+                                     * For more detail see class @p{FEDGLinear}.
                                      */
     FEQ1 (const int);
     
   public:
                                     /**
-                                     * Return the value of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the value of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      */
     virtual double shape_value(const unsigned int i,
                               const Point<dim>& p) const;
 
                                     /**
-                                     * Return the gradient of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the gradient of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      */
     virtual Tensor<1,dim> shape_grad(const unsigned int i,
                                     const Point<dim>& p) const;
 
                                     /**
                                      * Return the tensor of second derivatives
-                                     * of the #i#th shape function at
-                                     * point #p# on the unit cell.
+                                     * of the @p{i}th shape function at
+                                     * point @p{p} on the unit cell.
                                      *
                                      * For linear elements, all second
                                      * derivatives on the unit cell are zero.
@@ -122,7 +122,7 @@ class FEQ1 : public FEQ1Mapping<dim>
                                     /**
                                      * This function is simply singled out of
                                      * the constructor; it sets up the
-                                     * #restriction# and #prolongation#
+                                     * @p{restriction} and @p{prolongation}
                                      * matrices. Since we have two constructors
                                      * which need this functionality, we
                                      * provide a single function for this.
@@ -132,7 +132,7 @@ class FEQ1 : public FEQ1Mapping<dim>
 
 
 /**
- * Subparametric Q2 finite element in #dim# space dimensions.
+ * Subparametric Q2 finite element in @p{dim} space dimensions.
  * A Q1 mapping from the unit cell
  * to the real cell is implemented.
  *
@@ -181,33 +181,33 @@ class FEQ1 : public FEQ1Mapping<dim>
  *   The respective coordinate values of the support points of the degrees
  *   of freedom are as follows:
  *   \begin{itemize}
- *   \item Index 0: #[0, 0, 0]#;
- *   \item Index 1: #[1, 0, 0]#;
- *   \item Index 2: #[1, 0, 1]#;
- *   \item Index 3: #[0, 0, 1]#;
- *   \item Index 4: #[0, 1, 0]#;
- *   \item Index 5: #[1, 1, 0]#;
- *   \item Index 6: #[1, 1, 1]#;
- *   \item Index 7: #[0, 1, 1]#;
- *   \item Index 8: #[1/2, 0, 0]#;
- *   \item Index 9: #[1, 0, 1/2]#;
- *   \item Index 10: # [1/2, 0, 1]#;
- *   \item Index 11: # [0, 0, 1/2]#;
- *   \item Index 12: # [1/2, 1, 0]#;
- *   \item Index 13: # [1, 1, 1/2]#;
- *   \item Index 14: # [1/2, 1, 1]#;
- *   \item Index 15: # [0, 1, 1/2]#;
- *   \item Index 16: # [0, 1/2, 0]#;
- *   \item Index 17: # [1, 1/2, 0]#;
- *   \item Index 18: # [1, 1/2, 1]#;
- *   \item Index 19: # [0, 1/2, 1]#;
- *   \item Index 20: # [1/2, 0, 1/2]#;
- *   \item Index 21: # [1/2, 1, 1/2]#;
- *   \item Index 22: # [1/2, 1/2, 0]#;
- *   \item Index 23: # [1, 1/2, 1/2]#;
- *   \item Index 24: # [1/2, 1/2, 1]#;
- *   \item Index 25: # [0, 1/2, 1/2]#;
- *   \item Index 26: # [1/2, 1/2, 1/2]#
+ *   \item Index 0: @p{[0, 0, 0]};
+ *   \item Index 1: @p{[1, 0, 0]};
+ *   \item Index 2: @p{[1, 0, 1]};
+ *   \item Index 3: @p{[0, 0, 1]};
+ *   \item Index 4: @p{[0, 1, 0]};
+ *   \item Index 5: @p{[1, 1, 0]};
+ *   \item Index 6: @p{[1, 1, 1]};
+ *   \item Index 7: @p{[0, 1, 1]};
+ *   \item Index 8: @p{[1/2, 0, 0]};
+ *   \item Index 9: @p{[1, 0, 1/2]};
+ *   \item Index 10: @p{[1/2, 0, 1]};
+ *   \item Index 11: @p{[0, 0, 1/2]};
+ *   \item Index 12: @p{[1/2, 1, 0]};
+ *   \item Index 13: @p{[1, 1, 1/2]};
+ *   \item Index 14: @p{[1/2, 1, 1]};
+ *   \item Index 15: @p{[0, 1, 1/2]};
+ *   \item Index 16: @p{[0, 1/2, 0]};
+ *   \item Index 17: @p{[1, 1/2, 0]};
+ *   \item Index 18: @p{[1, 1/2, 1]};
+ *   \item Index 19: @p{[0, 1/2, 1]};
+ *   \item Index 20: @p{[1/2, 0, 1/2]};
+ *   \item Index 21: @p{[1/2, 1, 1/2]};
+ *   \item Index 22: @p{[1/2, 1/2, 0]};
+ *   \item Index 23: @p{[1, 1/2, 1/2]};
+ *   \item Index 24: @p{[1/2, 1/2, 1]};
+ *   \item Index 25: @p{[0, 1/2, 1/2]};
+ *   \item Index 26: @p{[1/2, 1/2, 1/2]}
  *   \end{itemize}
  * \end{itemize}
  *
@@ -225,35 +225,35 @@ class FEQ2 : public FEQ1Mapping<dim>
                                     /**
                                      * Constructor that is called by the
                                      * constructor of the derived
-                                     * #FEDGQuadraticSub# class.
+                                     * @p{FEDGQuadraticSub} class.
                                      * It uses no dofs in the vertices, no
                                      * dofs in the lines and 
                                      * $3^d$ dofs per cell. No constraint
                                      * matrices are build.
                                      * For more detail see class 
-                                     * #FEDGQuadraticSub#.
+                                     * @p{FEDGQuadraticSub}.
                                      */
     FEQ2 (const int);
     
   public:
                                     /**
-                                     * Return the value of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the value of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      */
     virtual double shape_value(const unsigned int i,
                               const Point<dim>& p) const;
 
                                     /**
-                                     * Return the gradient of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the gradient of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      */
     virtual Tensor<1,dim> shape_grad(const unsigned int i,
                                     const Point<dim>& p) const;
 
                                     /**
                                      * Return the tensor of second derivatives
-                                     * of the #i#th shape function at
-                                     * point #p# on the unit cell.
+                                     * of the @p{i}th shape function at
+                                     * point @p{p} on the unit cell.
                                      */
     virtual Tensor<2,dim> shape_grad_grad (const unsigned int  i,
                                           const Point<dim>   &p) const;
@@ -299,7 +299,7 @@ class FEQ2 : public FEQ1Mapping<dim>
                                     /**
                                      * This function is simply singled out of
                                      * the constructor; it sets up the
-                                     * #restriction# and #prolongation#
+                                     * @p{restriction} and @p{prolongation}
                                      * matrices. Since we have two constructors
                                      * which need this functionality, we
                                      * provide a single function for this.
@@ -309,7 +309,7 @@ class FEQ2 : public FEQ1Mapping<dim>
 
 
 /**
- * Subparametric Q3 finite element in #dim# space dimensions.
+ * Subparametric Q3 finite element in @p{dim} space dimensions.
  * A Q1 mapping from the unit cell
  * to the real cell is implemented.
  *
@@ -347,34 +347,34 @@ class FEQ3 : public FEQ1Mapping<dim>
                                     /**
                                      * Constructor that is called by the
                                      * constructor of the derived
-                                     * #FEDGCubicSub# class.
+                                     * @p{FEDGCubicSub} class.
                                      * It uses  no dofs in the vertices and 
                                      * $4^d$ dofs per cell. No constraint
                                      * matrices are build.
                                      * For more detail see class
-                                     * #FEDGCubicSub#.
+                                     * @p{FEDGCubicSub}.
                                      */
     FEQ3 (const int);
 
   public:
                                     /**
-                                     * Return the value of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the value of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      */
     virtual double shape_value(const unsigned int i,
                               const Point<dim>& p) const;
 
                                     /**
-                                     * Return the gradient of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the gradient of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      */
     virtual Tensor<1,dim> shape_grad(const unsigned int i,
                                     const Point<dim>& p) const;
 
                                     /**
                                      * Return the tensor of second derivatives
-                                     * of the #i#th shape function at
-                                     * point #p# on the unit cell.
+                                     * of the @p{i}th shape function at
+                                     * point @p{p} on the unit cell.
                                      */
     virtual Tensor<2,dim> shape_grad_grad (const unsigned int  i,
                                           const Point<dim>   &p) const;
@@ -420,7 +420,7 @@ class FEQ3 : public FEQ1Mapping<dim>
                                     /**
                                      * This function is simply singled out of
                                      * the constructor; it sets up the
-                                     * #restriction# and #prolongation#
+                                     * @p{restriction} and @p{prolongation}
                                      * matrices. Since we have two constructors
                                      * which need this functionality, we
                                      * provide a single function for this.
@@ -430,7 +430,7 @@ class FEQ3 : public FEQ1Mapping<dim>
 
 
 /**
- * Subparametric Q4 finite element in #dim# space dimensions.
+ * Subparametric Q4 finite element in @p{dim} space dimensions.
  * A linear (subparametric) mapping from the unit cell
  * to the real cell is implemented.
  *
@@ -470,34 +470,34 @@ class FEQ4 : public FEQ1Mapping<dim>
                                     /**
                                      * Constructor that is called by the
                                      * constructor of the derived
-                                     * #FEDGQuarticSub# class.
+                                     * @p{FEDGQuarticSub} class.
                                      * It uses  no dofs in the vertices and 
                                      * $5^d$ dofs per cell. No constraint
                                      * matrices are build.
                                      * For more detail see class
-                                     * #FEDGQuarticSub#.
+                                     * @p{FEDGQuarticSub}.
                                      */
     FEQ4 (const int);
 
   public:
                                     /**
-                                     * Return the value of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the value of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      */
     virtual double shape_value(const unsigned int i,
                               const Point<dim>& p) const;
 
                                     /**
-                                     * Return the gradient of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the gradient of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      */
     virtual Tensor<1,dim> shape_grad(const unsigned int i,
                                     const Point<dim>& p) const;
 
                                     /**
                                      * Return the tensor of second derivatives
-                                     * of the #i#th shape function at
-                                     * point #p# on the unit cell.
+                                     * of the @p{i}th shape function at
+                                     * point @p{p} on the unit cell.
                                      */
     virtual Tensor<2,dim> shape_grad_grad (const unsigned int  i,
                                           const Point<dim>   &p) const;
@@ -543,7 +543,7 @@ class FEQ4 : public FEQ1Mapping<dim>
                                     /**
                                      * This function is simply singled out of
                                      * the constructor; it sets up the
-                                     * #restriction# and #prolongation#
+                                     * @p{restriction} and @p{prolongation}
                                      * matrices. Since we have two constructors
                                      * which need this functionality, we
                                      * provide a single function for this.
index eb792f8c50b9b51965a06b869305e6324c3acfb1..c07bdd5093db12fcbb1a46d989005b2be0235d7a 100644 (file)
  * a usual finite element object, which is composed of several other finite
  * elements of the same class each.
  *
- * Basically, this composed finite element has #N# times as many degrees of
- * freedom (and therefore also #N# times as many shape functions) as a single
+ * Basically, this composed finite element has @p{N} times as many degrees of
+ * freedom (and therefore also @p{N} times as many shape functions) as a single
  * object of the underlying finite element would have had. Among these,
- * always #N# have the same properties, i.e. are represented by the same
- * shape functions. These #N# shape functions for each degree of freedom
+ * always @p{N} have the same properties, i.e. are represented by the same
+ * shape functions. These @p{N} shape functions for each degree of freedom
  * of the basic finite element are numbered consecutively, i.e. for
- * the common case of a velocity #(u,v,w)#, the sequence of basis functions
- * will be #u1, v1, w1, u2, v2, w2, ..., uN, vN, wN# compared to
- *  #u1, ..., uN, v1, ..., vN, w1, ...wN#.
+ * the common case of a velocity @p{(u,v,w)}, the sequence of basis functions
+ * will be @p{u1, v1, w1, u2, v2, w2, ..., uN, vN, wN} compared to
+ *  @p{u1, ..., uN, v1, ..., vN, w1, ...wN}.
  *
  * Using this scheme, the overall numbering of degrees of freedom is as
  * follows: for each subobject (vertex, line, quad, or hex), the degrees
  * before turning for the next dof on this subobject or for the next subobject.
  * For example, for the bicubic element in one space dimension, and for
  * two subobjects grouped together by this class, the ordering for
- * the system #s=(u,v)# is:
+ * the system @p{s=(u,v)} is:
  * \begin{itemize}
- * \item First vertex: #u0, v0 = s0, s1#
- * \item Second vertex: #u1, v1 = s2, s3#
+ * \item First vertex: @p{u0, v0 = s0, s1}
+ * \item Second vertex: @p{u1, v1 = s2, s3}
  * \item First degree of freedom on the line (=cell):
- *   #u2, v2 = s3, s4#
+ *   @p{u2, v2 = s3, s4}
  * \item Second degree of freedom on the line:
- *   #u3, v3 = s5, s6#.
+ *   @p{u3, v3 = s5, s6}.
  * \end{itemize}
  *
  * In the most cases, the composed element behaves as if it were a usual element
  * couple the degrees of freedom of the subobject. E.g. the continuity requirement
  * is imposed for the shape functions of the subobjects separately; no requirement
  * exist between shape functions of different subobjects, i.e. in the above
- * example: on a hanging node, the respective value of the #u# velocity is only
- * coupled to #u# at the vertices and the line on the larger cell next to this
- * vertex, there is no interaction with #v# and #w# of this or the other cell.
+ * example: on a hanging node, the respective value of the @p{u} velocity is only
+ * coupled to @p{u} at the vertices and the line on the larger cell next to this
+ * vertex, there is no interaction with @p{v} and @p{w} of this or the other cell.
  *
- * Likewise, the matrix computed by the #get_local_mass_matrix# function, which
+ * Likewise, the matrix computed by the @p{get_local_mass_matrix} function, which
  * originally is defined to be $m_{ij} = \int_K \phi_i \phi_j dx$ contains
  * only those $m_{ij}$ for which the respective shape functions belong to the
  * same subobject, all other entries are set to zero. The matrix therefore is
@@ -93,14 +93,14 @@ class FESystem : public FiniteElement<dim>
                                      * and the number of elements you want to
                                      * group together using this class.
                                      *
-                                     * In fact, the object #fe# is not used,
+                                     * In fact, the object @p{fe} is not used,
                                      * apart from getting the number of dofs
                                      * per vertex, line, etc for that finite
                                      * element class. The objects creates its
                                      * own copy of the finite element object
                                      * at construction time (but after
                                      * the initialization of the base class
-                                     * #FiniteElement#, which is why we need
+                                     * @p{FiniteElement}, which is why we need
                                      * a valid finite element object passed
                                      * to the constructor).
                                      *
@@ -140,40 +140,40 @@ class FESystem : public FiniteElement<dim>
     virtual ~FESystem ();
 
                                     /**
-                                     * Return the value of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the value of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      *
-                                     * For an element composed of #N#
-                                     * subelements, the first #N# shape
+                                     * For an element composed of @p{N}
+                                     * subelements, the first @p{N} shape
                                      * functions refer to the zeroth shape
                                      * function of the underlying object,
-                                     * the shape functions #N..2N-1# refer
+                                     * the shape functions @p{N..2N-1} refer
                                      * to the base shape function with
-                                     * number #1#, and so on. The #i# shape
+                                     * number @p{1}, and so on. The @p{i} shape
                                      * function therefore equals the
-                                     * #i/N# the shape function of the
+                                     * @p{i/N} the shape function of the
                                      * base object.
                                      */
     virtual double shape_value(const unsigned int i,
                               const Point<dim>  &p) const;
 
                                     /**
-                                     * Return the gradient of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the gradient of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      *
                                      * For the ordering of shape functions
-                                     * refer to the #shape_value# function.
+                                     * refer to the @p{shape_value} function.
                                      */
     virtual Tensor<1,dim> shape_grad(const unsigned int i,
                                     const Point<dim>& p) const;
 
                                     /**
                                      * Return the tensor of second derivatives
-                                     * of the #i#th shape function at
-                                     * point #p# on the unit cell.
+                                     * of the @p{i}th shape function at
+                                     * point @p{p} on the unit cell.
                                      *
                                      * For the ordering of shape functions
-                                     * refer to the #shape_value# function.
+                                     * refer to the @p{shape_value} function.
                                      */
     virtual Tensor<2,dim> shape_grad_grad (const unsigned int  i,
                                           const Point<dim>   &p) const;
@@ -183,7 +183,7 @@ class FESystem : public FiniteElement<dim>
                                      * information on this function.
                                      *
                                      * For the ordering of shape functions
-                                     * refer to the #shape_value# function.
+                                     * refer to the @p{shape_value} function.
                                      */
     virtual void get_unit_support_points (vector<Point<dim> > &support_points) const;
 
@@ -192,7 +192,7 @@ class FESystem : public FiniteElement<dim>
                                      * information on this function.
                                      *
                                      * For the ordering of shape functions
-                                     * refer to the #shape_value# function.
+                                     * refer to the @p{shape_value} function.
                                      */
     virtual void get_support_points (const DoFHandler<dim>::cell_iterator &cell,
                                     vector<Point<dim> > &support_points) const;
@@ -238,9 +238,9 @@ class FESystem : public FiniteElement<dim>
                                      * matrix of the base finite element as
                                      * described above. However, this is
                                      * not the numbering used by the
-                                     * #FESystem# class, so the block
+                                     * @p{FESystem} class, so the block
                                      * structure is usually lost for
-                                     * the {\it local} mass matrices, but
+                                     * the @em{local} mass matrices, but
                                      * can be recovered in the global
                                      * matrix by suitable renumbering
                                      * of global DoF numbers.
@@ -252,7 +252,7 @@ class FESystem : public FiniteElement<dim>
                                        FullMatrix<double> &local_mass_matrix) const;
 
                                     /**
-                                     * Return the value of the #i#th shape
+                                     * Return the value of the @p{i}th shape
                                      * function of the transformation mapping
                                      * from unit cell to real cell. Since
                                      * the transform functions are not
@@ -267,7 +267,7 @@ class FESystem : public FiniteElement<dim>
 
                                     /**
                                      * Same as above: return gradient of the
-                                     * #i#th shape function for the mapping
+                                     * @p{i}th shape function for the mapping
                                      * from unit to real cell.
                                      */
     virtual Tensor<1,dim> shape_grad_transform (const unsigned int i,
@@ -306,7 +306,7 @@ class FESystem : public FiniteElement<dim>
 
                                     /**
                                      * Return the normal vectors to the
-                                     * face with number #face_no# of #cell#.
+                                     * face with number @p{face_no} of @p{cell}.
                                      *
                                      * Since this function is only about the
                                      * mapping from unit to real cell, it
@@ -325,8 +325,8 @@ class FESystem : public FiniteElement<dim>
 
                                     /**
                                      * Return the normal vectors to the
-                                     * subface with number #subface_no# of
-                                     * the face with number #face_no# of #cell#.
+                                     * subface with number @p{subface_no} of
+                                     * the face with number @p{face_no} of @p{cell}.
                                      *
                                      * Since this function is only about the
                                      * mapping from unit to real cell, it
@@ -347,7 +347,7 @@ class FESystem : public FiniteElement<dim>
                                     /**
                                      * Implementation of the
                                      * corresponding function of
-                                     * #FiniteElement#.
+                                     * @p{FiniteElement}.
                                      */
     virtual void fill_fe_values (const DoFHandler<dim>::cell_iterator &cell,
                                 const vector<Point<dim> >            &unit_points,
@@ -389,7 +389,7 @@ class FESystem : public FiniteElement<dim>
                                      * want to have an FEValues object
                                      * with a lot of equal entries. Ok,
                                      * so initialize your FEValues with
-                                     * the #base_element# you get by
+                                     * the @p{base_element} you get by
                                      * this function. In a mixed
                                      * discretization, you can choose
                                      * the different base element types
@@ -422,11 +422,11 @@ class FESystem : public FiniteElement<dim>
 
                                     /**
                                      * Helper function used in the constructor:
-                                     * take a #FiniteElementData# object
+                                     * take a @p{FiniteElementData} object
                                      * and return an object of the same type
                                      * with the number of degrees of
                                      * freedom per vertex, line, etc.
-                                     * multiplied by #n#. Don't touch the
+                                     * multiplied by @p{n}. Don't touch the
                                      * number of functions for the
                                      * transformation from unit to real
                                      * cell.
@@ -460,11 +460,11 @@ class FESystem : public FiniteElement<dim>
 
                                     /**
                                      * Helper function used in the constructor:
-                                     * takes a #FiniteElement# object
+                                     * takes a @p{FiniteElement} object
                                      * and returns an boolean vector including
-                                     * the #restriction_is_additive_flags# of
-                                     * the mixed element consisting of #N#
-                                     * elements of the sub-element #fe#.
+                                     * the @p{restriction_is_additive_flags} of
+                                     * the mixed element consisting of @p{N}
+                                     * elements of the sub-element @p{fe}.
                                      */
     static vector<bool>
     compute_restriction_is_additive_flags (const FiniteElement<dim> &fe,
@@ -496,29 +496,29 @@ class FESystem : public FiniteElement<dim>
                                      * This function is simply singled out of
                                      * the constructor. It sets up the
                                      * index table for the system as well as
-                                     * #restriction# and #prolongation#
+                                     * @p{restriction} and @p{prolongation}
                                      * matrices. Since the operation of this
                                      * function can be done without explicit
                                      * knowledge of the data type of the
                                      * underlying finite element class, we
                                      * don't want to have this function in
                                      * the general template definition in
-                                     * the #.h# file.
+                                     * the @p{.h} file.
                                      */
     void initialize();
 
                                     /**
-                                     * Used by #initialize#.
+                                     * Used by @p{initialize}.
                                      */
     void build_cell_table();
     
                                     /**
-                                     * Used by #initialize#.
+                                     * Used by @p{initialize}.
                                      */
     void build_face_table();
 
                                     /**
-                                     * Used by #initialize#.
+                                     * Used by @p{initialize}.
                                      */
     void build_interface_constraints ();
     
index ca3ab3028b99ecaa0db9d13fc25c9aa2c7f57259..2917c7fe8aea07b57da2dfaab14248b8281ba88d 100644 (file)
@@ -24,8 +24,8 @@ template <typename number> class Vector;
 
 /**
  * This class performs interpolations and extrapolations of discrete
- * functions of one #FiniteElement# #fe1# to another #FiniteElement#
- * #fe2#.
+ * functions of one @p{FiniteElement} @p{fe1} to another @p{FiniteElement}
+ * @p{fe2}.
  *
  * It also provides the local interpolation matrices that interpolate
  * on each cell. Furthermore it provides the difference matrix
@@ -39,16 +39,16 @@ class FETools
   public:
                                   /**
                                    * Gives the interpolation matrix
-                                   * that interpolates a #fe1#-
-                                   * function to a #fe2#-function on
+                                   * that interpolates a @p{fe1}-
+                                   * function to a @p{fe2}-function on
                                    * each cell. The interpolation_matrix
                                    * needs to be of size
-                                   * #(fe2.dofs_per_cell, fe1.dofs_per_cell)#.
+                                   * @p{(fe2.dofs_per_cell, fe1.dofs_per_cell)}.
                                    *
                                    * Note, that if the finite element
-                                   * space #fe1# is a subset of
+                                   * space @p{fe1} is a subset of
                                    * the finite element space
-                                   * #fe2# than the #interpolation_matrix#
+                                   * @p{fe2} than the @p{interpolation_matrix}
                                    * is an embedding matrix.
                                    */
   template <int dim, typename number>
@@ -58,20 +58,20 @@ class FETools
     
                                   /**
                                    * Gives the interpolation matrix
-                                   * that interpolates a #fe1#-
-                                   * function to a #fe2#-function, and
+                                   * that interpolates a @p{fe1}-
+                                   * function to a @p{fe2}-function, and
                                    * interpolates this to a second
-                                   * #fe1#-function on
+                                   * @p{fe1}-function on
                                    * each cell. The interpolation_matrix
                                    * needs to be of size
-                                   * #(fe1.dofs_per_cell, fe1.dofs_per_cell)#.
+                                   * @p{(fe1.dofs_per_cell, fe1.dofs_per_cell)}.
                                    *
                                    * Note, that this function only
                                    * makes sense if the finite element
-                                   * space due to #fe1# is not a subset of
+                                   * space due to @p{fe1} is not a subset of
                                    * the finite element space due to
-                                   * #fe2#, as if it were a subset then
-                                   * the #interpolation_matrix# would be 
+                                   * @p{fe2}, as if it were a subset then
+                                   * the @p{interpolation_matrix} would be 
                                    * only the unit matrix.
                                    */
   template <int dim, typename number>
@@ -82,16 +82,16 @@ class FETools
                                   /**
                                    * Gives the unit matrix minus the
                                    * back interpolation matrix.
-                                   * The #difference_matrix#
+                                   * The @p{difference_matrix}
                                    * needs to be of size
-                                   * #(fe1.dofs_per_cell, fe1.dofs_per_cell)#.
+                                   * @p{(fe1.dofs_per_cell, fe1.dofs_per_cell)}.
                                    *
                                    * This function gives
                                    * the matrix that transforms a
-                                   * #fe1# function $z$ to $z-I_hz$
+                                   * @p{fe1} function $z$ to $z-I_hz$
                                    * where $I_h$ denotes the interpolation
-                                   * operator from the #fe1# space to
-                                   * the #fe2# space. This matrix hence
+                                   * operator from the @p{fe1} space to
+                                   * the @p{fe2} space. This matrix hence
                                    * is useful to evaluate
                                    * error-representations where $z$
                                    * denotes the dual solution.
@@ -104,20 +104,20 @@ class FETools
 
                                   /**
                                    * Gives the interpolation of a the
-                                   * #dof1#-function #u1# to a
-                                   * #dof2#-function #u2#. #dof1# and
-                                   * #dof2# need to be #DoFHandler#s
+                                   * @p{dof1}-function @p{u1} to a
+                                   * @p{dof2}-function @p{u2}. @p{dof1} and
+                                   * @p{dof2} need to be @p{DoFHandler}s
                                    * based on the same triangulation.
                                    *
-                                   * If the elements #fe1# and #fe2#
+                                   * If the elements @p{fe1} and @p{fe2}
                                    * are either both continuous or
                                    * both discontinuous then this
                                    * interpolation is the usual point
                                    * interpolation. The same is true
-                                   * if #fe1# is a continuous and
-                                   * #fe2# is a discontinuous finite
-                                   * element. For the case that #fe1#
-                                   * is a discontinuous and #fe2# is
+                                   * if @p{fe1} is a continuous and
+                                   * @p{fe2} is a discontinuous finite
+                                   * element. For the case that @p{fe1}
+                                   * is a discontinuous and @p{fe2} is
                                    * a continuous finite element
                                    * there is no point interpolation
                                    * defined at the discontinuities.
@@ -132,17 +132,17 @@ class FETools
                            Vector<number> &u2);
     
                                   /**
-                                   * Gives the interpolation of the #fe1#-
-                                   * function #u1# to a #fe2#-function, and
+                                   * Gives the interpolation of the @p{fe1}-
+                                   * function @p{u1} to a @p{fe2}-function, and
                                    * interpolates this to a second
-                                   * #fe1#-function named #u1_interpolated#.
+                                   * @p{fe1}-function named @p{u1_interpolated}.
                                    *
                                    * Note, that this function only
                                    * makes sense if the finite element
-                                   * space due to #fe1# is not a subset of
+                                   * space due to @p{fe1} is not a subset of
                                    * the finite element space due to
-                                   * #fe2#, as if it were a subset then
-                                   * #u1_interpolated# would be equal to #u1#.
+                                   * @p{fe2}, as if it were a subset then
+                                   * @p{u1_interpolated} would be equal to @p{u1}.
                                    */
   template <int dim, typename number>
     static void back_interpolate(const DoFHandler<dim> &dof1,
@@ -152,10 +152,10 @@ class FETools
 
                                   /**
                                    * Gives $(Id-I_h)z2$ for a given
-                                   * #fe2#-function #z2#, where $I_h$
-                                   * is the interpolation from #fe2#
-                                   * to #fe1#. $(Id-I_h)z2$ is
-                                   * denoted by #z2_difference#.
+                                   * @p{fe2}-function @p{z2}, where $I_h$
+                                   * is the interpolation from @p{fe2}
+                                   * to @p{fe1}. $(Id-I_h)z2$ is
+                                   * denoted by @p{z2_difference}.
                                    */
   template <int dim, typename number>
     static void interpolation_difference(const DoFHandler<dim> &dof1,
@@ -165,10 +165,10 @@ class FETools
     
                                   /**
                                    * Gives the patchwise
-                                   * extrapolation of a #dof1#
-                                   * function #z1# to a #dof2#
-                                   * function #z2#.  #dof1# and
-                                   * #dof2# need to be #DoFHandler#
+                                   * extrapolation of a @p{dof1}
+                                   * function @p{z1} to a @p{dof2}
+                                   * function @p{z2}.  @p{dof1} and
+                                   * @p{dof2} need to be @p{DoFHandler}
                                    * based on the same triangulation.
                                    *
                                    * This function is interesting for
index fadac746653c3d3a02830d0a8b1a98f6700968be..c72c797451afcbb2d56bd19d2b9bf99fbbeb6e05 100644 (file)
 
 
 /**
- * Provide a set of flags which tells the #FEValues<>::reinit# function, which
+ * Provide a set of flags which tells the @p{FEValues<>::reinit} function, which
  * fields are to be updated for each cell. E.g. if you do not need the
  * gradients since you want to assemble the mass matrix, you can switch that
  * off. By default, all flags are off, i.e. no reinitialization will be done.
  *
  * A variable of this type has to be passed to the constructor of the
- * #FEValues# object. You can select more than one flag by concatenation
- * using the #|# (bitwise #or#) operator.
+ * @p{FEValues} object. You can select more than one flag by concatenation
+ * using the @p{|} (bitwise @p{or}) operator.
  */
 enum UpdateFlags {
                                       /**
@@ -73,7 +73,7 @@ enum UpdateFlags {
                                        * located.
                                        *
                                        * Giving this flag to the
-                                       * #FESubfaceValues# class will result
+                                       * @p{FESubfaceValues} class will result
                                        * in an error, since support points are
                                        * not useful in that case.
                                        */
@@ -82,10 +82,10 @@ enum UpdateFlags {
                                        * Update the outward normal vectors
                                        * to the face relative to this cell.
                                        * This flag is only evaluated by
-                                       * the #FEFaceValues# class.
+                                       * the @p{FEFaceValues} class.
                                        *
                                        * Giving this flag to the
-                                       * #FEValues# class will result in
+                                       * @p{FEValues} class will result in
                                        * an error, since normal vectors are
                                        * not useful in that case.
                                        */
index 1d5dea2b953bb835ea35c000376010bd9b01643b..d3bc21b1df846a5a9acefc458bf54668e9266ed1 100644 (file)
@@ -28,7 +28,7 @@ template <int dim> class Quadrature;
 
 /**
  *  This class offers a multitude of arrays and other fields which are used by
- *  the derived classes #FEValues#, #FEFaceValues# and #FESubfaceValues#.
+ *  the derived classes @p{FEValues}, @p{FEFaceValues} and @p{FESubfaceValues}.
  *  In principle, it is the
  *  back end of the front end for the unification of a certain finite element
  *  and a quadrature formula which evaluates certain aspects of the finite
@@ -58,14 +58,14 @@ template <int dim> class Quadrature;
  *  a cell (using a given quadrature rule), we may be tempted to compute the
  *  restriction to all faces at startup (thus ending in four array of trial
  *  function values in two dimensions, one per face, and even more in higher
- *  dimensions) and let the respective #reinit# function of the derived classes
+ *  dimensions) and let the respective @p{reinit} function of the derived classes
  *  set a number which of the fields is to be taken when the user requests the
- *  function values. This is done through the #selected_dataset# variable. See
- *  the derived classes and the #get_values# function for the exact usage of
+ *  function values. This is done through the @p{selected_dataset} variable. See
+ *  the derived classes and the @p{get_values} function for the exact usage of
  *  this variable.
  *
- *  For many of the actual computations done by the #fill_fe_*# functions of
- *  the #FiniteElement# class and its decendants, the values and gradients of
+ *  For many of the actual computations done by the @p{fill_fe_*} functions of
+ *  the @p{FiniteElement} class and its decendants, the values and gradients of
  *  the transformation functions are needed. For example, for the computation
  *  of the real location of a quadrature point from the location on the unit
  *  cell, the values are needed, while for the computation of the Jacobian
@@ -73,25 +73,25 @@ template <int dim> class Quadrature;
  *  functions coincide with the trial functions, this does not hold for higher
  *  order elements with subparametric mappings and for other types of elements
  *  such as non-conforming ones, etc, such that the precomputed values and
- *  gradients of the trial functions (#unit_shape_values# and
- *  #unit_shape_grads#) cannot be used for the present purpose.
- *  In principle, these values could be computed each time the #fill_fe_*#
+ *  gradients of the trial functions (@p{unit_shape_values} and
+ *  @p{unit_shape_grads}) cannot be used for the present purpose.
+ *  In principle, these values could be computed each time the @p{fill_fe_*}
  *  function is called; however, this computation is highly redundant, since
  *  only the values on the unit cell and only at the quadrature points are
- *  needed, i.e. they are the same for each cell that #fill_fe_*# is called.
- *  Therefore, two additional arrays, #unit_shape_values_transform# and
- *  #unit_shape_grads_transform# are provided, which are filled upon construction
+ *  needed, i.e. they are the same for each cell that @p{fill_fe_*} is called.
+ *  Therefore, two additional arrays, @p{unit_shape_values_transform} and
+ *  @p{unit_shape_grads_transform} are provided, which are filled upon construction
  *  of an object of this type, which the actual finite element may or may not
- *  use. Later on, the #fill_fe_*# functions are passed pointers to these
+ *  use. Later on, the @p{fill_fe_*} functions are passed pointers to these
  *  arrays, which they may use to extract the values and gradients of the
  *  transform functions. If a concrete finite element choses not to use this
- *  field, it shall set its field #transform_functions# to zero.
+ *  field, it shall set its field @p{transform_functions} to zero.
  *
- *  The #unit_shape_grads_transform# array is provided by the derived classes
+ *  The @p{unit_shape_grads_transform} array is provided by the derived classes
  *  to allow for the inclusion of multiple faces, etc.
  *
  *
- *  \subsection{Definitions}
+ *  @sect3{Definitions}
  *
  *  The Jacobian matrix is defined to be
  *  $$ J_{ij} = {d\xi_i \over dx_j} $$
@@ -120,12 +120,12 @@ template <int dim> class Quadrature;
  *  \textit{from the right}; the whole situation is a bit confusing and it
  *  either takes deep though or trial-and-error to do it right. Some more
  *  information on this can be found in the source code documentation for the
- *  #FEQ1Mapping<dim>::fill_fe_values# function, where also a small test
+ *  @p{FEQ1Mapping<dim>::fill_fe_values} function, where also a small test
  *  program is presented.
  *
  *  The derivatives of the Jacobi matrices at the quadrature points with respect
  *  to unit cell coordinates is stored in the field names
- *  #jacobi_matrices_grad#. Since the gradient of a shape function is given by
+ *  @p{jacobi_matrices_grad}. Since the gradient of a shape function is given by
  *  $\partial_i \phi = \sum_k  \hat\partial_k \hat\phi  J_{ki}$, where
  *  $\hat\partial$ denotes differentiation on the unit cell, the second
  *  derivative of a function is given by
@@ -140,20 +140,20 @@ template <int dim> class Quadrature;
  *  stored in the named field.
  *
  *  
- *  \subsection{Member functions}
+ *  @sect3{Member functions}
  *
  *  The functions of this class fall into different cathegories:
  *  \begin{itemize}
- *  \item #shape_value#, #shape_grad#, etc: return one of the values
+ *  \item @p{shape_value}, @p{shape_grad}, etc: return one of the values
  *    of this object at a time. In many cases you will want to get
  *    a whole bunch at a time for performance or convenience reasons,
- *    then use the #get_*# functions.
+ *    then use the @p{get_*} functions.
  *   
- *  \item #get_shape_values#, #get_shape_grads#, etc: these return
+ *  \item @p{get_shape_values}, @p{get_shape_grads}, etc: these return
  *    a reference to a whole field. Usually these fields contain
  *    the values of all trial functions at all quadrature points.
  *
- *  \item #get_function_values#, #get_function_grads#, #...#: these
+ *  \item @p{get_function_values}, @p{get_function_grads}, @p{...}: these
  *    functions offer a simple way to avoid the detour of the
  *    trial functions, if you have a finite element solution (resp. the
  *    vector of values associated with the different trial functions.)
@@ -164,34 +164,34 @@ template <int dim> class Quadrature;
  *    you pass it a vector holding the finite element solution and the
  *    functions return the values or gradients of the finite element
  *    function restricted to the cell which was given last time the
- *    #reinit# function was given. The same applies for the functions
+ *    @p{reinit} function was given. The same applies for the functions
  *    returning higher derivatives of the solution.
  *   
  *    Though possible in principle, these functions do not call the
- *    #reinit# function, you have to do so yourself beforehand. On the
+ *    @p{reinit} function, you have to do so yourself beforehand. On the
  *    other hand, a copy of the cell iterator is stored which was used
- *    last time the #reinit# function was called. This frees us from
+ *    last time the @p{reinit} function was called. This frees us from
  *    the need to pass the cell iterator again to these two functions,
  *    which guarantees that the cell used here is in sync with that used
- *    for the #reinit# function. You should, however, make sure that
- *    nothing substantial happens to the #DoFHandler# object or any
- *    other involved instance between the #reinit# and the #get_function_*#
+ *    for the @p{reinit} function. You should, however, make sure that
+ *    nothing substantial happens to the @p{DoFHandler} object or any
+ *    other involved instance between the @p{reinit} and the @p{get_function_*}
  *    functions are called.
  *
- *  \item #reinit#: initialize the #FEValues# object for a certain cell.
+ *  \item @p{reinit}: initialize the @p{FEValues} object for a certain cell.
  *    This function is not in the present class but only in the derived
  *    classes and has a variable call syntax. 
  *    See the docs for the derived classes for more information.
  * \end{itemize}
  *
  *
- * \subsection{Implementational issues}
+ * @sect3{Implementational issues}
  *
- * The #FEValues# object keeps track of those fields which really need to
+ * The @p{FEValues} object keeps track of those fields which really need to
  * be computed, since the computation of the gradients of the trial functions
  * and of other values on each real cell can be quite an expensive thing
  * if it is not needed. The
- * object knows about which fields are needed by the #UpdateFlags# object
+ * object knows about which fields are needed by the @p{UpdateFlags} object
  * passed through the constructor. In debug mode, the accessor functions, which
  * return values from the different fields, check whether the required field
  * was initialized, thus avoiding use of unitialized data.
@@ -199,14 +199,14 @@ template <int dim> class Quadrature;
  * Functions should not assume that one flag is needed for another object as
  * well. For example, the computation of the Jacobi determinant usually
  * requires the computation of the Jacobi matrix. However, functions shall
- * not assume that someone who wants to get the #JxW_values# must set the
- * #update_jacobians# flag besides the #update_JxW_values# flag.
+ * not assume that someone who wants to get the @p{JxW_values} must set the
+ * @p{update_jacobians} flag besides the @p{update_JxW_values} flag.
  *
  * It is also forbidden that the constructor of a class set the
- * #update_jacobians# flag if the user specifies #update_JxW_values#. This is
- * since derived classes may be able to compute the #JxW_values# field without
+ * @p{update_jacobians} flag if the user specifies @p{update_JxW_values}. This is
+ * since derived classes may be able to compute the @p{JxW_values} field without
  * the Jacobian matrices, but need to do the latter since they can't know who
- * set the #update_jacobians# flag.
+ * set the @p{update_jacobians} flag.
  *
  * @author Wolfgang Bangerth, 1998
  */
@@ -240,12 +240,12 @@ class FEValuesBase
     
                                     /**
                                      * Constructor. Set up the array sizes
-                                     * with #n_q_points# quadrature points,
-                                     * #n_support_points# support points (on
-                                     * the cell or face), #n_dof# trial
+                                     * with @p{n_q_points} quadrature points,
+                                     * @p{n_support_points} support points (on
+                                     * the cell or face), @p{n_dof} trial
                                      * functions per cell and with the
                                      * given pattern to update the fields
-                                     * when the #reinit# function of the
+                                     * when the @p{reinit} function of the
                                      * derived classes is called. The
                                      * fields themselves are not set up,
                                      * this must happen in the derived
@@ -262,10 +262,10 @@ class FEValuesBase
 
 
                                     /**
-                                     * Return the value of the #i#th shape
-                                     * function at the #j# quadrature point
+                                     * Return the value of the @p{i}th shape
+                                     * function at the @p{j} quadrature point
                                      * on the cell, face or subface selected
-                                     * the last time the #reinit# function
+                                     * the last time the @p{reinit} function
                                      * of the derived class was called.
                                      */
     double shape_value (const unsigned int function,
@@ -276,7 +276,7 @@ class FEValuesBase
                                      * all values of shape functions at all
                                      * integration points, on the present cell,
                                      * face or subface selected
-                                     * the last time the #reinit# function
+                                     * the last time the @p{reinit} function
                                      * of the derived class was called.
                                      * For the format of this matrix, see the
                                      * documentation for the matrix itself.
@@ -286,9 +286,9 @@ class FEValuesBase
                                     /**
                                      * Return the values of the finite
                                      * element function characterized
-                                     * by #fe_function# restricted to
+                                     * by @p{fe_function} restricted to
                                      * the cell, face or subface selected
-                                     * the last time the #reinit# function
+                                     * the last time the @p{reinit} function
                                      * of the derived class was called,
                                      * at the quadrature points.
                                      *
@@ -299,19 +299,19 @@ class FEValuesBase
                                      * To get values of
                                      * multi-component elements,
                                      * there is another
-                                     * #get_function_values#
+                                     * @p{get_function_values}
                                      * returning a vector of vectors of
                                      * results.
                                      *
                                      * The function assumes that the
-                                     * #values# object already has the
+                                     * @p{values} object already has the
                                      * right size.
                                      *
                                      * The actual data type of the
                                      * input vector may be either a
-                                     * #Vector<double>#,
-                                     * #Vector<float>#, or
-                                     * #BlockVector<double,...>#.
+                                     * @p{Vector<double>},
+                                     * @p{Vector<float>}, or
+                                     * @p{BlockVector<double,...>}.
                                      */
     template <class InputVector, typename number>
     void get_function_values (const InputVector &fe_function,
@@ -322,26 +322,26 @@ class FEValuesBase
                                      * element functions.
                                      *
                                      * This function does the same as
-                                     * the other #get_function_values#,
+                                     * the other @p{get_function_values},
                                      * but applied to multi-component
                                      * elements.
                                      *
                                      * The actual data type of the
                                      * input vector may be either a
-                                     * #Vector<double>#,
-                                     * #Vector<float>#, or
-                                     * #BlockVector<double,...>#.
+                                     * @p{Vector<double>},
+                                     * @p{Vector<float>}, or
+                                     * @p{BlockVector<double,...>}.
                                      */
     template <class InputVector, typename number>
     void get_function_values (const InputVector       &fe_function,
                              vector<Vector<number> > &values) const;
 
                                     /**
-                                     * Return the gradient of the #i#th shape
-                                     * function at the #j# quadrature point.
+                                     * Return the gradient of the @p{i}th shape
+                                     * function at the @p{j} quadrature point.
                                      * If you want to get the derivative in
                                      * one of the coordinate directions, use
-                                     * the appropriate function of the #Tensor#
+                                     * the appropriate function of the @p{Tensor}
                                      * class to extract one component. Since
                                      * only a reference to the gradient's value
                                      * is returned, there should be no major
@@ -364,22 +364,22 @@ class FEValuesBase
                                     /**
                                      * Return the gradients of the finite
                                      * element function characterized
-                                     * by #fe_function# restricted to
-                                     * #cell# at the quadrature points.
+                                     * by @p{fe_function} restricted to
+                                     * @p{cell} at the quadrature points.
                                      *
                                      * If the present cell is not an active
                                      * one the interpolated function values
                                      * are returned.
                                      *
                                      * The function assumes that the
-                                     * #gradients# object already has the
+                                     * @p{gradients} object already has the
                                      * right size.
                                      *
                                      * The actual data type of the
                                      * input vector may be either a
-                                     * #Vector<double>#,
-                                     * #Vector<float>#, or
-                                     * #BlockVector<double,...>#.
+                                     * @p{Vector<double>},
+                                     * @p{Vector<float>}, or
+                                     * @p{BlockVector<double,...>}.
                                      */
     template <class InputVector>
     void get_function_grads (const InputVector      &fe_function,
@@ -388,27 +388,27 @@ class FEValuesBase
                                     /**
                                      * Return the gradients of the finite
                                      * element function characterized
-                                     * by #fe_function# restricted to
-                                     * #cell# at the quadrature points.
+                                     * by @p{fe_function} restricted to
+                                     * @p{cell} at the quadrature points.
                                      *
                                      * If the present cell is not an active
                                      * one the interpolated function values
                                      * are returned.
                                      *
                                      * The function assumes that the
-                                     * #gradients# object already has the
+                                     * @p{gradients} object already has the
                                      * right size.
                                      *
                                      * This function does the same as
-                                     * the other #get_function_values#,
+                                     * the other @p{get_function_values},
                                      * but applied to multi-component
                                      * elements.
                                      *
                                      * The actual data type of the
                                      * input vector may be either a
-                                     * #Vector<double>#,
-                                     * #Vector<float>#, or
-                                     * #BlockVector<double,...>#.
+                                     * @p{Vector<double>},
+                                     * @p{Vector<float>}, or
+                                     * @p{BlockVector<double,...>}.
                                      */
     template <class InputVector>
     void get_function_grads (const InputVector               &fe_function,
@@ -416,13 +416,13 @@ class FEValuesBase
 
                                     /**
                                      * Return the 2nd derivatives of
-                                     * the #i#th shape function at
-                                     * the #j# quadrature point. If
+                                     * the @p{i}th shape function at
+                                     * the @p{j} quadrature point. If
                                      * you want to get the derivatives
                                      * in one of the coordinate
                                      * directions, use the
                                      * appropriate function of the
-                                     * #Tensor# class to extract one
+                                     * @p{Tensor} class to extract one
                                      * component. Since only a
                                      * reference to the derivatives'
                                      * values is returned, there
@@ -451,25 +451,25 @@ class FEValuesBase
                                      * Return the tensor of second
                                      * derivatives of the finite
                                      * element function characterized
-                                     * by #fe_function# restricted to
-                                     * #cell# at the quadrature points.
+                                     * by @p{fe_function} restricted to
+                                     * @p{cell} at the quadrature points.
                                      *
                                      * The function assumes that the
-                                     * #second_derivatives# object already has
+                                     * @p{second_derivatives} object already has
                                      * the right size.
                                      *
                                      * The actual data type of the
                                      * input vector may be either a
-                                     * #Vector<double>#,
-                                     * #Vector<float>#, or
-                                     * #BlockVector<double,...>#.
+                                     * @p{Vector<double>},
+                                     * @p{Vector<float>}, or
+                                     * @p{BlockVector<double,...>}.
                                      */
     template <class InputVector>
     void get_function_2nd_derivatives (const InputVector      &fe_function,
                                       vector<Tensor<2,dim> > &second_derivatives) const;
 
                                     /**
-                                     * Return the position of the #i#th
+                                     * Return the position of the @p{i}th
                                      * quadrature point in real space.
                                      *
                                      * If this object is used to evaluate
@@ -491,7 +491,7 @@ class FEValuesBase
 
                                     /**
                                      * Return the point in real space where
-                                     * the #i#th trial function is located
+                                     * the @p{i}th trial function is located
                                      * (location is in the sense of where it
                                      * assumes its nominal properties, e.g. at
                                      * the vertex of a cell, at the center of
@@ -506,7 +506,7 @@ class FEValuesBase
                                      * locations.
                                      *
                                      * For the evaluation of finite elements on
-                                     * faces of cells, #i# is the number
+                                     * faces of cells, @p{i} is the number
                                      * of the trial function on the face, not
                                      * on the cell.
                                      */
@@ -521,7 +521,7 @@ class FEValuesBase
     
                                     /**
                                      * Return the Jacobi determinant times
-                                     * the weight of the #i#th quadrature
+                                     * the weight of the @p{i}th quadrature
                                      * point.
                                      *
                                      * If faces of cells are concerned,
@@ -529,7 +529,7 @@ class FEValuesBase
                                      * transformation of the unit face to
                                      * the present face, not of the unit
                                      * cell to the real cell (unlike for
-                                     * the #jacobi_matrix# array of the
+                                     * the @p{jacobi_matrix} array of the
                                      * derived classes which store the cell
                                      * transformation's Jacobi matrix in
                                      * all cases).
@@ -605,7 +605,7 @@ class FEValuesBase
                                      * vector contains as many elements as
                                      * there are faces, for subfaces the same
                                      * applies. Which of the matrices is active
-                                     * is determined by the #selected_dataset#
+                                     * is determined by the @p{selected_dataset}
                                      * variable.
                                      */
     vector<FullMatrix<double> >     shape_values;
@@ -619,7 +619,7 @@ class FEValuesBase
                                      * archetypic style.
                                      *
                                      * This field is reset each time
-                                     * #reinit# is called and contains the
+                                     * @p{reinit} is called and contains the
                                      * gradients on the real element, rather
                                      * than on the reference element.
                                      */
@@ -630,7 +630,7 @@ class FEValuesBase
                                      * functions at the quadrature points.
                                      *
                                      * This field is reset each time
-                                     * #reinit# is called and contains the
+                                     * @p{reinit} is called and contains the
                                      * gradients on the real element, rather
                                      * than on the reference element.
                                      */
@@ -653,7 +653,7 @@ class FEValuesBase
                                      * Store an array of weights times the
                                      * Jacobi determinant at the quadrature
                                      * points. This function is reset each time
-                                     * #reinit# is called. The Jacobi determinant
+                                     * @p{reinit} is called. The Jacobi determinant
                                      * is actually the reciprocal value of the
                                      * Jacobi matrices stored in this class,
                                      * see the general documentation of this
@@ -663,7 +663,7 @@ class FEValuesBase
 
                                     /**
                                      * Array of quadrature points. This array
-                                     * is set up upon calling #reinit# and
+                                     * is set up upon calling @p{reinit} and
                                      * contains the quadrature points on the
                                      * real element, rather than on the
                                      * reference element.
@@ -682,7 +682,7 @@ class FEValuesBase
                                     /**
                                      * Store the jacobi matrices at the
                                      * different quadrature points. This field
-                                     * is set each time #reinit# is called.
+                                     * is set each time @p{reinit} is called.
                                      *
                                      * If faces rather than cells are considered
                                      * this is the Jacobi matrix of the
@@ -696,14 +696,14 @@ class FEValuesBase
 
                                     /**
                                      * Store the derivatives of the jacobi
-                                     * matrices. If #J[j][k]# is the jacobi
-                                     * matrix, then the index #[i][j][k]#
+                                     * matrices. If @p{J[j][k]} is the jacobi
+                                     * matrix, then the index @p{[i][j][k]}
                                      * of this field denotes the derivation
-                                     * of #J[j][k]# with respect to the
-                                     * #i#th variable.
+                                     * of @p{J[j][k]} with respect to the
+                                     * @p{i}th variable.
                                      *
                                      * The same general remarks apply as for
-                                     * #jacobi_matrices#.
+                                     * @p{jacobi_matrices}.
                                      */
     vector<Tensor<3,dim> > jacobi_matrices_grad;
     
@@ -716,23 +716,23 @@ class FEValuesBase
                                      * really needed for the assemblage of
                                      * matrices and vectors but makes that
                                      * operation much faster. Each time the
-                                     * #FEValues::reinit# function calls
-                                     * the #FiniteElemenet::fill_fe_values#
+                                     * @p{FEValues::reinit} function calls
+                                     * the @p{FiniteElemenet::fill_fe_values}
                                      * function, this and the next array are
-                                     * passed. The #fill_fe_values# function
+                                     * passed. The @p{fill_fe_values} function
                                      * may or may not use this field.
                                      *
-                                     * The element #(i,j)# denotes the value
-                                     * of the #i#th transfer basis function
-                                     * at the #j#th quadrature point.
+                                     * The element @p{(i,j)} denotes the value
+                                     * of the @p{i}th transfer basis function
+                                     * at the @p{j}th quadrature point.
                                      */
     vector<FullMatrix<double> >     shape_values_transform;
 
                                     /**
                                      * Store which of the data sets in the
-                                     * #shape_values# array is presently
+                                     * @p{shape_values} array is presently
                                      * active. This variable is set by the
-                                     * #reinit# functions of the derived
+                                     * @p{reinit} functions of the derived
                                      * classes. For the exact meaning see
                                      * there and in the doc for this class.
                                      */
@@ -746,9 +746,9 @@ class FEValuesBase
 
                                     /**
                                      * Store the cell selected last time
-                                     * the #reinit# function was called
+                                     * the @p{reinit} function was called
                                      * to make access
-                                     * to the #get_function_*# functions
+                                     * to the @p{get_function_*} functions
                                      * safer.
                                      */
     DoFHandler<dim>::cell_iterator present_cell;
@@ -797,7 +797,7 @@ class FEValues : public FEValuesBase<dim>
                                      * the fields related to a real face (like
                                      * gradients, true quadrature points, etc.)
                                      * need to be initialized using the
-                                     * #reinit# function.
+                                     * @p{reinit} function.
                                      *
                                      * UPDATE!
                                      *
@@ -849,7 +849,7 @@ class FEValues : public FEValuesBase<dim>
                                     /**
                                      * Gradients of the basis
                                      * functions of the transformation.
-                                     * Analogous to the #shape_values_transform#
+                                     * Analogous to the @p{shape_values_transform}
                                      * array of the base class.
                                      */
     vector<vector<Tensor<1,dim> > > unit_shape_gradients_transform;
@@ -868,7 +868,7 @@ class FEValues : public FEValuesBase<dim>
  *  This class provides for the data elements needed for the restriction of
  *  finite elements to faces or subfaces. It does no real computations, apart
  *  from initialization of the fields with the right size. It more or
- *  less is only a base class to the #FEFaceValues# and #FESubfaceValues#
+ *  less is only a base class to the @p{FEFaceValues} and @p{FESubfaceValues}
  *  classes which do the real computations. See there for descriptions of
  *  what is really going on.
  *
@@ -877,16 +877,16 @@ class FEValues : public FEValuesBase<dim>
  *  those common concepts here, rather than in the derived classes.
  *
  *
- *  \subsection{Technical issues}
+ *  @sect3{Technical issues}
  *
  *  The unit face is defined to be the tensor product of the interval $[0,1]$
  *  in the present number of dimensions minus one. In part of the literature,
  *  the convention is used that the unit cell/face be the tensor product of the
  *  interval $[-1,1]$, which is to distinguished properly. A subface is the
  *  child of a face; they are numbered in the way laid down in the
- *  #Triangulation# class.
+ *  @p{Triangulation} class.
  *
- *  Just like in the #FEValues# class, function values and gradients on the unit
+ *  Just like in the @p{FEValues} class, function values and gradients on the unit
  *  face or subface are evaluated at the quadrature points only once, and stored
  *  by the common base class. Being a tensor of rank zero, the function values
  *  remain the same when we want them at the quadrature points on the real cell,
@@ -894,7 +894,7 @@ class FEValues : public FEValuesBase<dim>
  *  Jacobi matrix of the transformation, which we need to compute for each cell
  *  and each quadrature point.
  *
- *  However, while in the #FEValues# class the quadrature points are always the
+ *  However, while in the @p{FEValues} class the quadrature points are always the
  *  same, here we deal with more than one (sub)face. We therefore store the values
  *  and gradients of the trial functions on the unit cell in an array with as
  *  many elements as there are (sub)faces on a cell. The same applies for the
@@ -905,12 +905,12 @@ class FEValues : public FEValuesBase<dim>
  *  with the Jacobi matrix.
  *
  *  
- *  When the #reinit# function of a derived class is called, only those
+ *  When the @p{reinit} function of a derived class is called, only those
  *  gradients, quadrature points etc are transformed to the real cell which
  *  belong to the selected face or subface. The number of the selected face
- *  or subface is stored in the #selected_dataset# variable of the base class
- *  such that the #shape_value# function can return the shape function's
- *  values on the (sub)face which was last selected by a call to the #reinit#
+ *  or subface is stored in the @p{selected_dataset} variable of the base class
+ *  such that the @p{shape_value} function can return the shape function's
+ *  values on the (sub)face which was last selected by a call to the @p{reinit}
  *  function.
  *
  *  In addition to the complications described above, we need two different
@@ -943,13 +943,13 @@ class FEFaceValuesBase : public FEValuesBase<dim>
                                      * duty of the derived class's
                                      * constructors.
                                      *
-                                     * #n_faces_or_subfaces# is the number
+                                     * @p{n_faces_or_subfaces} is the number
                                      * of faces or subfaces that this object
                                      * is to store. The actual number depends
                                      * on the derived class, for
-                                     * #FEFaceValues# it is #2*dim#, while for
-                                     * the #FESubfaceValues# class it is
-                                     * #2*dim*(1<<(dim-1))#, i.e. the number
+                                     * @p{FEFaceValues} it is @p{2*dim}, while for
+                                     * the @p{FESubfaceValues} class it is
+                                     * @p{2*dim*(1<<(dim-1))}, i.e. the number
                                      * of faces times the number of subfaces
                                      * per face.
                                      */
@@ -963,7 +963,7 @@ class FEFaceValuesBase : public FEValuesBase<dim>
 
                                     /**
                                      * Return the outward normal vector to
-                                     * the cell at the #i#th quadrature
+                                     * the cell at the @p{i}th quadrature
                                      * point. The length of the vector
                                      * is normalized to one.
                                      */
@@ -987,7 +987,7 @@ class FEFaceValuesBase : public FEValuesBase<dim>
                                      *
                                      * There is one element for each face or
                                      * subface, with indices like that:
-                                     * #unit_shape_gradients[face][dof][q_point]#
+                                     * @p{unit_shape_gradients[face][dof][q_point]}
                                      */
     vector<vector<vector<Tensor<1,dim> > > > unit_shape_gradients;
     
@@ -1004,7 +1004,7 @@ class FEFaceValuesBase : public FEValuesBase<dim>
                                     /**
                                      * Gradients of the basis
                                      * functions of the transformation.
-                                     * Analogous to the #shape_values_transform#
+                                     * Analogous to the @p{shape_values_transform}
                                      * array of the base class.
                                      */
     vector<vector<vector<Tensor<1,dim> > > > unit_shape_gradients_transform;
@@ -1051,7 +1051,7 @@ class FEFaceValuesBase : public FEValuesBase<dim>
  * Represent a finite element evaluated with a specific quadrature rule on
  * the face of a cell.
  *
- * This class is very similar to the #FEValues# class; see there for more
+ * This class is very similar to the @p{FEValues} class; see there for more
  * documentation. It is, however, a bit more involved: since we want to
  * compute the restriction of finite element functions (here: the basis
  * functions, but a finite element function is obtained by multiplication
@@ -1086,7 +1086,7 @@ class FEFaceValues : public FEFaceValuesBase<dim>
                                      * the fields related to a real face (like
                                      * gradients, true quadrature points, etc.)
                                      * need to be initialized using the
-                                     * #reinit# function.
+                                     * @p{reinit} function.
                                      *
                                      * UPDATE!
                                      *
@@ -1110,7 +1110,7 @@ class FEFaceValues : public FEFaceValuesBase<dim>
                                     /**
                                      * Reinitialize the gradients, Jacobi
                                      * determinants, etc for the face with
-                                     * number #face_no# of #cell#
+                                     * number @p{face_no} of @p{cell}
                                      * and the given finite element.
                                      */
     void reinit (const typename DoFHandler<dim>::cell_iterator &cell,
@@ -1122,14 +1122,14 @@ class FEFaceValues : public FEFaceValuesBase<dim>
  * Represent a finite element evaluated with a specific quadrature rule on
  * the child of the face of a cell.
  *
- * This class is very similar to the #FEFaceValues# class; see there for
+ * This class is very similar to the @p{FEFaceValues} class; see there for
  * more documentation. It serves the computation of interface integrals
  * where the cells on both sides of the face have different refinement
  * levels. This is useful for example when we want to integrate the jump
  * of the gradient of the finite element solution along the boundary of
  * a cell to estimate the error. Now, this is not so much of a problem
  * if all neighbors of the cell have the same refinement level, then we
- * will use the #FEFaceValues# class, but it gets trickier if one of the
+ * will use the @p{FEFaceValues} class, but it gets trickier if one of the
  * cells is more refined than the other.
  *
  * To this end, there seem to be two ways which may be applicable:
@@ -1145,7 +1145,7 @@ class FEFaceValues : public FEFaceValuesBase<dim>
  *   a practical one, namely that by refining the cell virtually, we would
  *   end up with child cells which do not exist in real and can thus not be
  *   represented in terms of iterators. This would mean that we had to change
- *   the whole interface to the #FE*Values# classes to accept cell corner
+ *   the whole interface to the @p{FE*Values} classes to accept cell corner
  *   points by value, etc, instead of relying on appropriate iterators. This
  *   seems to be clumsy and not very suitable to maintain an orthogonal
  *   programming style. Apart from that, we already have iterators, why
@@ -1176,7 +1176,7 @@ class FEFaceValues : public FEFaceValuesBase<dim>
  *   points $(0,0)$, $(0.25,0)$ and $(0.5,0)$ (coordinates on the cell)
  *   which is not symmetric as was the original quadrature rule for a line.
  *   This modified quadrature rule is computed by projection onto the subface
- *   using the #QProjector<dim>::project_to_subface()# function. The neighboring
+ *   using the @p{QProjector<dim>::project_to_subface()} function. The neighboring
  *   cell, being refined once more than the present is evaluated with the
  *   quadrature formula projected to the common face, but using the original
  *   quadrature formula. This way, the locations of the quadrature points
@@ -1188,21 +1188,21 @@ class FEFaceValues : public FEFaceValuesBase<dim>
  * function's gradient across cell boundaries is computed.
  *
  *
- * \subsection{Other implementational subjects}
+ * @sect3{Other implementational subjects}
  *
  * It does not seem useful to ask for the off-points of the trial functions
- * (name #support_points# in the #FEValuesBase# class) for subfaces. These are
+ * (name @p{support_points} in the @p{FEValuesBase} class) for subfaces. These are
  * therefore not supported for this class and should throw an error if
- * accessed. Specifying #update_support_points# for the #UpdateFlags# in the
+ * accessed. Specifying @p{update_support_points} for the @p{UpdateFlags} in the
  * constructor is disallowed.
  *
  * The values of the trial functions on the subfaces are stored as an array
  * of matrices, each matrix representing the values of the trial functions at
  * the quadrature points at one subface. The ordering is as follows: the values
- * of the trial functions at face #face#, subface #subface# are stored in
- * #shape_values[face*(1<<(dim-1))+subface]#. The same order applies for the
+ * of the trial functions at face @p{face}, subface @p{subface} are stored in
+ * @p{shape_values[face*(1<<(dim-1))+subface]}. The same order applies for the
  * quadrature points on the unit cell, which are stored in the
- * #unit_quadrature_points# array. Note that #1<<(dim-1)# is the number of
+ * @p{unit_quadrature_points} array. Note that @p{1<<(dim-1)} is the number of
  * subfaces per face.
  *
  * One subtle problem is that if a face is at the boundary, then computation
@@ -1213,7 +1213,7 @@ class FEFaceValues : public FEFaceValuesBase<dim>
  * boundary, in the end this class was invented to facilitate integration
  * along faces with cells of different refinement levels on both sides,
  * integration along the boundary of the domain is better done through
- * the #FEFaceValues# class. For this reason, calling #reinit# with a
+ * the @p{FEFaceValues} class. For this reason, calling @p{reinit} with a
  * boundary face will result in an error.
  * 
  * @author Wolfgang Bangerth, 1998
@@ -1236,7 +1236,7 @@ class FESubfaceValues : public FEFaceValuesBase<dim>
                                      * the fields related to a real face (like
                                      * gradients, true quadrature points, etc.)
                                      * need to be initialized using the
-                                     * #reinit# function.
+                                     * @p{reinit} function.
                                      */
     FESubfaceValues (const FiniteElement<dim> &fe,
                     const Quadrature<dim-1>  &face_quadrature,
@@ -1245,7 +1245,7 @@ class FESubfaceValues : public FEFaceValuesBase<dim>
                                     /**
                                      * Reinitialize the gradients, Jacobi
                                      * determinants, etc for the face with
-                                     * number #face_no# of #cell#
+                                     * number @p{face_no} of @p{cell}
                                      * and the given finite element.
                                      */
     void reinit (const typename DoFHandler<dim>::cell_iterator &cell,
index 9867e1e8ac62265dbcf522267590ed217ece0c9d..3a554a15eeb57db92fd7d4b449f1e06c6dce86ce 100644 (file)
@@ -35,9 +35,9 @@ class FEQ1Mapping : public FiniteElement<dim>
                                     /**
                                      * Constructor. Simply passes through
                                      * its arguments to the base class. For
-                                     * one space dimension, #dofs_per_quad#
+                                     * one space dimension, @p{dofs_per_quad}
                                      * shall be zero; similarly, for one and
-                                     * two space dimensions, #dofs_per_hex#
+                                     * two space dimensions, @p{dofs_per_hex}
                                      * shall be zero.
                                      */
     FEQ1Mapping (const unsigned int  dofs_per_vertex,
@@ -48,8 +48,8 @@ class FEQ1Mapping : public FiniteElement<dim>
                 const vector<bool> &restriction_is_additive_flags);
 
                                     /**
-                                     * Return the value of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the value of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      * Here, the (bi-)linear basis functions
                                      * are meant, which are used for the
                                      * computation of the transformation from
@@ -59,8 +59,8 @@ class FEQ1Mapping : public FiniteElement<dim>
                                          const Point<dim>   &p) const;
 
                                     /**
-                                     * Return the gradient of the #i#th shape
-                                     * function at point #p# on the unit cell.
+                                     * Return the gradient of the @p{i}th shape
+                                     * function at point @p{p} on the unit cell.
                                      * Here, the (bi-)linear basis functions
                                      * are meant, which are used for the
                                      * computation of the transformation from
@@ -95,7 +95,7 @@ class FEQ1Mapping : public FiniteElement<dim>
 
                                     /**
                                      * Return the normal vectors to the
-                                     * face with number #face_no# of #cell#.
+                                     * face with number @p{face_no} of @p{cell}.
                                      *
                                      * For linear finite elements, this function
                                      * is particularly simple since all normal
@@ -114,8 +114,8 @@ class FEQ1Mapping : public FiniteElement<dim>
 
                                     /**
                                      * Return the normal vectors to the
-                                     * subface with number #subface_no# of
-                                     * the face with number #face_no# of #cell#.
+                                     * subface with number @p{subface_no} of
+                                     * the face with number @p{face_no} of @p{cell}.
                                      *
                                      * For linear finite elements, this function
                                      * is particularly simple since all normal
index 3daae3e46c9d27bf5830a05def2e1a42684ea833..7e52eaa1bbcb239e5e32e4ad77c70ec6632a1e4e 100644 (file)
@@ -19,7 +19,7 @@
 template <int _dim> struct GeometryInfo;
 
 /**
- * Pseudo-class for recursive functions in #GeometryInfo<dim>#.
+ * Pseudo-class for recursive functions in @p{GeometryInfo<dim>}.
  */
 struct GeometryInfo<0>
 {
@@ -35,9 +35,9 @@ struct GeometryInfo<0>
  * Topological description of cells.
  *
  * This class contains as static members information on vertices and
- * faces of a #dim#-dimensinal grid cell. The interface is the same
+ * faces of a @p{dim}-dimensinal grid cell. The interface is the same
  * for all dimensions. If a value is of no use in a low dimensional
- * cell, it is (correctly) set to zero, e.g. #sub_faces_per_cell# in
+ * cell, it is (correctly) set to zero, e.g. @p{sub_faces_per_cell} in
  * 1d.
  *
  * This information should always replace hard-coded numbers of
@@ -81,8 +81,8 @@ struct GeometryInfo
                                      * dimension, we provide a useless
                                      * number (in the hope that a compiler
                                      * may warn when it sees constructs like
-                                     * #for (i=0; i<vertices_per_face; ++i)#,
-                                     * at least if #i# is an #unsigned int#.
+                                     * @p{for (i=0; i<vertices_per_face; ++i)},
+                                     * at least if @p{i} is an @p{unsigned int}.
                                      */
     static const unsigned int vertices_per_face = GeometryInfo<_dim-1>::vertices_per_cell;
 
@@ -102,8 +102,8 @@ struct GeometryInfo
                                      * Computation of this value
                                      * follows the idea, that
                                      * building a hypercube of
-                                     * dimension #dim# from one of
-                                     * dimension #dim#-1 can be done
+                                     * dimension @p{dim} from one of
+                                     * dimension @p{dim}-1 can be done
                                      * in the following two steps:
                                      *
                                      * 1. Duplicated it in the new coordinate direction.
@@ -119,7 +119,7 @@ struct GeometryInfo
                                     /**
                                      * Number of quadrilaterals of a cell.
                                      *
-                                     * Computation is analogous to #lines_per_cell#.
+                                     * Computation is analogous to @p{lines_per_cell}.
                                      */
     static const unsigned int quads_per_cell = (2*GeometryInfo<dim-1>::quads_per_cell
                                                + GeometryInfo<dim-1>::lines_per_cell);
@@ -128,7 +128,7 @@ struct GeometryInfo
                                      * Number of hexahedra of a cell.
                                      *
                                      * Computation is analogous to
-                                     * #lines_per_cell#. Very
+                                     * @p{lines_per_cell}. Very
                                      * important for more than three
                                      * dimensions!
                                      */
@@ -139,8 +139,8 @@ struct GeometryInfo
                                      * List of numbers which is
                                      * denote which face is opposite
                                      * to a given face. In 1d, this
-                                     * list is #{1,0}#, in 2d #{2, 3, 0, 1}#,
-                                     * in 3d #{1, 0, 4, 5, 2, 3}#.
+                                     * list is @p{{1,0}}, in 2d @p{{2, 3, 0, 1}},
+                                     * in 3d @p{{1, 0, 4, 5, 2, 3}}.
                                      */
     static const unsigned int opposite_face[faces_per_cell];
     
@@ -182,7 +182,7 @@ struct GeometryInfo
                                      * For three spatial dimensions,
                                      * the exact order of the children is
                                      * laid down in the documentation of
-                                     * the #Triangulation# class.
+                                     * the @p{Triangulation} class.
                                      */
     static unsigned int child_cell_on_face (unsigned int face,
                                            unsigned int subface);
index f447a670cf4fb764886a6f92dea352546ab7f8e3..d33e0e70f9bc1a304e42eaff24de8660ab24adfa 100644 (file)
@@ -29,12 +29,12 @@ template <int dim> class Triangulation;
  *       domain which is the tensor product of an interval $[a,b]$ in
  *       the given number of spatial dimensions. If you want to create such
  *       a domain, which is a common test case for model problems, call
- *       #GridGenerator::hyper_cube (tria, a,b)#, which produces a
+ *       @p{GridGenerator::hyper_cube (tria, a,b)}, which produces a
  *       hypercube domain triangulated with exactly one element. You can
  *       get tensor product meshes by successive refinement of this cell.
  *
  *    \item Generalized L-shape domain:
- *      using the #GridGenerator::hyper_L (tria, a,b)# function produces
+ *      using the @p{GridGenerator::hyper_L (tria, a,b)} function produces
  *      the hypercube with the interval $[a,b]$ without the hypercube
  *      made out of the interval $[(a+b)/2,b]$. Let, for example, be $a=-1$
  *      and $b=1$, then the hpyer-L in two dimensions is the region
@@ -43,8 +43,8 @@ template <int dim> class Triangulation;
  *
  *    \item Hyper balls:
  *      You get the circle or ball (or generalized: hyperball) around origin
- *      #p# and with radius #r# by calling
- *      #GridGenerator::hyper_ball (tria, p, r)#. The circle is triangulated
+ *      @p{p} and with radius @p{r} by calling
+ *      @p{GridGenerator::hyper_ball (tria, p, r)}. The circle is triangulated
  *      by five cells, the ball by seven cells. The diameter of the center cell is
  *      chosen so that the aspect ratio of the boundary cells after one refinement
  *      is minimized in some way. To create a hyperball in one dimension results in
@@ -57,12 +57,12 @@ template <int dim> class Triangulation;
  *    \item Hyper shell: A hyper shell is the region between two hyper
  *      sphere with the same origin. Therefore, it is a ring in two
  *      spatial dimensions. To triangulation it, call the function
- *      #GridGenerator::hyper_shell (tria, origin, inner_radius,
- *      outer_radius, N)#, where the center of the spheres as well as
+ *      @pGridGenerator::hyper_shell (tria, origin, inner_radius, outer_radius, N)},
+ *      where the center of the spheres as well as
  *      the inner and outer radius of the two spheres are given as
  *      shown.
  *
- *      The parameter #N# denotes how many cells are to be used for
+ *      The parameter @p{N} denotes how many cells are to be used for
  *      this coarse triangulation. It defaults to zero, which tells
  *      the function to chose the number itself; this, then, is done
  *      such that the aspect ration of the resulting cells is as small
@@ -72,7 +72,7 @@ template <int dim> class Triangulation;
  *      used in the radial direction.
  *
  *      You need to attach a boundary object to the triangulation. A
- *      suitable boundary class is provided as #HyperSphereBoundary#
+ *      suitable boundary class is provided as @p{HyperSphereBoundary}
  *      in the library.
  *
  * \item Slit domain: The slit domain is a variant of the hyper cube
@@ -115,7 +115,7 @@ class GridGenerator
                                      * lower and upper bound of the
                                      * inner hypercube in all
                                      * coordinate directions.
-                                     * #thickness# marks the size of
+                                     * @p{thickness} marks the size of
                                      * the layer cells.
                                      *
                                      * If the flag colorize is set,
@@ -153,7 +153,7 @@ class GridGenerator
 
                                     /**
                                      * Initialize the given triangulation with a
-                                     * hyper-L consisting of exactly #2^dim-1#
+                                     * hyper-L consisting of exactly @p{2^dim-1}
                                      * cells. See the general documentation for a
                                      * description of the L-region. The limits
                                      * default to minus unity and unity.
@@ -170,7 +170,7 @@ class GridGenerator
                                      * Initialize the given
                                      * Triangulation with a hypercube
                                      * with a slit. The slit goes
-                                     * from #(x=0,y=-1)# to #(0,0)# in 2d.
+                                     * from @p{(x=0,y=-1)} to @p{(0,0)} in 2d.
                                      *
                                      * The triangulation needs to be void
                                      * upon calling this function.
index e7c87afa09054d015d972f7b6dee0a0f44622a8e..4069d214b3e2a5b7c767fc854eb715b0238db413 100644 (file)
@@ -47,12 +47,12 @@ template <int dim> class Triangulation;
  * further details.
  *
  *
- * \subsection{Structure of input grid data}
+ * @sect3{Structure of input grid data}
  * 
  * It is your duty to use a correct numbering of vertices in the cell list,
  * i.e. for lines, you have to first give the vertex with the lower coordinate
  * value, then that with the higher coordinate value. For quadrilaterals in
- * two dimensions, the vertex indices in the #quad# list have to be such that
+ * two dimensions, the vertex indices in the @p{quad} list have to be such that
  * the vertices are numbered in counter-clockwise sense.
  *
  * In two dimensions, another difficulty occurs, which has to do with the sense
@@ -73,10 +73,10 @@ template <int dim> class Triangulation;
  *   0---1---2
  * \end{verbatim}
  * may be characterised by the vertex numbers (0 1 4 3) and (1 2 5 4), since
- * the middle line would get the direction #1->4# when viewed from both cells.
+ * the middle line would get the direction @p{1->4} when viewed from both cells.
  * The numbering (0 1 4 3) and (5 4 1 2) would not be allowed, since the left
- * quad would give the common line the direction #1->4#, while the right one
- * would want to use #4->1#, leading to ambiguity. The #Triangulation# object
+ * quad would give the common line the direction @p{1->4}, while the right one
+ * would want to use @p{4->1}, leading to ambiguity. The @p{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 (4 1 2 5), since then it
index 1fa6704210196e3020434606c5e593abcd89ff7c..1c561f8007eb44a626566af245927c1b052aa0bd 100644 (file)
@@ -27,13 +27,13 @@ template <int dim> class Triangulation;
  * the different output functions based on a parameter given, e.g., through
  * a parameter file, thus making user programs invariant of the number and
  * names of the file formats implemented in this class. The main advantage of
- * this class over the #DataOut# class is that it does not have to mess around
- * with actual data vectors and that no #DoFHandler# object is needed to
+ * this class over the @p{DataOut} class is that it does not have to mess around
+ * with actual data vectors and that no @p{DoFHandler} object is needed to
  * write the pure geometrical information involved here.
  *
- * Available output formats can be found in the functions with names #write_...#
+ * Available output formats can be found in the functions with names @p{write_...}
  *
- * \subsection{Usage}
+ * @sect3{Usage}
  * Usage is simple: either you use the direct form
  * \begin{verbatim}
  *   ofstream output_file("some_filename");
@@ -47,28 +47,28 @@ template <int dim> class Triangulation;
  *   ofstream output_file("some_filename" + GridOut::default_suffix(output_format));
  *   GridOut().write (tria, output_file, output_format);
  * \end{verbatim}
- * The function #get_output_format_names()# provides a list of possible names of
- * output formats in a string that is understandable by the #ParameterHandler# class.
+ * The function @p{get_output_format_names()} provides a list of possible names of
+ * output formats in a string that is understandable by the @p{ParameterHandler} class.
  *
- * Note that here, we have created an unnamed object of type #GridOut# and called
- * one of its #write_*# functions. This looks like as if the respective function
- * could really be made #static#. This was not done in order to allow for
+ * Note that here, we have created an unnamed object of type @p{GridOut} and called
+ * one of its @p{write_*} functions. This looks like as if the respective function
+ * could really be made @p{static}. This was not done in order to allow for
  * parameters to be passed to the different output functions in a way compatible
  * with the scheme of allowing the right output format to be selected at run-time
- * through the generic #write# function.
+ * through the generic @p{write} function.
  *
  * In order to explain this, consider each function had one or more additional
  * parameters giving the details of output, for example position of the spectator
  * for 3d meshed, line thicknesses, etc. While this would allow each output
  * function any flexibility it needs, it would not allow us to use the generic
- * function #write# which is given a parameter determining the output format,
+ * function @p{write} which is given a parameter determining the output format,
  * since it is impractical to give it a list of parameters for each and every
  * output format supported which it may then pass on to the respective output
  * function.
  *
- * Rather, we have chosen to let each object of this class #GridOut# have a
+ * Rather, we have chosen to let each object of this class @p{GridOut} have a
  * set of parameters for each supported output format. These are collected
- * in structures #EpsFlags#, #GnuplotFlags#, etc and you can set your preferred
+ * in structures @p{EpsFlags}, @p{GnuplotFlags}, etc and you can set your preferred
  * flags like this:
  * \begin{verbatim}
  *   GridOut grid_out;
@@ -81,18 +81,18 @@ template <int dim> class Triangulation;
  * 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 #grid_out.set_flags (GridOut::UcdFlags());#, since the
+ * be done by calling @p{grid_out.set_flags (GridOut::UcdFlags());}, since the
  * default constructor of each of the flags structures sets the parameters
  * to their initial values.
  *
  * The advantage of this approach is that it is possible to change the flags
  * of one or more output formats according to your needs and later use the
- * generic #write# function; the actual output function then called will
+ * generic @p{write} function; the actual output function then called will
  * use the flags as set before.
  *
  * Note that some of the structures describing the flags of the different
  * output formats are empty since the respective format does not support
- * any flags. The structure and the #set_flags# function are provided
+ * any flags. The structure and the @p{set_flags} function are provided
  * anyway. Note also that some of the structures may differ between the
  * dimensions supported by this class; they then have a template parameter,
  * as usual.
@@ -120,7 +120,7 @@ class GridOut
                                          * by this, so you can switch it off
                                          * this way.
                                          *
-                                         * Default: #true#.
+                                         * Default: @p{true}.
                                          */
        bool write_preamble;
        
@@ -139,7 +139,7 @@ class GridOut
                                          * to write the triangulation to
                                          * view or print it.
                                          *
-                                         * Default: #false#.
+                                         * Default: @p{false}.
                                          */
        bool write_faces;
 
@@ -169,7 +169,7 @@ class GridOut
                                          * the size of the output
                                          * significantly, however.
                                          *
-                                         * Default: #false#.
+                                         * Default: @p{false}.
                                          */
        bool write_cell_numbers;
                                         /**
@@ -196,7 +196,7 @@ class GridOut
                                         /**
                                          * Enum denoting the possibilities
                                          * whether the scaling should be done
-                                         * such that the given #size# equals
+                                         * such that the given @p{size} equals
                                          * the width or the height of
                                          * the resulting picture.
                                          */
@@ -205,7 +205,7 @@ class GridOut
        };
 
                                         /**
-                                         * See above. Default is #width#.
+                                         * See above. Default is @p{width}.
                                          */
        SizeType size_type;
        
@@ -216,7 +216,7 @@ class GridOut
                                          * strange unit 1/72 inch. Whether
                                          * this is height or width is
                                          * specified by the flag
-                                         * #size_type#.
+                                         * @p{size_type}.
                                          *
                                          * Default is 300.
                                          */
@@ -228,7 +228,7 @@ class GridOut
                                          */
        double line_width;
                                         /**
-                                         * Should lines with a set #user_flag#
+                                         * Should lines with a set @p{user_flag}
                                          * be drawn in a different color?
                                          */
        bool color_lines_on_user_flag;
@@ -358,7 +358,7 @@ class GridOut
                                      * flags controlling the output
                                      * can be found in the
                                      * documentation of the
-                                     * #GridOut::GnuplotFlags# class.
+                                     * @p{GridOut::GnuplotFlags} class.
                                      */
     template <int dim>
     void write_gnuplot (const Triangulation<dim> &tria,
@@ -377,14 +377,14 @@ class GridOut
                                      * only, you can decide through
                                      * additional flags (see below,
                                      * and the documentation of the
-                                     * #GridOut::UcdFlags# class)
+                                     * @p{GridOut::UcdFlags} class)
                                      * whether boundary faces with
                                      * non-zero boundary indicator
                                      * shall be written to the file
                                      * explicitely. This is useful,
                                      * if you want to re-read the
                                      * grid later on, since
-                                     * #deal.II# sets the boundary
+                                     * @p{deal.II} sets the boundary
                                      * indicator to zero by default;
                                      * therefore, to obtain the
                                      * same triangulation as before,
@@ -397,7 +397,7 @@ class GridOut
                                      * flags controlling the output
                                      * can be found in the
                                      * documentation of the
-                                     * #GridOut::UcdFlags# class.
+                                     * @p{GridOut::UcdFlags} class.
                                      */
     template <int dim>
     void write_ucd (const Triangulation<dim> &tria,
@@ -420,7 +420,7 @@ class GridOut
                                      * shall fit into is determined
                                      * by the output flags (see
                                      * below, and the documentation
-                                     * of the #GridOut::EpsFlags#
+                                     * of the @p{GridOut::EpsFlags}
                                      * class).
                                      *
                                      * The bounding box is close to
@@ -434,11 +434,11 @@ class GridOut
                                      * of which the default is 300.
                                      *
                                      * The flag 
-                                     * #color_lines_on_user_flag#
+                                     * @p{color_lines_on_user_flag}
                                      * allows to draw lines with the
-                                     * #user_flag# set to be drawn in
+                                     * @p{user_flag} set to be drawn in
                                      * red. The colors black and red
-                                     * are defined as #b# and #r# in
+                                     * are defined as @p{b} and @p{r} in
                                      * the preamble of the output
                                      * file and can be changed there
                                      * according to need.
@@ -447,7 +447,7 @@ class GridOut
                                      * flags controlling the output
                                      * can be found in the
                                      * documentation of the
-                                     * #GridOut::EpsFlags#
+                                     * @p{GridOut::EpsFlags}
                                      * class. Especially the
                                      * viewpoint for three
                                      * dimensional grids is of
@@ -458,10 +458,10 @@ class GridOut
                    ostream                  &out);
     
                                     /**
-                                     * Write data and grid to #out# according
+                                     * Write data and grid to @p{out} according
                                      * to the given data format. This function
                                      * simply calls the appropriate
-                                     * #write_*# function.
+                                     * @p{write_*} function.
                                      */
     template <int dim>
     void write (const Triangulation<dim> &tria,
@@ -504,9 +504,9 @@ class GridOut
                                      * usually has. At present the following
                                      * formats are defined:
                                      * \begin{itemize}
-                                     * \item #gnuplot#: #.gnuplot#
-                                     * \item #ucd#: #.inp#
-                                     * \item #eps#: #.eps#.
+                                     * \item @p{gnuplot}: @p{.gnuplot}
+                                     * \item @p{ucd}: @p{.inp}
+                                     * \item @p{eps}: @p{.eps}.
                                      * \end{itemize}
                                      *
                                      * Since this function does not need data
@@ -517,7 +517,7 @@ class GridOut
     static string default_suffix (const OutputFormat output_format);
 
                                     /**
-                                     * Return the #OutputFormat# value
+                                     * Return the @p{OutputFormat} value
                                      * corresponding to the given string. If
                                      * the string does not match any known
                                      * format, an exception is thrown.
@@ -533,16 +533,16 @@ class GridOut
                                      *
                                      * To get a list of presently available
                                      * format names, e.g. to give it to the
-                                     * #ParameterHandler# class, use the
-                                     * function #get_output_format_names ()#.
+                                     * @p{ParameterHandler} class, use the
+                                     * function @p{get_output_format_names ()}.
                                      */
     static OutputFormat parse_output_format (const string &format_name);
 
                                     /**
                                      * Return a list of implemented output
                                      * formats. The different names are
-                                     * separated by vertical bar signs (#`|'#)
-                                     * as used by the #ParameterHandler#
+                                     * separated by vertical bar signs (@p{`|'})
+                                     * as used by the @p{ParameterHandler}
                                      * classes.
                                      */
     static string get_output_format_names ();
@@ -562,21 +562,21 @@ class GridOut
                                     /**
                                      * Flags to be used upon output of UCD
                                      * data. Can be changed by using the
-                                     * #set_flags# function.
+                                     * @p{set_flags} function.
                                      */
     UcdFlags     ucd_flags;
 
                                     /**
                                      * Flags to be used upon output of GNUPLOT
                                      * data. Can be changed by using the
-                                     * #set_flags# function.
+                                     * @p{set_flags} function.
                                      */
     GnuplotFlags gnuplot_flags;
 
                                     /**
                                      * Flags to be used upon output of EPS
                                      * data in one space dimension. Can be
-                                     * changed by using the #set_flags#
+                                     * changed by using the @p{set_flags}
                                      * function.
                                      */
     EpsFlags<1>  eps_flags_1;
@@ -584,7 +584,7 @@ class GridOut
                                     /**
                                      * Flags to be used upon output of EPS
                                      * data in two space dimensions. Can be
-                                     * changed by using the #set_flags#
+                                     * changed by using the @p{set_flags}
                                      * function.
                                      */
     EpsFlags<2>  eps_flags_2;
@@ -592,7 +592,7 @@ class GridOut
                                     /**
                                      * Flags to be used upon output of EPS
                                      * data in three space dimensions. Can be
-                                     * changed by using the #set_flags#
+                                     * changed by using the @p{set_flags}
                                      * function.
                                      */
     EpsFlags<3>  eps_flags_3;
@@ -600,27 +600,27 @@ class GridOut
 
                                     /**
                                      * Write the grid information about
-                                     * faces to #out#. Only those faces
+                                     * faces to @p{out}. Only those faces
                                      * are printed which are on the boundary
                                      * and which have a boundary indicator
                                      * not equal to zero, since the latter
                                      * is the default for boundary faces.
                                      *
                                      * Since cells and faces are continuously
-                                     * numbered, the #starting_index# for
+                                     * numbered, the @p{starting_index} for
                                      * the numbering of the faces is passed
                                      * also.
                                      *
                                      * This function unfortunately can not
-                                     * be included in the regular #write_ucd#
+                                     * be included in the regular @p{write_ucd}
                                      * function, since it needs special
-                                     * treatment for the case #dim==1#, in
+                                     * treatment for the case @p{dim==1}, in
                                      * which case the face iterators are
-                                     * #void*#'s and lack the member functions
+                                     * @p{void*}'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 #dim==1#. Bad luck.
+                                     * the function for @p{dim==1}. Bad luck.
                                      */
     template <int dim>
     void write_ucd_faces (const Triangulation<dim> &tria,
@@ -632,7 +632,7 @@ class GridOut
                                      * triangulation which have a boundary
                                      * indicator not equal to zero. Only
                                      * these faces are explicitely printed
-                                     * in the #write_*# functions;
+                                     * in the @p{write_*} functions;
                                      * all faces with indicator 255 are
                                      * interior ones and an indicator with
                                      * value zero for faces at the boundary
@@ -642,7 +642,7 @@ class GridOut
                                      * list in one dimension.
                                      *
                                      * The reason for this function is the
-                                     * same as for #write_ucd_faces#. See
+                                     * same as for @p{write_ucd_faces}. See
                                      * there for more information.
                                      */
     template <int dim>
index 65f5078082b9410cfab21ba2ac26b2d4e41a1c30..a5b329f60768081f9530d6a4731c19770281c12f 100644 (file)
@@ -19,7 +19,7 @@ template <class T> class SmartPointer;
  * 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
- * #operator []#.
+ * @p{operator []}.
  *
  * Usually, the two grids will be refined differently. Then, the value
  * returned for an iterator on the source grid will be either:
@@ -60,17 +60,17 @@ template <class T> class SmartPointer;
  *
  * The implementation of this class is such that not only cell iterators
  * into triangulations can be mapped, but also iterators into objects of
- * type #DoFHandler# and #MGDoFHandler#. The extension to other classes
+ * type @p{DoFHandler} and @p{MGDoFHandler}. The extension to other classes
  * offering iterator functions and some minor additional requirements is
  * simple.
  *
- * Note that this class could in principle be based on the C++ #map<Key,Value>#
+ * Note that this class could in principle be based on the C++ @p{map<Key,Value>}
  * 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.
  *
  *
- * \section{Usage}
+ * @sect2{Usage}
  *
  * In practice, use of this class is as follows:
  * \begin{verbatim}
@@ -92,15 +92,15 @@ template <class T> class SmartPointer;
  *                                           endc = dof_handler_1.end();
  *   for (; cell!=endc; ++cell)
  *                    // now do something with the cell of dof_handler_2
- *                    // corresponding to #cell# (which is one of
+ *                    // corresponding to @p{cell} (which is one of
  *                    // dof_handler_1
  *     f( grid_1_to_2_map[cell]);
  * \end{verbatim}
  *
  * Note that the template parameters to this class have to be given as
- * #InterGridMap<DoFHandler,2>#, i.e. the dimension is given explicitely and
+ * @p{InterGridMap<DoFHandler,2>}, i.e. the dimension is given explicitely and
  * no dimension is attributed to the first parameter, which here is
- * #DoFHandler# (and could equally well be #Triangulation# or #MGDoFHandler#).
+ * @p{DoFHandler} (and could equally well be @p{Triangulation} or @p{MGDoFHandler}).
  *
  * @author Wolfgang Bangerth, 1999
  */
@@ -209,16 +209,16 @@ class InterGridMap
                      const cell_iterator &dst_cell);
 
                                     /**
-                                     * Set the value of the key #src_cell#
-                                     * to #dst_cell#. Do so as well for
+                                     * Set the value of the key @p{src_cell}
+                                     * to @p{dst_cell}. Do so as well for
                                      * all the children and their children
-                                     * of #src_cell#. This function is
+                                     * of @p{src_cell}. This function is
                                      * used for cells which are more
-                                     * refined on #src_grid# than on
-                                     * #dst_grid#; then all values of
+                                     * refined on @p{src_grid} than on
+                                     * @p{dst_grid}; then all values of
                                      * the hierarchy of cells and their
                                      * children point to one cell on the
-                                     * #dst_grid#.
+                                     * @p{dst_grid}.
                                      */
     void set_entries_to_cell (const cell_iterator &src_cell,
                              const cell_iterator &dst_cell);
index b1f22a8f6cc93e4f80e480f59a44adc6daa58779..cb0602e05d1ecba8c7a21adc838968477335c65d 100644 (file)
  * of cell numbers to the geometrical cells.
  *
  * Basically, this is a drop-in replacement for the triangulation. Since it
- * is derived from the #Triangulation<dim># class, it shares all the
+ * is derived from the @p{Triangulation<dim>} class, it shares all the
  * functionality, but it overrides some virtual functions and adds some
  * functions, too. The main change to the base class is that it overrides
- * the #execute_coarsening_and_refinement# function, where the new version
+ * the @p{execute_coarsening_and_refinement} function, where the new version
  * first stores all refinement and coarsening flags and only then calls the
  * respective function of the base class. The stored flags may later be
  * used to restore the grid just as it was before. Some other functions
  *
  * We note that since the triangulation is created in exactly the same state
  * as it was before, other objects working on it should result in the same
- * state as well. This holds in particular for the #DoFHandler# object, which
+ * state as well. This holds in particular for the @p{DoFHandler} object, which
  * will assign the same degrees of freedom to the original cells and the ones
  * after reconstruction of the triangulation. You can therefore safely use data
  * vectors computed on the original grid on the reconstructed grid as well.
  *
  *
- * \subsection{Usage}
+ * @sect3{Usage}
  * You can use objects of this class almost in the same way as objects of the
- * #Triangulation# class. One of the few differences is that you can only
+ * @p{Triangulation} class. One of the few differences is that you can only
  * construct such an object by giving a coarse grid to the constructor. The
  * coarse grid will be used to base the triangulation on, and therefore the
  * lifetime of the coarse grid has to be longer than the lifetime of the
  *     };
  * \end{verbatim}
  *
- * Note that initially, the #PersistentTriangulation# object does not
- * constitute a triangulation; it only becomes one after #restore# is first
- * called. Note also that the #execute_coarsening_and_refinement# stores
- * all necessary flags for later reconstruction using the #restore# function.
- * #Triangulation<dim>::clear ()# resets the underlying triangulation to a
+ * Note that initially, the @p{PersistentTriangulation} object does not
+ * constitute a triangulation; it only becomes one after @p{restore} is first
+ * called. Note also that the @p{execute_coarsening_and_refinement} stores
+ * all necessary flags for later reconstruction using the @p{restore} function.
+ * @p{Triangulation<dim>::clear ()} resets the underlying triangulation to a
  * virgin state, but does not affect the stored refinement flags needed for
  * later reconstruction and does also not touch the coarse grid which is
- * used withing #restore()#.
+ * used withing @p{restore()}.
  *
  * @author Wolfgang Bangerth, 1999
  */
@@ -107,7 +107,7 @@ class PersistentTriangulation : public Triangulation<dim>
                                      * flags, etc from that grid as well.
                                      * Note that the initial state of the
                                      * triangulation is empty, unless
-                                     * #restore_grid# is called for the
+                                     * @p{restore_grid} is called for the
                                      * first time.
                                      *
                                      * The coarse grid must persist until
@@ -153,19 +153,19 @@ class PersistentTriangulation : public Triangulation<dim>
                                      * an error if the underlying triangulation
                                      * is not empty, i.e. it will only succeed
                                      * if this object is newly created or
-                                     * #clear()# was called on it before.
+                                     * @p{clear()} was called on it before.
                                      */
     void restore ();
 
                                     /**
                                      * Overload this function to use
-                                     * #tria# as a new coarse grid. The
+                                     * @p{tria} as a new coarse grid. The
                                      * present triangulation and all
                                      * refinement and coarsening flags
                                      * storing its history are deleted,
                                      * and the state of the underlying
                                      * triangulation is reset to be
-                                     * empty, until #restore_grid# is
+                                     * empty, until @p{restore_grid} is
                                      * called the next time.
                                      *
                                      * The coarse grid must persist until
@@ -186,14 +186,14 @@ class PersistentTriangulation : public Triangulation<dim>
 
                                     /**
                                      * Writes all refine and coarsen
-                                     * flags to the ostream #out#.
+                                     * flags to the ostream @p{out}.
                                      */
     virtual void write_flags(ostream &out) const;
 
                                     /**
                                      * Reads all refine and coarsen flags
                                      * that previously were written by
-                                     * #write_flags(...)#. This is especially
+                                     * @p{write_flags(...)}. This is especially
                                      * useful for rebuilding the triangulation
                                      * after the end or breakdown of a program
                                      * and its restart.
index 25f37423b116de12ec0e6d8ea0bb9b948fbdd5ad..b3592e646e8c92843fae76a83ceff68736ff3e29 100644 (file)
@@ -34,7 +34,7 @@ template <int dim> class MGDoFHandler;
 
 
 /**
- *  Structure which is passed to the #Triangulation<dim>::create_triangulation#
+ *  Structure which is passed to the @p{Triangulation<dim>::create_triangulation}
  *  function. It contains all data needed to construct a cell, namely the
  *  indices of the vertices and the material indicator.
  */
@@ -50,7 +50,7 @@ struct CellData {
 
 
 /**
- *  Structure to be passed to the #Triangulation<dim>::create_triangulation#
+ *  Structure to be passed to the @p{Triangulation<dim>::create_triangulation}
  *  function to describe boundary information.
  *
  *  This structure is the same for all dimensions, since we use an input
@@ -91,9 +91,9 @@ struct SubCellData {
                                      * This function checks whether the vectors
                                      * which may not be used in a given
                                      * dimension are really empty. I.e.,
-                                     * whether the #boundary_*# arrays are
+                                     * whether the @p{boundary_*} arrays are
                                      * empty when in one space dimension
-                                     * and whether the #boundary_quads#
+                                     * and whether the @p{boundary_quads}
                                      * array is empty when in two dimensions.
                                      *
                                      * Since this structure is the same for all
@@ -120,10 +120,10 @@ class TriaDimensionInfo;
  *  This class implements some types which differ between the dimensions.
  *  These are the declararions for the 1D case only.
  *
- *  A #line_iterator# is typdef'd to an iterator operating on the
- *  #lines# member variable of a #Triangulation<1># object. An
- *  #active_line_iterator# only operates on the active lines.
- *  #raw_line_iterator# objects operate on all lines, used or not.
+ *  A @p{line_iterator} is typdef'd to an iterator operating on the
+ *  @p{lines} member variable of a @p{Triangulation<1>} object. An
+ *  @p{active_line_iterator} only operates on the active lines.
+ *  @p{raw_line_iterator} objects operate on all lines, used or not.
  *
  *  Since we are in one dimension, the following identities are declared:
  *  \begin{verbatim}
@@ -132,13 +132,13 @@ class TriaDimensionInfo;
  *    typedef active_line_iterator active_cell_iterator;
  *  \end{verbatim}
  *
- *  To enable the declaration of #begin_quad# and the like in
- *  #Triangulation<1>#, the #quad_iterator#s are declared as
- *  #void *#. Thus these types exist, but are useless and will
+ *  To enable the declaration of @p{begin_quad} and the like in
+ *  @p{Triangulation<1>}, the @p{quad_iterator}s are declared as
+ *  @p{void *}. Thus these types exist, but are useless and will
  *  certainly make any involuntary use visible. The same holds
  *  for hexahedron iterators.
  *
- *  The same applies for the #face_iterator# types, since lines
+ *  The same applies for the @p{face_iterator} types, since lines
  *  have no substructures apart from vertices, which are handled in
  *  a different way, however.
  */
@@ -171,21 +171,21 @@ class TriaDimensionInfo<1> {
  *  This class implements some types which differ between the dimensions.
  *  These are the declararions for the 2D case only.
  *
- *  A #line_iterator# is typdef'd to an iterator operating on the
- *  #lines# member variable of a #Triangulation<2># object. An
- *  #active_line_iterator# only operates on the active lines.
- *  #raw_line_iterator# objects operate on all lines, used or not.
- *  Using #active_line_iterator#s may not be particularly in 2D useful since it
+ *  A @p{line_iterator} is typdef'd to an iterator operating on the
+ *  @p{lines} member variable of a @p{Triangulation<2>} object. An
+ *  @p{active_line_iterator} only operates on the active lines.
+ *  @p{raw_line_iterator} objects operate on all lines, used or not.
+ *  Using @p{active_line_iterator}s may not be particularly in 2D useful since it
  *  only operates on unrefined lines. However, also refined lines may bound
  *  unrefined cells if the neighboring cell is refined once more than the
  *  present one.
  *
- *  Similarly to line iterators, #quad_iterator#, #raw_quad_iterator# and
- *  #active_quad_iterator# are declared.
+ *  Similarly to line iterators, @p{quad_iterator}, @p{raw_quad_iterator} and
+ *  @p{active_quad_iterator} are declared.
  *  
- *  To enable the declaration of #begin_hex# and the like in
- *  #Triangulation<[12]>#, the #hex_iterator#s are declared as
- *  #void *#. Thus these types exist, but are useless and will
+ *  To enable the declaration of @p{begin_hex} and the like in
+ *  @p{Triangulation<[12]>}, the @p{hex_iterator}s are declared as
+ *  @p{void *}. Thus these types exist, but are useless and will
  *  certainly make any involuntary use visible.
  *
  *  Since we are in two dimension, the following identities are declared:
@@ -229,7 +229,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 #TriaDimensionInfo<[12]>#). The
+ *  as for lower dimensions (see @p{TriaDimensionInfo<[12]>}). The
  *  dimension specific data types are here, since we are in three dimensions:
  *  \begin{verbatim}
  *    typedef raw_hex_iterator    raw_cell_iterator;
@@ -342,7 +342,7 @@ struct TriaNumberCache<1>
  * Cache class used to store the number of used and active elements
  * (lines or quads etc) within the levels of a triangulation. This
  * specialization stores the numbers of quads. Due to the inheritance
- * from the base class #TriaNumberCache<1>#, the numbers of lines
+ * from the base class @p{TriaNumberCache<1>}, the numbers of lines
  * are also within this class.
  *
  * In the old days, whenever one wanted to access one of these
@@ -395,7 +395,7 @@ struct TriaNumberCache<2> : public TriaNumberCache<1>
  * Cache class used to store the number of used and active elements
  * (lines or quads etc) within the levels of a triangulation. This
  * specialization stores the numbers of hexes. Due to the inheritance
- * from the base class #TriaNumberCache<2>#, the numbers of lines
+ * from the base class @p{TriaNumberCache<2>}, the numbers of lines
  * and quads are also within this class.
  *
  * In the old days, whenever one wanted to access one of these
@@ -448,20 +448,20 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
 
 
 /**
- *  #Triangulation#s denote a hierarchy of levels of elements which together
- *  form a region in #dim# spatial dimensions.
+ *  @p{Triangulation}s denote a hierarchy of levels of elements which together
+ *  form a region in @p{dim} spatial dimensions.
  *
  *  This class is written to be as independent of the dimension as possible
- *  (thus the complex construction of the #TriangulationLevel# classes) to
+ *  (thus the complex construction of the @p{TriangulationLevel} classes) to
  *  allow code-sharing, to allow reducing the need to mirror changes in the code
  *  for one dimension to the code for other dimensions. Nonetheless, some of
  *  the functions are dependent of the dimension and there only exist
  *  specialized versions for distinct dimensions.
  *
  *
- *  \subsection{Structure and iterators}
+ *  @sect3{Structure and iterators}
  *
- *  The actual data structure of a #Triangulation# object is rather complex
+ *  The actual data structure of a @p{Triangulation} object is rather complex
  *  and quite inconvenient if one attempted to operate on it directly, since
  *  data is spread over quite a lot of arrays and other places. However,
  *  there are ways powerful enough to work on these data structures
@@ -470,39 +470,39 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *  In order to make things as easy and dimension independent as possible,
  *  use of class local typedefs is made, see below.
  *  
- *  In the base class #TriaDimensionInfo#, a #Cell# is typedef'd to be whatever
- *  is reasonable for a cell in the respective dimension, i.e. a #Line# in
- *  one dimension, a #Quad# in two dimensions, and so on.
+ *  In the base class @p{TriaDimensionInfo}, a @p{Cell} is typedef'd to be whatever
+ *  is reasonable for a cell in the respective dimension, i.e. a @p{Line} in
+ *  one dimension, a @p{Quad} in two dimensions, and so on.
  *
- *  The #Triangulation# class provides iterator which enable looping over all
+ *  The @p{Triangulation} class provides iterator which enable looping over all
  *  lines, cells,
  *  etc without knowing the exact representation used to describe them. Their
- *  names are typedefs in the #TriaDimensionInfo# base class (thus making them
+ *  names are typedefs in the @p{TriaDimensionInfo} base class (thus making them
  *  local types to this class) and are as follows:
  *
- *  #raw_line_iterator#: loop over all lines, used or not (declared for
+ *  @p{raw_line_iterator}: loop over all lines, used or not (declared for
  *  all dimensions).
  *  
- *  #line_iterator#: loop over all used lines (declared for all dimensions).
+ *  @p{line_iterator}: loop over all used lines (declared for all dimensions).
  *
- *  #active_line_iterator#: loop over all active lines (declared for all
+ *  @p{active_line_iterator}: loop over all active lines (declared for all
  *  dimensions).
  *
- *  #raw_quad_iterator#: loop over all quads, used or not (declared only
- *  for #dim>=2#).
+ *  @p{raw_quad_iterator}: loop over all quads, used or not (declared only
+ *  for @p{dim>=2}).
  *  
- *  #quad_iterator#: loop over all quads (declared only for #dim#>=2).
+ *  @p{quad_iterator}: loop over all quads (declared only for @p{dim}>=2).
  *
- *  #active_quad_iterator#: loop over all active quads (declared only for
- *  #dim#>=2).
+ *  @p{active_quad_iterator}: loop over all active quads (declared only for
+ *  @p{dim}>=2).
  *
- *  Additionaly, for #dim#==1, the following identities hold:
+ *  Additionaly, for @p{dim}==1, the following identities hold:
  *  \begin{verbatim}
  *    typedef raw_line_iterator    raw_cell_iterator;
  *    typedef line_iterator        cell_iterator;
  *    typedef active_line_iterator active_cell_iterator;
  *  \end{verbatim}
- *  while for #dim#==2
+ *  while for @p{dim}==2
  *  \begin{verbatim}
  *    typedef quad_line_iterator   raw_cell_iterator;    
  *    typedef quad_iterator        cell_iterator;
@@ -519,14 +519,14 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *  cell is be a vertex in 1D and a line in 2D; however, vertices are
  *  handled in a different way and therefore lines have no faces.
  *
- *  The #Triangulation# class offers functions like #begin_active# which gives
+ *  The @p{Triangulation} class offers functions like @p{begin_active} which gives
  *  you an iterator to the first active cell. There are quite a lot of functions
  *  returning iterators. Take a look at the class doc to get an overview.
  *
  *  Usage of these iterators works mostly like with the STL iterators. Some
- *  examples taken from the #Triangulation# source code follow.
+ *  examples taken from the @p{Triangulation} source code follow.
  *  \begin{itemize}
- *  \item {\it Counting the number of cells on a specific level}
+ *  \item @em{Counting the number of cells on a specific level}
  *    \begin{verbatim}
  *     template <int dim>
  *     int Triangulation<dim>::n_cells (const int level) const {
@@ -538,7 +538,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *        return n;
  *      };
  *    \end{verbatim}
- *    Another way which uses the STL #distance# function would be to write
+ *    Another way which uses the STL @p{distance} function would be to write
  *    \begin{verbatim}
  *      template <int dim>
  *      int Triangulation<dim>::n_cells (const int level) const {
@@ -552,7 +552,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *      };  
  *    \end{verbatim}
  *    
- *  \item {\it Refining all cells of a triangulation}
+ *  \item @em{Refining all cells of a triangulation}
  *    \begin{verbatim}
  *      template <int dim>
  *      void Triangulation<dim>::refine_global () {
@@ -567,9 +567,9 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *  \end{itemize}
  *
  *
- *  \subsection{Usage}
+ *  @sect3{Usage}
  *
- *  Usage of a #Triangulation# is mainly done through the use of iterators.
+ *  Usage of a @p{Triangulation} is mainly done through the use of iterators.
  *  An example probably shows best how to use it:
  *  \begin{verbatim}
  *  void main () {
@@ -611,18 +611,18 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *  \end{verbatim}
  *
  *  
- *  \subsection{Creating a triangulation}
+ *  @sect3{Creating a triangulation}
  *
  *  There are several possibilities to create a triangulation:
  *  \begin{itemize}
  *    \item The most common domains, such as hypercubes (i.e. lines, squares,
  *       cubes, etc), hyper-balls (circles, balls, ...) and some other, more
  *       weird domains such as the L-shape region and higher dimensional
- *       generalizations and others, are provided by the #GridGenerator#
+ *       generalizations and others, are provided by the @p{GridGenerator}
  *       class which takes a triangulation and fills it by a division
  *       of the required domain.
  *   
- *     \item Reading in a triangulation: By using an object of the #DataIn#
+ *     \item Reading in a triangulation: By using an object of the @p{DataIn}
  *        class, you can read in fairly general triangulations. See there for
  *        more information. The mentioned class uses the interface described
  *        directly below to transfer the data into the triangulation.
@@ -631,8 +631,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
- *        #DataIn<dim>::read_*# functions. The appropriate function to be
- *        called is #Triangulation<dim>::create_triangulation (2)#.
+ *        @p{DataIn<dim>::read_*} functions. The appropriate function to be
+ *        called is @p{Triangulation<dim>::create_triangulation (2)}.
  *
  *        Creating the hierarchical information needed for this library from
  *        cells storing only vertex information can be quite a complex task.
@@ -663,12 +663,12 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *        \Ref{DataIn} class for more details on this. 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
- *        #Triangulation<dim>::create_triangulation (2)# function.
+ *        @p{Triangulation<dim>::create_triangulation (2)} function.
  *
  *     \item Copying a triangulation: when computing on time dependant meshes
  *        of when using adaptive refinement, you will often want to create a
  *        new triangulation to be the same as another one. This is facilitated
- *        by the #copy_triangulation# function.
+ *        by the @p{copy_triangulation} function.
  *
  *        It is guaranteed that vertex, line or cell numbers in the two
  *        triangulations are the same and that two iterators walking on the
@@ -713,7 +713,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:
- *   #Triangulation<dim>::distort_random#. It moves all the vertices in the
+ *   @p{Triangulation<dim>::distort_random}. 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.
@@ -735,18 +735,18 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *
  *
  *
- *   \subsection{Refinement and coarsening of a triangulation}
+ *   @sect3{Refinement and coarsening of a triangulation}
  *
  *   Refinement of a triangulation may be done through several ways. The most
- *   low-level way is directly through iterators: let #i# be an iterator to
+ *   low-level way is directly through iterators: let @p{i} be an iterator to
  *   an active cell (i.e. the cell pointed to has no children), then the
- *   function call #i->set_refine_flag()# marks the respective cell for
+ *   function call @p{i->set_refine_flag()} marks the respective cell for
  *   refinement. Marking non-active cells results in an error.
  *
  *   After all the cells you wanted to mark for refinement, call the
- *   #execute_coarsening_and_refinement# function to actually perform
+ *   @p{execute_coarsening_and_refinement} function to actually perform
  *   the refinement. This function itself first calls the
- *   #prepare_coarsening_and_refinement# function to regularize the resulting
+ *   @p{prepare_coarsening_and_refinement} function to regularize the resulting
  *   triangulation: since a face between two adjacent cells may only
  *   be subdivided once (i.e. the levels of two adjacent cells may
  *   differ by one at most; it is not possible to have a cell refined
@@ -759,7 +759,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
- *   #i->set_coarsen_flag# and calling #execute_coarsening_and_refinement#.
+ *   @p{i->set_coarsen_flag} and calling @p{execute_coarsening_and_refinement}.
  *
  *   The reason for first coarsening, then refining is that the
  *   refinement usually adds some additional cells to keep the triangulation
@@ -779,41 +779,41 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   elements.
  *
  *   The central function to this is
- *   #refine (const Vector<float> &criterion, const double threshold)#: it takes a
+ *   @p{refine (const Vector<float> &criterion, const double threshold)}: 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,
- *   #coarsen (const Vector<float> &criterion, const double threshold)# flags those
+ *   @p{coarsen (const Vector<float> &criterion, const double threshold)} flags those
  *   cells for coarsening for which the criterion is less than the threshold.
  *
- *   There are two variations of these functions, which rely on #refine# and
+ *   There are two variations of these functions, which rely on @p{refine} and
  *   coarsen by computing the thresholds from other information:
  *   \begin{itemize}
- *   \item #refine_and_coarsen_fixed_number#: this function takes a vector as
+ *   \item @p{refine_and_coarsen_fixed_number}: this function takes a vector as
  *     above and two values between zero and one denoting the fractions of cells to
  *     be refined and coarsened. For this purpose, it sorts the criteria per cell
  *     and takes the threshold to be the one belonging to the cell with the
- *     #fraction times n_active_cells# highest criterion. For example, if
+ *     @p{fraction times n_active_cells} 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
- *     the central #refine# function. For coarsening, the same holds.
+ *     the central @p{refine} function. For coarsening, the same holds.
  *
  *     The sorting of criteria is not done actually, since we only need one
  *     value, in the example above the criterion of the cell which is at
  *     30 per cent in the sorted list of cells. The order of cells with higher
  *     and of those with lower criteria is irrelevant. Getting this value is
- *     accomplished by the #nth_element# function of the #C++# standard
+ *     accomplished by the @p{nth_element} function of the @p{C++} standard
  *     library, which takes only linear time in the number of elements, rather
- *     than #N log N# for sorting all values.
+ *     than @p{N log N} 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
  *     want to chose a smaller value to avoid overrefinement in regions which
  *     do not contribute much to the error.
  *
- *   \item #refine_and_coarsen_fixed_fraction#: this function computes the
+ *   \item @p{refine_and_coarsen_fixed_fraction}: this function computes the
  *     threshold such that the number of cells getting flagged for refinement
  *     makes up for a certain fraction of the total error. If this fraction is 50
  *     per cent, for example, the threshold is computed such that the cells with
@@ -839,8 +839,8 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *     From the point of view of implementation, this time we really need to
  *     sort the array of criteria.
  *     Just like the other strategy described above, this function only
- *     computes the threshold values and then passes over to #refine# and
- *     #coarsen#.
+ *     computes the threshold values and then passes over to @p{refine} and
+ *     @p{coarsen}.
  *
  *     A typical value for the fraction of the total error is 0.5.
  *   \end{itemize}
@@ -858,37 +858,37 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   for one of the operations.
  *
  *
- *   \subsection{Smoothing of a triangulation}
+ *   @sect3{Smoothing of a triangulation}
  *
  *   Some degradation of approximation properties has been observed
  *   for grids which are too unstructured. Therefore, the
- *   #prepare_coarsening_and_refinement# function which is automatically called
- *   by the #execute_coarsening_and_refinement# function can do some
+ *   @p{prepare_coarsening_and_refinement} function which is automatically called
+ *   by the @p{execute_coarsening_and_refinement} function can do some
  *   smoothing of the triangulation. Note that mesh smoothing is only
  *   done for two or more space dimensions, no smoothing is available
  *   at present for one spatial dimension. In the sequel, let
- *   #execute_*# stand for #execute_coarsening_and_refinement#.
+ *   @p{execute_*} 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 #execute_*#
+ *   @p{Triangulation} constructor takes an argument specifying whether a
+ *   smoothing step shall be performed on the grid each time @p{execute_*}
  *   is called. The default is that such a step not be done, since this results
  *   in additional cells being produced, which may not be necessary in all
- *   cases. If switched on, calling #execute_*# results in
+ *   cases. If switched on, calling @p{execute_*} 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 #execute_*# is that it would result
- *   in algorithmic problems if you called #execute_*# once without
+ *   constructor rather than to @p{execute_*} is that it would result
+ *   in algorithmic problems if you called @p{execute_*} 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 #enum MeshSmoothing#. The meaning
+ *   bitwise by the constants defined in the @p{enum MeshSmoothing}. The meaning
  *   of these constants is explained in the following:
  *   \begin{itemize}
- *   \item #limit_level_difference_at_vertices#:
+ *   \item @p{limit_level_difference_at_vertices}:
  *     It can be shown, that degradation of approximation occurs if the
  *     triangulation contains vertices which are member of cells with levels
  *     differing by more than one. One such example is the following:
@@ -929,17 +929,17 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *     of this cell (but with a less degree of deviation from the true value).
  *
  *     If the smoothing indicator given to the constructor contains the bit for
- *     #limit_level_difference_at_vertices#, situations as the above one are
+ *     @p{limit_level_difference_at_vertices}, situations as the above one are
  *     eliminated by also marking the lower left cell for refinement.
  *
- *   \item #eliminate_unrefined_islands#:
+ *   \item @p{eliminate_unrefined_islands}:
  *     Single cells which are not refined and are surrounded by cells which are
  *     refined usually also lead to a sharp decline in approximation properties
  *     locally. The reason is that the nodes on the faces between unrefined and
  *     refined cells are not real degrees of freedom but carry constraints. The
  *     patch without additional degrees of freedom is thus significantly larger
  *     then the unrefined cell itself. If in the parameter passed to the
- *     constructor the bit for #eliminate_unrefined_islands# is set, all cells
+ *     constructor the bit for @p{eliminate_unrefined_islands} is set, all cells
  *     which are not flagged for refinement but which are surrounded by more
  *     refined cells than unrefined cells are flagged for refinement. Cells
  *     which are not yet refined but flagged for that are accounted for the
@@ -951,10 +951,10 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *     name of the flag may indicate. However, no better name came to mind to
  *     the author by now.
  *
- *   \item #eliminate_refined_*_islands#:
+ *   \item @p{eliminate_refined_*_islands}:
  *     This algorithm seeks for isolated cells which are refined or flagged
  *     for refinement. This definition is unlike that for
- *     #eliminate_unrefined_islands#, which would mean that an island is
+ *     @p{eliminate_unrefined_islands}, which would mean that an island is
  *     defined as a cell which
  *     is refined but more of its neighbors are not refined than are refined.
  *     For example, in 2D, a cell's refinement would be reverted if at most
@@ -974,7 +974,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *     refinement flag.
  *
  *     Actually there are two versions of this flag,
- *     #eliminate_refined_inner_islands# and #eliminate_refined_boundary_islands#.
+ *     @p{eliminate_refined_inner_islands} and @p{eliminate_refined_boundary_islands}.
  *     There first eliminates islands defined by the definition above which are
  *     in the interior of the domain, while the second eliminates only those
  *     islands if the cell is at the boundary. The reason for this split of
@@ -983,39 +983,39 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *     refines the mesh according to a criterion associated with a boundary
  *     integral or if one has rough boundary data.
  *
- *   \item #do_not_produce_unrefined_islands#:
+ *   \item @p{do_not_produce_unrefined_islands}:
  *     This flag prevents the occurrence of unrefined islands. In more detail:
  *     It prohibits the coarsening of a cell if 'most of the neighbors' will
  *     be refined after the step.
  *
- * \item #patch_level_1#:
+ * \item @p{patch_level_1}:
  *     Ensures patch level 1. As result the triangulation consists of
  *     patches, i.e. of cells that are refined once. It follows that
  *     if at least one of the children of a cell is or will be refined
- *     than all children need to be refined. If the #path_level_1# flag
- *     is set, than the flags #eliminate_unrefined_islands#,
- *     #eliminate_refined_inner_islands# and
- *     #eliminate_refined_boundary_islands# will be ignored as they will
+ *     than all children need to be refined. If the @p{path_level_1} flag
+ *     is set, than the flags @p{eliminate_unrefined_islands},
+ *     @p{eliminate_refined_inner_islands} and
+ *     @p{eliminate_refined_boundary_islands} will be ignored as they will
  *     be fulfilled automatically.
  *
- *   \item #smoothing_on_refinement#:
+ *   \item @p{smoothing_on_refinement}:
  *     This flag sums up all smoothing algorithms which may be performed upon
  *     refinement by flagging some more cells for refinement.
  *
- *   \item #smoothing_on_coarsening#:
+ *   \item @p{smoothing_on_coarsening}:
  *     This flag sums up all smoothing algorithms which may be performed upon
  *     coarsening by flagging some more cells for coarsening.
  *
- *   \item #maximum_smoothing#:
+ *   \item @p{maximum_smoothing}:
  *     This flag includes all the above ones and therefore combines all
  *     smoothing algorithms implemented.
  *
- *   \item #none#:
+ *   \item @p{none}:
  *     Select no smoothing at all.
  *   \end{itemize}
  *
  *
- *   \subsection{Material and boundary information}
+ *   @sect3{Material and boundary information}
  *
  *   Each line, quad, etc stores one byte of information denoting the
  *   material of a cell or the part of the boundary, a lower
@@ -1054,11 +1054,11 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   the different handling of vertices from lines and quads.
  *
  *
- *   \subsection{History of a triangulation}
+ *   @sect3{History of a triangulation}
  *
  *   It is possible to reconstruct a grid from its refinement history, which
- *   can be stored and loaded through the #save_refine_flags# and
- *   #load_refine_flags# functions. Normally, the code will look like this:
+ *   can be stored and loaded through the @p{save_refine_flags} and
+ *   @p{load_refine_flags} functions. Normally, the code will look like this:
  *   \begin{verbatim}
  *                                 // open output file
  *     ofstream history("mesh.history");
@@ -1094,15 +1094,15 @@ 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 #save_*_flags# and #load_*_flags# functions.
+ *   There actually are two sets of @p{save_*_flags} and @p{load_*_flags} 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 #vector<bool>#. This enables the user to temporarily store
+ *   argument of type @p{vector<bool>}. This enables the user to temporarily store
  *   some flags, e.g. if another function needs them, and restore them
  *   afterwards.
  *
  *
- *   \subsection{User flags and data}
+ *   @sect3{User flags and data}
  *
  *   A triangulation offers one bit per line, quad, etc for user data.
  *   This field can be
@@ -1110,44 +1110,44 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   used if an algorithm walks over all cells and needs information whether
  *   another cell, e.g. a neighbor, has already been processed. It can also
  *   be used to flag the lines subject to constraints in 2D, as for example the
- *   functions in the #DoFHandler# classes do.
+ *   functions in the @p{DoFHandler} classes do.
  *
- *   There are two functions, #save_user_flags# and #load_user_flags# which
+ *   There are two functions, @p{save_user_flags} and @p{load_user_flags} which
  *   write and read these flags to and from a stream. Unlike
- *   #save_refine_flags# and #load_refine_flags#, these two functions store
+ *   @p{save_refine_flags} and @p{load_refine_flags}, these two functions store
  *   and read the flags of all used lines, quads, etc, not only of the
  *   active ones (well, activity is a concept which really only applies to
  *   cells, not for example to lines in 2D, so the abovementioned generalization
- *   to {\it all} lines, quads, etc seems plausible).
+ *   to @em{all} lines, quads, etc seems plausible).
  *
  *   If you want to store more specific user flags, you can use the functions
- *   #save_user_flags_line# and #load_user_flags_line# and the generalizations
+ *   @p{save_user_flags_line} and @p{load_user_flags_line} and the generalizations
  *   for quads, etc.
  *
  *   As for the refinement and coarsening flags, there exist two versions of these
  *   functions, one which reads/writes from a stream and one which does so from
- *   a #vector<bool>#. The latter is used to store flags temporarily, while the
+ *   a @p{vector<bool>}. 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
- *   #Triangulation<>::clear_user_flags()# function before usage, since it is
+ *   @p{Triangulation<>::clear_user_flags()} 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 #void *#, for each
+ *   There is another set of user data, namely a @p{void *}, for each
  *   line, quad, etc. You can access these user pointers through the
- *   functions #user_pointer()#, #clear_user_pointer()# and
- *   #set_user_pointer(p)# in the accessor classes. These pointers are
+ *   functions @p{user_pointer()}, @p{clear_user_pointer()} and
+ *   @p{set_user_pointer(p)} in the accessor classes. These pointers are
  *   neither used nor changed by the library and are @p NULL by
  *   default. Thus, their handling is the sole responsibility of the
  *   application program.  Especially, the pointers are not inherited
  *   to children upon refinement. Still, after a remeshing they are
  *   available on all cells, where they were set on the previous mesh.
  *
- *   The usual warning about the missing type safety of #void# pointers are
+ *   The usual warning about the missing type safety of @p{void} pointers are
  *   obviously in place here; responsibility for correctness of types etc
  *   lies entirely with the user of the pointer.
  *
@@ -1155,15 +1155,15 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   which does no harm since the vertices have a unique and continuous number
  *   unlike the structured objects lines and quads. 
  *
- *   \subsection{Boundary approximation}
+ *   @sect3{Boundary approximation}
  *
  *   You can specify a boundary function for each boundary
  *   component. If a new vertex is created on a side or face at the
  *   boundary, this function is used to compute where it will be
  *   placed. The boundary indicator of the face will be used to
  *   determine the proper component. See \Ref{Boundary} for the
- *   details. Usage with the #Triangulation# object is then like this
- *   (let #Ball# be a class derived from #Boundary<2>#):
+ *   details. Usage with the @p{Triangulation} object is then like this
+ *   (let @p{Ball} be a class derived from @p{Boundary<2>}):
  * 
  *   \begin{verbatim}
  *     void main () {
@@ -1206,9 +1206,9 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   coarse grid.
  *
  *
- *   \subsection{Technical details}
+ *   @sect3{Technical details}
  *
- *   \subsubsection{Algorithms for mesh regularization and smoothing upon refinement}
+ *   @sect4{Algorithms for mesh regularization and smoothing upon refinement}
  *
  *   We chose an inductive point of view: since upon creation of the
  *   triangulation all cells are on the same level, all regularity assumptions
@@ -1218,13 +1218,13 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   further the assumptions also hold.
  *
  *   The regularization and smoothing is done in the
- *   #prepare_coarsening_and_refinement# function, which is called by
- *   #execute_coarsening_and_refinement# at the very beginning.  It
+ *   @p{prepare_coarsening_and_refinement} function, which is called by
+ *   @p{execute_coarsening_and_refinement} at the very beginning.  It
  *   decides which additional cells to flag for refinement by looking
  *   at the old grid and the refinement flags for each cell.
  *
  *   \begin{itemize}
- *   \item {\it Regularization:} The algorithm walks over all cells checking
+ *   \item @em{Regularization:} The algorithm walks over all cells checking
  *     whether the present cell is flagged for refinement and a neighbor of the
  *     present cell is refined once less than the present one. If so, flag the
  *     neighbor for refinement. Because of the induction above, there may be no
@@ -1238,9 +1238,9 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *     on lower levels, but if these induce more refinement needed, this is
  *     performed later on when we visit them in out backward running loop.
  *
- *   \item {\it Smoothing:}
+ *   \item @em{Smoothing:}
  *     \begin{itemize}
- *     \item #limit_level_difference_at_vertices#:
+ *     \item @p{limit_level_difference_at_vertices}:
  *       First a list is set up which stores for each vertex
  *       the highest level one of the adjacent cells belongs to. Now, since we did
  *       smoothing in the previous refinement steps also, each cell may only have
@@ -1254,7 +1254,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *       refinement, but these are on lower levels, as above, which is why we
  *       may do all kinds of additional flagging in one loop only.
  *
- *     \item #eliminate_unrefined_islands#:
+ *     \item @p{eliminate_unrefined_islands}:
  *       For each cell we count the number of neighbors which are refined or
  *       flagged for refinement. If this exceeds the total number of neighbors
  *       (which is the number of faces minus the number of faces of this cell
@@ -1263,7 +1263,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *       will need refinement, we will need additional loops of regularization
  *       and smoothing over all cells until nothing changes any more.
  *
- *     \item #eliminate_refined_*_islands#:
+ *     \item @p{eliminate_refined_*_islands}:
  *       This one does much the same as the above one, but for coarsening. If
  *       a cell is flagged for refinement or if all of its children are active
  *       and if the number of neighbors which are either active and not flagged
@@ -1291,7 +1291,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   upon later.
  *
  *
- *   \subsubsection{Implementation conventions for two spatial dimensions}
+ *   @sect4{Implementation conventions for two spatial dimensions}
  *
  *   There is a convention about the direction of the bounding lines of quads in
  *   2D. The direction of a line is the direction of point 0 towards point 1. We
@@ -1311,14 +1311,14 @@ 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 #subline(0).vertex(0)==line.vertex(0)# and
- *   #subline(1).vertex(1)==line.vertex(1)#. This also implies, that the
- *   first subline (#subline(0)#) is the one at vertex(0) of the old line.
+ *   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.
  *
  *   Similarly we define, that the four children of a quad are adjacent to the
  *   vertex with the same number of the old quad.
  *
- *   \subsubsection{Coordinate systems}
+ *   @sect4{Coordinate systems}
  *
  *   When explicit coordinates are required for points in a cell (e.g for
  *   quadrature formulae or the point of definition of trial functions), we
@@ -1332,10 +1332,10 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *     *-------------->x
  *   \end{verbatim}
  *   with vertex 0 being the origin of the coordinate system, vertex 1 having
- *   coordinates #(1,0)#, vertex 2 at #(1,1)# and vertex 3 at #(0,1)#.
+ *   coordinates @p{(1,0)}, vertex 2 at @p{(1,1)} and vertex 3 at @p{(0,1)}.
  *
  *
- *   \subsection{Implementation conventions for three spatial dimensions}
+ *   @sect3{Implementation conventions for three spatial dimensions}
  *
  *   By convention, we will use the following numbering for vertices, lines and
  *   faces of hexahedra in three space dimensions. Before giving these 
@@ -1357,7 +1357,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   cube, while the right one shall be the top, right and front face. You may
  *   recover the whole cube by moving the two parts together into one.
  *
- *   \subsubsection{Vertices}
+ *   @sect4{Vertices}
  *
  *   The vertices on the front face are numbered exactly the same way as are
  *   the vertices on a quadrilateral. The vertices on the back face are numbered
@@ -1376,7 +1376,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *     0-------1        0-------1
  *   \end{verbatim}
  *
- *   \subsubsection{Lines}
+ *   @sect4{Lines}
  *
  *   Here, the same holds as for the vertices: the lines of the front face are
  *   numbered as for the quadrilateral, for the back face they are just shifted.
@@ -1408,7 +1408,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *     *--->---*        *--->---*
  *   \end{verbatim}
  *
- *   \subsubsection{Faces}
+ *   @sect4{Faces}
  *
  *   The faces are numbered in the same order as the lines were numbered: front
  *   face, back face, then the four side faces:
@@ -1488,7 +1488,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   \end{itemize}
  *
  *
- *   \subsubsection{Children}
+ *   @sect4{Children}
  *
  *   The eight children of a cell are numbered as follows:
  *   \begin{verbatim}
@@ -1514,11 +1514,11 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   \item Face 4: children 3, 2, 6, 7;
  *   \item Face 5: children 0, 4, 7, 3.
  *   \end{itemize}
- *   You can get these numbers using the #GeometryInfo<3>::child_cell_on_face#
+ *   You can get these numbers using the @p{GeometryInfo<3>::child_cell_on_face}
  *   function. Each child is adjacent to the vertex with the same number.
  *
  *
- *   \subsubsection{Coordinate systems}
+ *   @sect4{Coordinate systems}
  *
  *   We define the following coordinate system for the explicit coordinates of
  *   the vertices of the unit cell:
@@ -1535,29 +1535,29 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *    *------>x        0-------1        0-------1
  *   \end{verbatim}
  *   This convention in conjunction with the numbering of the vertices is a bit
- *   unfortunate, since the vertices 0 through 3 have the coordinates #(x,0,z)#
- *   with #x# and #z# being the same as the #x# and #y# coordinates of a quad
+ *   unfortunate, since the vertices 0 through 3 have the coordinates @p{(x,0,z)}
+ *   with @p{x} and @p{z} being the same as the @p{x} and @p{y} coordinates of a quad
  *   in the plane; more intuitive would have been if they had the coordinates
- *   #(x,y,0)#. However, the vertex numbering was historically chosen as shown.
+ *   @p{(x,y,0)}. However, the vertex numbering was historically chosen as shown.
  *
  *   By the convention laid down as above, the vertices have the following
  *   coordinates:
  *   \begin{itemize}
- *      \item Vertex 0: #(0,0,0)#;
- *      \item Vertex 1: #(1,0,0)#;
- *      \item Vertex 2: #(1,0,1)#;
- *      \item Vertex 3: #(0,0,1)#;
- *      \item Vertex 4: #(0,1,0)#;
- *      \item Vertex 5: #(1,1,0)#;
- *      \item Vertex 6: #(1,1,1)#;
- *      \item Vertex 7: #(0,1,1)#.
+ *      \item Vertex 0: @p{(0,0,0)};
+ *      \item Vertex 1: @p{(1,0,0)};
+ *      \item Vertex 2: @p{(1,0,1)};
+ *      \item Vertex 3: @p{(0,0,1)};
+ *      \item Vertex 4: @p{(0,1,0)};
+ *      \item Vertex 5: @p{(1,1,0)};
+ *      \item Vertex 6: @p{(1,1,1)};
+ *      \item Vertex 7: @p{(0,1,1)}.
  *   \end{itemize}
  *
  *
- *   \subsection{Warning}
+ *   @sect3{Warning}
  *
- *   It seems impossible to preserve #const#ness of a triangulation through
- *   iterator usage. Thus, if you declare pointers to a #const# triangulation
+ *   It seems impossible to preserve @p{const}ness of a triangulation through
+ *   iterator usage. Thus, if you declare pointers to a @p{const} triangulation
  *   object, you should be well aware that you might involuntarily alter the
  *   data stored in the triangulation.
  *
@@ -1572,7 +1572,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
   private:
                                     /**
                                      * Default boundary object. This declaration is used
-                                     * for the default argument in #set_boundary#.
+                                     * for the default argument in @p{set_boundary}.
                                      */
     static const StraightBoundary<dim>& straight_boundary;
 
@@ -1580,7 +1580,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
     
 /**
  * Declare some symbolic names for mesh smoothing algorithms. The meaning of
- * these flags is documented in the #Triangulation# class.
+ * these flags is documented in the @p{Triangulation} class.
  */
     enum MeshSmoothing
     {
@@ -1632,7 +1632,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Copy constructor. You should really
-                                     *  use the #copy_triangulation# function,
+                                     *  use the @p{copy_triangulation} function,
                                      *  so we declare this function but let
                                      *  it throw an internal error. The
                                      *  reason for this is that we may use
@@ -1658,7 +1658,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *
                                      * Note that this operation is only allowed
                                      * if no subscriptions to this object exist
-                                     * any more, such as #DoFHandler# objects
+                                     * any more, such as @p{DoFHandler} objects
                                      * using it.
                                      */
     void clear ();
@@ -1666,7 +1666,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                     /**                                        
                                      * Assign a boundary object to
                                      * the triangulation. If a face
-                                     * with boundary number #number#
+                                     * with boundary number @p{number}
                                      * is refined, this object is
                                      * used to find the location of
                                      * new vertices on the
@@ -1692,15 +1692,15 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * and are accessed with accessor
                                      * functions of that name.
                                      *
-                                     * The #boundary_object# is not
+                                     * The @p{boundary_object} is not
                                      * copied and MUST persist until
                                      * the triangulation is
                                      * destroyed. Otherwise, the
-                                     * #Subscriptor# class will issue
-                                     * #ExcObjectInUse#.  This is
+                                     * @p{Subscriptor} class will issue
+                                     * @p{ExcObjectInUse}.  This is
                                      * also true for triangulations
                                      * generated from this one by
-                                     * #copy_triangulation#.
+                                     * @p{copy_triangulation}.
                                      *
                                      * It is possible to remove or
                                      * replace the boundary object
@@ -1711,7 +1711,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * refinement and is dangerous
                                      * afterwards.  Removal of a
                                      * boundary object is done by
-                                     * #set_boundary(number)#, which
+                                     * @p{set_boundary(number)}, which
                                      * uses the default argument of this
                                      * function and replaces the boundary
                                      * approximation by a piecewise
@@ -1723,7 +1723,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                     /**
                                      * Return a constant reference to a boundary
                                      * object used for this triangulation.
-                                     * Number is the same as in #set_boundary#
+                                     * Number is the same as in @p{set_boundary}
                                      */
     const Boundary<dim> & get_boundary (unsigned int number) const;
     
@@ -1739,7 +1739,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  Keep in mind that this function also
                                      *  copies the pointer to the boundary
                                      *  descriptor previously set by the
-                                     *  #set_boundary# function. You must
+                                     *  @p{set_boundary} function. You must
                                      *  therefore also guarantee that the
                                      *  boundary objects has a lifetime at
                                      *  least as long as the copied
@@ -1749,7 +1749,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  beforehand.
                                      *
                                      *  The function is made
-                                     *  #virtual# since some derived
+                                     *  @p{virtual} since some derived
                                      *  classes might want to disable
                                      *  or extend the functionality
                                      *  of this function.
@@ -1759,23 +1759,23 @@ 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 #1<<dim#
+                                     * the latter being a list of @p{1<<dim}
                                      * vertex indices. The triangulation must
                                      * be empty upon calling this function and
                                      * the cell list should be useful (connected
                                      * domain, etc.).
                                      *
                                      * Material data for the cells is given
-                                     * within the #cells# array, while boundary
+                                     * within the @p{cells} array, while boundary
                                      * information is given in the
-                                     * #subcelldata# field.
+                                     * @p{subcelldata} field.
                                      *
                                      * The numbering of vertices within the
-                                     * #cells# array is subject to some
+                                     * @p{cells} array is subject to some
                                      * constraints; see the general class
                                      * documentation for this.
                                      *
-                                     * This function is made #virtual# to allow
+                                     * This function is made @p{virtual} to allow
                                      * derived classes to set up some data
                                      * structures as well.
                                      */
@@ -1788,13 +1788,13 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * around all the vertices of the grid.
                                      * The direction of moving is random,
                                      * while the length of the shift vector
-                                     * has a value of #factor# times the
+                                     * has a value of @p{factor} times the
                                      * minimal length of the active lines
                                      * adjacent to this vertex. Note that
-                                     * #factor# should obviously be well
-                                     * below #0.5#.
+                                     * @p{factor} should obviously be well
+                                     * below @p{0.5}.
                                      *
-                                     * If #keep_boundary# is set to #true#
+                                     * If @p{keep_boundary} is set to @p{true}
                                      * (which is the default), then boundary
                                      * vertices are not moved.
                                      */
@@ -1819,14 +1819,14 @@ class Triangulation : public TriaDimensionInfo<dim>,
     void set_all_refine_flags ();
 
                                     /**
-                                     *  Refine all cells #times# times, by
-                                     *  alternatingly calling #refine_global()#
-                                     *  and #execute_coarsening_and_refinement()#.
+                                     *  Refine all cells @p{times} times, by
+                                     *  alternatingly calling @p{refine_global()}
+                                     *  and @p{execute_coarsening_and_refinement()}.
                                      *  This function actually starts the
                                      *  refinement process, so you have no way
                                      *  to store the refinement flags unless
                                      *  you overload the
-                                     *  #execute_coarsening_and_refinement#
+                                     *  @p{execute_coarsening_and_refinement}
                                      *  function.
                                      */
     void refine_global (const unsigned int times);
@@ -1834,7 +1834,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                     /**
                                      * Refine the triangulation according to
                                      * the given criteria. The criterion is a
-                                     * #double# value for each cell which
+                                     * @p{double} value for each cell which
                                      * determines which cells are to be refined
                                      * by comparison with the threshold: if the
                                      * value for a cell is larger than the
@@ -1842,17 +1842,17 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * refinement. It is your duty to guarantee
                                      * that the threshold value is in a
                                      * resonable range. Please note that the
-                                     * #criteria# array may contain negative
+                                     * @p{criteria} array may contain negative
                                      * values (sometimes, error estimators
                                      * are evaluated in a way which produces
                                      * positive and negative values), but the
-                                     * comparison with #threshold# is done only
+                                     * comparison with @p{threshold} is done only
                                      * on the absolute values of the criteria.
                                      *
                                      * The cells are only flagged for
                                      * refinement, they are not actually
                                      * refined. To do so, you have to call the
-                                     * #execute_coarsening_and_refinement# function.
+                                     * @p{execute_coarsening_and_refinement} function.
                                      *
                                      * There are more sophisticated strategies
                                      * for mesh refinement; refer to the
@@ -1860,8 +1860,8 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * doc for this class for more information.
                                      *
                                      * Note that this function takes a vector
-                                     * of #float#s, rather than the usual
-                                     * #double#s, since accuracy is not so
+                                     * of @p{float}s, rather than the usual
+                                     * @p{double}s, since accuracy is not so
                                      * much needed here and saving memory may
                                      * be a good goal when using many cells.
                                      */
@@ -1870,15 +1870,15 @@ class Triangulation : public TriaDimensionInfo<dim>,
                 const double         threshold);
 
                                     /**
-                                     * Analogue to the #refine# function:
+                                     * Analogue to the @p{refine} function:
                                      * flag all cells for coarsening for
                                      * which the absolute value of the
                                      * criterion is less than the
                                      * given threshold.
                                      *
                                      * Note that this function takes a vector
-                                     * of #float#s, rather than the usual
-                                     * #double#s, since accuracy is not so
+                                     * of @p{float}s, rather than the usual
+                                     * @p{double}s, since accuracy is not so
                                      * much needed here and saving memory may
                                      * be a good goal when using many cells.
                                      */
@@ -1888,22 +1888,22 @@ class Triangulation : public TriaDimensionInfo<dim>,
     
                                     /**
                                      * Refine the triangulation by refining
-                                     * a certain fraction #top_fraction_of_cells#
+                                     * a certain fraction @p{top_fraction_of_cells}
                                      * with the highest error. Likewise coarsen
-                                     * the fraction #bottom_fraction_of_cells#
+                                     * the fraction @p{bottom_fraction_of_cells}
                                      * with the least error. To actually
                                      * perform the refinement, call
-                                     * #execute_coarsening_and_refinement#.
+                                     * @p{execute_coarsening_and_refinement}.
                                      *
-                                     * #fraction_of_cells# shall be a value
+                                     * @p{fraction_of_cells} shall be a value
                                      * between zero and one.
                                      *
                                      * Refer to the general doc of this class
                                      * for more information.
                                      *
                                      * Note that this function takes a vector
-                                     * of #float#s, rather than the usual
-                                     * #double#s, since accuracy is not so
+                                     * of @p{float}s, rather than the usual
+                                     * @p{double}s, since accuracy is not so
                                      * much needed here and saving memory may
                                      * be a good goal when using many cells.
                                      */
@@ -1915,21 +1915,21 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                     /**
                                      * Refine the triangulation by flagging
                                      * those cells which make up a certain
-                                     * #top_fraction# of the total error.
+                                     * @p{top_fraction} of the total error.
                                      * Likewise, coarsen all cells which
-                                     * make up only #bottom_fraction#.
+                                     * make up only @p{bottom_fraction}.
                                      * To actually perform the refinement, call
-                                     * #execute_coarsening_and_refinement#.
+                                     * @p{execute_coarsening_and_refinement}.
                                      *
-                                     * #*_fraction# shall be a values
+                                     * @p{*_fraction} shall be a values
                                      * between zero and one.
                                      *
                                      * Refer to the general doc of this class
                                      * for more information.
                                      *
                                      * Note that this function takes a vector
-                                     * of #float#s, rather than the usual
-                                     * #double#s, since accuracy is not so
+                                     * of @p{float}s, rather than the usual
+                                     * @p{double}s, since accuracy is not so
                                      * much needed here and saving memory may
                                      * be a good goal when using many cells.
                                      */
@@ -1950,7 +1950,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                       * See the general docs for more
                                       * information.
                                      *
-                                     * Note that this function is #virtual# to
+                                     * Note that this function is @p{virtual} to
                                      * allow derived classes to insert hooks,
                                      * such as saving refinement flags and the
                                      * like.
@@ -1962,7 +1962,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * coarsening as well as mesh smoothing.
                                      *
                                      * Regarding the refinement process it fixes
-                                     * the closure of the refinement in #dim>=2#
+                                     * the closure of the refinement in @p{dim>=2}
                                      * (make sure that no two cells are
                                      * adjacent with a refinement level
                                      * differing with more than one), etc.
@@ -1979,7 +1979,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * This part of the function is mostly
                                      * dimension independent. However, for some
                                      * dimension dependent things, it calls
-                                     * #prepare_refinement_dim_dependent#.
+                                     * @p{prepare_refinement_dim_dependent}.
                                      *
                                      * Regarding the coarsening part, flagging
                                      * and deflagging cells in preparation 
@@ -2015,7 +2015,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                     /*@{*/
                                     /**
                                      *  Save the addresses of the cells which
-                                     *  are flagged for refinement to #out#.
+                                     *  are flagged for refinement to @p{out}.
                                      *  For usage, read the general
                                      *  documentation for this class.
                                      */
@@ -2029,18 +2029,18 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Read the information stored by
-                                     *  #save_refine_flags#.
+                                     *  @p{save_refine_flags}.
                                      */
     void load_refine_flags (istream &in);
 
                                     /**
                                      *  Read the information stored by
-                                     *  #save_refine_flags#.
+                                     *  @p{save_refine_flags}.
                                      */
     void load_refine_flags (const vector<bool> &v);
 
                                     /**
-                                     * Analogue to #save_refine_flags#.
+                                     * Analogue to @p{save_refine_flags}.
                                      */
     void save_coarsen_flags (ostream &out) const;
 
@@ -2051,12 +2051,12 @@ class Triangulation : public TriaDimensionInfo<dim>,
     void save_coarsen_flags (vector<bool> &v) const;
 
                                     /**
-                                     * Analogue to #load_refine_flags#.
+                                     * Analogue to @p{load_refine_flags}.
                                      */
     void load_coarsen_flags (istream &out);
 
                                     /**
-                                     * Analogue to #load_refine_flags#.
+                                     * Analogue to @p{load_refine_flags}.
                                      */
     void load_coarsen_flags (const vector<bool> &v);
 
@@ -2081,7 +2081,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  Save all user flags. See the general
                                      *  documentation for this class
                                      *  and the documentation for the
-                                     *  #save_refine_flags# for more
+                                     *  @p{save_refine_flags} for more
                                      *  details.
                                      */
     void save_user_flags (ostream &out) const;
@@ -2096,13 +2096,13 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Read the information stored by
-                                     *  #save_user_flags#.
+                                     *  @p{save_user_flags}.
                                      */
     void load_user_flags (istream &in);
 
                                     /**
                                      *  Read the information stored by
-                                     *  #save_user_flags#.
+                                     *  @p{save_user_flags}.
                                      */
     void load_user_flags (const vector<bool> &v);
 
@@ -2184,30 +2184,30 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                     /*@{*/
                                     /**
                                      *  Iterator to the first cell, used
-                                     *  or not, on level #level#. If a level
+                                     *  or not, on level @p{level}. If a level
                                      *  has no cells, a past-the-end iterator
                                      *  is returned.
                                      *
-                                     *  This function calls #begin_raw_line#
-                                     *  in 1D and #begin_raw_quad# in 2D.
+                                     *  This function calls @p{begin_raw_line}
+                                     *  in 1D and @p{begin_raw_quad} in 2D.
                                      */
     raw_cell_iterator    begin_raw   (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first used cell
-                                     *  on level #level#.
+                                     *  on level @p{level}.
                                      *
-                                     *  This function calls #begin_line#
-                                     *  in 1D and #begin_quad# in 2D.
+                                     *  This function calls @p{begin_line}
+                                     *  in 1D and @p{begin_quad} in 2D.
                                      */
     cell_iterator        begin       (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first active
-                                     *  cell on level #level#.
+                                     *  cell on level @p{level}.
                                      *
-                                     *  This function calls #begin_active_line#
-                                     *  in 1D and #begin_active_quad# in 2D.
+                                     *  This function calls @p{begin_active_line}
+                                     *  in 1D and @p{begin_active_quad} in 2D.
                                      */
     active_cell_iterator begin_active(const unsigned int level = 0) const;
 
@@ -2217,32 +2217,32 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  iterators with past-the-end or
                                      *  before-the-beginning states.
                                      *
-                                     *  This function calls #end_line#
-                                     *  in 1D and #end_quad# in 2D.
+                                     *  This function calls @p{end_line}
+                                     *  in 1D and @p{end_quad} in 2D.
                                      */
     raw_cell_iterator    end () const;
 
                                     /**
                                      * Return an iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     cell_iterator        end (const unsigned int level) const;
     
                                     /**
                                      * Return a raw iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     raw_cell_iterator    end_raw (const unsigned int level) const;
 
                                     /**
                                      * Return an active iterator which is the
-                                     * first iterator not on level. If #level#
+                                     * first iterator not on level. If @p{level}
                                      * is the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     active_cell_iterator end_active (const unsigned int level) const;
 
@@ -2251,17 +2251,17 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  Return an iterator pointing to the
                                      *  last cell, used or not.
                                      *
-                                     *  This function calls #last_raw_line#
-                                     *  in 1D and #last_raw_quad# in 2D.
+                                     *  This function calls @p{last_raw_line}
+                                     *  in 1D and @p{last_raw_quad} in 2D.
                                      */
     raw_cell_iterator    last_raw () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  cell of the level #level#, used or not.
+                                     *  cell of the level @p{level}, used or not.
                                      *
-                                     *  This function calls #last_raw_line#
-                                     *  in 1D and #last_raw_quad# in 2D.
+                                     *  This function calls @p{last_raw_line}
+                                     *  in 1D and @p{last_raw_quad} in 2D.
                                      */
     raw_cell_iterator    last_raw (const unsigned int level) const;
 
@@ -2269,17 +2269,17 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  Return an iterator pointing to the last
                                      *  used cell.
                                      *
-                                     *  This function calls #last_line#
-                                     *  in 1D and #last_quad# in 2D.
+                                     *  This function calls @p{last_line}
+                                     *  in 1D and @p{last_quad} in 2D.
                                      */
     cell_iterator        last () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  used cell on level #level#.
+                                     *  used cell on level @p{level}.
                                      *
-                                     *  This function calls #last_line#
-                                     *  in 1D and #last_quad# in 2D.
+                                     *  This function calls @p{last_line}
+                                     *  in 1D and @p{last_quad} in 2D.
                                      */
     cell_iterator        last (const unsigned int level) const;
 
@@ -2287,17 +2287,17 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  Return an iterator pointing to the last
                                      *  active cell.
                                      *
-                                     *  This function calls #last_active_line#
-                                     *  in 1D and #last_active_quad# in 2D.
+                                     *  This function calls @p{last_active_line}
+                                     *  in 1D and @p{last_active_quad} in 2D.
                                      */
     active_cell_iterator last_active () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  active cell on level #level#.
+                                     *  active cell on level @p{level}.
                                      *
-                                     *  This function calls #last_active_line#
-                                     *  in 1D and #last_active_quad# in 2D.
+                                     *  This function calls @p{last_active_line}
+                                     *  in 1D and @p{last_active_quad} in 2D.
                                      */
     active_cell_iterator last_active (const unsigned int level) const;
                                     /*@}*/
@@ -2311,30 +2311,30 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                     /*@{*/
                                     /**
                                      *  Iterator to the first face, used
-                                     *  or not, on level #level#. If a level
+                                     *  or not, on level @p{level}. If a level
                                      *  has no faces, a past-the-end iterator
                                      *  is returned.
                                      *
-                                     *  This function calls #begin_raw_line#
-                                     *  in 2D and #begin_raw_quad# in 3D.
+                                     *  This function calls @p{begin_raw_line}
+                                     *  in 2D and @p{begin_raw_quad} in 3D.
                                      */
     raw_face_iterator    begin_raw_face   (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first used face
-                                     *  on level #level#.
+                                     *  on level @p{level}.
                                      *
-                                     *  This function calls #begin_line#
-                                     *  in 2D and #begin_quad# in 3D.
+                                     *  This function calls @p{begin_line}
+                                     *  in 2D and @p{begin_quad} in 3D.
                                      */
     face_iterator        begin_face       (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first active
-                                     *  face on level #level#.
+                                     *  face on level @p{level}.
                                      *
-                                     *  This function calls #begin_active_line#
-                                     *  in 2D and #begin_active_quad# in 3D.
+                                     *  This function calls @p{begin_active_line}
+                                     *  in 2D and @p{begin_active_quad} in 3D.
                                      */
     active_face_iterator begin_active_face(const unsigned int level = 0) const;
 
@@ -2344,32 +2344,32 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  iterators with past-the-end or
                                      *  before-the-beginning states.
                                      *
-                                     *  This function calls #end_line#
-                                     *  in 2D and #end_quad# in 3D.
+                                     *  This function calls @p{end_line}
+                                     *  in 2D and @p{end_quad} in 3D.
                                      */
     raw_face_iterator    end_face () const;
 
                                     /**
                                      * Return an iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     face_iterator        end_face (const unsigned int level) const;
     
                                     /**
                                      * Return a raw iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     raw_face_iterator    end_raw_face (const unsigned int level) const;
 
                                     /**
                                      * Return an active iterator which is the
-                                     * first iterator not on level. If #level#
+                                     * first iterator not on level. If @p{level}
                                      * is the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     active_face_iterator end_active_face (const unsigned int level) const;
 
@@ -2377,17 +2377,17 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  Return an iterator pointing to the
                                      *  last face, used or not.
                                      *
-                                     *  This function calls #last_raw_line#
-                                     *  in 2D and #last_raw_quad# in 3D.
+                                     *  This function calls @p{last_raw_line}
+                                     *  in 2D and @p{last_raw_quad} in 3D.
                                      */
     raw_face_iterator    last_raw_face () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  face of the level #level#, used or not.
+                                     *  face of the level @p{level}, used or not.
                                      *
-                                     *  This function calls #last_raw_line#
-                                     *  in 2D and #last_raw_quad# in 3D.
+                                     *  This function calls @p{last_raw_line}
+                                     *  in 2D and @p{last_raw_quad} in 3D.
                                      */
     raw_face_iterator    last_raw_face (const unsigned int level) const;
 
@@ -2395,17 +2395,17 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  Return an iterator pointing to the last
                                      *  used face.
                                      *
-                                     *  This function calls #last_line#
-                                     *  in 2D and #last_quad# in 3D.
+                                     *  This function calls @p{last_line}
+                                     *  in 2D and @p{last_quad} in 3D.
                                      */
     face_iterator        last_face () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  used face on level #level#.
+                                     *  used face on level @p{level}.
                                      *
-                                     *  This function calls #last_line#
-                                     *  in 2D and #last_quad# in 3D.
+                                     *  This function calls @p{last_line}
+                                     *  in 2D and @p{last_quad} in 3D.
                                      */
     face_iterator        last_face (const unsigned int level) const;
 
@@ -2413,17 +2413,17 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  Return an iterator pointing to the last
                                      *  active face.
                                      *
-                                     *  This function calls #last_active_line#
-                                     *  in 2D and #last_active_quad# in 3D.
+                                     *  This function calls @p{last_active_line}
+                                     *  in 2D and @p{last_active_quad} in 3D.
                                      */
     active_face_iterator last_active_face () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  active face on level #level#.
+                                     *  active face on level @p{level}.
                                      *
-                                     *  This function calls #last_active_line#
-                                     *  in 2D and #last_active_quad# in 3D.
+                                     *  This function calls @p{last_active_line}
+                                     *  in 2D and @p{last_active_quad} in 3D.
                                      */
     active_face_iterator last_active_face (const unsigned int level) const;
                                     /*@}*/
@@ -2437,7 +2437,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                     /*@{*/
                                     /**
                                      *  Iterator to the first line, used
-                                     *  or not, on level #level#. If a level
+                                     *  or not, on level @p{level}. If a level
                                      *  has no lines, a past-the-end iterator
                                      *  is returned.
                                      */
@@ -2446,14 +2446,14 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Iterator to the first used line
-                                     *  on level #level#.
+                                     *  on level @p{level}.
                                      */
     line_iterator
     begin_line       (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first active
-                                     *  line on level #level#.
+                                     *  line on level @p{level}.
                                      */
     active_line_iterator
     begin_active_line(const unsigned int level = 0) const;
@@ -2469,25 +2469,25 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      * Return an iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     line_iterator        end_line (const unsigned int level) const;
     
                                     /**
                                      * Return a raw iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     raw_line_iterator    end_raw_line (const unsigned int level) const;
 
                                     /**
                                      * Return an active iterator which is the
-                                     * first iterator not on level. If #level#
+                                     * first iterator not on level. If @p{level}
                                      * is the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     active_line_iterator end_active_line (const unsigned int level) const;
 
@@ -2500,7 +2500,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  line of the level #level#, used or not.
+                                     *  line of the level @p{level}, used or not.
 
                                      */
     raw_line_iterator
@@ -2515,7 +2515,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  used line on level #level#.
+                                     *  used line on level @p{level}.
                                      */
     line_iterator
     last_line (const unsigned int level) const;
@@ -2529,7 +2529,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  active line on level #level#.
+                                     *  active line on level @p{level}.
                                      */
     active_line_iterator
     last_active_line (const unsigned int level) const;
@@ -2543,7 +2543,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      */
                                     /**
                                      *  Iterator to the first quad, used
-                                     *  or not, on level #level#. If a level
+                                     *  or not, on level @p{level}. If a level
                                      *  has no quads, a past-the-end iterator
                                      *  is returned.
                                      */
@@ -2552,14 +2552,14 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Iterator to the first used quad
-                                     *  on level #level#.
+                                     *  on level @p{level}.
                                      */
     quad_iterator
     begin_quad       (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first active
-                                     *  quad on level #level#.
+                                     *  quad on level @p{level}.
                                      */
     active_quad_iterator
     begin_active_quad(const unsigned int level = 0) const;
@@ -2575,25 +2575,25 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      * Return an iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     quad_iterator        end_quad (const unsigned int level) const;
     
                                     /**
                                      * Return a raw iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     raw_quad_iterator    end_raw_quad (const unsigned int level) const;
 
                                     /**
                                      * Return an active iterator which is the
-                                     * first iterator not on level. If #level#
+                                     * first iterator not on level. If @p{level}
                                      * is the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     active_quad_iterator end_active_quad (const unsigned int level) const;
 
@@ -2606,7 +2606,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  quad of the level #level#, used or not.
+                                     *  quad of the level @p{level}, used or not.
 
                                      */
     raw_quad_iterator
@@ -2621,7 +2621,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  used quad on level #level#.
+                                     *  used quad on level @p{level}.
                                      */
     quad_iterator
     last_quad (const unsigned int level) const;
@@ -2635,7 +2635,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  active quad on level #level#.
+                                     *  active quad on level @p{level}.
                                      */
     active_quad_iterator
     last_active_quad (const unsigned int level) const;
@@ -2649,7 +2649,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      */
                                     /**
                                      *  Iterator to the first hex, used
-                                     *  or not, on level #level#. If a level
+                                     *  or not, on level @p{level}. If a level
                                      *  has no hexs, a past-the-end iterator
                                      *  is returned.
                                      */
@@ -2658,14 +2658,14 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Iterator to the first used hex
-                                     *  on level #level#.
+                                     *  on level @p{level}.
                                      */
     hex_iterator
     begin_hex       (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first active
-                                     *  hex on level #level#.
+                                     *  hex on level @p{level}.
                                      */
     active_hex_iterator
     begin_active_hex(const unsigned int level = 0) const;
@@ -2681,25 +2681,25 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      * Return an iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     hex_iterator        end_hex (const unsigned int level) const;
     
                                     /**
                                      * Return a raw iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     raw_hex_iterator    end_raw_hex (const unsigned int level) const;
 
                                     /**
                                      * Return an active iterator which is the
-                                     * first iterator not on level. If #level#
+                                     * first iterator not on level. If @p{level}
                                      * is the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     active_hex_iterator end_active_hex (const unsigned int level) const;
 
@@ -2712,7 +2712,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  hex of the level #level#, used or not.
+                                     *  hex of the level @p{level}, used or not.
 
                                      */
     raw_hex_iterator
@@ -2727,7 +2727,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  used hex on level #level#.
+                                     *  used hex on level @p{level}.
                                      */
     hex_iterator
     last_hex (const unsigned int level) const;
@@ -2741,7 +2741,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  active hex on level #level#.
+                                     *  active hex on level @p{level}.
                                      */
     active_hex_iterator
     last_active_hex (const unsigned int level) const;
@@ -2761,7 +2761,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
     
                                     /**
                                      *  Return total number of used lines,
-                                     *  active or not on level #level#.
+                                     *  active or not on level @p{level}.
                                      */
     unsigned int n_lines (const unsigned int level) const;
     
@@ -2772,7 +2772,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
     
                                     /**
                                      *  Return total number of active lines,
-                                     *  on level #level#.
+                                     *  on level @p{level}.
                                      */
     unsigned int n_active_lines (const unsigned int level) const;
     
@@ -2784,7 +2784,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Return total number of used quads,
-                                     *  active or not on level #level#.
+                                     *  active or not on level @p{level}.
                                      */
     unsigned int n_quads (const unsigned int level) const;
     
@@ -2796,7 +2796,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
     
                                     /**
                                      *  Return total number of active quads,
-                                     *  active or not on level #level#.
+                                     *  active or not on level @p{level}.
                                      */
     unsigned int n_active_quads (const unsigned int level) const;
     
@@ -2808,7 +2808,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Return total number of used hexahedra,
-                                     *  active or not on level #level#.
+                                     *  active or not on level @p{level}.
                                      */
     unsigned int n_hexs(const unsigned int level) const;
     
@@ -2820,37 +2820,37 @@ class Triangulation : public TriaDimensionInfo<dim>,
     
                                     /**
                                      *  Return total number of active hexahedra,
-                                     *  active or not on level #level#.
+                                     *  active or not on level @p{level}.
                                      */
     unsigned int n_active_hexs(const unsigned int level) const;
 
                                     /**
                                      *  Return total number of used cells,
                                      *  active or not.
-                                     *  Maps to #n_lines()# in one space
+                                     *  Maps to @p{n_lines()} in one space
                                      *  dimension and so on.
                                      */
     unsigned int n_cells () const;
 
                                     /**
                                      *  Return total number of used cells,
-                                     *  active or not, on level #level#.
-                                     *  Maps to #n_lines(level)# in one space
+                                     *  active or not, on level @p{level}.
+                                     *  Maps to @p{n_lines(level)} in one space
                                      *  dimension and so on.
                                      */
     unsigned int n_cells (const unsigned int level) const;
 
                                     /**
                                      *  Return total number of active cells.
-                                     *  Maps to #n_active_lines()# in one space
+                                     *  Maps to @p{n_active_lines()} in one space
                                      *  dimension and so on.
                                      */
     unsigned int n_active_cells () const;
 
                                     /**
                                      * Return total number of active cells
-                                     * on level #level#.
-                                     * Maps to #n_active_lines(level)# in one
+                                     * on level @p{level}.
+                                     * Maps to @p{n_active_lines(level)} in one
                                      * space dimension and so on.
                                      */
     unsigned int n_active_cells (const unsigned int level) const;
@@ -2876,7 +2876,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * renumber the remaining one, leading to
                                      * holes in the numbers of used vertices.
                                      * You can get the number of used vertices
-                                     * using #n_used_vertices# function.
+                                     * using @p{n_used_vertices} function.
                                      */
     unsigned int n_vertices () const;
     
@@ -3028,11 +3028,11 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      *  as ASCII text.
                                      *
                                      *  The flags are stored in a binary
-                                     *  format: for each #true#, a #1#
-                                     *  bit is stored, a #0# bit otherwise.
-                                     *  The bits are stored as #unsigned char#,
+                                     *  format: for each @p{true}, a @p{1}
+                                     *  bit is stored, a @p{0} bit otherwise.
+                                     *  The bits are stored as @p{unsigned char},
                                      *  thus avoiding endianess. They are
-                                     *  written to #out# in plain text, thus
+                                     *  written to @p{out} in plain text, thus
                                      *  amounting to 3.6 bits per active cell
                                      *  on the overage. Other information
                                      *  (magic numbers ans number of elements)
@@ -3047,7 +3047,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      * Re-read a vector of bools previously
-                                     * written by #write_bool_vector# and
+                                     * written by @p{write_bool_vector} and
                                      * compare with the magic numbers.
                                      */
     static void read_bool_vector (const unsigned int  magic_number1,
@@ -3077,7 +3077,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * it children, which is the
                                      * main step for the coarsening process.
                                      * This is the dimension dependent part
-                                     * of #execute_coarsening#.
+                                     * of @p{execute_coarsening}.
                                      */
     void delete_children (cell_iterator &cell);
 
@@ -3094,7 +3094,7 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                      * otherwise to steps of interpolation
                                      * would be necessary. This would make
                                      * the processes implemented in the
-                                     * #ConstraintMatrix# class much more
+                                     * @p{ConstraintMatrix} class much more
                                      * complex, since these two steps of
                                      * interpolation do not commute.
                                      */
@@ -3110,8 +3110,8 @@ class Triangulation : public TriaDimensionInfo<dim>,
                                     /**
                                      * Re-compute the number of lines, quads,
                                      * etc. This function is called by
-                                     * #execute_{coarsening,refinement}# and
-                                     * by #create_triangulation# after the
+                                     * @p{execute_{coarsening,refinement}} and
+                                     * by @p{create_triangulation} after the
                                      * grid was changed.
                                      *
                                      * This function simply delegates to the
@@ -3138,11 +3138,11 @@ class Triangulation : public TriaDimensionInfo<dim>,
 
                                     /**
                                      *  Array of pointers pointing to the
-                                     *  #TriangulationLevel<dim># objects
+                                     *  @p{TriangulationLevel<dim>} objects
                                      *  storing the data on the different
                                      *  levels.
                                      *
-                                     *  Usage is like #levels[3]->quads#.
+                                     *  Usage is like @p{levels[3]->quads}.
                                      */
     vector<TriangulationLevel<dim>*> levels;
 
index 7f1cefe083b943212e1da5831bd87b19779dd82d..2b4c559fec76c0a83d40f6478591309634ae2f88 100644 (file)
@@ -56,7 +56,7 @@ class TriaAccessor
                                      * iterator classes. Since the pure
                                      * triangulation iterators need no
                                      * additional data, this data type is
-                                     * #void#.
+                                     * @p{void}.
                                      */
     typedef void AccessorData;
 
@@ -88,10 +88,10 @@ class TriaAccessor
                                     /**
                                      *  Copy operator. This is normally
                                      *  used in a context like
-                                     *  #iterator a,b;  *a=*b;#. Since
+                                     *  @p{iterator a,b;  *a=*b;}. Since
                                      *  the meaning is to copy the object
-                                     *  pointed to by #b# to the object
-                                     *  pointed to by #a# and since
+                                     *  pointed to by @p{b} to the object
+                                     *  pointed to by @p{a} and since
                                      *  accessors are not real but
                                      *  virtual objects, this operation
                                      *  is not useful for iterators on
@@ -251,9 +251,9 @@ class TriaAccessor
 
 /**
  * Common template for line, quad, hex accessors.
- * According to #celldim# objects of this class represent lines,
- * quadrilaterals, or hexahedra in #dim# space dimensions. Concrete implementations
- * are done for specialized #celldim# template parameter. For easier access,
+ * According to @p{celldim} objects of this class represent lines,
+ * quadrilaterals, or hexahedra in @p{dim} space dimensions. Concrete implementations
+ * are done for specialized @p{celldim} template parameter. For easier access,
  * we nevertheless document all functions of the specialized classes here as
  * well. However, they are not implemented.
  *
@@ -282,18 +282,18 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
 
                                     /**
                                      *  Copy the data of a line. Only
-                                     * implemented for #celldim==1#.
+                                     * implemented for @p{celldim==1}.
                                      */
 
     void set (const Line&) const;
                                     /**
                                      *  Copy the data of the given quad. Only
-                                     * implemented for #celldim==2#.
+                                     * implemented for @p{celldim==2}.
                                      */
     void set (const Quad&) const;
                                     /**
                                      *  Copy the data of the given hex. Only
-                                     * implemented for #celldim==3#.
+                                     * implemented for @p{celldim==3}.
                                      */
     void set (const Hexahedron&) const;
     
@@ -301,58 +301,58 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                      *  Index of vertex. The convention regarding the
                                      *  numbering of vertices is laid down
                                      *  in the documentation of the
-                                     *  #Triangulation# class.
+                                     *  @p{Triangulation} class.
                                      */ 
     int vertex_index (const unsigned int i) const;
 
                                     /**
                                      *  Reference (not an iterator!)
-                                     *  to the #i#th vertex.
+                                     *  to the @p{i}th vertex.
                                      */
     Point<dim> & vertex (const unsigned int i) const;
 
                                     /**
-                                     *  Pointer to the #i#th line
+                                     *  Pointer to the @p{i}th line
                                      *  bounding this object.
                                      *
-                                     * Implemented only for #celldim>1#.
+                                     * Implemented only for @p{celldim>1}.
                                      */
     TriaIterator<dim,TriaObjectAccessor<1, dim> > line (const unsigned int i) const;
 
                                     /**
-                                     * Line index of the #i#th
+                                     * Line index of the @p{i}th
                                      * line. The level is naturally
                                      * the same as that of the object.
                                      *
-                                     * Implemented only for #celldim>1#.
+                                     * Implemented only for @p{celldim>1}.
                                      */
     unsigned int line_index (const unsigned int i) const;
     
                                     /**
-                                     *  Pointer to the #i#th quad
+                                     *  Pointer to the @p{i}th quad
                                      *  bounding this object.
                                      *
-                                     * Implemented only for #celldim>2#.
+                                     * Implemented only for @p{celldim>2}.
                                      */
     TriaIterator<dim,TriaObjectAccessor<2, dim> > quad (const unsigned int i) const;
 
                                     /**
-                                     * Quad index of the #i#th
+                                     * Quad index of the @p{i}th
                                      * quad. The level is naturally
                                      * the same as that of the object.
                                      *
-                                     * Implemented only for #celldim>2#.
+                                     * Implemented only for @p{celldim>2}.
                                      */
     unsigned int quad_index (const unsigned int i) const;
 
                                     /**
                                      *  Test for the element being
                                      *  used or not.  The return
-                                     *  value is #true# for all
+                                     *  value is @p{true} for all
                                      *  iterators that are either
                                      *  normal iterators or active
                                      *  iterators, only raw iterators
-                                     *  can return #false#. Since raw
+                                     *  can return @p{false}. Since raw
                                      *  iterators are only used in
                                      *  the interiors of the library,
                                      *  you will not usually need
@@ -361,7 +361,7 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
     bool used () const;
 
                                     /**
-                                     *  Set the #used# flag. You should know
+                                     *  Set the @p{used} flag. You should know
                                      *  quite exactly what you are doing of you
                                      *  touch this function. It is exclusively
                                      *  for internal use in the library.
@@ -369,7 +369,7 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
     void set_used_flag () const;
 
                                     /**
-                                     *  Clear the #used# flag. You should know
+                                     *  Clear the @p{used} flag. You should know
                                      *  quite exactly what you are doing of you
                                      *  touch this function. It is exclusively
                                      *  for internal use in the library.
@@ -405,13 +405,13 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
 
                                     /**
                                      * Set the user pointer
-                                     * to #p#.
+                                     * to @p{p}.
                                      */
     void set_user_pointer (void *p) const;
 
                                     /**
                                      * Reset the user pointer
-                                     * to a #NULL# pointer.
+                                     * to a @p{NULL} pointer.
                                      */
     void clear_user_pointer () const;
 
@@ -422,19 +422,19 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                      * something useful. You should use the
                                      * new style cast operator to maintain
                                      * a minimum of typesafety, e.g.
-                                     * #A *a=static_cast<A*>(cell->user_pointer());#.
+                                     * @p{A *a=static_cast<A*>(cell->user_pointer());}.
                                      */
     void * user_pointer () const;
 
                                     /**
-                                     *  Pointer to the #i#th
+                                     *  Pointer to the @p{i}th
                                      *  child.
                                      */
     TriaIterator<dim,TriaObjectAccessor<celldim,dim> >
     child (const unsigned int i) const;
 
                                     /**
-                                     *  Index of the #i#th child.
+                                     *  Index of the @p{i}th child.
                                      *  The level of the child is one higher
                                      *  than that of the present cell.
                                      *  If the child does not exist, -1
@@ -469,7 +469,7 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                      * Number of times that this
                                      * object is refined. Note that not all
                                      * its children are refined that often
-                                     * (which is why we prepend #max_#), 
+                                     * (which is why we prepend @p{max_}), 
                                      * the returned number is rather the
                                      * maximum number of refinement in
                                      * any branch of children of this object.
@@ -485,14 +485,14 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                      * Since boundary data is only useful
                                      * for structures with a dimension less
                                      * than the dimension of a cell, this
-                                     * function issues an error if #dim<4#.
+                                     * function issues an error if @p{dim<4}.
                                      */
     unsigned char boundary_indicator () const;
 
                                     /**
                                      * Set the boundary indicator.
                                      * The same applies as for the
-                                     * #boundary_indicator()# function.
+                                     * @p{boundary_indicator()} function.
                                      *
                                      * Caution: Never set the
                                      * boundary indicator to 255, unless
@@ -513,9 +513,9 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                      * is always 255 if the hex is in the
                                      * interior of the domain. Obviously,
                                      * the use of this function is only
-                                     * possible for #dim>celldim#;
-                                     * however, for #dim==celldim#, an object is
-                                     * a cell and the #CellAccessor# class
+                                     * possible for @p{dim>celldim};
+                                     * however, for @p{dim==celldim}, an object is
+                                     * a cell and the @p{CellAccessor} class
                                      * offers another possibility to
                                      * determine whether a cell is at the
                                      * boundary or not.
@@ -583,10 +583,10 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                     /**
                                      *  Copy operator. This is normally
                                      *  used in a context like
-                                     *  #iterator a,b;  *a=*b;#. Since
+                                     *  @p{iterator a,b;  *a=*b;}. Since
                                      *  the meaning is to copy the object
-                                     *  pointed to by #b# to the object
-                                     *  pointed to by #a# and since
+                                     *  pointed to by @p{b} to the object
+                                     *  pointed to by @p{a} and since
                                      *  accessors are not real but
                                      *  virtual objects, this operation
                                      *  is not useful for iterators on
@@ -619,7 +619,7 @@ class TriaObjectAccessor :  public TriaAccessor<dim>
                                      *  the previous element.
                                      *
                                      *  The previous element is previous on
-                                     *  this level if #index>0#. If the
+                                     *  this level if @p{index>0}. If the
                                      *  present element is the first on
                                      *  this level, the last on the
                                      *  previous level is accessed.
@@ -665,7 +665,7 @@ class TriaObjectAccessor<0, dim> : public TriaAccessor<dim>
 
 /**
  *   Accessor to dereference the data of lines. This accessor is used to
- *   point to lines in #dim# space dimensions. There is a derived class
+ *   point to lines in @p{dim} space dimensions. There is a derived class
  *   for lines in one space dimension, in which case a line is also a cell
  *   and thus has much more functionality than in other dimensions.
  *
@@ -696,25 +696,25 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
     void set (const Line &l) const;
 
                                     /**
-                                     *  Return the index of vertex #i=0,1#
+                                     *  Return the index of vertex @p{i=0,1}
                                      *  of a line.
                                      */ 
     int vertex_index (const unsigned int i) const;
 
                                     /**
                                      *  Return a reference (not an iterator!)
-                                     *  to the #i#th vertex.
+                                     *  to the @p{i}th vertex.
                                      */
     Point<dim> & vertex (const unsigned int i) const;
 
                                     /**
                                      *  Test for the element being
                                      *  used or not.  The return
-                                     *  value is #true# for all
+                                     *  value is @p{true} for all
                                      *  iterators that are either
                                      *  normal iterators or active
                                      *  iterators, only raw iterators
-                                     *  can return #false#. Since raw
+                                     *  can return @p{false}. Since raw
                                      *  iterators are only used in
                                      *  the interiors of the library,
                                      *  you will not usually need
@@ -723,13 +723,13 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
     bool used () const;
 
                                     /**
-                                     *  Set the #used# flag. Only for
+                                     *  Set the @p{used} flag. Only for
                                      *  internal use in the library.
                                      */
     void set_used_flag () const;
 
                                     /**
-                                     *  Clear the #used# flag. Only for
+                                     *  Clear the @p{used} flag. Only for
                                      *  internal use in the library.
                                      */
     void clear_used_flag () const;
@@ -766,13 +766,13 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
 
                                     /**
                                      * Set the user pointer of this line
-                                     * to #p#.
+                                     * to @p{p}.
                                      */
     void set_user_pointer (void *p) const;
 
                                     /**
                                      * Reset the user pointer of this line
-                                     * to a #NULL# pointer.
+                                     * to a @p{NULL} pointer.
                                      */
     void clear_user_pointer () const;
 
@@ -784,19 +784,19 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
                                      * something useful. You should use the
                                      * new style cast operator to maintain
                                      * a minimum of typesafety, e.g.
-                                     * #A *a=static_cast<A*>(cell->user_pointer());#.
+                                     * @p{A *a=static_cast<A*>(cell->user_pointer());}.
                                      */
     void * user_pointer () const;
     
                                     /**
-                                     *  Return a pointer to the #i#th
+                                     *  Return a pointer to the @p{i}th
                                      *  child.
                                      */
     TriaIterator<dim,TriaObjectAccessor<1, dim> >
     child (const unsigned int i) const;
 
                                     /**
-                                     *  Return the index of the #i#th child.
+                                     *  Return the index of the @p{i}th child.
                                      *  The level of the child is one higher
                                      *  than that of the present cell.
                                      *  If the child does not exist, -1
@@ -831,7 +831,7 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
                                      * Return the number of times that this
                                      * cell is refined. Note that not all
                                      * its children are refined that often
-                                     * (which is why we prepend #max_#), 
+                                     * (which is why we prepend @p{max_}), 
                                      * the returned number is rather the
                                      * maximum number of refinement in
                                      * any branch of children of this object.
@@ -843,7 +843,7 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
                                      * line. Since boundary data is only useful
                                      * for structures with a dimension less
                                      * than the dimension of a cell, this
-                                     * function issues an error if #dim<2#.
+                                     * function issues an error if @p{dim<2}.
                                      *
                                      * If the return value is 255, then this
                                      * line is in the interior of the domain.
@@ -853,7 +853,7 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
                                     /**
                                      * Set the boundary indicator of this line.
                                      * The same applies as for the
-                                     * #boundary_indicator()# function.
+                                     * @p{boundary_indicator()} function.
                                      *
                                      * You should be careful with this function
                                      * and especially never try to set the
@@ -874,9 +874,9 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
                                      * the boundary indicator field, which
                                      * is always 255 if the line is in the
                                      * interior of the domain. Obviously,
-                                     * this is only possible for #dim>1#;
-                                     * however, for #dim==1#, a line is
-                                     * a cell and the #CellAccessor# class
+                                     * this is only possible for @p{dim>1};
+                                     * however, for @p{dim==1}, a line is
+                                     * a cell and the @p{CellAccessor} class
                                      * offers another possibility to
                                      * determine whether a cell is at the
                                      * boundary or not.
@@ -911,7 +911,7 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
                                     /**
                                      * Return the barycenter of the line,
                                      * which is the midpoint. The same
-                                     * applies as for the #center# function
+                                     * applies as for the @p{center} function
                                      * with regard to lines at the boundary.
                                      */
     Point<dim> barycenter () const;
@@ -919,7 +919,7 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
                                     /**
                                      * Return the length of the line.
                                      * The same
-                                     * applies as for the #center# function
+                                     * applies as for the @p{center} function
                                      * with regard to lines at the boundary.
                                      */
     double measure () const;
@@ -944,10 +944,10 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
                                     /**
                                      *  Copy operator. This is normally
                                      *  used in a context like
-                                     *  #iterator a,b;  *a=*b;#. Since
+                                     *  @p{iterator a,b;  *a=*b;}. Since
                                      *  the meaning is to copy the object
-                                     *  pointed to by #b# to the object
-                                     *  pointed to by #a# and since
+                                     *  pointed to by @p{b} to the object
+                                     *  pointed to by @p{a} and since
                                      *  accessors are not real but
                                      *  virtual objects, this operation
                                      *  is not useful for iterators on
@@ -982,7 +982,7 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
                                      *  the previous element.
                                      *
                                      *  The previous element is previous on
-                                     *  this level if #index>0#. If the
+                                     *  this level if @p{index>0}. If the
                                      *  present element is the first on
                                      *  this level, the last on the
                                      *  previous level is accessed.
@@ -999,7 +999,7 @@ class TriaObjectAccessor<1, dim> :  public TriaAccessor<dim>
 
 /**
  *   Accessor to dereference the data of quads. This accessor is used to
- *   point to quads in #dim# space dimensions (only #dim>=2# seems reasonable
+ *   point to quads in @p{dim} space dimensions (only @p{dim>=2} seems reasonable
  *   to me). There is a derived class
  *   for quads in two space dimension, in which case a quad is also a cell
  *   and thus has much more functionality than in other dimensions.
@@ -1031,9 +1031,9 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
     void set (const Quad &q) const;
     
                                     /**
-                                     *  Return index of vertex #i=0 through 3# of
-                                     *  a quad. The #i#th vertex is the common
-                                     *  one of line #i# and #(i+3)%4#. See also
+                                     *  Return index of vertex @p{i=0 through 3} of
+                                     *  a quad. The @p{i}th vertex is the common
+                                     *  one of line @p{i} and @p{(i+3)%4}. See also
                                      *  the introduced convention
                                      *  (\Ref{Triangulation}).
                                      */ 
@@ -1041,19 +1041,19 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
 
                                     /**
                                      *  Return a reference (not an iterator!)
-                                     *  to the #i#th vertex.
+                                     *  to the @p{i}th vertex.
                                      */
     Point<dim> & vertex (const unsigned int i) const;
 
                                     /**
-                                     *  Return a pointer to the #i#th line
-                                     *  bounding this #Quad#.
+                                     *  Return a pointer to the @p{i}th line
+                                     *  bounding this @p{Quad}.
                                      */
     TriaIterator<dim,TriaObjectAccessor<1, dim> >
     line (const unsigned int i) const;
 
                                     /**
-                                     * Return the line index of the #i#th
+                                     * Return the line index of the @p{i}th
                                      * side (a line). The level is naturally
                                      * the same as that of the quad.
                                      */
@@ -1062,11 +1062,11 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
                                     /**
                                      *  Test for the element being
                                      *  used or not.  The return
-                                     *  value is #true# for all
+                                     *  value is @p{true} for all
                                      *  iterators that are either
                                      *  normal iterators or active
                                      *  iterators, only raw iterators
-                                     *  can return #false#. Since raw
+                                     *  can return @p{false}. Since raw
                                      *  iterators are only used in
                                      *  the interiors of the library,
                                      *  you will not usually need
@@ -1075,7 +1075,7 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
     bool used () const;
 
                                     /**
-                                     *  Set the #used# flag. You should know
+                                     *  Set the @p{used} flag. You should know
                                      *  quite exactly what you are doing of you
                                      *  touch this function. It is exclusively
                                      *  for internal use in the library.
@@ -1083,7 +1083,7 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
     void set_used_flag () const;
 
                                     /**
-                                     *  Clear the #used# flag. You should know
+                                     *  Clear the @p{used} flag. You should know
                                      *  quite exactly what you are doing of you
                                      *  touch this function. It is exclusively
                                      *  for internal use in the library.
@@ -1122,13 +1122,13 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
 
                                     /**
                                      * Set the user pointer of this quad
-                                     * to #p#.
+                                     * to @p{p}.
                                      */
     void set_user_pointer (void *p) const;
 
                                     /**
                                      * Reset the user pointer of this quad
-                                     * to a #NULL# pointer.
+                                     * to a @p{NULL} pointer.
                                      */
     void clear_user_pointer () const;
 
@@ -1140,18 +1140,18 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
                                      * something useful. You should use the
                                      * new style cast operator to maintain
                                      * a minimum of typesafety, e.g.
-                                     * #A *a=static_cast<A*>(cell->user_pointer());#.
+                                     * @p{A *a=static_cast<A*>(cell->user_pointer());}.
                                      */
     void * user_pointer () const;
 
                                     /**
-                                     *  Return a pointer to the #i#th
+                                     *  Return a pointer to the @p{i}th
                                      *  child.
                                      */
     TriaIterator<dim,TriaObjectAccessor<2, dim> > child (const unsigned int i) const;
 
                                     /**
-                                     *  Return the index of the #i#th child.
+                                     *  Return the index of the @p{i}th child.
                                      *  The level of the child is one higher
                                      *  than that of the present cell.
                                      *  If the child does not exist, -1
@@ -1186,7 +1186,7 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
                                      * Return the number of times that this
                                      * cell is refined. Note that not all
                                      * its children are refined that often
-                                     * (which is why we prepend #max_#), 
+                                     * (which is why we prepend @p{max_}), 
                                      * the returned number is rather the
                                      * maximum number of refinement in
                                      * any branch of children of this object.
@@ -1198,7 +1198,7 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
                                      * quad. Since boundary data is only useful
                                      * for structures with a dimension less
                                      * than the dimension of a cell, this
-                                     * function issues an error if #dim<3#.
+                                     * function issues an error if @p{dim<3}.
                                      *
                                      * If the return value is 255, then this
                                      * quad is in the interior of the domain.
@@ -1208,7 +1208,7 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
                                     /**
                                      * Set the boundary indicator of this quad.
                                      * The same applies as for the
-                                     * #boundary_indicator()# function.
+                                     * @p{boundary_indicator()} function.
                                      *
                                      * You should be careful with this function
                                      * and especially never try to set the
@@ -1229,9 +1229,9 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
                                      * the boundary indicator field, which
                                      * is always 255 if the quad is in the
                                      * interior of the domain. Obviously,
-                                     * this function is only useful for #dim>2#;
-                                     * however, for #dim==2#, a quad is
-                                     * a cell and the #CellAccessor# class
+                                     * this function is only useful for @p{dim>2};
+                                     * however, for @p{dim==2}, a quad is
+                                     * a cell and the @p{CellAccessor} class
                                      * offers another possibility to
                                      * determine whether a cell is at the
                                      * boundary or not.
@@ -1280,7 +1280,7 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
 
                                     /**
                                      * Return the barycenter of the qaud. The
-                                     * same applies as for the #center# function
+                                     * same applies as for the @p{center} function
                                      * with regard to quads at the boundary.
                                      */
     Point<dim> barycenter () const;
@@ -1318,10 +1318,10 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
                                     /**
                                      *  Copy operator. This is normally
                                      *  used in a context like
-                                     *  #iterator a,b;  *a=*b;#. Since
+                                     *  @p{iterator a,b;  *a=*b;}. Since
                                      *  the meaning is to copy the object
-                                     *  pointed to by #b# to the object
-                                     *  pointed to by #a# and since
+                                     *  pointed to by @p{b} to the object
+                                     *  pointed to by @p{a} and since
                                      *  accessors are not real but
                                      *  virtual objects, this operation
                                      *  is not useful for iterators on
@@ -1354,7 +1354,7 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
                                      *  the previous element.
                                      *
                                      *  The previous element is previous on
-                                     *  this level if #index>0#. If the
+                                     *  this level if @p{index>0}. If the
                                      *  present element is the first on
                                      *  this level, the last on the
                                      *  previous level is accessed.
@@ -1371,7 +1371,7 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
 
 /**
  *   Accessor to dereference the data of hexahedra. This accessor is used to
- *   point to hexs in #dim# space dimensions (only #dim>=3# seems reasonable
+ *   point to hexs in @p{dim} space dimensions (only @p{dim>=3} seems reasonable
  *   to me). There is a derived class
  *   for hexs in three space dimension, in which case a hex is also a cell
  *   and thus has much more functionality than in other dimensions.
@@ -1403,43 +1403,43 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
     void set (const Hexahedron &h) const;
     
                                     /**
-                                     *  Return index of vertex #i=0 through 7# of
+                                     *  Return index of vertex @p{i=0 through 7} of
                                      *  a hex. The convention regarding the
                                      *  numbering of vertices is laid down
                                      *  in the documentation of the
-                                     *  #Triangulation# class.
+                                     *  @p{Triangulation} class.
                                      */ 
     int vertex_index (const unsigned int i) const;
 
                                     /**
                                      *  Return a reference (not an iterator!)
-                                     *  to the #i#th vertex.
+                                     *  to the @p{i}th vertex.
                                      */
     Point<dim> & vertex (const unsigned int i) const;
 
                                     /**
-                                     *  Return a pointer to the #i#th line
-                                     *  bounding this #Hex#.
+                                     *  Return a pointer to the @p{i}th line
+                                     *  bounding this @p{Hex}.
                                      */
     TriaIterator<dim,TriaObjectAccessor<1, dim> >
     line (const unsigned int i) const;
 
                                     /**
-                                     * Return the line index of the #i#th
+                                     * Return the line index of the @p{i}th
                                      * line. The level is naturally
                                      * the same as that of the hex.
                                      */
     unsigned int line_index (const unsigned int i) const;
     
                                     /**
-                                     *  Return a pointer to the #i#th quad
-                                     *  bounding this #Hex#.
+                                     *  Return a pointer to the @p{i}th quad
+                                     *  bounding this @p{Hex}.
                                      */
     TriaIterator<dim,TriaObjectAccessor<2, dim> >
     quad (const unsigned int i) const;
 
                                     /**
-                                     * Return the quad index of the #i#th
+                                     * Return the quad index of the @p{i}th
                                      * side (a quad). The level is naturally
                                      * the same as that of the hex.
                                      */
@@ -1448,11 +1448,11 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
                                     /**
                                      *  Test for the element being
                                      *  used or not.  The return
-                                     *  value is #true# for all
+                                     *  value is @p{true} for all
                                      *  iterators that are either
                                      *  normal iterators or active
                                      *  iterators, only raw iterators
-                                     *  can return #false#. Since raw
+                                     *  can return @p{false}. Since raw
                                      *  iterators are only used in
                                      *  the interiors of the library,
                                      *  you will not usually need
@@ -1461,7 +1461,7 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
     bool used () const;
 
                                     /**
-                                     *  Set the #used# flag. You should know
+                                     *  Set the @p{used} flag. You should know
                                      *  quite exactly what you are doing of you
                                      *  touch this function. It is exclusively
                                      *  for internal use in the library.
@@ -1469,7 +1469,7 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
     void set_used_flag () const;
 
                                     /**
-                                     *  Clear the #used# flag. You should know
+                                     *  Clear the @p{used} flag. You should know
                                      *  quite exactly what you are doing of you
                                      *  touch this function. It is exclusively
                                      *  for internal use in the library.
@@ -1508,13 +1508,13 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
 
                                     /**
                                      * Set the user pointer of this hex
-                                     * to #p#.
+                                     * to @p{p}.
                                      */
     void set_user_pointer (void *p) const;
 
                                     /**
                                      * Reset the user pointer of this hex
-                                     * to a #NULL# pointer.
+                                     * to a @p{NULL} pointer.
                                      */
     void clear_user_pointer () const;
 
@@ -1526,19 +1526,19 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
                                      * something useful. You should use the
                                      * new style cast operator to maintain
                                      * a minimum of typesafety, e.g.
-                                     * #A *a=static_cast<A*>(cell->user_pointer());#.
+                                     * @p{A *a=static_cast<A*>(cell->user_pointer());}.
                                      */
     void * user_pointer () const;
 
                                     /**
-                                     *  Return a pointer to the #i#th
+                                     *  Return a pointer to the @p{i}th
                                      *  child.
                                      */
     TriaIterator<dim,TriaObjectAccessor<3, dim> >
     child (const unsigned int i) const;
 
                                     /**
-                                     *  Return the index of the #i#th child.
+                                     *  Return the index of the @p{i}th child.
                                      *  The level of the child is one higher
                                      *  than that of the present cell.
                                      *  If the child does not exist, -1
@@ -1573,7 +1573,7 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
                                      * Return the number of times that this
                                      * cell is refined. Note that not all
                                      * its children are refined that often
-                                     * (which is why we prepend #max_#), 
+                                     * (which is why we prepend @p{max_}), 
                                      * the returned number is rather the
                                      * maximum number of refinement in
                                      * any branch of children of this object.
@@ -1585,7 +1585,7 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
                                      * hex. Since boundary data is only useful
                                      * for structures with a dimension less
                                      * than the dimension of a cell, this
-                                     * function issues an error if #dim<4#.
+                                     * function issues an error if @p{dim<4}.
                                      *
                                      * If the return value is 255, then this
                                      * line is in the interior of the domain.
@@ -1595,7 +1595,7 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
                                     /**
                                      * Set the boundary indicator of this hex.
                                      * The same applies as for the
-                                     * #boundary_indicator()# function.
+                                     * @p{boundary_indicator()} function.
                                      *
                                      * You should be careful with this function
                                      * and especially never try to set the
@@ -1617,9 +1617,9 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
                                      * is always 255 if the hex is in the
                                      * interior of the domain. Obviously,
                                      * the use of this function is only
-                                     * possible for #dim>3#;
-                                     * however, for #dim==3#, a hex is
-                                     * a cell and the #CellAccessor# class
+                                     * possible for @p{dim>3};
+                                     * however, for @p{dim==3}, a hex is
+                                     * a cell and the @p{CellAccessor} class
                                      * offers another possibility to
                                      * determine whether a cell is at the
                                      * boundary or not.
@@ -1694,10 +1694,10 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
                                     /**
                                      *  Copy operator. This is normally
                                      *  used in a context like
-                                     *  #iterator a,b;  *a=*b;#. Since
+                                     *  @p{iterator a,b;  *a=*b;}. Since
                                      *  the meaning is to copy the object
-                                     *  pointed to by #b# to the object
-                                     *  pointed to by #a# and since
+                                     *  pointed to by @p{b} to the object
+                                     *  pointed to by @p{a} and since
                                      *  accessors are not real but
                                      *  virtual objects, this operation
                                      *  is not useful for iterators on
@@ -1730,7 +1730,7 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
                                      *  the previous element.
                                      *
                                      *  The previous element is previous on
-                                     *  this level if #index>0#. If the
+                                     *  this level if @p{index>0}. If the
                                      *  present element is the first on
                                      *  this level, the last on the
                                      *  previous level is accessed.
@@ -1779,7 +1779,7 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
                    TriaObjectAccessor<dim,dim> (parent, level, index, local_data) {};
 
                                     /**
-                                     *  Return a pointer to the #i#th
+                                     *  Return a pointer to the @p{i}th
                                      *  neighbor.
                                      *  If the neighbor does not exist, an
                                      *  invalid iterator is returned.
@@ -1788,22 +1788,22 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
     neighbor (const unsigned int i) const;
 
                                     /**
-                                     *  Return the index of the #i#th neighbor.
+                                     *  Return the index of the @p{i}th neighbor.
                                      *  If the neighbor does not exist, its
                                      *  index is -1.
                                      */
     int neighbor_index (const unsigned int i) const;
 
                                     /**
-                                     *  Return the level of the #i#th neighbor.
+                                     *  Return the level of the @p{i}th neighbor.
                                      *  If the neighbor does not exist, its
                                      *  level is -1.
                                      */
     int neighbor_level (const unsigned int i) const;
 
                                     /**
-                                     *  Set the neighbor #i# of this cell
-                                     *  to the cell pointed to by #pointer#.
+                                     *  Set the neighbor @p{i} of this cell
+                                     *  to the cell pointed to by @p{pointer}.
                                      *  This line must be used.
                                      */
     void set_neighbor (const unsigned int i,
@@ -1812,10 +1812,10 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
                                     /**
                                      * Return the how-many'th
                                      * neighbor this cell is of
-                                     * #cell->neighbor(neighbor)#,
-                                     * i.e. return the number #n#
+                                     * @p{cell->neighbor(neighbor)},
+                                     * i.e. return the number @p{n}
                                      * such that
-                                     * #cell->neighbor(neighbor)->neighbor(n)==cell#. This
+                                     * @p{cell->neighbor(neighbor)->neighbor(n)==cell}. This
                                      * function is the right one if
                                      * you want to know how to get
                                      * back from a neighbor to the
@@ -1825,9 +1825,9 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
                                      * only useful if the neighbor is
                                      * not on a coarser level than
                                      * the present cell
-                                     * (i.e. #cell->neighbor(neighbor)->level()#
+                                     * (i.e. @p{cell->neighbor(neighbor)->level()}
                                      * needs to be equal to
-                                     * #cell->level()#, since
+                                     * @p{cell->level()}, since
                                      * otherwise the neighbors of the
                                      * neighbor cell are on a coarser
                                      * level than the present one and
@@ -1837,10 +1837,10 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
     unsigned int neighbor_of_neighbor (const unsigned int neighbor) const;
     
                                     /**
-                                     *  Return whether the #i#th vertex or
+                                     *  Return whether the @p{i}th vertex or
                                      *  face (depending on the dimension) is
                                      *  part of the boundary. This is true, if
-                                     *  the #i#th neighbor does not exist.
+                                     *  the @p{i}th neighbor does not exist.
                                      */
     bool at_boundary (const unsigned int i) const;
 
@@ -1888,7 +1888,7 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
     void clear_coarsen_flag () const;
 
                                     /**
-                                     *  Return a pointer to the #i#th
+                                     *  Return a pointer to the @p{i}th
                                      *  child. Overloaded version which returns
                                      *  a more reasonable iterator class.
                                      */
@@ -1896,7 +1896,7 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
     child (const unsigned int i) const;
 
                                     /**
-                                     * Return an iterator to the #i#th face
+                                     * Return an iterator to the @p{i}th face
                                      * of this cell.
                                      *
                                      * This function is not implemented in 1D,
@@ -1938,10 +1938,10 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
                                     /**
                                      *  Copy operator. This is normally
                                      *  used in a context like
-                                     *  #iterator a,b;  *a=*b;#. Since
+                                     *  @p{iterator a,b;  *a=*b;}. Since
                                      *  the meaning is to copy the object
-                                     *  pointed to by #b# to the object
-                                     *  pointed to by #a# and since
+                                     *  pointed to by @p{b} to the object
+                                     *  pointed to by @p{a} and since
                                      *  accessors are not real but
                                      *  virtual objects, this operation
                                      *  is not useful for iterators on
index 51e5e35e362b9702f654b4d8a4a59c9796b008ef..205f7521bfcfeb478843fa001bac1168a8d5ef89 100644 (file)
@@ -956,7 +956,7 @@ CellAccessor<dim>::refine_flag_set () const
 {
   Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
                                   // cells flagged for refinement must be active
-                                  // (the #set_refine_flag# function checks this,
+                                  // (the @p{set_refine_flag} function checks this,
                                   // but activity may change when refinement is
                                   // executed and for some reason the refine
                                   // flag is not cleared).
@@ -999,7 +999,7 @@ CellAccessor<dim>::coarsen_flag_set () const
 {
   Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
                                   // cells flagged for coarsening must be active
-                                  // (the #set_refine_flag# function checks this,
+                                  // (the @p{set_refine_flag} function checks this,
                                   // but activity may change when refinement is
                                   // executed and for some reason the refine
                                   // flag is not cleared).
index dd6cd2681207ef373b6e623dd4e10f744f1caf62..907f8f47e7cb86d6f5bb5b5f095647aecaad643b 100644 (file)
@@ -32,7 +32,7 @@ template <int dim> class Triangulation;
  *     Point<2> new_vertex = boundary.get_new_point_on_line (line);
  *     ...
  *   \end{verbatim}
- *   #line# denotes the line at the boundary that shall be refined
+ *   @p{line} denotes the line at the boundary that shall be refined
  *   and for which we seek the common point of the two child lines.
  *
  *   In 3D, a new vertex may be placed on the middle of a line or on
@@ -62,9 +62,9 @@ template <int dim> class Triangulation;
  *   about boundary indicators and the like, as well as all other information
  *   provided by these objects.
  *
- *   There are specialisations, #StraightBoundary<dim>#, which places
+ *   There are specialisations, @p{StraightBoundary<dim>}, which places
  *   the new point right into the middle of the given points, and
- *   #HyperBallBoundary<dim># creating a hyperball with given radius
+ *   @p{HyperBallBoundary<dim>} creating a hyperball with given radius
  *   around a given center point.
  *
  *   @author Wolfgang Bangerth, 1999
@@ -101,11 +101,11 @@ class Boundary : public Subscriptor {
                                      * not be called for lower dimensions.
                                      *
                                      * This function is called after the
-                                     * four lines bounding the given #quad#
+                                     * four lines bounding the given @p{quad}
                                      * are refined, so you may want to use
                                      * the information provided by
-                                     * #quad->line(i)->child(j)#, #i=0...3#,
-                                     * #j=0,1#.
+                                     * @p{quad->line(i)->child(j)}, @p{i=0...3},
+                                     * @p{j=0,1}.
                                      *
                                      * Because in 2D, this function is not
                                      * needed, it is not made pure virtual,
index b91976235052017b2ffc6fc37794a67f67a1830d..4a079c524616227fadee64bc7fb62945696a7f24 100644 (file)
@@ -26,9 +26,9 @@
  *   The center of the ball and its radius may be given upon construction of
  *   an object of this type. They default to the origin and a radius of 1.0.
  *
- *   This class is derived from #StraightBoundary# rather than from
- *   #Boundary#, which would seem natural, since this way we can use the
- *   #StraightBoundary<dim>::in_between(neighbors)# function.
+ *   This class is derived from @p{StraightBoundary} rather than from
+ *   @p{Boundary}, which would seem natural, since this way we can use the
+ *   @p{StraightBoundary<dim>::in_between(neighbors)} function.
  *
  * @author Wolfgang Bangerth, 1998
  */
@@ -81,7 +81,7 @@ class HyperBallBoundary : public StraightBoundary<dim> {
 
 
 /**
- * Variant of #HyperBallBoundary# which denotes a half hyper ball
+ * Variant of @p{HyperBallBoundary} which denotes a half hyper ball
  * where the first coordinate is restricted to the range $x>=0$ (or
  * $x>=center(0)$). In two dimensions, this equals the right half
  * circle, in three space dimensions it is a half ball.
@@ -98,7 +98,7 @@ class HalfHyperBallBoundary : public HyperBallBoundary<dim> {
                           const double     radius = 1.0);
 
                                     /**
-                                     * Check if on the line #x==0#,
+                                     * Check if on the line @p{x==0},
                                      * otherwise pass to the base
                                      * class.
                                      */
@@ -106,7 +106,7 @@ class HalfHyperBallBoundary : public HyperBallBoundary<dim> {
     get_new_point_on_line (const typename Triangulation<dim>::line_iterator &line) const;
 
                                     /**
-                                     * Check if on the line #x==0#,
+                                     * Check if on the line @p{x==0},
                                      * otherwise pass to the base
                                      * class.
                                      */
index 386936591eaaf8d39034dbde5e05d3133db5a8e4..71011ae33459c9b44fa3c8b83fbe425925223e8f 100644 (file)
 #include <base/exceptions.h>
 
 /**
- *   #Hexahedron#s denote the fundamental entities of triangulations in three
+ *   @p{Hexahedron}s denote the fundamental entities of triangulations in three
  *   dimensions. They are
  *   characterized by the (global) indices of the six bounding quadrilaterals.
  *
  *   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 implicitely given by the position
- *   in the #hexes.hexes# list attached to the information of each level
+ *   in the @p{hexes.hexes} list attached to the information of each level
  *   of the triangulation.
  *
  *   For conventions on the numbering of faces, lines and vertices within a
- *   hexahedron, refer to the documentation of the #Triangulation# class.
+ *   hexahedron, refer to the documentation of the @p{Triangulation} class.
  *
  *   @author Wolfgang Bangerth, 1998
  */
@@ -37,7 +37,7 @@ class Hexahedron {
 
                                     /**
                                      *  Construct a Hex with quad
-                                     *  indices #i0# through #i5#. By default,
+                                     *  indices @p{i0} through @p{i5}. By default,
                                      *  indices are set to -1, i.e. an
                                      *  invalid value.
                                      *
@@ -52,14 +52,14 @@ class Hexahedron {
                const int i5 = -1);
     
                                     /**
-                                     *  Return the index of quad #i#=0
+                                     *  Return the index of quad @p{i}=0
                                      *  through 5.
                                      */
     int quad (const int i) const;
     
                                     /**
-                                     *  Set the index of the #i#th quad to
-                                     *  #index#. #i#=0 through 5.
+                                     *  Set the index of the @p{i}th quad to
+                                     *  @p{index}. @p{i}=0 through 5.
                                      */
     void set_quad (const int i, const int index);
     
index c28a6feece251065e63ca8fd8e6946c422b3c947..9a4a48ee9a96b376115b47041070c23ac8d31e75 100644 (file)
@@ -37,15 +37,15 @@ template <int dim> class Triangulation;
  *   template library (STL). It fulfills the requirements of a bidirectional iterator.
  *   See the C++ documentation for further details of iterator specification and
  *   usage. In addition to the STL
- *   iterators an iterator of this class provides a #-># operator, i.e. you can
- *   write statements like #i->set_refine_flag ();#.
+ *   iterators an iterator of this class provides a @p{->} operator, i.e. you can
+ *   write statements like @p{i->set_refine_flag ();}.
  *   
  *   {\bf Note:} Please read the documentation about the prefix and the
- *   postfix #++# operators in this and the derived classes!
+ *   postfix @p{++} operators in this and the derived classes!
  *   
- *   \subsection{Purpose}
+ *   @sect3{Purpose}
  *
- *   #iterators# are used whenever a loop over all lines, quads, cells etc.
+ *   @p{iterators} are used whenever a loop over all lines, quads, cells etc.
  *   is to be performed. These loops can then be coded like this:
  *   \begin{verbatim}
  *     cell_iterator i   = tria.begin();
@@ -54,32 +54,32 @@ template <int dim> class Triangulation;
  *       if (cell->at_boundary())
  *         cell->set_refine_flag();
  *   \end{verbatim}
- *   Note the usage of #++i# instead of #i++# since this does not involve
+ *   Note the usage of @p{++i} instead of @p{i++} since this does not involve
  *   temporaries and copying. You should also really use a fixed value
- *   #end# rather than coding #for (; i!=tria.end(); ++i)#, since
+ *   @p{end} rather than coding @p{for (; i!=tria.end(); ++i)}, since
  *   the creation and copying of these iterators is rather expensive
  *   compared to normal pointers.
  *   
- *   The objects pointed to by iterators are #TriangulationLevel<1>::LinesData#,
- *   #TriangulationLevel<2>::LinesData#
- *   and #TriangulationLevel<2>::QuadsData#. To chose which of those, the
- *   template parameter #Pointee# is used.
+ *   The objects pointed to by iterators are @p{TriangulationLevel<1>::LinesData},
+ *   @p{TriangulationLevel<2>::LinesData}
+ *   and @p{TriangulationLevel<2>::QuadsData}. To chose which of those, the
+ *   template parameter @p{Pointee} is used.
  *
- *   Since the names as is are quite unhandy, the #Triangulation<># class which
+ *   Since the names as is are quite unhandy, the @p{Triangulation<>} class which
  *   uses these iterators declares typedef'd versions. See there for more
  *   information.
  *
- *   The objects pointed to are, as mentioned, #LinesData# etc. To be
- *   more exact, when dereferencing an iterator, you do not get a #LineData#
- *   object (or the like, but we will assume that you have a #line_iterator#
- *   in the following), but a {\it virtual} object (called {\it accessor}) which
+ *   The objects pointed to are, as mentioned, @p{LinesData} etc. To be
+ *   more exact, when dereferencing an iterator, you do not get a @p{LineData}
+ *   object (or the like, but we will assume that you have a @p{line_iterator}
+ *   in the following), but a @em{virtual} object (called @em{accessor}) which
  *   behaves as if it stored the data of a line. It does not contain any data
  *   itself, but provides functions to manipulate the data of the line it
  *   stands for.
  *
  *   Since the data of one line is splitted to
- *   several arrays (#lines#, #children# and #used#) for performance reasons
- *   rather than keeping all information in a #Line# struct, access through
+ *   several arrays (@p{lines}, @p{children} and @p{used}) for performance reasons
+ *   rather than keeping all information in a @p{Line} struct, access through
  *   an accessor is usually much simpler than handling the exact data structure
  *   and also less error prone since the data structure itself can be changed
  *   in an arbitrary way while the only pieces of code which access these
@@ -90,8 +90,8 @@ template <int dim> class Triangulation;
  *   to handcode yourself anyway. Most iterator and accessor functions are
  *   inlined. 
  *
- *   The main functionality of iterators, however, resides in the #++# and
- *   #--# operators. These move the iterator forward or backward just as if
+ *   The main functionality of iterators, however, resides in the @p{++} and
+ *   @p{--} operators. These move the iterator forward or backward just as if
  *   it were a pointer into an array. Here, this operation is not so easy,
  *   since it may include skipping some elements and the transition between
  *   the triangulation levels. This is completely hidden from the user, though
@@ -104,108 +104,108 @@ template <int dim> class Triangulation;
  *   Furthermore, the iterators decribed here satisfy the requirement of
  *   input and bidirectional iterators as stated by the C++ standard and
  *   the STL documentation. It is therefore possible to use the functions
- *   from the {\it algorithm section} of the C++ standard, e.g. #count_if#
+ *   from the @em{algorithm section} of the C++ standard, e.g. @p{count_if}
  *   (see the documentation for \Ref{Triangulation} for an example) and
  *   several others.
  *   
  *
- *   \subsection{Differences between the classes in this inheritance tree}
+ *   @sect3{Differences between the classes in this inheritance tree}
  *
- *   #TriaRawIterator# objects point to lines, cells, etc in
- *   the lists whether they are used or not (in the vectors, also {\it dead}
+ *   @p{TriaRawIterator} objects point to lines, cells, etc in
+ *   the lists whether they are used or not (in the vectors, also @em{dead}
  *   objects are stored, since deletion in vectors is expensive and we
  *   also do not want to destroy the ordering induced by the numbering
  *   in the vectors). Therefore not all raw iterators point to valid objects.
  *   
  *   There are two derived versions of this class: \Ref{TriaIterator}
  *   objects, which only loop over used (valid) cells and
- *   #TriaActiveIterator# objects
+ *   @p{TriaActiveIterator} objects
  *   which only loop over active cells (not refined).
  *
  *   
- *   \subsection{Implementation}
+ *   @sect3{Implementation}
  *
  *   In principle, the Iterator class does not have much functionality. It
- *   only becomes useful when assigned an #Accessor# (the second template
- *   parameter), which really does the access to data. An #Accessor# has to
+ *   only becomes useful when assigned an @p{Accessor} (the second template
+ *   parameter), which really does the access to data. An @p{Accessor} has to
  *   fulfil some requirements:
  *   \begin{itemize}
- *     \item It must have two members named #present_level# and #present_index#
+ *     \item It must have two members named @p{present_level} and @p{present_index}
  *       storing the address of the element in the triangulation presently
- *       pointed to. Furthermore, the three #Tria{Raw| |Active}Iterator# classes
+ *       pointed to. Furthermore, the three @p{Tria{Raw| |Active}Iterator} classes
  *       have to be friends to the accessor or these data members must be public.
- *     \item It must have a constructor which takes 1. a #Triangulation<dim>*#,
+ *     \item It must have a constructor which takes 1. a @p{Triangulation<dim>*},
  *       2. and 3. and integer, denoting the initial level and index.
- *     \item For the #TriaIterator# and the #TriaActiveIterator# class, it must
- *       have a member function #bool used()#, for the latter a member function
- *       #bool active()#.
- *     \item It must have void operators #++# and #--#.
- *     \item It must declare a local #typedef# #AccessorData# which states
+ *     \item For the @p{TriaIterator} and the @p{TriaActiveIterator} class, it must
+ *       have a member function @p{bool used()}, for the latter a member function
+ *       @p{bool active()}.
+ *     \item It must have void operators @p{++} and @p{--}.
+ *     \item It must declare a local @p{typedef} @p{AccessorData} which states
  *       the data type the accessor expects to get passed as fourth constructor
  *       argument. By declaring a local data type, the respective iterator
  *       class may type-safely enforce that data type to be one of its own
  *       constructor argument types. If an accessor class does not need
- *       additional data, this type shall be #void#.
+ *       additional data, this type shall be @p{void}.
  *   \end{itemize}
  *   Then the iterator is able to do what it is supposed to. All of the necessary
- *   functions are implemented in the #Accessor# base class, but you may write
+ *   functions are implemented in the @p{Accessor} base class, but you may write
  *   your own version (non-virtual, since we use templates) to add functionality.
  *
  *   There is a standard implementation, using classes which are derived from
- *   \Ref{TriaAccessor}. These classes point to #Line#s, #Quad#s and the like.
+ *   \Ref{TriaAccessor}. These classes point to @p{Line}s, @p{Quad}s and the like.
  *   For advanced use of the iterator classes, derive classes from
- *   #{Line|Quad|Cell}Accessor# which also dereference data structures in other
+ *   @p{{Line|Quad|Cell}Accessor} which also dereference data structures in other
  *   objects, e.g. in a finite element context. An iterator with such an accessor
  *   then simultaneously points to (for example) a cell in the triangulation and
  *   the data stored on it in the finite element class.
  *
- *   Derived accessor classes may need additional data (e.g. the #DoFAccessor#
- *   needs a pointer to the #DoFHandler# to work on). This data can be
+ *   Derived accessor classes may need additional data (e.g. the @p{DoFAccessor}
+ *   needs a pointer to the @p{DoFHandler} to work on). This data can be
  *   set upon construction through the last argument of the constructors.
  *   The data type of this additional data is given by the local data type
- *   #AccessorData# explained above. The iterator classes take a pointer to
+ *   @p{AccessorData} explained above. The iterator classes take a pointer to
  *   an object of that data type; by default, this parameter equals the
- *   #NULL# pointer.
+ *   @p{NULL} pointer.
  *   
  *   
- *   \subsection{Warning}
+ *   @sect3{Warning}
  *
- *   It seems impossible to preserve #const#ness of a triangulation through
- *   iterator usage. Thus, if you declare pointers to a #const# triangulation
+ *   It seems impossible to preserve @p{const}ness of a triangulation through
+ *   iterator usage. Thus, if you declare pointers to a @p{const} triangulation
  *   object, you should be well aware that you might involuntarily alter the
  *   data stored in the triangulation.
  *
  *
- *   \subsection{Internals}
+ *   @sect3{Internals}
  *   
  *   There is a representation of past-the-end-pointers, denoted by special
- *   values of the member variables #present_level# and #present_index#:
- *   If #present_level>=0# and #present_index>=0#, then the object is valid
+ *   values of the member variables @p{present_level} and @p{present_index}:
+ *   If @p{present_level>=0} and @p{present_index>=0}, then the object is valid
  *   (there is no check whether the triangulation really has that
  *   many levels or that many cells on the present level when we investigate
  *   the state of an iterator; however, in many places where an iterator is
  *   dereferenced we make this check);
- *   if #present_level==-1# and #present_index==-1#, then the iterator points
+ *   if @p{present_level==-1} and @p{present_index==-1}, then the iterator points
  *   past the end; in all other cases, the iterator is considered invalid.
- *   You can check this by calling the #state()# function.
+ *   You can check this by calling the @p{state()} function.
  *
- *   An iterator is also invalid, if the pointer pointing to the #Triangulation#
+ *   An iterator is also invalid, if the pointer pointing to the @p{Triangulation}
  *   object is invalid or zero.
  *
  *   Finally, an iterator is invalid, if the element pointed to by
- *   #present_level# and #present_index# is not used, i.e. if the #used#
+ *   @p{present_level} and @p{present_index} is not used, i.e. if the @p{used}
  *   flag is set to false.
  *
- *   The last two checks are not made in #state()# since both cases should only
- *   occur upon unitialized construction through #memcpy# and the like (the
+ *   The last two checks are not made in @p{state()} since both cases should only
+ *   occur upon unitialized construction through @p{memcpy} and the like (the
  *   parent triangulation can only be set upon construction). If
  *   an iterator is constructed empty through the empty constructor,
- *   #present_level==-2# and #present_index==-2#. Thus, the iterator is
+ *   @p{present_level==-2} and @p{present_index==-2}. Thus, the iterator is
  *   invalid anyway, regardless of the state of the triangulation pointer
  *   and the state of the element pointed to.
  *
  *   Past-the-end iterators may also be used to compare an iterator with the
- *   {\it before-the-start} value, when running backwards. There is no
+ *   @em{before-the-start} value, when running backwards. There is no
  *   distiction between the iterators pointing past the two ends of a vector.
  *   
  *   By defining only one value to be past-the-end and making all other values
@@ -252,9 +252,11 @@ class TriaRawIterator : public bidirectional_iterator<Accessor,int> {
                                      * Through this constructor, it is also
                                      * possible to construct object for
                                      * derived iterators:
-                                     * #DoFCellAccessor dof_accessor;
+                                     * \begin{verbatim}
+                                     * DoFCellAccessor dof_accessor;
                                      * Triangulation::active_cell_iterator cell
-                                     *   = accessor; #.
+                                     *   = accessor;
+                                     * \end{verbatim}
                                      */
     TriaRawIterator (const Accessor &a);
     
@@ -277,17 +279,17 @@ class TriaRawIterator : public bidirectional_iterator<Accessor,int> {
                                      * iterator type and copies the data;
                                      * this conversion works, if there is
                                      * a conversion path from the
-                                     * #OtherAccessor# class to the #Accessor#
+                                     * @p{OtherAccessor} class to the @p{Accessor}
                                      * class of this object. One such path
                                      * would be derived class to base class,
                                      * which for example may be used to get
-                                     * a #Triangulation::raw_cell_iterator# from
-                                     * a #DoFHandler::raw_cell_iterator#, since
-                                     * the #DoFAccessor# class is derived from
-                                     * the #TriaAccessor# class.
+                                     * a @p{Triangulation::raw_cell_iterator} from
+                                     * a @p{DoFHandler::raw_cell_iterator}, since
+                                     * the @p{DoFAccessor} class is derived from
+                                     * the @p{TriaAccessor} class.
                                      *
-                                     * Since #TriaIterator# and
-                                     * #TriaActiveIterator# are derived classes
+                                     * Since @p{TriaIterator} and
+                                     * @p{TriaActiveIterator} are derived classes
                                      * of this class, this constructor also
                                      * serves to convert these iterators with
                                      * other accessor classes.
@@ -302,15 +304,15 @@ class TriaRawIterator : public bidirectional_iterator<Accessor,int> {
                                     /**
                                      *  Dereferencing operator, returns a
                                      *  reference to an accessor.
-                                     *  Usage is thus like #(*i).index ();#
+                                     *  Usage is thus like @p{(*i).index ();}
                                      *
                                      *  This function has to be specialized
                                      *  explicitely for the different
-                                     *  #Pointee#s, to allow an
-                                     *  #iterator<1,TriangulationLevel<1>::LinesData>#
-                                     *  to point to #tria->lines.lines[index]# while
+                                     *  @p{Pointee}s, to allow an
+                                     *  @p{iterator<1,TriangulationLevel<1>::LinesData>}
+                                     *  to point to @p{tria->lines.lines[index]} while
                                      *  for one dimension higher it has
-                                     *  to point to #tria->quads.quads[index]#.
+                                     *  to point to @p{tria->quads.quads[index]}.
                                      *
                                      *  You must not dereference invalid or
                                      *  past the end iterators.
@@ -318,7 +320,7 @@ class TriaRawIterator : public bidirectional_iterator<Accessor,int> {
     const Accessor & operator * () const;
     
                                     /**
-                                     *  Dereferencing operator, non-#const#
+                                     *  Dereferencing operator, non-@p{const}
                                      *  version.
                                      */
     Accessor & operator * ();
@@ -326,15 +328,15 @@ class TriaRawIterator : public bidirectional_iterator<Accessor,int> {
                                     /**
                                      *  Dereferencing operator, returns a
                                      *  reference of the cell pointed to.
-                                     *  Usage is thus like #i->index ();#
+                                     *  Usage is thus like @p{i->index ();}
                                      *
-                                     *  There is a #const# and a non-#const#
+                                     *  There is a @p{const} and a non-@p{const}
                                      *  version.
                                      */
     const Accessor * operator -> () const;
         
                                     /**
-                                     *  Dereferencing operator, non-#const#
+                                     *  Dereferencing operator, non-@p{const}
                                      *  version.
                                      */
     Accessor * operator -> ();
@@ -357,11 +359,11 @@ class TriaRawIterator : public bidirectional_iterator<Accessor,int> {
 
                                     /**
                                      * Offer a weak ordering of iterators,
-                                     * which is needed to make #map#s with
+                                     * which is needed to make @p{map}s with
                                      * iterators being keys. An iterator
-                                     * pointing to an element #a# is
+                                     * pointing to an element @p{a} is
                                      * less than another iterator pointing
-                                     * to an element #b# if
+                                     * to an element @p{b} if
                                      * level(a)<level(b) or
                                      * (level(a)==level(b) and index(a)<index(b)).
                                      *
@@ -377,10 +379,10 @@ class TriaRawIterator : public bidirectional_iterator<Accessor,int> {
                                     /**@name Advancement of iterators*/
                                     /*@{*/
                                     /**
-                                     *  Prefix #++# operator: #++i#. This
+                                     *  Prefix @p{++} operator: @p{++i}. This
                                      *  operator advances the iterator to
                                      *  the next element and returns
-                                     *  a reference to #*this#.
+                                     *  a reference to @p{*this}.
                                      *
                                      *  The next element is next on this
                                      *  level if there are more. If the
@@ -391,32 +393,32 @@ class TriaRawIterator : public bidirectional_iterator<Accessor,int> {
     TriaRawIterator & operator ++ ();
     
                                     /**
-                                     *  Postfix #++# operator: #i++#. This
+                                     *  Postfix @p{++} operator: @p{i++}. This
                                      *  operator advances the iterator to
                                      *  the next element, but
                                      *  returns an iterator to the element
                                      *  priviously pointed to. Since this
                                      *  involves a temporary and a copy
                                      *  operation and since an
-                                     *  #iterator# is quite a large
+                                     *  @p{iterator} is quite a large
                                      *  object for a pointer, use the
-                                     *  prefix operator #++i# whenever
+                                     *  prefix operator @p{++i} whenever
                                      *  possible, especially in the head
                                      *  of for loops
-                                     *  (#for (; i!=end; ++i)#) since there
+                                     *  (@p{for (; i!=end; ++i)}) since there
                                      *  you normally never need the
                                      *  returned value.
                                      */
     TriaRawIterator operator ++ (int);
 
                                     /**
-                                     *  Prefix #--# operator: #--i#. This
+                                     *  Prefix @p{--} operator: @p{--i}. This
                                      *  operator advances the iterator to
                                      *  the previous element and returns
-                                     *  a reference to #*this#.
+                                     *  a reference to @p{*this}.
                                      *
                                      *  The previous element is previous on
-                                     *  this level if #index>0#. If the
+                                     *  this level if @p{index>0}. If the
                                      *  present element is the first on
                                      *  this level, the last on the
                                      *  previous level is accessed.
@@ -424,19 +426,19 @@ class TriaRawIterator : public bidirectional_iterator<Accessor,int> {
     TriaRawIterator & operator -- ();
     
                                     /**
-                                     *  Postfix #--# operator: #i--#. This
+                                     *  Postfix @p{--} operator: @p{i--}. This
                                      *  operator advances the iterator to
                                      *  the previous element, but
                                      *  returns an iterator to the element
                                      *  priviously pointed to. Since this
                                      *  involves a temporary and a copy
                                      *  operation and since an
-                                     *  #iterator# is quite a large
+                                     *  @p{iterator} is quite a large
                                      *  object for a pointer, use the
-                                     *  prefix operator #--i# whenever
+                                     *  prefix operator @p{--i} whenever
                                      *  possible, especially in the head
                                      *  of for loops
-                                     *  (#for (; i!=end; --i)#) since there
+                                     *  (@p{for (; i!=end; --i)}) since there
                                      *  you normally never need the
                                      *  returned value.
                                      */
@@ -449,8 +451,8 @@ class TriaRawIterator : public bidirectional_iterator<Accessor,int> {
     IteratorState state () const;
 
                                     /**
-                                     * Print the iterator to #out#. The
-                                     * format is like #level.index#.
+                                     * Print the iterator to @p{out}. The
+                                     * format is like @p{level.index}.
                                      */
     void print (ostream &out) const;
 
@@ -499,7 +501,7 @@ class TriaRawIterator : public bidirectional_iterator<Accessor,int> {
 
 /**
  *   This specialization of \Ref{TriaRawIterator} provides access only to the
- *   {\it used} lines, quads, cells, etc.
+ *   @em{used} lines, quads, cells, etc.
  */
 template <int dim, typename Accessor>
 class TriaIterator : public TriaRawIterator<dim,Accessor> {
@@ -551,16 +553,16 @@ class TriaIterator : public TriaRawIterator<dim,Accessor> {
                                      * iterator type and copies the data;
                                      * this conversion works, if there is
                                      * a conversion path from the
-                                     * #OtherAccessor# class to the #Accessor#
+                                     * @p{OtherAccessor} class to the @p{Accessor}
                                      * class of this object. One such path
                                      * would be derived class to base class,
                                      * which for example may be used to get
-                                     * a #Triangulation::cell_iterator# from
-                                     * a #DoFHandler::cell_iterator#, since
-                                     * the #DoFAccessor# class is derived from
-                                     * the #TriaAccessor# class.
+                                     * a @p{Triangulation::cell_iterator} from
+                                     * a @p{DoFHandler::cell_iterator}, since
+                                     * the @p{DoFAccessor} class is derived from
+                                     * the @p{TriaAccessor} class.
                                      *
-                                     * Since #TriaActiveIterator# is a derived
+                                     * Since @p{TriaActiveIterator} is a derived
                                      * class of this class, this constructor
                                      * also serves to convert these iterators 
                                      * with other accessor classes.
@@ -595,42 +597,42 @@ class TriaIterator : public TriaRawIterator<dim,Accessor> {
                                     /**@name Advancement of iterators*/
                                     /*@{*/
                                     /**
-                                     *  Prefix #++# operator: #++i#. This
+                                     *  Prefix @p{++} operator: @p{++i}. This
                                      *  operator advances the iterator to
                                      *  the next used element and returns
-                                     *  a reference to #*this#.
+                                     *  a reference to @p{*this}.
                                      */
     TriaIterator<dim,Accessor> & operator ++ ();
 
                                     /**
-                                     *  Postfix #++# operator: #i++#. This
+                                     *  Postfix @p{++} operator: @p{i++}. This
                                      *  operator advances the iterator to
                                      *  the next used element, but
                                      *  returns an iterator to the element
                                      *  previously pointed to. Since this
                                      *  involves a temporary and a copy
                                      *  operation and since an
-                                     *  #active_iterator# is quite a large
+                                     *  @p{active_iterator} is quite a large
                                      *  object for a pointer, use the
-                                     *  prefix operator #++i# whenever
+                                     *  prefix operator @p{++i} whenever
                                      *  possible, especially in the head
                                      *  of for loops
-                                     *  (#for (; i!=end; ++i)#) since there
+                                     *  (@p{for (; i!=end; ++i)}) since there
                                      *  you normally never need the
                                      *  returned value.
                                      */
     TriaIterator<dim,Accessor> operator ++ (int);
 
                                     /**
-                                     *  Prefix #--# operator: #--i#. This
+                                     *  Prefix @p{--} operator: @p{--i}. This
                                      *  operator advances the iterator to
                                      *  the previous used element and returns
-                                     *  a reference to #*this#.
+                                     *  a reference to @p{*this}.
                                      */
     TriaIterator<dim,Accessor> & operator -- ();
 
                                     /**
-                                     *  Postfix #--# operator: #i--#.
+                                     *  Postfix @p{--} operator: @p{i--}.
                                      */
     TriaIterator<dim,Accessor> operator -- (int);
                                     /*@}*/
@@ -644,7 +646,7 @@ class TriaIterator : public TriaRawIterator<dim,Accessor> {
 
 /**
  *   This specialization of \Ref{TriaIterator} provides access only to the
- *   {\it active} lines, quads, cells, etc. An active cell is a cell which is not
+ *   @em{active} lines, quads, cells, etc. An active cell is a cell which is not
  *   refined and thus a cell on which calculations on the finest level are done.
  */
 template <int dim, typename Accessor>
@@ -709,14 +711,14 @@ class TriaActiveIterator : public TriaIterator<dim,Accessor> {
                                      * iterator type and copies the data;
                                      * this conversion works, if there is
                                      * a conversion path from the
-                                     * #OtherAccessor# class to the #Accessor#
+                                     * @p{OtherAccessor} class to the @p{Accessor}
                                      * class of this object. One such path
                                      * would be derived class to base class,
                                      * which for example may be used to get
-                                     * a #Triangulation::active_cell_iterator# from
-                                     * a #DoFHandler::active_cell_iterator#, since
-                                     * the #DoFAccessor# class is derived from
-                                     * the #TriaAccessor# class.
+                                     * a @p{Triangulation::active_cell_iterator} from
+                                     * a @p{DoFHandler::active_cell_iterator}, since
+                                     * the @p{DoFAccessor} class is derived from
+                                     * the @p{TriaAccessor} class.
                                      */
     template <typename OtherAccessor>
     TriaActiveIterator (const TriaActiveIterator<dim,OtherAccessor> &i);
@@ -729,7 +731,7 @@ class TriaActiveIterator : public TriaIterator<dim,Accessor> {
                                      * raw iterators. Since usual iterators
                                      * are also raw iterators, this constructor
                                      * works also for parameters of type
-                                     * #TriaIterator<dim,OtherAccessor>#.
+                                     * @p{TriaIterator<dim,OtherAccessor>}.
                                      */
     template <typename OtherAccessor>
     TriaActiveIterator (const TriaRawIterator<dim,OtherAccessor> &i);
@@ -759,44 +761,44 @@ class TriaActiveIterator : public TriaIterator<dim,Accessor> {
     operator = (const TriaIterator<dim,Accessor> &);
 
                                     /**
-                                     *  Prefix #++# operator: #++i#. This
+                                     *  Prefix @p{++} operator: @p{++i}. This
                                      *  operator advances the iterator to
                                      *  the next active element and returns
-                                     *  a reference to #*this#.
+                                     *  a reference to @p{*this}.
                                      */
     TriaActiveIterator<dim,Accessor> & operator ++ ();
 
                                     /**@name Advancement of iterators*/
                                     /*@{*/
                                     /**
-                                     *  Postfix #++# operator: #i++#. This
+                                     *  Postfix @p{++} operator: @p{i++}. This
                                      *  operator advances the iterator to
                                      *  the next active element, but
                                      *  returns an iterator to the element
                                      *  previously pointed to. Since this
                                      *  involves a temporary and a copy
                                      *  operation and since an
-                                     *  #active_iterator# is quite a large
+                                     *  @p{active_iterator} is quite a large
                                      *  object for a pointer, use the
-                                     *  prefix operator #++i# whenever
+                                     *  prefix operator @p{++i} whenever
                                      *  possible, especially in the head
                                      *  of for loops
-                                     *  (#for (; i!=end; ++i)#) since there
+                                     *  (@p{for (; i!=end; ++i)}) since there
                                      *  you normally never need the
                                      *  returned value.
                                      */
     TriaActiveIterator<dim,Accessor> operator ++ (int);
 
                                     /**
-                                     *  Prefix #--# operator: #--i#. This
+                                     *  Prefix @p{--} operator: @p{--i}. This
                                      *  operator advances the iterator to
                                      *  the previous active element and
-                                     *  returns a reference to #*this#.
+                                     *  returns a reference to @p{*this}.
                                      */
     TriaActiveIterator<dim,Accessor> & operator -- ();
 
                                     /**
-                                     *  Postfix #--# operator: #i--#.
+                                     *  Postfix @p{--} operator: @p{i--}.
                                      */
     TriaActiveIterator<dim,Accessor> operator -- (int);
                                     /*@}*/
index 9f0897749a1961915521671f4530bc3dca1a4e2b..f4b423ded0a6e1531f16c2c8402b5d15968541c8 100644 (file)
@@ -36,7 +36,7 @@ class TriangulationLevel;
 /**
  *  Store all information which belongs to one level of the multilevel hierarchy.
  *
- *  In #TriangulationLevel<0># all data is stored which is not
+ *  In @p{TriangulationLevel<0>} all data is stored which is not
  *  dependant on the dimension, e.g. a field to store the
  *  refinement flag for the cells (what a cell actually is
  *  is declared elsewhere), etc. Actually, it is only cell-based
@@ -63,8 +63,8 @@ class TriangulationLevel<0> {
                                      *  vector depends on the dimension: in
                                      *  one dimension, the length of this
                                      *  vector equals the length of the
-                                     *  #lines# vector, in two dimensions
-                                     *  that of the #quads# vector, etc.
+                                     *  @p{lines} vector, in two dimensions
+                                     *  that of the @p{quads} vector, etc.
                                      */
     vector<bool> refine_flags;
 
@@ -78,26 +78,26 @@ class TriangulationLevel<0> {
                                     /**
                                      *  Levels and indices of the neighbors
                                      *  of the cells. Convention is, that the
-                                     *  neighbors of the cell with index #i#
+                                     *  neighbors of the cell with index @p{i}
                                      *  are stored in the fields following
                                      *  $i*(2*real_space_dimension)$, e.g. in
                                      *  one spatial dimension, the neighbors
-                                     *  of cell 0 are stored in #neighbors[0]#
-                                     *  and #neighbors[1]#, the neighbors of
-                                     *  cell 1 are stored in #neighbors[2]#
-                                     *  and #neighbors[3]#, and so on.
+                                     *  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.
                                      *
-                                     *  In neighbors, #neighbors[i].first# is
-                                     *  the level, while #neighbors[i].first#
+                                     *  In neighbors, @p{neighbors[i].first} is
+                                     *  the level, while @p{neighbors[i].first}
                                      *  is the index of the neighbor.
                                      *
                                      *  If a neighbor does not exist (cell is
-                                     *  at the boundary), #level=index=-1#
+                                     *  at the boundary), @p{level=index=-1}
                                      *  is set.
                                      *
-                                     *  {\bf Conventions:} The #i#th neighbor
+                                     *  {\bf Conventions:} The @p{i}th neighbor
                                      *  of a cell is the one which shares
-                                     *  the #i#th face (#Line# in 2D, #Quad#
+                                     *  the @p{i}th face (@p{Line} in 2D, @p{Quad}
                                      *  in 3D) of this cell.
                                      *
                                      *  The neighbor of a cell has at most the
@@ -127,13 +127,13 @@ class TriangulationLevel<0> {
     
                                     /**
                                      *  Reserve enough space to accomodate
-                                     *  #total_cells# cells on this level.
-                                     *  Since there are no #used# flags on this
+                                     *  @p{total_cells} cells on this level.
+                                     *  Since there are no @p{used} flags on this
                                      *  level, you have to give to total number
                                      *  of cells, not only the number of newly
                                      *  to accomodate ones, like in the
-                                     *  #TriangulationLevel<N>::reserve_space#
-                                     *  functions, with #N>0#.
+                                     *  @p{TriangulationLevel<N>::reserve_space}
+                                     *  functions, with @p{N>0}.
                                      *
                                      *  Since the
                                      *  number of neighbors per cell depends
@@ -146,10 +146,10 @@ class TriangulationLevel<0> {
                                     /**
                                      *  Check the memory consistency of the
                                      *  different containers. Should only be
-                                     *  called with the prepro flag #DEBUG#
+                                     *  called with the prepro flag @p{DEBUG}
                                      *  set. The function should be called from
                                      *  the functions of the higher
-                                     *  #TriangulationLevel# classes.
+                                     *  @p{TriangulationLevel} classes.
                                      */
     void monitor_memory (const unsigned int true_dimension) const;
 
@@ -180,7 +180,7 @@ class TriangulationLevel<0> {
  *  
  *  In one dimension, this is a list of the lines associated with this level,
  *  as well as a list with the indices of the children of these lines.
- *  The #TriangulationsLevel# objects of higher dimensions are derived from
+ *  The @p{TriangulationsLevel} objects of higher dimensions are derived from
  *  this one.
  *
  *  @memo Information belonging to one level of the multilevel hierarchy.
@@ -220,22 +220,22 @@ class TriangulationLevel<1> : public TriangulationLevel<0> {
                                          *  stored in this list. A line is
                                          *  called active if it has no
                                          *  children. The function
-                                         *  #TriaIterator::active()#
+                                         *  @p{TriaIterator::active()}
                                          *  tests for this.
                                          */
        vector<int>  children;
        
                                         /**
                                          *  Vector storing whether a line is
-                                         *  used in the #lines# vector.
+                                         *  used in the @p{lines} vector.
                                          *
                                          *  Since it is difficult to delete
-                                         *  elements in a #vector#, when an
+                                         *  elements in a @p{vector}, when an
                                          *  element is not needed any more
                                          *  (e.g. after derefinement), it is
                                          *  not deleted from the list, but
-                                         *  rather the according #used# flag
-                                         *  is set to #false#.
+                                         *  rather the according @p{used} flag
+                                         *  is set to @p{false}.
                                          */
        vector<bool> used;
 
@@ -248,7 +248,7 @@ class TriangulationLevel<1> : public TriangulationLevel<0> {
                                          *  already been processed.
                                          *
                                          *  You can clear all used flags using
-                                         *  #Triangulation<>::clear_user_flags()#.
+                                         *  @p{Triangulation<>::clear_user_flags()}.
                                          */
        vector<bool> user_flags;
 
@@ -292,9 +292,9 @@ class TriangulationLevel<1> : public TriangulationLevel<0> {
 
                                     /**
                                      *  Assert that enough space is allocated
-                                     *  to accomodate #new_lines# new lines.
+                                     *  to accomodate @p{new_lines} new lines.
                                      *  This function does not only call
-                                     *  #vector::reserve()#, but does really
+                                     *  @p{vector::reserve()}, but does really
                                      *  append the needed elements.
                                      *  There are pendants for higher
                                      *  dimensions, which you have to call
@@ -303,7 +303,7 @@ class TriangulationLevel<1> : public TriangulationLevel<0> {
                                      *  between the number of new quads and
                                      *  the number of new lines, etc.). Also
                                      *  don't forget to call the
-                                     *  #TriangulationLevel<0>::reserve_space#
+                                     *  @p{TriangulationLevel<0>::reserve_space}
                                      *  function.
                                      */
     void reserve_space (const unsigned int new_lines);
@@ -311,10 +311,10 @@ class TriangulationLevel<1> : public TriangulationLevel<0> {
                                     /**
                                      *  Check the memory consistency of the
                                      *  different containers. Should only be
-                                     *  called with the prepro flag #DEBUG#
+                                     *  called with the prepro flag @p{DEBUG}
                                      *  set. The function should be called from
                                      *  the functions of the higher
-                                     *  #TriangulationLevel# classes.
+                                     *  @p{TriangulationLevel} classes.
                                      */
     void monitor_memory (const unsigned int true_dimension) const;
 };
@@ -328,7 +328,7 @@ class TriangulationLevel<1> : public TriangulationLevel<0> {
  *  information about the children of these lines and quads.
  *
  *  The vector of lines and their children is derived from
- *  #TriangulationLevel<1>#.
+ *  @p{TriangulationLevel<1>}.
  *
  *  @memo Information belonging to one level of the multilevel hierarchy.
  *  @author Wolfgang Bangerth, 1998
@@ -342,16 +342,16 @@ class TriangulationLevel<2> :  public TriangulationLevel<1>
                                      *  level.
                                      *
                                      *  It is fully analogous to the
-                                     *  #LinesData# structure inherited from
-                                     *  #Triangulation<1>#.
+                                     *  @p{LinesData} structure inherited from
+                                     *  @p{Triangulation<1>}.
                                      */
     struct QuadsData {
                                         /**
-                                         *  Same as for the #lines# array.
+                                         *  Same as for the @p{lines} array.
                                          */
        vector<Quad> quads;
                                         /**
-                                         *  Same as for the #LineData::chilren#
+                                         *  Same as for the @p{LineData::chilren}
                                          *  array, but since there are four
                                          *  children, the index points to the
                                          *  first while the other three are
@@ -360,12 +360,12 @@ class TriangulationLevel<2> :  public TriangulationLevel<1>
        vector<int>  children;
 
                                         /**
-                                         *  Same as for #LineData::used#.
+                                         *  Same as for @p{LineData::used}.
                                          */
        vector<bool> used;
 
                                         /**
-                                         *  Same as for #LineData::used#.
+                                         *  Same as for @p{LineData::used}.
                                          */
        vector<bool> user_flags;
 
@@ -410,17 +410,17 @@ class TriangulationLevel<2> :  public TriangulationLevel<1>
 
                                     /**
                                      *  Assert that enough space is allocated
-                                     *  to accomodate #new_quads# new quads.
+                                     *  to accomodate @p{new_quads} new quads.
                                      */
     void reserve_space (const unsigned int new_quads);
 
                                     /**
                                      *  Check the memory consistency of the
                                      *  different containers. Should only be
-                                     *  called with the prepro flag #DEBUG#
+                                     *  called with the prepro flag @p{DEBUG}
                                      *  set. The function should be called from
                                      *  the functions of the higher
-                                     *  #TriangulationLevel# classes.
+                                     *  @p{TriangulationLevel} classes.
                                      */
     void monitor_memory (const unsigned int true_dimension) const;
 };
@@ -434,7 +434,7 @@ class TriangulationLevel<2> :  public TriangulationLevel<1>
  *  information about the children of these lines, quads and hexs.
  *
  *  The vectors of lines and quads and their children are derived from
- *  #TriangulationLevel<2>#.
+ *  @p{TriangulationLevel<2>}.
  *
  *  @memo Information belonging to one level of the multilevel hierarchy.
  *  @author Wolfgang Bangerth, 1998
@@ -448,16 +448,16 @@ class TriangulationLevel<3> :  public TriangulationLevel<2>
                                      *  level.
                                      *
                                      *  It is fully analogous to the
-                                     *  #LinesData# structure inherited from
-                                     *  #Triangulation<1>#.
+                                     *  @p{LinesData} structure inherited from
+                                     *  @p{Triangulation<1>}.
                                      */
     struct HexesData {
                                         /**
-                                         *  Same as for the #lines# array.
+                                         *  Same as for the @p{lines} array.
                                          */
        vector<Hexahedron> hexes;
                                         /**
-                                         *  Same as for the #LineData::chilren#
+                                         *  Same as for the @p{LineData::chilren}
                                          *  array, but since there are four
                                          *  children, the index points to the
                                          *  first while the other three are
@@ -466,12 +466,12 @@ class TriangulationLevel<3> :  public TriangulationLevel<2>
        vector<int>  children;
 
                                         /**
-                                         *  Same as for #LineData::used#.
+                                         *  Same as for @p{LineData::used}.
                                          */
        vector<bool> used;
 
                                         /**
-                                         *  Same as for #LineData::used#.
+                                         *  Same as for @p{LineData::used}.
                                          */
        vector<bool> user_flags;
 
@@ -516,17 +516,17 @@ class TriangulationLevel<3> :  public TriangulationLevel<2>
 
                                     /**
                                      *  Assert that enough space is allocated
-                                     *  to accomodate #new_quads# new quads.
+                                     *  to accomodate @p{new_quads} new quads.
                                      */
     void reserve_space (const unsigned int new_quads);
 
                                     /**
                                      *  Check the memory consistency of the
                                      *  different containers. Should only be
-                                     *  called with the prepro flag #DEBUG#
+                                     *  called with the prepro flag @p{DEBUG}
                                      *  set. The function should be called from
                                      *  the functions of the higher
-                                     *  #TriangulationLevel# classes.
+                                     *  @p{TriangulationLevel} classes.
                                      */
     void monitor_memory (const unsigned int true_dimension) const;
 };
index 79e3fac16834d7d94155d043410f6e6ea12c8ecd..d04bbe2808b8d3b47c28de4171a3b4fd8cda78fd 100644 (file)
@@ -24,7 +24,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 implicitely given by the position
- *   in the #lines.lines# list attached to the information of each level.
+ *   in the @p{lines.lines} list attached to the information of each level.
  *
  *   @author Wolfgang Bangerth, 1998
  */
@@ -32,7 +32,7 @@ class Line {
   public:
                                     /**
                                      *  Construct a line with end point
-                                     *  indices #i0# and #i1#. By default,
+                                     *  indices @p{i0} and @p{i1}. By default,
                                      *  indices are set to -1, i.e. an
                                      *  invalid value.
                                      */
@@ -40,14 +40,14 @@ class Line {
          const int i1 = -1);
     
                                     /**
-                                     *  Return the index of end point #i#=0
+                                     *  Return the index of end point @p{i}=0
                                      *  or 1.
                                      */
     int vertex (const int i) const;
     
                                     /**
-                                     *  Set the index of the #i#th vertex to
-                                     *  #index#. #i#=0 or 1.
+                                     *  Set the index of the @p{i}th vertex to
+                                     *  @p{index}. @p{i}=0 or 1.
                                      */
     void set_vertex (const int i, const int index);
     
index 4a996f909e29707ef82bbbbd179e5bed92fb2be5..3a3e7323a66c35a9b9411bef3d9bfdc8911952fb 100644 (file)
 
 
 /**
- *   #Quad#s denote the fundamental entities of triangulations in two dimensions
+ *   @p{Quad}s denote the fundamental entities of triangulations in two dimensions
  *   and the boundaries of hexaeders in three dimensions. They are
  *   characterized by the (global) indices of the dour bounding lines.
  *
  *   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 implicitely given by the position
- *   in the #quads.quads# list attached to the information of each level
+ *   in the @p{quads.quads} list attached to the information of each level
  *   of the triangulation.
  *
  *   @author Wolfgang Bangerth, 1998
@@ -35,7 +35,7 @@ class Quad {
 
                                     /**
                                      *  Construct a Quad with line
-                                     *  indices #i0# through #i3#. By default,
+                                     *  indices @p{i0} through @p{i3}. By default,
                                      *  indices are set to -1, i.e. an
                                      *  invalid value.
                                      *
@@ -48,14 +48,14 @@ class Quad {
          const int i3 = -1);
     
                                     /**
-                                     *  Return the index of line #i#=0
+                                     *  Return the index of line @p{i}=0
                                      *  through 3.
                                      */
     int line (const int i) const;
     
                                     /**
-                                     *  Set the index of the #i#th line to
-                                     *  #index#. #i#=0 through 3.
+                                     *  Set the index of the @p{i}th line to
+                                     *  @p{index}. @p{i}=0 through 3.
                                      */
     void set_line (const int i, const int index);
     
index 0037d7e679a84f7d3665ca7677ec17ec64144a52..fd65894c5b579e55ce427f14f29e105a0ccb558f 100644 (file)
@@ -52,13 +52,13 @@ class MGLevelObject : public Subscriptor
                      const unsigned int maxlevel = 0);
     
                                     /**
-                                     * Access object on level #level#.
+                                     * Access object on level @p{level}.
                                      */
     Object & operator[] (const unsigned int level);
     
                                     /**
                                      * Access object on level
-                                     * #level#. Constant version.
+                                     * @p{level}. Constant version.
                                      */
     const Object & operator[] (const unsigned int level) const;
 
@@ -66,24 +66,24 @@ class MGLevelObject : public Subscriptor
                                      * Delete all previous contents
                                      * of this object and reset its
                                      * size according to the values
-                                     * of #new_minlevel# and
-                                     * #new_maxlevel#.
+                                     * of @p{new_minlevel} and
+                                     * @p{new_maxlevel}.
                                      */
     void resize (const unsigned int new_minlevel,
                 const unsigned int new_maxlevel);
     
                                     /**
-                                     * Call #clear# on all objects
+                                     * Call @p{clear} on all objects
                                      * stored by this object. This
                                      * function is only implemented
-                                     * for some #Object# classes,
+                                     * for some @p{Object} classes,
                                      * most notably for vectors and
                                      * matrices. Note that if
-                                     * #Object==Vector<T>#, #clear#
+                                     * @p{Object==Vector<T>}, @p{clear}
                                      * will set all entries to zero,
                                      * while if
-                                     * #Object==std::vector<T>#,
-                                     * #clear# deletes the elements
+                                     * @p{Object==std::vector<T>},
+                                     * @p{clear} deletes the elements
                                      * of the vectors. This class
                                      * might therefore not be useful
                                      * for STL vectors.
@@ -129,7 +129,7 @@ class MGCoarseGridSolver : public Subscriptor
                                      * This is only the interface for
                                      * a function defined in a derived
                                      * class like
-                                     * #MGCoarseGridLACIteration#.
+                                     * @p{MGCoarseGridLACIteration}.
                                      *
                                      * Note that the information
                                      * about the matrix is removed to
@@ -146,8 +146,8 @@ class MGCoarseGridSolver : public Subscriptor
  * This is a little wrapper, transforming a triplet of iterative
  * solver, matrix and preconditioner into a coarse grid solver.
  *
- * The type of the matrix (i.e. the template parameter #MATRIX#)
- * should be derived from #Subscriptor# to allow for the use of a
+ * The type of the matrix (i.e. the template parameter @p{MATRIX})
+ * should be derived from @p{Subscriptor} to allow for the use of a
  * smart pointer to it.
  *
  * @author Guido Kanschat, 1999
@@ -213,15 +213,15 @@ class MGTransferBase : public Subscriptor
 
                                     /**
                                      * Prolongate a vector from level
-                                     * #to_level-1# to level
-                                     * #to_level#. The previous
-                                     * content of #dst# is
+                                     * @p{to_level-1} to level
+                                     * @p{to_level}. The previous
+                                     * content of @p{dst} is
                                      * overwritten.
                                      *
-                                     * #src# is assumed to be a vector with
+                                     * @p{src} is assumed to be a vector with
                                      * as many elements as there are degrees
                                      * of freedom on the coarser level of
-                                     * the two involved levels, while #src#
+                                     * the two involved levels, while @p{src}
                                      * shall have as many elements as there
                                      * are degrees of freedom on the finer
                                      * level.
@@ -232,23 +232,23 @@ class MGTransferBase : public Subscriptor
 
                                     /**
                                      * Restrict a vector from level
-                                     * #from_level# to level
-                                     * #from_level-1# and add this
+                                     * @p{from_level} to level
+                                     * @p{from_level-1} and add this
                                      * restriction to
-                                     * #dst#. Obviously, if the
+                                     * @p{dst}. Obviously, if the
                                      * refined region on level
-                                     * #from_level# is smaller than
-                                     * that on level #from_level-1#,
+                                     * @p{from_level} is smaller than
+                                     * that on level @p{from_level-1},
                                      * some degrees of freedom in
-                                     * #dst# are not covered and will
+                                     * @p{dst} are not covered and will
                                      * not be altered. For the other
                                      * degress of freedom, the result
                                      * of the restriction is added.
                                      *
-                                     * #src# is assumed to be a vector with
+                                     * @p{src} is assumed to be a vector with
                                      * as many elements as there are degrees
                                      * of freedom on the finer level of
-                                     * the two involved levels, while #src#
+                                     * the two involved levels, while @p{src}
                                      * shall have as many elements as there
                                      * are degrees of freedom on the coarser
                                      * level.
@@ -270,10 +270,10 @@ class MGTransferBase : public Subscriptor
  * not sure that these restrictions on the class might cause numerical
  * inefficiencies.
  *
- * The function #precondition# is the actual multigrid method and
+ * The function @p{precondition} is the actual multigrid method and
  * makes use of several operations to be implemented in derived
- * classes. It takes a defect in #src# and the result is the multigrid
- * preconditioned defect in #dst#.
+ * classes. It takes a defect in @p{src} and the result is the multigrid
+ * preconditioned defect in @p{dst}.
  *
  * @author Guido Kanschat, 1999
  */
@@ -309,20 +309,20 @@ class MGBase : public Subscriptor
                                      * Execute one step of the
                                      * v-cycle algorithm.  This
                                      * function assumes, that the
-                                     * vector #d# is properly filled
+                                     * vector @p{d} is properly filled
                                      * with the residual in the outer
                                      * defect correction
                                      * scheme. After execution of
-                                     * #vcycle()#, the result is in
-                                     * the vector #s#. We propose to
-                                     * write functions #copy_from_mg#
-                                     * and #copy_to_mg# in derived
-                                     * classes of #MGBase# to access
-                                     * #d# and #s#.
+                                     * @p{vcycle()}, the result is in
+                                     * the vector @p{s}. We propose to
+                                     * write functions @p{copy_from_mg}
+                                     * and @p{copy_to_mg} in derived
+                                     * classes of @p{MGBase} to access
+                                     * @p{d} and @p{s}.
                                      *
                                      * The actual work for this
                                      * function is done in
-                                     * #level_mgstep#.
+                                     * @p{level_mgstep}.
                                      */
     void vcycle(const MGSmootherBase     &pre_smooth,
                const MGSmootherBase     &post_smooth,
@@ -363,13 +363,13 @@ class MGBase : public Subscriptor
 
                                     /**
                                      * The actual v-cycle multigrid method.
-                                     * #level# is the level the
+                                     * @p{level} is the level the
                                      * function should work on. It
                                      * will usually be called for the
                                      * highest level from outside,
                                      * but will then call itself
-                                     * recursively for #level-1#,
-                                     * unless we are on #minlevel#
+                                     * recursively for @p{level-1},
+                                     * unless we are on @p{minlevel}
                                      * where instead of recursing
                                      * deeper, the coarse grid solver
                                      * is used to solve the matrix of
@@ -381,7 +381,7 @@ class MGBase : public Subscriptor
                       const MGCoarseGridSolver &cgs);  
 
                                     /**
-                                     * Apply negative #vmult# on all
+                                     * Apply negative @p{vmult} on all
                                      * cells of a level.
                                      * This is implemented in a
                                      * derived class.
@@ -412,10 +412,10 @@ class MGBase : public Subscriptor
  * Here, we collect all information needed for multi-level preconditioning
  * and provide the standard interface for LAC iterative methods.
  *
- * The template parameter class #MG# is required to inherit #MGBase#.
- * Furthermore, it needs functions #void copy_to_mg(const VECTOR&)#
- * to store #src# in the right hand side of the multi-level method and
- * #void copy_from_mg(VECTOR&)# to store the result of the v-cycle in #dst#.
+ * The template parameter class @p{MG} is required to inherit @p{MGBase}.
+ * Furthermore, it needs functions @p{void copy_to_mg(const VECTOR&)}
+ * to store @p{src} in the right hand side of the multi-level method and
+ * @p{void copy_from_mg(VECTOR&)} to store the result of the v-cycle in @p{dst}.
  *
  * @author Guido Kanschat, 1999
  */
@@ -436,8 +436,8 @@ class PreconditionMG
     
                                     /**
                                      * Preconditioning operator,
-                                     * calling the #vcycle# function
-                                     * of the #MG# object passed to
+                                     * calling the @p{vcycle} function
+                                     * of the @p{MG} object passed to
                                      * the constructor.
                                      *
                                      * This is the operator used by
index 0ddec9695274442b1e346c0d212be26600aa7d09..18be3c550f05a5556cabbf1010f07c799199293f 100644 (file)
@@ -23,14 +23,14 @@ template <int dim> class MGDoFHandler;
  * a multigrid DoF handler object.
  *
  * Note that it is allowed to construct an object of which the
- * #mg_dof_handler# pointer is a Null pointer. Such an object would
+ * @p{mg_dof_handler} pointer is a Null pointer. Such an object would
  * result in a strange kind of behaviour, though every reasonable
  * operating system should disallow access through that pointer.
  * The reason we do not check for the null pointer in the
- * constructor which gets passed the #DoFHandler# pointer is that
+ * constructor which gets passed the @p{DoFHandler} pointer is that
  * if we did we could not make dof iterators member of other classes
- * (like in the #FEValues# class) if we did not know about the
- * #DoFHandler# object to be used upon construction of that object.
+ * (like in the @p{FEValues} class) if we did not know about the
+ * @p{DoFHandler} object to be used upon construction of that object.
  * Through the way this class is implemented here, we allow the
  * creation of a kind of virgin object which only gets useful if
  * assigned to from another object before first usage.
@@ -39,7 +39,7 @@ template <int dim> class MGDoFHandler;
  * which has an invalid dof handler pointer. This is to guarantee
  * that every iterator which is once assigned to is a valid
  * object. However, this assertion only holds in debug mode, when
- * the #Assert# macro is switched on.
+ * the @p{Assert} macro is switched on.
  *
  * @author Wolfgang Bangerth, 1998
  */
@@ -55,7 +55,7 @@ class MGDoFAccessor {
 
                                     /**
                                      * This should be the default constructor.
-                                     * We cast away the #const#ness of the
+                                     * We cast away the @p{const}ness of the
                                      * pointer which clearly is EVIL but
                                      * we can't help without making all
                                      * functions which could somehow use
@@ -89,7 +89,7 @@ class MGDoFAccessor {
 
   protected:
                                     /**
-                                     * Store the address of the #MGDoFHandler# object
+                                     * Store the address of the @p{MGDoFHandler} object
                                      * to be accessed.
                                      */
     MGDoFHandler<dim> *mg_dof_handler;  
@@ -99,14 +99,14 @@ class MGDoFAccessor {
 /* -------------------------------------------------------------------------- */
 
 /**
- * This is a switch class which only declares a #typdef#. It is meant to
- * determine which class a #MGDoFObjectAccessor# class is to be derived
- * from. By default, #MGDoFObjectAccessor<celldim,dim># derives from
- * the #typedef# in the general #MGDoFObjectAccessor_Inheritance<celldim,dim>#
- * class, which is #DoFObjectAccessor<celldim,dim>#,
- * but if #celldim==dim#, then the specialization #MGDoFObjectAccessor_Inheritance<dim,dim>#
- * is used which declares its local type to be #DoFCellAccessor<dim>#. Therefore,
- * the inheritance is automatically chosen to be from #DoFCellAccessor# if the
+ * 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,
+ * the inheritance is automatically chosen to be from @p{DoFCellAccessor} if the
  * object under consideration has full dimension, i.e. constitutes a cell.
  *
  * @author Wolfgang Bangerth, 1999
@@ -115,7 +115,7 @@ template <int celldim, int dim>
 class MGDoFObjectAccessor_Inheritance 
 {
                                     /**
-                                     * Declaration of the #typedef#.
+                                     * Declaration of the @p{typedef}.
                                      * See the full documentation for
                                      * more information.
                                      */
@@ -124,14 +124,14 @@ class MGDoFObjectAccessor_Inheritance
 
 
 /**
- * This is a switch class which only declares a #typdef#. It is meant to
- * determine which class a #DoFObjectAccessor# class is to be derived
- * from. By default, #DoFObjectAccessor<celldim,dim># derives from
- * the #typedef# in the general #DoFObjectAccessor_Inheritance<celldim,dim>#
- * class, which is #TriaObjectAccessor<celldim,dim>#,
- * but if #celldim==dim#, then the specialization #TriaObjectAccessor<dim,dim>#
- * is used which declares its local type to be #CellAccessor<dim>#. Therefore,
- * the inheritance is automatically chosen to be from #CellAccessor# if the
+ * 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,
+ * the inheritance is automatically chosen to be from @p{CellAccessor} if the
  * object under consideration has full dimension, i.e. constitutes a cell.
  *
  * @author Wolfgang Bangerth, 1999
@@ -140,7 +140,7 @@ template <int dim>
 class MGDoFObjectAccessor_Inheritance<dim,dim>
 {
                                     /**
-                                     * Declaration of the #typedef#.
+                                     * Declaration of the @p{typedef}.
                                      * See the full documentation for
                                      * more information.
                                      */
@@ -197,7 +197,7 @@ class MGDoFObjectAccessor<0, dim>
  * lines in 1D-, 2D-, etc dimensions).
  *
  *
- * \subsection{Usage}
+ * @sect3{Usage}
  *
  * The \Ref{DoFDimensionInfo} classes inherited by the \Ref{DoFHandler} classes
  * declare typedefs to iterators using the accessors declared in this class
@@ -206,11 +206,11 @@ class MGDoFObjectAccessor<0, dim>
  * as they provide easier typing (much less complicated names!).
  * 
  * 
- * \subsection{Notes about the class hierarchy structure}
+ * @sect3{Notes about the class hierarchy structure}
  *
- * Inheritance from #MGDoFObjectAccessor_Inheritance<1,dim>::BaseClass# yields
- * inheritance from #DoFCellAccessor<1># if #dim==1# and from
- * #TriaObjectAccessor<1,dim># for all other #dim# values. Thus, an object
+ * 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
  * of this class shares all features of cells in one dimension, but behaves
  * like an ordinary line in all other cases.
  *
@@ -235,9 +235,9 @@ class MGDoFObjectAccessor<1, dim> :  public MGDoFAccessor<dim>,
     MGDoFObjectAccessor ();
     
                                     /**
-                                     * Constructor. The #local_data#
+                                     * Constructor. The @p{local_data}
                                      * argument is assumed to be a pointer
-                                     * to a #MGDoFHandler<dim># object.
+                                     * to a @p{MGDoFHandler<dim>} object.
                                      */
     MGDoFObjectAccessor (Triangulation<dim> *tria,
                         const int           level,
@@ -245,31 +245,31 @@ class MGDoFObjectAccessor<1, dim> :  public MGDoFAccessor<dim>,
                         const AccessorData *local_data);
     
                                     /**
-                                     * Return the index of the #i#th degree
+                                     * Return the index of the @p{i}th degree
                                      * of freedom of this line on the level
                                      * this line lives on.
                                      */
     unsigned int mg_dof_index (const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the #i#th degree
+                                     * Set the index of the @p{i}th degree
                                      * of freedom of this line on the
-                                     * level this line lives on to #index#.
+                                     * level this line lives on to @p{index}.
                                      */
     void set_mg_dof_index (const unsigned int i,
                           const unsigned int index) const;
 
                                     /**
-                                     * Return the index of the #i#th degree
-                                     * on the #vertex#th vertex for the
+                                     * Return the index of the @p{i}th degree
+                                     * on the @p{vertex}th vertex for the
                                      * level this line lives on.
                                      */
     unsigned int mg_vertex_dof_index (const unsigned int vertex,
                                      const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the #i#th degree
-                                     * on the #vertex#th vertex to #index#
+                                     * Set the index of the @p{i}th degree
+                                     * on the @p{vertex}th vertex to @p{index}
                                      * for the level this line lives on.
                                      */
     void set_mg_vertex_dof_index (const unsigned int vertex,
@@ -311,7 +311,7 @@ class MGDoFObjectAccessor<1, dim> :  public MGDoFAccessor<dim>,
                            Vector<number>       &dof_values) const;
 
                                     /**
-                                     * Return the #i#th child as a MGDoF line
+                                     * Return the @p{i}th child as a MGDoF line
                                      * iterator. This function is needed since
                                      * the child function of the base
                                      * class returns a line accessor without
@@ -351,9 +351,9 @@ class MGDoFObjectAccessor<2, dim> :  public MGDoFAccessor<dim>,
     MGDoFObjectAccessor ();
 
                                     /**
-                                     * Constructor. The #local_data#
+                                     * Constructor. The @p{local_data}
                                      * argument is assumed to be a pointer
-                                     * to a #DoFHandler<dim># object.
+                                     * to a @p{DoFHandler<dim>} object.
                                      */
     MGDoFObjectAccessor (Triangulation<dim> *tria,
                       const int           level,
@@ -361,32 +361,32 @@ class MGDoFObjectAccessor<2, dim> :  public MGDoFAccessor<dim>,
                       const AccessorData *local_data);
     
                                     /**
-                                     * Return the index of the #i#th degree
+                                     * Return the index of the @p{i}th degree
                                      * of freedom of this quad on the level
                                      * this quad lives on.
                                      */
     unsigned int mg_dof_index (const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the #i#th degree
+                                     * Set the index of the @p{i}th degree
                                      * of freedom of this quad on the
-                                     * level this quad lives on to #index#.
+                                     * level this quad lives on to @p{index}.
                                      */
     void set_mg_dof_index (const unsigned int i,
                           const unsigned int index) const;
 
                                     /**
-                                     * Return the index of the #i#th degree
-                                     * on the #vertex#th vertex for the level
+                                     * Return the index of the @p{i}th degree
+                                     * on the @p{vertex}th vertex for the level
                                      * this quad lives on.
                                      */
     unsigned int mg_vertex_dof_index (const unsigned int vertex,
                                      const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the #i#th degree
-                                     * on the #vertex#th vertex for the
-                                     * level this quad lives on to #index#.
+                                     * Set the index of the @p{i}th degree
+                                     * on the @p{vertex}th vertex for the
+                                     * level this quad lives on to @p{index}.
                                      */
     void set_mg_vertex_dof_index (const unsigned int vertex,
                                  const unsigned int i,
@@ -428,14 +428,14 @@ class MGDoFObjectAccessor<2, dim> :  public MGDoFAccessor<dim>,
                            Vector<number>       &dof_values) const;
 
                                     /**
-                                     * Return a pointer to the #i#th line
-                                     * bounding this #Quad#.
+                                     * Return a pointer to the @p{i}th line
+                                     * bounding this @p{Quad}.
                                      */
     TriaIterator<dim,MGDoFObjectAccessor<1, dim> >
     line (const unsigned int i) const;
 
                                     /**
-                                     * Return the #i#th child as a DoF quad
+                                     * Return the @p{i}th child as a DoF quad
                                      * iterator. This function is needed since
                                      * the child function of the base
                                      * class returns a quad accessor without
@@ -476,9 +476,9 @@ class MGDoFObjectAccessor<3, dim> :  public MGDoFAccessor<dim>,
     MGDoFObjectAccessor ();
 
                                     /**
-                                     * Constructor. The #local_data#
+                                     * Constructor. The @p{local_data}
                                      * argument is assumed to be a pointer
-                                     * to a #DoFHandler<dim># object.
+                                     * to a @p{DoFHandler<dim>} object.
                                      */
     MGDoFObjectAccessor (Triangulation<dim> *tria,
                      const int           level,
@@ -486,32 +486,32 @@ class MGDoFObjectAccessor<3, dim> :  public MGDoFAccessor<dim>,
                      const AccessorData *local_data);
     
                                     /**
-                                     * Return the index of the #i#th degree
+                                     * Return the index of the @p{i}th degree
                                      * of freedom of this hex on the level
                                      * this quad lives on.
                                      */
     unsigned int mg_dof_index (const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the #i#th degree
+                                     * Set the index of the @p{i}th degree
                                      * of freedom of this hex on the
-                                     * level this hex lives on to #index#.
+                                     * level this hex lives on to @p{index}.
                                      */
     void set_mg_dof_index (const unsigned int i,
                           const unsigned int index) const;
 
                                     /**
-                                     * Return the index of the #i#th degree
-                                     * on the #vertex#th vertex for the level
+                                     * Return the index of the @p{i}th degree
+                                     * on the @p{vertex}th vertex for the level
                                      * this hex lives on.
                                      */
     unsigned int mg_vertex_dof_index (const unsigned int vertex,
                                      const unsigned int i) const;
 
                                     /**
-                                     * Set the index of the #i#th degree
-                                     * on the #vertex#th vertex for the
-                                     * level this hex lives on to #index#.
+                                     * Set the index of the @p{i}th degree
+                                     * on the @p{vertex}th vertex for the
+                                     * level this hex lives on to @p{index}.
                                      */
     void set_mg_vertex_dof_index (const unsigned int vertex,
                                  const unsigned int i,
@@ -553,21 +553,21 @@ class MGDoFObjectAccessor<3, dim> :  public MGDoFAccessor<dim>,
                            Vector<number>       &dof_values) const;
 
                                     /**
-                                     * Return a pointer to the #i#th line
-                                     * bounding this #Hex#.
+                                     * Return a pointer to the @p{i}th line
+                                     * bounding this @p{Hex}.
                                      */
     TriaIterator<dim,MGDoFObjectAccessor<1, dim> >
     line (const unsigned int i) const;
 
                                     /**
-                                     * Return a pointer to the #i#th quad
-                                     * bounding this #Hex#.
+                                     * Return a pointer to the @p{i}th quad
+                                     * bounding this @p{Hex}.
                                      */
     TriaIterator<dim,MGDoFObjectAccessor<2, dim> >
     quad (const unsigned int i) const;
 
                                     /**
-                                     * Return the #i#th child as a DoF quad
+                                     * Return the @p{i}th child as a DoF quad
                                      * iterator. This function is needed since
                                      * the child function of the base
                                      * class returns a hex accessor without
@@ -586,13 +586,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
- * #DoFObjectAccessor<1, 1># and #DoFObjectAccessor<2, 2># for the space dimension
+ * @p{DoFObjectAccessor<1, 1>} and @p{DoFObjectAccessor<2, 2>} for the space dimension
  * one and two, respectively, this class only collects the pieces
- * together by deriving from the appropriate #DoF*Accessor# and the
- * right #CellAccessor<dim># 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 #CellAccessor<dim># class).
+ * together by deriving from the appropriate @p{DoF*Accessor} and the
+ * right @p{CellAccessor<dim>} and finally adding two functions which give
+ * access to the neighbors and children as @p{DoFCellAccessor} objects
+ * rather than @p{CellAccessor} objects (the latter function was inherited
+ * from the @p{CellAccessor<dim>} class).
  *
  * @author Wolfgang Bangerth, 1998
  */
@@ -622,7 +622,7 @@ class MGDoFCellAccessor :  public MGDoFObjectAccessor<dim, dim> {
                    MGDoFObjectAccessor<dim, dim> (tria,level,index,local_data) {};
 
                                     /**
-                                     * Return the #i#th neighbor as a MGDoF cell
+                                     * Return the @p{i}th neighbor as a MGDoF cell
                                      * iterator. This function is needed since
                                      * the neighbor function of the base
                                      * class returns a cell accessor without
@@ -631,7 +631,7 @@ class MGDoFCellAccessor :  public MGDoFObjectAccessor<dim, dim> {
     TriaIterator<dim,MGDoFCellAccessor<dim> > neighbor (const unsigned int) const;
 
                                     /**
-                                     * Return the #i#th child as a MGDoF cell
+                                     * Return the @p{i}th child as a MGDoF cell
                                      * iterator. This function is needed since
                                      * the child function of the base
                                      * class returns a cell accessor without
@@ -640,7 +640,7 @@ class MGDoFCellAccessor :  public MGDoFObjectAccessor<dim, dim> {
     TriaIterator<dim,MGDoFCellAccessor<dim> > child (const unsigned int) const;
 
                                     /**
-                                     * Return an iterator to the #i#th face
+                                     * Return an iterator to the @p{i}th face
                                      * of this cell.
                                      *
                                      * This function is not implemented in 1D,
index 4db78746b61b6d302b561363bb5904a5bc52b4f3..d1661cdc955af0b6961d5d32d50d309663a13761 100644 (file)
@@ -122,7 +122,7 @@ class MGDoFDimensionInfo<3> {
 
 /**
  * This class manages degrees of freedom for a multilevel hierarchy of
- * grids. It does mostly the same as does the #DoDHandler# class, but
+ * grids. It does mostly the same as does the @p{DoDHandler} class, but
  * it uses a separate enumeration of the degrees of freedom on each
  * level. For example, a vertex has several DoF numbers, one for each
  * level of the triangulation on which it exists.
@@ -158,7 +158,7 @@ class MGDoFHandler : public DoFHandler<dim>
     typedef typename MGDoFDimensionInfo<dim>::active_face_iterator active_face_iterator;
 
                                     /**
-                                     * Constructor. Take #tria# as the
+                                     * Constructor. Take @p{tria} as the
                                      * triangulation to work on.
                                      */
     MGDoFHandler (Triangulation<dim> &tria);
@@ -173,7 +173,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * distribute the degrees of freedoms
                                      * needed for the given finite element
                                      * according to the given distribution
-                                     * method. We first call the #DoFHandler#'s
+                                     * method. We first call the @p{DoFHandler}'s
                                      * function and then distribute the
                                      * levelwise numbers.
                                      *
@@ -192,7 +192,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                      * a list of new dof numbers for all the
                                      * dofs. 
                                      *
-                                     * #new_numbers# is an array of integers
+                                     * @p{new_numbers} is an array of integers
                                      * with size equal to the number of dofs
                                      * on the present level. It stores the new
                                      * indices after renumbering in the
@@ -209,30 +209,30 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /*@{*/
                                     /**
                                      *  Iterator to the first cell, used
-                                     *  or not, on level #level#. If a level
+                                     *  or not, on level @p{level}. If a level
                                      *  has no cells, a past-the-end iterator
                                      *  is returned.
                                      *
-                                     *  This function calls #begin_raw_line#
-                                     *  in 1D and #begin_raw_quad# in 2D.
+                                     *  This function calls @p{begin_raw_line}
+                                     *  in 1D and @p{begin_raw_quad} in 2D.
                                      */
     raw_cell_iterator    begin_raw   (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first used cell
-                                     *  on level #level#.
+                                     *  on level @p{level}.
                                      *
-                                     *  This function calls #begin_line#
-                                     *  in 1D and #begin_quad# in 2D.
+                                     *  This function calls @p{begin_line}
+                                     *  in 1D and @p{begin_quad} in 2D.
                                      */
     cell_iterator        begin       (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first active
-                                     *  cell on level #level#.
+                                     *  cell on level @p{level}.
                                      *
-                                     *  This function calls #begin_active_line#
-                                     *  in 1D and #begin_active_quad# in 2D.
+                                     *  This function calls @p{begin_active_line}
+                                     *  in 1D and @p{begin_active_quad} in 2D.
                                      */
     active_cell_iterator begin_active(const unsigned int level = 0) const;
 
@@ -242,32 +242,32 @@ class MGDoFHandler : public DoFHandler<dim>
                                      *  iterators with past-the-end or
                                      *  before-the-beginning states.
                                      *
-                                     *  This function calls #end_line#
-                                     *  in 1D and #end_quad# in 2D.
+                                     *  This function calls @p{end_line}
+                                     *  in 1D and @p{end_quad} in 2D.
                                      */
     raw_cell_iterator    end () const;
 
                                     /**
                                      * Return an iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     cell_iterator        end (const unsigned int level) const;
     
                                     /**
                                      * Return a raw iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     raw_cell_iterator    end_raw (const unsigned int level) const;
 
                                     /**
                                      * Return an active iterator which is the
-                                     * first iterator not on level. If #level#
+                                     * first iterator not on level. If @p{level}
                                      * is the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     active_cell_iterator end_active (const unsigned int level) const;
 
@@ -275,17 +275,17 @@ class MGDoFHandler : public DoFHandler<dim>
                                      *  Return an iterator pointing to the
                                      *  last cell, used or not.
                                      *
-                                     *  This function calls #last_raw_line#
-                                     *  in 1D and #last_raw_quad# in 2D.
+                                     *  This function calls @p{last_raw_line}
+                                     *  in 1D and @p{last_raw_quad} in 2D.
                                      */
     raw_cell_iterator    last_raw () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  cell of the level #level#, used or not.
+                                     *  cell of the level @p{level}, used or not.
                                      *
-                                     *  This function calls #last_raw_line#
-                                     *  in 1D and #last_raw_quad# in 2D.
+                                     *  This function calls @p{last_raw_line}
+                                     *  in 1D and @p{last_raw_quad} in 2D.
                                      */
     raw_cell_iterator    last_raw (const unsigned int level) const;
 
@@ -293,17 +293,17 @@ class MGDoFHandler : public DoFHandler<dim>
                                      *  Return an iterator pointing to the last
                                      *  used cell.
                                      *
-                                     *  This function calls #last_line#
-                                     *  in 1D and #last_quad# in 2D.
+                                     *  This function calls @p{last_line}
+                                     *  in 1D and @p{last_quad} in 2D.
                                      */
     cell_iterator        last () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  used cell on level #level#.
+                                     *  used cell on level @p{level}.
                                      *
-                                     *  This function calls #last_line#
-                                     *  in 1D and #last_quad# in 2D.
+                                     *  This function calls @p{last_line}
+                                     *  in 1D and @p{last_quad} in 2D.
                                      */
     cell_iterator        last (const unsigned int level) const;
 
@@ -311,17 +311,17 @@ class MGDoFHandler : public DoFHandler<dim>
                                      *  Return an iterator pointing to the last
                                      *  active cell.
                                      *
-                                     *  This function calls #last_active_line#
-                                     *  in 1D and #last_active_quad# in 2D.
+                                     *  This function calls @p{last_active_line}
+                                     *  in 1D and @p{last_active_quad} in 2D.
                                      */
     active_cell_iterator last_active () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  active cell on level #level#.
+                                     *  active cell on level @p{level}.
                                      *
-                                     *  This function calls #last_active_line#
-                                     *  in 1D and #last_active_quad# in 2D.
+                                     *  This function calls @p{last_active_line}
+                                     *  in 1D and @p{last_active_quad} in 2D.
                                      */
     active_cell_iterator last_active (const unsigned int level) const;
                                     //@}
@@ -334,30 +334,30 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /*@{*/
                                     /**
                                      *  Iterator to the first face, used
-                                     *  or not, on level #level#. If a level
+                                     *  or not, on level @p{level}. If a level
                                      *  has no faces, a past-the-end iterator
                                      *  is returned.
                                      *
-                                     *  This function calls #begin_raw_line#
-                                     *  in 2D and #begin_raw_quad# in 3D.
+                                     *  This function calls @p{begin_raw_line}
+                                     *  in 2D and @p{begin_raw_quad} in 3D.
                                      */
     raw_face_iterator    begin_raw_face   (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first used face
-                                     *  on level #level#.
+                                     *  on level @p{level}.
                                      *
-                                     *  This function calls #begin_line#
-                                     *  in 2D and #begin_quad# in 3D.
+                                     *  This function calls @p{begin_line}
+                                     *  in 2D and @p{begin_quad} in 3D.
                                      */
     face_iterator        begin_face       (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first active
-                                     *  face on level #level#.
+                                     *  face on level @p{level}.
                                      *
-                                     *  This function calls #begin_active_line#
-                                     *  in 2D and #begin_active_quad# in 3D.
+                                     *  This function calls @p{begin_active_line}
+                                     *  in 2D and @p{begin_active_quad} in 3D.
                                      */
     active_face_iterator begin_active_face(const unsigned int level = 0) const;
 
@@ -367,32 +367,32 @@ class MGDoFHandler : public DoFHandler<dim>
                                      *  iterators with past-the-end or
                                      *  before-the-beginning states.
                                      *
-                                     *  This function calls #end_line#
-                                     *  in 2D and #end_quad# in 3D.
+                                     *  This function calls @p{end_line}
+                                     *  in 2D and @p{end_quad} in 3D.
                                      */
     raw_face_iterator    end_face () const;
 
                                     /**
                                      * Return an iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     face_iterator        end_face (const unsigned int level) const;
     
                                     /**
                                      * Return a raw iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     raw_face_iterator    end_raw_face (const unsigned int level) const;
 
                                     /**
                                      * Return an active iterator which is the
-                                     * first iterator not on level. If #level#
+                                     * first iterator not on level. If @p{level}
                                      * is the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     active_face_iterator end_active_face (const unsigned int level) const;
 
@@ -400,17 +400,17 @@ class MGDoFHandler : public DoFHandler<dim>
                                      *  Return an iterator pointing to the
                                      *  last face, used or not.
                                      *
-                                     *  This function calls #last_raw_line#
-                                     *  in 2D and #last_raw_quad# in 3D.
+                                     *  This function calls @p{last_raw_line}
+                                     *  in 2D and @p{last_raw_quad} in 3D.
                                      */
     raw_face_iterator    last_raw_face () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  face of the level #level#, used or not.
+                                     *  face of the level @p{level}, used or not.
                                      *
-                                     *  This function calls #last_raw_line#
-                                     *  in 2D and #last_raw_quad# in 3D.
+                                     *  This function calls @p{last_raw_line}
+                                     *  in 2D and @p{last_raw_quad} in 3D.
                                      */
     raw_face_iterator    last_raw_face (const unsigned int level) const;
 
@@ -418,17 +418,17 @@ class MGDoFHandler : public DoFHandler<dim>
                                      *  Return an iterator pointing to the last
                                      *  used face.
                                      *
-                                     *  This function calls #last_line#
-                                     *  in 2D and #last_quad# in 3D.
+                                     *  This function calls @p{last_line}
+                                     *  in 2D and @p{last_quad} in 3D.
                                      */
     face_iterator        last_face () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  used face on level #level#.
+                                     *  used face on level @p{level}.
                                      *
-                                     *  This function calls #last_line#
-                                     *  in 2D and #last_quad# in 3D.
+                                     *  This function calls @p{last_line}
+                                     *  in 2D and @p{last_quad} in 3D.
                                      */
     face_iterator        last_face (const unsigned int level) const;
 
@@ -436,17 +436,17 @@ class MGDoFHandler : public DoFHandler<dim>
                                      *  Return an iterator pointing to the last
                                      *  active face.
                                      *
-                                     *  This function calls #last_active_line#
-                                     *  in 2D and #last_active_quad# in 3D.
+                                     *  This function calls @p{last_active_line}
+                                     *  in 2D and @p{last_active_quad} in 3D.
                                      */
     active_face_iterator last_active_face () const;
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  active face on level #level#.
+                                     *  active face on level @p{level}.
                                      *
-                                     *  This function calls #last_active_line#
-                                     *  in 2D and #last_active_quad# in 3D.
+                                     *  This function calls @p{last_active_line}
+                                     *  in 2D and @p{last_active_quad} in 3D.
                                      */
     active_face_iterator last_active_face (const unsigned int level) const;
                                     //@}
@@ -460,7 +460,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                     /*@{*/
                                     /**
                                      *  Iterator to the first line, used
-                                     *  or not, on level #level#. If a level
+                                     *  or not, on level @p{level}. If a level
                                      *  has no lines, a past-the-end iterator
                                      *  is returned.
                                      */
@@ -468,13 +468,13 @@ class MGDoFHandler : public DoFHandler<dim>
 
                                     /**
                                      *  Iterator to the first used line
-                                     *  on level #level#.
+                                     *  on level @p{level}.
                                      */
     line_iterator     begin_line (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first active
-                                     *  line on level #level#.
+                                     *  line on level @p{level}.
                                      */
     active_line_iterator begin_active_line(const unsigned int level = 0) const;
 
@@ -488,25 +488,25 @@ class MGDoFHandler : public DoFHandler<dim>
 
                                     /**
                                      * Return an iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     line_iterator        end_line (const unsigned int level) const;
     
                                     /**
                                      * Return a raw iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     raw_line_iterator    end_raw_line (const unsigned int level) const;
 
                                     /**
                                      * Return an active iterator which is the
-                                     * first iterator not on level. If #level#
+                                     * first iterator not on level. If @p{level}
                                      * is the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     active_line_iterator end_active_line (const unsigned int level) const;
 
@@ -519,7 +519,7 @@ class MGDoFHandler : public DoFHandler<dim>
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  line of the level #level#, used or not.
+                                     *  line of the level @p{level}, used or not.
 
                                      */
     raw_line_iterator    last_raw_line (const unsigned int level) const;
@@ -532,7 +532,7 @@ class MGDoFHandler : public DoFHandler<dim>
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  used line on level #level#.
+                                     *  used line on level @p{level}.
                                      */
     line_iterator        last_line (const unsigned int level) const;
 
@@ -544,7 +544,7 @@ class MGDoFHandler : public DoFHandler<dim>
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  active line on level #level#.
+                                     *  active line on level @p{level}.
                                      */
     active_line_iterator last_active_line (const unsigned int level) const;
                                     /*@}*/       
@@ -557,7 +557,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                      */
                                     /**
                                      *  Iterator to the first quad, used
-                                     *  or not, on level #level#. If a level
+                                     *  or not, on level @p{level}. If a level
                                      *  has no quads, a past-the-end iterator
                                      *  is returned.
                                      */
@@ -565,13 +565,13 @@ class MGDoFHandler : public DoFHandler<dim>
 
                                     /**
                                      *  Iterator to the first used quad
-                                     *  on level #level#.
+                                     *  on level @p{level}.
                                      */
     quad_iterator        begin_quad       (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first active
-                                     *  quad on level #level#.
+                                     *  quad on level @p{level}.
                                      */
     active_quad_iterator begin_active_quad(const unsigned int level = 0) const;
 
@@ -585,25 +585,25 @@ class MGDoFHandler : public DoFHandler<dim>
 
                                     /**
                                      * Return an iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     quad_iterator        end_quad (const unsigned int level) const;
     
                                     /**
                                      * Return a raw iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     raw_quad_iterator    end_raw_quad (const unsigned int level) const;
 
                                     /**
                                      * Return an active iterator which is the
-                                     * first iterator not on level. If #level#
+                                     * first iterator not on level. If @p{level}
                                      * is the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     active_quad_iterator end_active_quad (const unsigned int level) const;
 
@@ -616,7 +616,7 @@ class MGDoFHandler : public DoFHandler<dim>
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  quad of the level #level#, used or not.
+                                     *  quad of the level @p{level}, used or not.
 
                                      */
     raw_quad_iterator    last_raw_quad (const unsigned int level) const;
@@ -629,7 +629,7 @@ class MGDoFHandler : public DoFHandler<dim>
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  used quad on level #level#.
+                                     *  used quad on level @p{level}.
                                      */
     quad_iterator        last_quad (const unsigned int level) const;
 
@@ -641,7 +641,7 @@ class MGDoFHandler : public DoFHandler<dim>
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  active quad on level #level#.
+                                     *  active quad on level @p{level}.
                                      */
     active_quad_iterator last_active_quad (const unsigned int level) const;
                                     /*@}*/
@@ -654,7 +654,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                      */
                                     /**
                                      *  Iterator to the first hex, used
-                                     *  or not, on level #level#. If a level
+                                     *  or not, on level @p{level}. If a level
                                      *  has no hexs, a past-the-end iterator
                                      *  is returned.
                                      */
@@ -662,13 +662,13 @@ class MGDoFHandler : public DoFHandler<dim>
 
                                     /**
                                      *  Iterator to the first used hex
-                                     *  on level #level#.
+                                     *  on level @p{level}.
                                      */
     hex_iterator        begin_hex       (const unsigned int level = 0) const;
 
                                     /**
                                      *  Iterator to the first active
-                                     *  hex on level #level#.
+                                     *  hex on level @p{level}.
                                      */
     active_hex_iterator begin_active_hex(const unsigned int level = 0) const;
 
@@ -682,25 +682,25 @@ class MGDoFHandler : public DoFHandler<dim>
 
                                     /**
                                      * Return an iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     hex_iterator        end_hex (const unsigned int level) const;
     
                                     /**
                                      * Return a raw iterator which is the first
-                                     * iterator not on level. If #level# is
+                                     * iterator not on level. If @p{level} is
                                      * the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     raw_hex_iterator    end_raw_hex (const unsigned int level) const;
 
                                     /**
                                      * Return an active iterator which is the
-                                     * first iterator not on level. If #level#
+                                     * first iterator not on level. If @p{level}
                                      * is the last level, then this returns
-                                     * #end()#.
+                                     * @p{end()}.
                                      */
     active_hex_iterator end_active_hex (const unsigned int level) const;
 
@@ -713,7 +713,7 @@ class MGDoFHandler : public DoFHandler<dim>
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  hex of the level #level#, used or not.
+                                     *  hex of the level @p{level}, used or not.
 
                                      */
     raw_hex_iterator    last_raw_hex (const unsigned int level) const;
@@ -726,7 +726,7 @@ class MGDoFHandler : public DoFHandler<dim>
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  used hex on level #level#.
+                                     *  used hex on level @p{level}.
                                      */
     hex_iterator        last_hex (const unsigned int level) const;
 
@@ -738,7 +738,7 @@ class MGDoFHandler : public DoFHandler<dim>
 
                                     /**
                                      *  Return an iterator pointing to the last
-                                     *  active hex on level #level#.
+                                     *  active hex on level @p{level}.
                                      */
     active_hex_iterator last_active_hex (const unsigned int level) const;
                                     /*@}*/
@@ -789,7 +789,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                          * because it is difficult to make it
                                          * efficient to use vector<>'s and
                                          * still construct the object using
-                                         * the constructor. Use the #init#
+                                         * the constructor. Use the @p{init}
                                          * function to really allocate
                                          * memory.
                                          */
@@ -797,7 +797,7 @@ class MGDoFHandler : public DoFHandler<dim>
 
                                         /**
                                          * Allocate memory and
-                                         * set all indices to #-1#.
+                                         * set all indices to @p{-1}.
                                          */
        void init (const unsigned int coarsest_level,
                   const unsigned int finest_level,
@@ -810,8 +810,8 @@ class MGDoFHandler : public DoFHandler<dim>
 
                                         /**
                                          * Set the index with number
-                                         * #dof_number# of this vertex on
-                                         * #level# to the given index. To
+                                         * @p{dof_number} of this vertex on
+                                         * @p{level} to the given index. To
                                          * compute the position in the array,
                                          * one has to specify how many
                                          * dofs per vertex there are. It is
@@ -829,8 +829,8 @@ class MGDoFHandler : public DoFHandler<dim>
        
                                         /**
                                          * Return the index with number
-                                         * #dof_number# of this vertex on
-                                         * #level#. To
+                                         * @p{dof_number} of this vertex on
+                                         * @p{level}. To
                                          * compute the position in the array,
                                          * one has to specify how many
                                          * dofs per vertex there are. It is
@@ -886,7 +886,7 @@ class MGDoFHandler : public DoFHandler<dim>
                                          * Finest level this level lives on.
                                          * This is mostly used for error
                                          * checking but can also be accessed
-                                         * by the function #get_finest_level#.
+                                         * by the function @p{get_finest_level}.
                                          */
        unsigned int finest_level;
 
@@ -900,14 +900,14 @@ class MGDoFHandler : public DoFHandler<dim>
 /**
                                      * Distribute dofs on the given cell,
                                      * with new dofs starting with index
-                                     * #next_free_dof#. Return the next
+                                     * @p{next_free_dof}. Return the next
                                      * unused index number. The finite
                                      * element used is the one given to
-                                     * #distribute_dofs#, which is copied
-                                     * to #selected_fe#.
+                                     * @p{distribute_dofs}, which is copied
+                                     * to @p{selected_fe}.
                                      *
                                      * This function is excluded from the
-                                     * #distribute_dofs# function since
+                                     * @p{distribute_dofs} function since
                                      * it can not be implemented dimension
                                      * independent.
                                      *
@@ -926,8 +926,8 @@ class MGDoFHandler : public DoFHandler<dim>
 
                                     /**
                                      * Space to store the DoF numbers for the
-                                     * different levels. Unlike the #levels#
-                                     * object in the #DoFHandler#, these are
+                                     * different levels. Unlike the @p{levels}
+                                     * object in the @p{DoFHandler}, these are
                                      * not global numbers but rather are
                                      * numbers which start from zero on each
                                      * level.
index 224483b997c498093bea386ec25f812ce5c2ffb5..37e7a0105c5794695b0e51758ee9e18e86b5db02 100644 (file)
 /**
  * This is a collection of functions operating on, and manipulating
  * the numbers of degrees of freedom in a multilevel triangulation. It
- * is similar in purpose and function to the #DoFTools# class, but
- * operates on #MGDoFHandler# objects instead of #DoFHandler#
+ * is similar in purpose and function to the @p{DoFTools} class, but
+ * operates on @p{MGDoFHandler} objects instead of @p{DoFHandler}
  * objects. See there and the documentation of the member functions
  * for more information.
  *
  * All member functions are static, so there is no need to create an
- * object of class #MGDoFTools#.
+ * object of class @p{MGDoFTools}.
  *
  * @author Wolfgang Bangerth, Guido Kanschat, 1999, 2000
  */
@@ -35,12 +35,12 @@ class MGDoFTools
                                     /**
                                      * Write the sparsity structure
                                      * of the matrix belonging to the
-                                     * specified #level#. The sparsity pattern
+                                     * specified @p{level}. The sparsity pattern
                                      * is not compressed, so before 
                                      * creating the actual matrix
                                      * you have to compress the
                                      * matrix yourself, using
-                                     * #SparseMatrixStruct::compress()#.
+                                     * @p{SparseMatrixStruct::compress()}.
                                      *
                                      * There is no need to consider
                                      * hanging nodes here, since only
index dd5dc9b3c87f748df0cdcae8e66c8393aa244041..c3634b403a7b0931ca48b194cb00036ab22d1428 100644 (file)
@@ -24,7 +24,7 @@ template <int dim> class MGDoFHandler;
 /**
  * Abstract base class for multigrid smoothers.
  * In fact, this class only provides the interface of the smoothing function.
- * Using #deal.II# grid handling, #MGSmoother# is a good point to start.
+ * Using @p{deal.II} grid handling, @p{MGSmoother} is a good point to start.
  *
  * @author Wolfgang Bangerth, Guido Kanschat, 1999
  */
@@ -39,20 +39,20 @@ class MGSmootherBase :  public Subscriptor
     virtual ~MGSmootherBase();
     
                                     /**
-                                     * Smooth the residual of #u# on
+                                     * Smooth the residual of @p{u} on
                                      * the given level. If $S$ is the
                                      * smoothing operator, then this
                                      * function should do the
                                      * following operation:
-                                     * $u += S (rhs - Au)$, where #u# and
-                                     * #rhs# are the input parameters.
+                                     * $u += S (rhs - Au)$, where @p{u} and
+                                     * @p{rhs} are the input parameters.
                                      *
                                      * This function should keep the
                                      * interior level boundary
                                      * values, so you may want to
-                                     * call #set_zero_interior_boundary#
+                                     * call @p{set_zero_interior_boundary}
                                      * in the derived class
-                                     * #MGSmoother# somewhere in your
+                                     * @p{MGSmoother} somewhere in your
                                      * derived function, or another
                                      * function doing similar things.
                                      */
@@ -75,7 +75,7 @@ class MGSmootherIdentity : public MGSmootherBase
   public:
                                     /**
                                      * Implementation of the
-                                     * interface in #MGSmootherBase#.
+                                     * interface in @p{MGSmootherBase}.
                                      * This function does nothing,
                                      * which by comparison with the
                                      * definition of this function
@@ -91,7 +91,7 @@ class MGSmootherIdentity : public MGSmootherBase
 
 /**
  * Base class for multigrid smoothers. It declares the interface
- * to smoothers by inheriting #MGSmootherBase# and implements some functionality for setting
+ * to smoothers by inheriting @p{MGSmootherBase} and implements some functionality for setting
  * the values
  * of vectors at interior boundaries (i.e. boundaries between differing
  * levels of the triangulation) to zero, by building a list of these degrees
@@ -119,7 +119,7 @@ class MGSmoother : public MGSmootherBase
                                      * on the interior boundaries between
                                      * the different levels, which are
                                      * needed by the function
-                                     * #set_zero_interior_boundaries#.
+                                     * @p{set_zero_interior_boundaries}.
                                      *
                                      * Since this function is implemented
                                      * a bit different in 1d (there are no
@@ -138,10 +138,10 @@ class MGSmoother : public MGSmootherBase
                                      * on the interior boundaries between
                                      * the different levels, which are
                                      * needed by the function
-                                     * #set_zero_interior_boundaries#.
+                                     * @p{set_zero_interior_boundaries}.
                                      *
                                      * The parameter steps indicates the number of smoothing
-                                     * steps to be executed by #smooth#.
+                                     * steps to be executed by @p{smooth}.
                                      */
     template <int dim>
     MGSmoother (const MGDoFHandler<dim> &mg_dof,
@@ -151,9 +151,9 @@ class MGSmoother : public MGSmootherBase
                                      * Reset the values of the degrees of
                                      * freedom on interior boundaries between
                                      * different levels to zero in the given
-                                     * data vector #u#.
+                                     * data vector @p{u}.
                                      *
-                                     * Since the coarsest level (#level==0#)
+                                     * Since the coarsest level (@p{level==0})
                                      * has no interior boundaries, this
                                      * function does nothing in this case.
                                      */
@@ -208,14 +208,14 @@ class MGSmootherRelaxation : public MGSmoother
     
                                     /**
                                      * Constructor.
-                                     * The constructor uses an #MGDoFHandler# to initialize
+                                     * The constructor uses an @p{MGDoFHandler} to initialize
                                      * data structures for interior level boundary handling
-                                     * in #MGSmoother#.
+                                     * in @p{MGSmoother}.
                                      *
                                      * Furthermore, it takes a pointer to the
                                      * level matrices and their smoothing function.
                                      * This function must perform one relaxation step
-                                     * like #SparseMatrix<number>::SOR_step# does. Do not
+                                     * like @p{SparseMatrix<number>::SOR_step} does. Do not
                                      * use the preconditioning methods because they apply
                                      * a preconditioning matrix to the residual.
                                      *
@@ -231,8 +231,8 @@ class MGSmootherRelaxation : public MGSmoother
                         const double                                   omega = 1.);
     
                                     /**
-                                     * Implementation of the interface in #MGSmootherBase#.
-                                     * We use the SOR method in #SparseMatrix# for the real work
+                                     * Implementation of the interface in @p{MGSmootherBase}.
+                                     * We use the SOR method in @p{SparseMatrix} for the real work
                                      * and find a way to keep the boundary values.
                                      */
     virtual void smooth (const unsigned int   level,
index 73f18a8f87ed1c2fbf3d4d52dd7daeb034bde783..7665a476774025972ef1a45d02bc09dbb91f4f5a 100644 (file)
@@ -27,7 +27,7 @@
 
 /**
  * Implementation of multigrid with matrices.
- * While #MGBase# was only an abstract framework for the V-cycle,
+ * While @p{MGBase} was only an abstract framework for the V-cycle,
  * here we have the implementation of the pure virtual functions defined there.
  * Furthermore, level information is obtained from a triangulation object.
  * 
@@ -75,7 +75,7 @@ class Multigrid : public MGBase
                                      * Transfer from a vector on the
                                      * global grid to vectors defined
                                      * on each of the levels
-                                     * separately, i.a. an #MGVector#.
+                                     * separately, i.a. an @p{MGVector}.
                                      */
     template<typename number>
     void copy_to_mg (const Vector<number> &src);
@@ -87,7 +87,7 @@ class Multigrid : public MGBase
                                      * Copies data from active
                                      * portions of an MGVector into
                                      * the respective positions of a
-                                     * #Vector<double>#. In order to
+                                     * @p{Vector<double>}. In order to
                                      * keep the result consistent,
                                      * constrained degrees of freedom
                                      * are set to zero.
@@ -96,7 +96,7 @@ class Multigrid : public MGBase
     void copy_from_mg (Vector<number> &dst) const;
 
                                     /**
-                                     * Negative #vmult# on a level.
+                                     * Negative @p{vmult} on a level.
 //TODO: what does this function do?                                  
                                      * @see MGBase.
                                      */
@@ -120,7 +120,7 @@ class Multigrid : public MGBase
 
   private:
                                     /**
-                                     * Associated #MGDoFHandler#.
+                                     * Associated @p{MGDoFHandler}.
                                      */
     SmartPointer<const MGDoFHandler<dim> > mg_dof_handler;
 
@@ -133,7 +133,7 @@ class Multigrid : public MGBase
                                     /**
                                      * Matrices for each level. The
                                      * matrices are prepared by the
-                                     * constructor of #Multigrid# and
+                                     * constructor of @p{Multigrid} and
                                      * can be accessed for
                                      * assembling.
                                      */
@@ -148,7 +148,7 @@ class Multigrid : public MGBase
 
 
 /**
- * Implementation of the #MGTransferBase# interface for which the transfer
+ * Implementation of the @p{MGTransferBase} interface for which the transfer
  * operations are prebuilt upon construction of the object of this class as
  * matrices. This is the fast way, since it only needs to build the operation
  * once by looping over all cells and storing the result in a matrix for
@@ -173,15 +173,15 @@ class MGTransferPrebuilt : public MGTransferBase
 
                                     /**
                                      * Prolongate a vector from level
-                                     * #to_level-1# to level
-                                     * #to_level#. The previous
-                                     * content of #dst# is
+                                     * @p{to_level-1} to level
+                                     * @p{to_level}. The previous
+                                     * content of @p{dst} is
                                      * overwritten.
                                      *
-                                     * #src# is assumed to be a vector with
+                                     * @p{src} is assumed to be a vector with
                                      * as many elements as there are degrees
                                      * of freedom on the coarser level of
-                                     * the two involved levels, while #src#
+                                     * the two involved levels, while @p{src}
                                      * shall have as many elements as there
                                      * are degrees of freedom on the finer
                                      * level.
@@ -192,23 +192,23 @@ class MGTransferPrebuilt : public MGTransferBase
 
                                     /**
                                      * Restrict a vector from level
-                                     * #from_level# to level
-                                     * #from_level-1# and add this
+                                     * @p{from_level} to level
+                                     * @p{from_level-1} and add this
                                      * restriction to
-                                     * #dst#. Obviously, if the
+                                     * @p{dst}. Obviously, if the
                                      * refined region on level
-                                     * #from_level# is smaller than
-                                     * that on level #from_level-1#,
+                                     * @p{from_level} is smaller than
+                                     * that on level @p{from_level-1},
                                      * some degrees of freedom in
-                                     * #dst# are not covered and will
+                                     * @p{dst} are not covered and will
                                      * not be altered. For the other
                                      * degress of freedom, the result
                                      * of the restriction is added.
                                      *
-                                     * #src# is assumed to be a vector with
+                                     * @p{src} is assumed to be a vector with
                                      * as many elements as there are degrees
                                      * of freedom on the finer level of
-                                     * the two involved levels, while #src#
+                                     * the two involved levels, while @p{src}
                                      * shall have as many elements as there
                                      * are degrees of freedom on the coarser
                                      * level.
index d571b4930e4a8bbfa26ea3a943ffc6c7c9d192f4..49eecc2283331c281d61670141b80e9c09f76253 100644 (file)
@@ -57,7 +57,7 @@ class Equation
                                      * derived classes should check for
                                      * this.
                                      * For that purpose, the two exceptions
-                                     * #ExcWrongSize# and #ExcObjectNotEmpty#
+                                     * @p{ExcWrongSize} and @p{ExcObjectNotEmpty}
                                      * are declared.
                                      */
     virtual void assemble (FullMatrix<double>  &cell_matrix,
@@ -75,7 +75,7 @@ class Equation
                                      * derived classes should check for
                                      * this.
                                      * For that purpose, the two exceptions
-                                     * #ExcWrongSize# and #ExcObjectNotEmpty#
+                                     * @p{ExcWrongSize} and @p{ExcObjectNotEmpty}
                                      * are declared.
                                      */
     virtual void assemble (FullMatrix<double>  &cell_matrix,
@@ -92,7 +92,7 @@ class Equation
                                      * derived classes should check for
                                      * this.
                                      * For that purpose, the two exceptions
-                                     * #ExcWrongSize# and #ExcObjectNotEmpty#
+                                     * @p{ExcWrongSize} and @p{ExcObjectNotEmpty}
                                      * are declared.
                                      */
     virtual void assemble (Vector<double>      &rhs,
@@ -136,7 +136,7 @@ class Equation
 /**
  * The use of this class is now deprecated!
  *
- * An #Assembler# is a specialized version of a #DoFCellAccessor# which adds
+ * An @p{Assembler} is a specialized version of a @p{DoFCellAccessor} which adds
  * functionality to assemble global matrices and vectors from cell base ones.
  *
  * @author Wolfgang Bangerth, 1998
@@ -228,9 +228,9 @@ class Assembler : public DoFCellAccessor<dim>
     Assembler ();
     
                                     /**
-                                     * Constructor. The #local_data#
+                                     * Constructor. The @p{local_data}
                                      * argument is assumed to be a pointer
-                                     * to an #AssemblerData# object. The data
+                                     * to an @p{AssemblerData} object. The data
                                      * is copied, so the object need not live
                                      * longer than the constructor call.
                                      */
index 9bdab4ad1a6b2667e42a3621133d4ec7fead65a9..92e2f0d9f194f1eda01a1d5625b4c5135425b5e1 100644 (file)
@@ -42,9 +42,9 @@ template <int dim> class Equation;
  * a display of concept how to work with deal.II.
  *
  *
- * \subsection{Assemblage}
+ * @sect3{Assemblage}
  *
- * The #assemble# member function does the assemblage of the system matrix and
+ * The @p{assemble} member function does the assemblage of the system matrix and
  * the given number of right hand sides. It does the following steps:
  * \begin{itemize}
  *   \item Initialize solution vector with zero entries.
@@ -60,33 +60,33 @@ template <int dim> class Equation;
  *     induced by hanging nodes.
  * \end{itemize}
  *
- * The #assemble# function needs an object describing the boundary of the domain,
+ * The @p{assemble} function needs an object describing the boundary of the domain,
  * since for higher order finite elements, we may be tempted to use curved faces
  * of cells for better approximation of the boundary. In this case, the
  * transformation from the unit cell to the real cell requires knowledge of
  * the exact boundary of the domain.
  * 
  *
- * \subsection{Solving}
+ * @sect3{Solving}
  *
- * Calling the #solve# function with a solver object, the system of equations
- * which results after having called the #assemble# function is solved. After
+ * Calling the @p{solve} function with a solver object, the system of equations
+ * which results after having called the @p{assemble} function is solved. After
  * this, the solution vector is distributed again, i.e. the constrained nodes
  * are given their correct values.
  *
  *
- * \subsection{Boundary conditions}
+ * @sect3{Boundary conditions}
  *
  * During assemblage of matrices and right hand side, use is made of dirichlet
- * boundary conditions (in short: bc) specified to the #assemble# function. You
- * can specify a list of pairs of boundary indicators (of type #unsigned char#;
+ * boundary conditions (in short: bc) specified to the @p{assemble} function. You
+ * can specify a list of pairs of boundary indicators (of type @p{unsigned char};
  * see the section in the documentation of the \Ref{Triangulation} class for more
  * details) and the according functions denoting the dirichlet boundary values
  * of the nodes on boundary faces with this boundary indicator.
  *
  * To actually apply the boundary conditions, use is made of the
- * #MatrixTools::apply_boundary_values# function and by interpolation of
- * the #boundary_values# using the #MatrixTool::interpolate_boundary_values#
+ * @p{MatrixTools::apply_boundary_values} function and by interpolation of
+ * the @p{boundary_values} using the @p{MatrixTool::interpolate_boundary_values}
  * function. See there for more information.
  *
  *
@@ -103,7 +103,7 @@ class ProblemBase
                                      * values on this part of the boundary.
                                      * Only one boundary function may be given
                                      * for each boundary indicator, which is
-                                     * guaranteed by the #map# data type.
+                                     * guaranteed by the @p{map} data type.
                                      * 
                                      * See the general documentation of this
                                      * class for more detail.
@@ -175,27 +175,27 @@ class ProblemBase
     virtual void solve ();
 
                                     /**
-                                     * Initialize the #DataOut# object with
+                                     * Initialize the @p{DataOut} object with
                                      * the grid and DoF handler used for this
                                      * computation, as well as with the
                                      * solution. Overload this function if
                                      * you have multiple data sets to be
                                      * written, or alternativelt call this
                                      * function and attach the additional
-                                     * vectors directly to the #DataOut#
+                                     * vectors directly to the @p{DataOut}
                                      * object.
                                      *
                                      * The solution name are
                                      * derived by calling the virtual
-                                     * function #get_solution_name#.
+                                     * function @p{get_solution_name}.
                                      */
     virtual void fill_data (DataOut<dim> &) const;
 
 
                                     /**
                                      * Return the name of the solution as a
-                                     * #string#. The default implementation
-                                     * returns #"solution"#.
+                                     * @p{string}. The default implementation
+                                     * returns @p{"solution"}.
                                      * Overload this function, if you
                                      * want anything else.
                                      */
index acf4d72503f9f93066811d6df3930370399f298b..31336cd2eaedc3ed4fa1b0f95a9fecc35c82a6d0 100644 (file)
@@ -23,7 +23,7 @@ template <int dim> class DoFHandler;
 class EpsOutputData;
 
 /**
- * This class is deprecated. Use the #DataOut# class instead.
+ * This class is deprecated. Use the @p{DataOut} class instead.
  *
  * This class implements an output mechanism for grid and simulation data
  * in several formats.
@@ -33,12 +33,12 @@ class EpsOutputData;
  * Encapsulated Postscript supports Q1-Elements only.
  *
  * It allows the user to attach a degree of freedom handler object
- * (#DoFHandler#) which also gives access to the geometry data of the
+ * (@p{DoFHandler}) which also gives access to the geometry data of the
  * underlying triangulation and to add data vectors of which the values
  * are to be written.
  *
  *
- * \subsection{Limitations}
+ * @sect3{Limitations}
  * 
  * At present, no grouping of components to vectors is implemented, i.e.
  * you can only write each component independent of the others. Also, it
@@ -46,7 +46,7 @@ class EpsOutputData;
  * with more or less than one degree of freedom per vertex.
  *
  * 
- * \subsection{UCD format}
+ * @sect3{UCD format}
  *
  * The UCD format is described in the AVS developer's guide. Due to
  * limitations in the present format, only node based data can be output,
@@ -65,7 +65,7 @@ class EpsOutputData;
  * much easier.
  *
  *
- * \subsection{GNUPLOT draft format}
+ * @sect3{GNUPLOT draft format}
  *
  * The GNUPLOT format is not able to handle data on unstructured grids
  * directly. Directly would mean that you only give the vertices and
@@ -73,27 +73,27 @@ class EpsOutputData;
  * to represent the data. This is only possible for a structured tensor
  * product grid in two dimensions.
  *
- * In one dimension, the format is obviously #x v1 v2 ...#, where #x#
- * is the coordinate value of a grid point, while the #vi# are the
+ * In one dimension, the format is obviously @p{x v1 v2 ...}, where @p{x}
+ * is the coordinate value of a grid point, while the @p{vi} are the
  * vector elements referring to the present node. Within GNUPLOT,
- * call #plot "filename" using 1:x#. #x# denotes the number of the data set you
- * want to see plus one. For example #using 1:4# would mean to plot the
+ * call @p{plot "filename" using 1:x}. @p{x} denotes the number of the data set you
+ * want to see plus one. For example @p{using 1:4} would mean to plot the
  * third data vector.
  *
- * For more than one dimension, the #DataOut_Old<dim>::write_gnuplot()# somehow
- * duplicates the functionality of the #Triangulation<dim>::print_gnuplot()#
+ * For more than one dimension, the @p{DataOut_Old<dim>::write_gnuplot()} somehow
+ * duplicates the functionality of the @p{Triangulation<dim>::print_gnuplot()}
  * functions. These, however, offer more functionality in some respect.
  * The grid is represented as a sequence of lines, where each cell is
  * a sequence of five vertices (the first one is appended at the end to close
  * the contour of the cell) with the data appended after each vertex. Each cell
- * is therefore a sequence of five lines #x y v1 v2 ...# forming together
+ * is therefore a sequence of five lines @p{x y v1 v2 ...} forming together
  * the bounding line of this cell. After each cell, two newlines are inserted
  * to prevent GNUPLOT from joining the lines bounding two cells.
  *
- * To view the results in two dimensions, use #set data style lines#
- * within gnuplot and call #plot "filename"# to see the grid. Use
- * #set parametric# and #splot "filename" using 1:2:x# to get a 3d surface
- * plot of the (#x-2#)th data set. For example, using #x=4# would mean to
+ * To view the results in two dimensions, use @p{set data style lines}
+ * within gnuplot and call @p{plot "filename"} to see the grid. Use
+ * @p{set parametric} and @p{splot "filename" using 1:2:x} to get a 3d surface
+ * plot of the (@p{x-2})th data set. For example, using @p{x=4} would mean to
  * plot the second data set.
  *
  * This format is somewhat restricted to continuous data and to finite elements
@@ -107,7 +107,7 @@ class EpsOutputData;
  * interior of a cell nor on the lines bounding it.
  *
  *
- * \subsection{GNUPLOT 'quality' format}
+ * @sect3{GNUPLOT 'quality' format}
  *
  * To remedy the abovementioned problems, the GNUPLOT 'quality' format was
  * introduced. As noted above, GNUPLOT can handle tensor grids and displays
@@ -115,7 +115,7 @@ class EpsOutputData;
  * than one tensor grid, then called a patch. The idea now is to describe
  * each cell as a patch of $N\times N$ points (in 2D). For linear elements,
  * $2\times 2$ is sufficient, but for higher elements you will want to use
- * a higher number. The #write_gnuplot# function writes the data in this format
+ * a higher number. The @p{write_gnuplot} function writes the data in this format
  * and the argument it takes is the number of subintervals it divides each cell
  * into, i.e. $N-1$.
  *
@@ -125,7 +125,7 @@ class EpsOutputData;
  * also plot discontinuities, if they are there.
  *
  *
- * \subsection{POVRAY mesh format}
+ * @sect3{POVRAY mesh format}
  *
  * POVRAY is a ray tracing tool in the public domain and poduces high quality
  * images of three dimensional scenes. Since this tool can handle only one
@@ -140,55 +140,55 @@ class EpsOutputData;
  * term of memory and speed to the triangle mesh supported by POVRAY.
  *
  *
- * \subsection{Encapsulated Postscript format}
+ * @sect3{Encapsulated Postscript format}
  *
  * There is a function for generating encapsulated Postscript
  * (EPS) without the need for another graphics tool. This functionality
- * is provided through #write_eps# and #EpsOutputData#
- * #write_eps# can use one data vector for height information and one
+ * is provided through @p{write_eps} and @p{EpsOutputData}
+ * @p{write_eps} can use one data vector for height information and one
  * cell vector for shading information. Control is done through an
- * object of class #EpsOutputData# as follows or by default.
+ * object of class @p{EpsOutputData} as follows or by default.
  *
- * Vectors are added as usual by #add_data_vector#. Then one has to
+ * Vectors are added as usual by @p{add_data_vector}. Then one has to
  * decide, wether to produce a 2D or 3D plot. This is done by setting
- * #height_info# to 
+ * @p{height_info} to 
  * \begin{description} 
  *   \item[NoHeight] for 2D-Output (or Top-View thats the same by no
  *     turning is done) or to
  *   \item[HeightVector] for 3D-Output. You have to attach a
- *     #dof_data_vector# to actually get 3D. If you don't then output
+ *     @p{dof_data_vector} to actually get 3D. If you don't then output
  *     will be generated in 2D.
- *   \item[DefaultHeight] is 3D if there is a #dof_data_vector# and 2D if
+ *   \item[DefaultHeight] is 3D if there is a @p{dof_data_vector} and 2D if
  *     none is present.
  * \end{description}
- * For 3D-Output one has to set #azimuth# and #elevation# for the
- * angle of view and #height_vector# to the number of the #dof_data#
+ * For 3D-Output one has to set @p{azimuth} and @p{elevation} for the
+ * angle of view and @p{height_vector} to the number of the @p{dof_data}
  * vector that provides the height information to be used. The default
  * values are analogous to GNUPlot for azimuth and elevation and
  * vector 0 for the height vector.
  *
  * The cells can be shaded in four different modes, controlled by the
- * attribute #cell_shading#:
+ * attribute @p{cell_shading}:
  * \begin{enumerate}
  *   \item[NoShading] provides transparent shading.
  *   \item[ShadingVector] uses a cell vector to do shading. The number
- *     of the cell vector to be uses is provided in #cell_vector#. To
- *     scale the cell vector there is the method #color#. It is called
+ *     of the cell vector to be uses is provided in @p{cell_vector}. To
+ *     scale the cell vector there is the method @p{color}. It is called
  *     with the actual value of the cell, the maximum and the minimum
  *     value of a cell in the cell vector. It returns three values for
- *     red, green and blue. If there no #cell_data# vector than there is
+ *     red, green and blue. If there no @p{cell_data} vector than there is
  *     transparent shading.
  *   \item[LightShaded] just shades the plot. This is controlled by
- *     the vector #light# which stores the direction of the light 
+ *     the vector @p{light} which stores the direction of the light 
  *     beams. This is done only if there is height information.
  *   \item[DefaultShading] is controlled by presence of different
  *     vectors. If there no height information then do no
- *     shading. Otherwise if there is #cell_data# use this for shading.
+ *     shading. Otherwise if there is @p{cell_data} use this for shading.
  *     Otherwise do light shading.
  * \end{enumerate}
  *
  * Finnaly one can choose to mark the cell boundaries by setting
- * #cell_boundary_shading#. It can take one of four values:
+ * @p{cell_boundary_shading}. It can take one of four values:
  * \begin{itemize}
  *   \item NoBoundary for no cell boundaries,
  *   \item DefaultBoundary or
@@ -198,13 +198,13 @@ class EpsOutputData;
  *
  * Another interesting feature is that you can write multiple
  * eps-pictures to one file by just doing several invocations of
- * #write_eps#. One than can switch between the different graphics
- * with the #>># Button in GhostView for example.
+ * @p{write_eps}. One than can switch between the different graphics
+ * with the @p{>>} Button in GhostView for example.
  *
  *
- * \subsection{GMV format}
+ * @sect3{GMV format}
  *
- * The #write_gmv# function and the #write# function through the #gmv# parameter
+ * The @p{write_gmv} function and the @p{write} function through the @p{gmv} parameter
  * write the data in a format understood by the GMV (general mesh viewer)
  * program. This program is able to generate 2d and 3d plots of almost
  * arbitrarily many data sets, along with shading, cuts through data sets and
@@ -250,7 +250,7 @@ class DataOut_Old {
                                      * you have to make sure the vector
                                      * exists at that address at least as
                                      * long as you call the
-                                     * #write_*# functions.
+                                     * @p{write_*} functions.
                                      *
                                      * It is assumed that the vector has the
                                      * same number of components as there are
@@ -264,7 +264,7 @@ class DataOut_Old {
                                      * The name and unit of a data vector shall
                                      * only contain characters which are
                                      * letters, underscore and a few other
-                                     * ones. Refer to the #ExcInvalidCharacter#
+                                     * ones. Refer to the @p{ExcInvalidCharacter}
                                      * exception declared in this class to
                                      * see which characters are valid and which
                                      * are not.
@@ -277,7 +277,7 @@ class DataOut_Old {
                                      * Release the pointers to the data
                                      * vectors. You have to set all data
                                      * entries again using the
-                                     * #add_data_vector# function. The pointer
+                                     * @p{add_data_vector} function. The pointer
                                      * to the dof handler remains stored,
                                      * however.
                                      */
@@ -298,7 +298,7 @@ class DataOut_Old {
                                     /**
                                      * Write data and grid in GNUPLOT format.
                                      * Write a patch for each grid cell using
-                                     * #accuracy# subintervals per dimension.
+                                     * @p{accuracy} subintervals per dimension.
                                      */
     void write_gnuplot (ostream &out, const unsigned int accuracy=1) const;
 
@@ -333,10 +333,10 @@ class DataOut_Old {
     void write_gmv (ostream &out) const;
 
                                     /**
-                                     * Write data and grid to #out# according
+                                     * Write data and grid to @p{out} according
                                      * to the given data format. This function
                                      * simply calls the appropriate
-                                     * #write_*# function.
+                                     * @p{write_*} function.
                                      *
                                      * In case of gnuplot output, the
                                      * standard accuracy of 1 is
@@ -350,12 +350,12 @@ class DataOut_Old {
                                      * usually has. At present the following
                                      * formats are defined:
                                      * \begin{itemize}
-                                     * \item #ucd#: #.inp#
-                                     * \item #gnuplot# and #gnuplot_draft#:
-                                     *    #.gnuplot#
-                                     * \item #povray_mesh#: #.pov#
-                                     * \item #eps#: #.eps#
-                                     * \item #gmv#: #.gmv#.
+                                     * \item @p{ucd}: @p{.inp}
+                                     * \item @p{gnuplot} and @p{gnuplot_draft}:
+                                     *    @p{.gnuplot}
+                                     * \item @p{povray_mesh}: @p{.pov}
+                                     * \item @p{eps}: @p{.eps}
+                                     * \item @p{gmv}: @p{.gmv}.
                                      * \end{itemize}
                                      *
                                      * Since this function does not need data
@@ -366,7 +366,7 @@ class DataOut_Old {
     static string default_suffix (const OutputFormat output_format);
 
                                     /**
-                                     * Return the #OutputFormat# value
+                                     * Return the @p{OutputFormat} value
                                      * corresponding to the given string. If
                                      * the string does not match any known
                                      * format, an exception is thrown.
@@ -382,16 +382,16 @@ class DataOut_Old {
                                      *
                                      * To get a list of presently available
                                      * format names, e.g. to give it to the
-                                     * #ParameterHandler# class, use the
-                                     * function #get_output_format_names ()#.
+                                     * @p{ParameterHandler} class, use the
+                                     * function @p{get_output_format_names ()}.
                                      */
     static OutputFormat parse_output_format (const string &format_name);
 
                                     /**
                                      * Return a list of implemented output
                                      * formats. The different names are
-                                     * separated by vertical bar signs (#`|'#)
-                                     * as used by the #ParameterHandler#
+                                     * separated by vertical bar signs (@p{`|'})
+                                     * as used by the @p{ParameterHandler}
                                      * classes.
                                      */
     static string get_output_format_names ();
@@ -489,7 +489,7 @@ class DataOut_Old {
                                      * triangulation which have a boundary
                                      * indicator not equal to zero. Only
                                      * these faces are explicitely printed
-                                     * in the #write_*# functions;
+                                     * in the @p{write_*} functions;
                                      * all faces with indicator 255 are
                                      * interior ones and an indicator with
                                      * value zero for faces at the boundary
@@ -499,34 +499,34 @@ class DataOut_Old {
                                      * list in one dimension.
                                      *
                                      * The reason for this function is the
-                                     * same as for #write_ucd_faces#. See
+                                     * same as for @p{write_ucd_faces}. See
                                      * there for more information.
                                      */
     unsigned int n_boundary_faces () const;
 
                                     /**
                                      * Write the grid information about
-                                     * faces to #out#. Only those faces
+                                     * faces to @p{out}. Only those faces
                                      * are printed which are on the boundary
                                      * and which have a boundary indicator
                                      * not equal to zero, since the latter
                                      * is the default for boundary faces.
                                      *
                                      * Since cells and faces are continuously
-                                     * numbered, the #starting_index# for
+                                     * numbered, the @p{starting_index} for
                                      * the numbering of the faces is passed
                                      * also.
                                      *
                                      * This function unfortunately can not
-                                     * be included in the regular #write_ucd#
+                                     * be included in the regular @p{write_ucd}
                                      * function, since it needs special
-                                     * treatment for the case #dim==1#, in
+                                     * treatment for the case @p{dim==1}, in
                                      * which case the face iterators are
-                                     * #void*#'s and lack the member functions
+                                     * @p{void*}'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 #dim==1#. Bad luck.
+                                     * the function for @p{dim==1}. Bad luck.
                                      */
     void write_ucd_faces (ostream &out,
                          const unsigned int starting_index) const;
@@ -602,7 +602,7 @@ class DataOut_Old {
 
 /**
  * Structure for the control of encapsulated postscript output. See
- * general documentation of class #DataOut_Old# for description.
+ * general documentation of class @p{DataOut_Old} for description.
  *
  * @author Stefan Nauber
  */
@@ -701,16 +701,16 @@ class EpsOutputData{
                                      * Default constructor. Sets height and
                                      * shading flags to their default values,
                                      * azimut and elevation to 0.2 each, and
-                                     * puts the light source at #(-1,-1,0)#.
+                                     * puts the light source at @p{(-1,-1,0)}.
                                      */
     EpsOutputData();
 
                                     /**
                                      * Function returning a color value in
                                      * rgb variables corresponding to the
-                                     * given value #x#. #x# is considered
+                                     * given value @p{x}. @p{x} is considered
                                      * to be a values within the range
-                                     * #xmin...xmax#.
+                                     * @p{xmin...xmax}.
                                      */
     void color (const float x,
                const float xmax,
index 3442db7b7ea69bbf3eceede15252ce34c097df5a..8b04cc83fbe0442dd44e3a9af09e56a188cb3619 100644 (file)
@@ -23,15 +23,15 @@ template <int dim> class DoFHandler;
 /**
  * This is an abstract class which provides the functionality to generate
  * patches for output by base classes from data vectors on a grid. It alloes
- * to store a pointer to a #DoFHandler# object and one or more pointers to
+ * to store a pointer to a @p{DoFHandler} object and one or more pointers to
  * node and cell data denoting functions on the grid which shall later
  * be written in any of the implemented data formats.
  *
  *
- * \subsection{User visible interface}
+ * @sect3{User visible interface}
  *
  * The user visible interface of this class consists of functions which allow
- * a user to make a #DoFHandler# object known to this class and to add data
+ * a user to make a @p{DoFHandler} object known to this class and to add data
  * vectors which will later be written to a file in some format. Instead of
  * pondering about the different functions, an example is probably the best
  * way:
@@ -60,48 +60,48 @@ template <int dim> class DoFHandler;
  *   data_out.clear();
  * \end{verbatim}
  *
- * #attach_dof_handler# tells this class that all future operations are to take
- * place with the #DoFHandler# object and the triangulation it lives on. We then
+ * @p{attach_dof_handler} tells this class that all future operations are to take
+ * place with the @p{DoFHandler} object and the triangulation it lives on. We then
  * add the solution vector and the error estimator; note that they have different
  * dimensions, because the solution is a nodal vector, here consisting of two
  * components ("x-displacement" and "y-displacement") while the error estimator
  * 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 #vector<string># as second argument; if only one component is in the
+ * of type @p{vector<string>} as second argument; if only one component is in the
  * vector, for example if we are adding cell data as in the second case, or if
- * the finite element used by the #DoFHandler# has only one component, then you
- * can use the second #add_data_vector# function which takes a #string# instead
- * of the #vector<string>#.
+ * the finite element used by the @p{DoFHandler} has only one component, then you
+ * can use the second @p{add_data_vector} function which takes a @p{string} instead
+ * of the @p{vector<string>}.
  *
  * You should note that this class does not copy the vector given to it through
- * the #add_data_vector# functions, for memory consumption reasons. It only
+ * the @p{add_data_vector} functions, for memory consumption reasons. It only
  * stores a reference to it, so it is in your responsibility to make sure that
  * the data vectors exist long enough.
  *
  * After adding all data vectors, you need to call a function which generates
  * the patches for output from the stored data. This function is here called
- * #build_patches#, but the naming is up to the derived class that actually
+ * @p{build_patches}, but the naming is up to the derived class that actually
  * implements this.
  *
- * Finally, you write the data in one format or other, indicated by #write_xxx#,
+ * Finally, you write the data in one format or other, indicated by @p{write_xxx},
  * to a file and may want to clear this object as soon as possible to reduce
  * memory requirements.
  *
- * Please note, that in the example above, an object of type #DataOut# was
+ * Please note, that in the example above, an object of type @p{DataOut} was
  * used, i.e. an object of a derived class. This is necessary since this
  * class does not provide means to actually generate the patches, only aids to
  * store and access data.
  *
- * Note that the base class of this class, #DataOutInterface# offers several
+ * Note that the base class of this class, @p{DataOutInterface} offers several
  * functions to ease programming with run-time determinable output formats
- * (i.e. you need not use a fixed format by calling #write_xxx# in the above
+ * (i.e. you need not use a fixed format by calling @p{write_xxx} in the above
  * example, but you can select it by a run-time parameter without having
- * to write the #if () ... else ...# clauses yourself), and also functions
+ * to write the @p{if () ... else ...} clauses yourself), and also functions
  * and classes offering ways to control the appearance of the output by
  * setting flags for each output format.
  * 
  *
- * \subsection{Information for derived classes}
+ * @sect3{Information for derived classes}
  *
  * What is actually missing this class is a way to produce the patched for
  * output itself, from the stored data and degree of freedom information.
@@ -115,7 +115,7 @@ template <int dim> class DoFHandler;
  * different cells.
  *
  * For this reason, it is left to a derived class to provide a function, named
- * usually #build_patches# or the like, which fills the #patches# array of
+ * usually @p{build_patches} or the like, which fills the @p{patches} array of
  * this class.
  *
  * @author Wolfgang Bangerth, 1999
@@ -152,7 +152,7 @@ class DataOut_DoFData : public DataOutInterface<dim>
                                      * you have to make sure the vector
                                      * exists at that address at least as
                                      * long as you call the
-                                     * #write_*# functions.
+                                     * @p{write_*} functions.
                                      *
                                      * It is assumed that the vector has the
                                      * same number of components as there are
@@ -176,7 +176,7 @@ class DataOut_DoFData : public DataOutInterface<dim>
                                      * The names of a data vector shall
                                      * only contain characters which are
                                      * letters, underscore and a few other
-                                     * ones. Refer to the #ExcInvalidCharacter#
+                                     * ones. Refer to the @p{ExcInvalidCharacter}
                                      * exception declared in this class to
                                      * see which characters are valid and which
                                      * are not.
@@ -192,17 +192,17 @@ class DataOut_DoFData : public DataOutInterface<dim>
                                      * name per data vector needs to be given,
                                      * which is what this function takes. It
                                      * simply relays its arguments after a
-                                     * conversion of the #name# to a vector
+                                     * conversion of the @p{name} to a vector
                                      * of strings, to the other
-                                     * #add_data_vector# function above.
+                                     * @p{add_data_vector} function above.
                                      *
-                                     * If #data# is a vector with
+                                     * If @p{data} is a vector with
                                      * multiple components this
                                      * function will generate
                                      * distinct names for all
                                      * components by appending an
                                      * underscore and the number of
-                                     * each component to #name#
+                                     * each component to @p{name}
                                      */
     void add_data_vector (const Vector<double> &data,
                          const string         &name);
@@ -213,7 +213,7 @@ class DataOut_DoFData : public DataOutInterface<dim>
                                      * output of a new set of vectors
                                      * without supplying the DoF
                                      * handler again. Therefore, the
-                                     * #DataOut# object can be used
+                                     * @p{DataOut} object can be used
                                      * in an algebraic context.
                                      */
     void clear_data_vectors ();
@@ -223,7 +223,7 @@ class DataOut_DoFData : public DataOutInterface<dim>
                                      * Release the pointers to the data
                                      * vectors and the DoF handler. You have to set all data
                                      * entries again using the
-                                     * #add_data_vector# function. The pointer
+                                     * @p{add_data_vector} function. The pointer
                                      * to the dof handler is cleared as well,
                                      * along with all other data. In effect,
                                      * this function resets everything to a
@@ -317,7 +317,7 @@ class DataOut_DoFData : public DataOutInterface<dim>
 
                                     /**
                                      * This is a list of patches that is
-                                     * created each time #build_patches#
+                                     * created each time @p{build_patches}
                                      * is called. These patches are used
                                      * in the output routines of the base
                                      * classes.
@@ -344,13 +344,13 @@ class DataOut_DoFData : public DataOutInterface<dim>
 
 /**
  * This class is an actual implementation of the functionality proposed by
- * the #DataOut_DoFData# class. It offers a function #build_patches# that
+ * the @p{DataOut_DoFData} class. It offers a function @p{build_patches} that
  * generates the patches to be written in some graphics format from the data
  * stored in the base class. Most of the interface and an example of its
  * use is described in the documentation of the base class.
  *
- * The only thing this class offers is the function #build_patches# which
- * loops over all cells of the triangulation stored by the #attach_dof_handler#
+ * The only thing this class offers is the function @p{build_patches} which
+ * loops over all cells of the triangulation stored by the @p{attach_dof_handler}
  * function of the base class and convert the data on these to actual patches
  * which are the objects that are later output by the functions of the
  * base classes. You can give a parameter to the function which determines
@@ -359,37 +359,37 @@ class DataOut_DoFData : public DataOutInterface<dim>
  * for quadratic elementsyou may want to choose two, for cubic elements three,
  * and so on.
  *
- * Note that after having called #build_patches# once, you can call one or
- * more of the #write_*# functions of the base classes. You can therefore
+ * Note that after having called @p{build_patches} once, you can call one or
+ * more of the @p{write_*} functions of the base classes. You can therefore
  * output the same data in more than one format without having to rebuild
  * the patches.
  *
  *
- * \subsection{User interface information}
+ * @sect3{User interface information}
  *
- * The base classes of this class, #DataOutBase#, #DataOutInterface# and
- * #DataOut_DoFData# offer several interfaces of their own. Refer to the
- * #DataOutBase# class's documentation for a discussion of the different
- * output formats presently supported, #DataOutInterface# for ways of
+ * The base classes of this class, @p{DataOutBase}, @p{DataOutInterface} and
+ * @p{DataOut_DoFData} offer several interfaces of their own. Refer to the
+ * @p{DataOutBase} class's documentation for a discussion of the different
+ * output formats presently supported, @p{DataOutInterface} for ways of
  * selecting which format to use upon output at run-time and without
  * the need to adapt your program when new formats become available, as
- * well as for flags to determine aspects of output. The #DataOut_DoFData#
+ * well as for flags to determine aspects of output. The @p{DataOut_DoFData}
  * class's documentation has an example of using nodal data to generate
  * output.
  *
  *
- * \subsection{Extensions}
+ * @sect3{Extensions}
  *
  * By default, this class produces patches for all active cells. Sometimes,
  * this is not what you want, maybe because they are simply too many (and too
  * small to be seen individually) or because you only want to see a certain
  * region of the domain, or for some other reason.
  *
- * For this, internally the #build_patches# function does not generate
+ * For this, internally the @p{build_patches} function does not generate
  * the sequence of cells to be converted into patches itself, but relies
- * on the two functions #first_cell# and #next_cell#. By default, they
+ * on the two functions @p{first_cell} and @p{next_cell}. By default, they
  * return the first active cell, and the next active cell, respectively.
- * Since they are #virtual# functions, you may overload them to select other
+ * Since they are @p{virtual} functions, you may overload them to select other
  * cells for output. If cells are not active, interpolated values are taken
  * for output instead of the exact values on active cells.
  *
@@ -418,7 +418,7 @@ class DataOut : public DataOut_DoFData<dim>
                                      * mode. The default number of
                                      * threads to be used to build
                                      * the patches is set to
-                                     * #multithread_info.n_default_threads#.
+                                     * @p{multithread_info.n_default_threads}.
                                      */
     virtual void build_patches (const unsigned int n_subdivisions = 1,
                                const unsigned int n_threads      = multithread_info.n_default_threads);
@@ -435,10 +435,10 @@ class DataOut : public DataOut_DoFData<dim>
     first_cell ();
     
                                     /**
-                                     * Return the next cell after #cell# which
+                                     * Return the next cell after @p{cell} which
                                      * we want output for.
                                      * If there are no more cells,
-                                     * #dofs->end()# shall be returned.
+                                     * @p{dofs->end()} shall be returned.
                                      *
                                      * The default
                                      * implementation returns the next
@@ -447,8 +447,8 @@ class DataOut : public DataOut_DoFData<dim>
                                      * class. Note that the default
 
                                      * implementation assumes that
-                                     * the given #cell# is active, which
-                                     * is guaranteed as long as #first_cell#
+                                     * the given @p{cell} is active, which
+                                     * is guaranteed as long as @p{first_cell}
                                      * is also used from the default
                                      * implementation. Overloading only one
                                      * of the two functions might not be
@@ -479,7 +479,7 @@ class DataOut : public DataOut_DoFData<dim>
          {}
     };
                                     /**
-                                     * Builds every #n_threads#'s
+                                     * Builds every @p{n_threads}'s
                                      * patch. This function may be
                                      * called in parallel.
                                      * If multithreading is not
index 1bb1ec1b891617ffb42554632ef85081ceb7e167..dcc1eb43d3910da15f518ced2fd89fa9ce5102eb 100644 (file)
@@ -30,7 +30,7 @@ template <int dim> class DoFHandler;
  * space-time output file, or for example to connect the results of
  * solutions of a parameter dependent equation for several parameter
  * value together into one. The interface is mostly modelled after the
- * #DataOut# class.
+ * @p{DataOut} class.
  *
  * We will explain the concept for a time dependent problem, but
  * instead of the time any parameter can be substituted. In our
@@ -50,15 +50,15 @@ template <int dim> class DoFHandler;
  * interpolations in time may be added in the future.
  *
  *
- * \section{Example of Use}
+ * @sect2{Example of Use}
  *
  * The following little example shall illustrate the different steps
  * of use of this class. It is assumed that the finite element used is
- * composed of two components, #u# and #v#, that the solution vector
- * is named #solution# and that a vector #error# is computed which
+ * composed of two components, @p{u} and @p{v}, that the solution vector
+ * is named @p{solution} and that a vector @p{error} is computed which
  * contains an error indicator for each spatial cell.
  *
- * Note that unlike for the #DataOut# class it is necessary to first
+ * Note that unlike for the @p{DataOut} class it is necessary to first
  * declare data vectors and the names of the components before first
  * use. This is because on all time levels the same data should be
  * present to produce reasonable time-space output. The output is
@@ -111,16 +111,16 @@ class DataOutStack : public DataOutInterface<dim+1>
 
                                     /**
                                      * Destructor. Only declared to make
-                                     * it #virtual#.
+                                     * it @p{virtual}.
                                      */
     virtual ~DataOutStack ();
     
                                     /**
                                      * Start the next set of data for a
                                      * specific parameter value. The argument
-                                     * #parameter_step# denotes the interval
+                                     * @p{parameter_step} denotes the interval
                                      * (in backward direction, counted from
-                                     * #parameter_value#) with which the
+                                     * @p{parameter_value}) with which the
                                      * output will be extended in parameter
                                      * direction, i.e. orthogonal to the
                                      * space directions.
@@ -132,7 +132,7 @@ class DataOutStack : public DataOutInterface<dim+1>
                                      * Attach the DoF handler for the
                                      * grid and data associated with the
                                      * parameter previously set by
-                                     * #new_parameter_value#.
+                                     * @p{new_parameter_value}.
                                      *
                                      * This has to happen before adding
                                      * data vectors for the present
@@ -141,14 +141,14 @@ class DataOutStack : public DataOutInterface<dim+1>
     void attach_dof_handler (const DoFHandler<dim> &dof_handler);
 
                                     /**
-                                     * Declare a data vector. The #vector_type#
+                                     * Declare a data vector. The @p{vector_type}
                                      * argument determines whether the data
                                      * vector will be considered as DoF or
                                      * cell data.
                                      *
                                      * This version may be called if the
                                      * finite element presently used by the
-                                     * #DoFHandler# (and previously attached
+                                     * @p{DoFHandler} (and previously attached
                                      * to this object) has only one component
                                      * and therefore only one name needs to
                                      * be given.
@@ -157,19 +157,19 @@ class DataOutStack : public DataOutInterface<dim+1>
                              const VectorType  vector_type);
 
                                     /**
-                                     * Declare a data vector. The #vector_type#
+                                     * Declare a data vector. The @p{vector_type}
                                      * argument determines whether the data
                                      * vector will be considered as DoF or
                                      * cell data.
                                      *
                                      * This version must be called if the
                                      * finite element presently used by the
-                                     * #DoFHandler# (and previously attached
+                                     * @p{DoFHandler} (and previously attached
                                      * to this object) has more than one
                                      * component and therefore more than one
                                      * name needs to be given. However, you
                                      * can also call this function with a
-                                     * #vector<string># containing only one
+                                     * @p{vector<string>} containing only one
                                      * element if the finite element has
                                      * only one component.
                                      */
@@ -183,18 +183,18 @@ class DataOutStack : public DataOutInterface<dim+1>
                                      *
                                      * This version may be called if the
                                      * finite element presently used by the
-                                     * #DoFHandler# (and previously attached
+                                     * @p{DoFHandler} (and previously attached
                                      * to this object) has only one component
                                      * and therefore only one name needs to
                                      * be given.
                                      *
                                      * The data vector must have been
-                                     * registered using the #declare_data_vector#
+                                     * registered using the @p{declare_data_vector}
                                      * function before actually using it the
                                      * first time.
                                      *
                                      * Note that a copy of this vector is
-                                     * stored until #finish_parameter_value#
+                                     * stored until @p{finish_parameter_value}
                                      * is called the next time, so if you are
                                      * short of memory you may want to call
                                      * this function only after all
@@ -211,22 +211,22 @@ class DataOutStack : public DataOutInterface<dim+1>
                                      *
                                      * This version must be called if the
                                      * finite element presently used by the
-                                     * #DoFHandler# (and previously attached
+                                     * @p{DoFHandler} (and previously attached
                                      * to this object) has more than one
                                      * component and therefore more than one
                                      * name needs to be given. However, you
                                      * can also call this function with a
-                                     * #vector<string># containing only one
+                                     * @p{vector<string>} containing only one
                                      * element if the finite element has
                                      * only one component.
                                      *
                                      * The data vector must have been
-                                     * registered using the #declare_data_vector#
+                                     * registered using the @p{declare_data_vector}
                                      * function before actually using it the
                                      * first time.
                                      *
                                      * Note that a copy of this vector is
-                                     * stored until #finish_parameter_value#
+                                     * stored until @p{finish_parameter_value}
                                      * is called the next time, so if you are
                                      * short of memory you may want to call
                                      * this function only after all
@@ -241,10 +241,10 @@ class DataOutStack : public DataOutInterface<dim+1>
                                      * Actually build the patches for output
                                      * by the base classes from the data
                                      * stored in the data vectors and using
-                                     * the previously attached #DoFHandler#
+                                     * the previously attached @p{DoFHandler}
                                      * object.
                                      *
-                                     * By #n_subdivisions# you can decide
+                                     * By @p{n_subdivisions} you can decide
                                      * into how many subdivisions (in each
                                      * space and parameter direction) each
                                      * patch is divided. This is useful
@@ -258,11 +258,11 @@ class DataOutStack : public DataOutInterface<dim+1>
 
                                     /**
                                      * Release all data that is no
-                                     * more needed once #build_patches#
+                                     * more needed once @p{build_patches}
                                      * was called and all other transactions
                                      * for a given parameter value are done.
                                      *
-                                     * Couterpart of #new_parameter_value#.
+                                     * Couterpart of @p{new_parameter_value}.
                                      */
     void finish_parameter_value ();
 
@@ -383,8 +383,8 @@ class DataOutStack : public DataOutInterface<dim+1>
                                      * This is the function through
                                      * which derived classes propagate
                                      * preprocessed data in the form of
-                                     * #Patch# structures (declared in
-                                     * the base class #DataOutBase#) to
+                                     * @p{Patch} structures (declared in
+                                     * the base class @p{DataOutBase}) to
                                      * the actual output function.
                                      */
     virtual const vector<DataOutBase::Patch<dim+1> > & get_patches () const;
index 7834338d75235c935e131baa8390a9984e6d8ce5..4dafb4685f4141fc876c6239b5e04340b5b7798a 100644 (file)
  * the values of the finite element field at the centers of the cells
  * are taken. It might therefore only be useful to use this class for
  * discontinuous, piecewise constant elements (i.e. using the
- * #FEDG_Q0# class), since all other finite elements can approximate
+ * @p{FEDG_Q0} class), since all other finite elements can approximate
  * gradients themselves.
  *
  *
- * \section{Refinement indicators based on the gradients}
+ * @sect2{Refinement indicators based on the gradients}
  *
  * If you would like to base a refinement criterion upon this
  * approximation of the gradient, you will have to scale the results
index 366bb0edfc8dd71868540f3fcbfb9d92ad234bac..82cae1d6c458d2563420331999476fcccef66d8e 100644 (file)
@@ -23,7 +23,7 @@
 /**
  * Print intermediate solutions in solvers.
  * This is derived from a solver class provided as template argument.
- * It implements the #print_vector# function of the solver using a
+ * It implements the @p{print_vector} function of the solver using a
  * @ref DoFHandler. This way, the intermediate vectors can be viewed as
  * finite element functions.
  *
@@ -44,7 +44,7 @@ class DoFPrintSolverStep :
                                      * function.
                                      *
                                      * One output file with the name
-                                     * #basename.[step].[suffix]#
+                                     * @p{basename.[step].[suffix]}
                                      * will be produced for each
                                      * iteration step.
                                      */
index 5c195929a5ef8134efff09080e37d09f01371231..7b95b83d52beec87fc30fb086b09fee550e58d3b 100644 (file)
@@ -21,7 +21,7 @@
  * Implementation of a number of renumbering algorithms for the degrees of
  * freedom on a triangulation.
  *
- * \section{Cuthill-McKee like algorithms}
+ * @sect2{Cuthill-McKee like algorithms}
  *
  * Within this class, the Cuthill-McKee algorithm is implemented. It starts
  * at a degree of freedom, searches the other DoFs for those which are couple
  * not that important any more.
  *
  * 
- * \subsection{Implementation of renumbering schemes}
+ * @sect3{Implementation of renumbering schemes}
  *
  * The renumbering algorithms need quite a lot of memory, since they have
  * to store for each dof with which other dofs it couples. This is done
- * using a #SparsityPattern# object used to store the sparsity pattern of
+ * using a @p{SparsityPattern} object used to store the sparsity pattern of
  * matrices. It
  * is not useful for the user to do anything between distributing the dofs
- * and renumbering, i.e. the calls to #DoFHandler::distribute_dofs# and
- * #DoFHandler::renumber_dofs# should follow each other immediately. If
+ * and renumbering, i.e. the calls to @p{DoFHandler::distribute_dofs} and
+ * @p{DoFHandler::renumber_dofs} should follow each other immediately. If
  * you try to create a sparsity pattern or anything else in between, these
  * will be invalid afterwards.
  *
  * The renumbering may take care of dof-to-dof couplings only induced by
  * eliminating constraints. In addition to the memory consumption mentioned
  * above, this also takes quite some computational time, but it may be
- * switched off upon calling the #renumber_dofs# function. This will then
+ * switched off upon calling the @p{renumber_dofs} function. This will then
  * give inferior results, since knots in the graph (representing dofs)
  * are not found to be neighbors even if they would be after condensation.
  * 
  * will search for its own starting point.
  *
  * 
- * \subsection{Results of renumbering}
+ * @sect3{Results of renumbering}
  *
  * The renumbering schemes mentioned above do not lead to optimal results.
  * However, after all there is no algorithm that accomplishes this within
  * may be difficult, however, and in many cases will not justify the effort.
  *
  *
- * \section{Componentwise numbering}
+ * @sect2{Componentwise numbering}
  *
- * For finite elements composed of several base elements using the #FESystem#
+ * For finite elements composed of several base elements using the @p{FESystem}
  * class, or for elements which provide several components themselves, it
  * may be of interest to sort the DoF indices by component. This will then
  * bring out the block matrix structure, since otherwise the degrees of freedom
  * are numbered cell-wise without taking into account that they may belong to
  * different components.
  *
- * This kind of numbering may be obtained by calling the #component_wise# function
+ * This kind of numbering may be obtained by calling the @p{component_wise} function
  * of this class. Since it does not touch the order of indices within each, it
  * may be worthwhile to first renumber using the Cuthill-McKee or a similar
  * algorithm and afterwards renumbering component-wise. This will bring out the
  * matrix structure and additionally have a good numbering within each block.
  *
  *
- * \section{Multigrid DoF numbering}
+ * @sect2{Multigrid DoF numbering}
  *
  * Most algorithms also work on multigrid degree of freedom numberings. Refer
  * to the actual function declarations to get more information on this.
@@ -223,10 +223,10 @@ class DoFRenumbering
                                      * You may want to give the order in
                                      * which the components are to be ordered
                                      * (e.g. if the second argument contains
-                                     * the numbers #(0, 3, 2, 1)#, then all
-                                     * indices of component #0# will be
-                                     * before those of component #3#, before
-                                     * those of component #2#, ...). The
+                                     * the numbers @p{(0, 3, 2, 1)}, then all
+                                     * indices of component @p{0} will be
+                                     * before those of component @p{3}, before
+                                     * those of component @p{2}, ...). The
                                      * length of this list has to be the
                                      * same as the number of components
                                      * in the finite element, and has to
@@ -247,8 +247,8 @@ class DoFRenumbering
 
                                     /**
                                      * Sort those degrees of freedom
-                                     * which are tagged with #true#
-                                     * in the #selected_dofs# array
+                                     * which are tagged with @p{true}
+                                     * in the @p{selected_dofs} array
                                      * to the back of the DoF
                                      * numbers. The sorting is
                                      * stable, i.e. the relative
index 5afae24f58c3c06fb9467e13f81c87239402b263..978636baf98a0d09da1612dba860ecbd01d9c309 100644 (file)
@@ -46,13 +46,13 @@ 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<dim>::refine_*# functions. This
- *  vector contains elements of data type #float#, rather than #double#,
+ *  can be used to feed the @p{Triangulation<dim>::refine_*} functions. This
+ *  vector contains elements of data type @p{float}, rather than @p{double},
  *  since accuracy is not so important here, and since this can save rather
  *  a lot of memory, when using many cells.
  *
  *  
- *  \subsection{Implementation}
+ *  @sect3{Implementation}
  *
  *  In principle, the implementation of the error estimation is simple: let
  *  $$ \eta_K^2 =
@@ -66,8 +66,8 @@ template <int dim> class FESubfaceValues;
  *  is considered, but may lead to wrong results. You may scale the vector
  *  appropriately afterwards.
  *
- *  To perform the integration, use is made of the #FEFaceValues# and
- *  #FESubfaceValues# classes. The integration is performed by looping
+ *  To perform the integration, use is made of the @p{FEFaceValues} and
+ *  @p{FESubfaceValues} classes. The integration is performed by looping
  *  over all cells and integrating over faces that are not yet treated.
  *  This way we avoid integration on faces twice, once for each time we
  *  visit one of the adjacent cells. In a second loop over all cells, we
@@ -75,11 +75,11 @@ template <int dim> class FESubfaceValues;
  *  square of the jumps) of each cell and take the square root.
  *
  *  The integration is done using a quadrature formula on the face.
- *  For linear trial functions (#FELinear#), the #Gauss2# or even the
- *  #Midpoint# rule will suffice. For higher order elements, it is
+ *  For linear trial functions (@p{FELinear}), the @p{Gauss2} or even the
+ *  @p{Midpoint} rule will suffice. For higher order elements, it is
  *  necessary to utilize higher order quadrature formulae as well.
  *
- *  We store the contribution of each face in a #map#, as provided by the
+ *  We store the contribution of each face in a @p{map}, as provided by the
  *  C++ standard library, with the iterator pointing to that face being the
  *  key into the map. In fact, we do not store the indicator per face, but
  *  only the integral listed above. When looping the second time over all
@@ -94,7 +94,7 @@ template <int dim> class FESubfaceValues;
  *  the diameter of the cell.
  *  
  *
- *  \subsection{Vector-valued functions}
+ *  @sect3{Vector-valued functions}
  *
  *  If the finite element field for which the error is to be estimated
  *  is vector-valued, i.e. the finite element has more than one
@@ -102,7 +102,7 @@ template <int dim> class FESubfaceValues;
  *  components at the same time. The main function of this class takes
  *  a list of flags denoting the components for which components the
  *  error estimator is to be applied; by default, it is a list of only
- *  #true#s, meaning that all variables shall be treated.
+ *  @p{true}s, meaning that all variables shall be treated.
  *
  *  In case the different components of a field have different
  *  physical meaning (for example velocity and pressure in the Stokes
@@ -116,7 +116,7 @@ template <int dim> class FESubfaceValues;
  *  a scalar coefficient which will then be used for all components.
  *
  *
- *  \subsection{Boundary values}
+ *  @sect3{Boundary values}
  *  
  *  If the face is at the boundary, i.e. there is no neighboring cell to which
  *  the jump in the gradiend could be computed, there are two possibilities:
@@ -154,11 +154,11 @@ template <int dim> class FESubfaceValues;
  *  conditions.
  *
  *  
- *  \subsection{Handling of hanging nodes}
+ *  @sect3{Handling of hanging nodes}
  *  
  *  The integration along faces with hanging nodes is quite tricky, since one
  *  of the elements has to be shifted one level up or down. See the
- *  documentation for the #FESubfaceValues# class for more information about
+ *  documentation for the @p{FESubfaceValues} class for more information about
  *  technical issues regarding this topic.
  *
  *  In praxi, since we integrate over each face only once, we do this when we
@@ -192,7 +192,7 @@ class KellyErrorEstimator
                                      * values on this part of the boundary.
                                      * Only one boundary function may be given
                                      * for each boundary indicator, which is
-                                     * guaranteed by the #map# data type.
+                                     * guaranteed by the @p{map} data type.
                                      */    
     typedef map<unsigned char,const Function<dim>*> FunctionMap;
 
@@ -220,11 +220,11 @@ class KellyErrorEstimator
                                      * components you want to
                                      * evaluate, in case the finite
                                      * element used by the
-                                     * #DoFHandler# object is
+                                     * @p{DoFHandler} object is
                                      * vector-valued. You then have
                                      * to set those entries to true
                                      * in the bit-vector
-                                     * #component_mask# for which the
+                                     * @p{component_mask} for which the
                                      * respective component is to be
                                      * used in the error
                                      * estimator. The default is to
@@ -237,7 +237,7 @@ class KellyErrorEstimator
                                      * The estimator supports
                                      * multithreading and splits the
                                      * cells to
-                                     * #multithread_info.n_default_threads#
+                                     * @p{multithread_info.n_default_threads}
                                      * (default) threads. The number
                                      * of threads to be used in
                                      * multithreaded mode can be set
@@ -306,7 +306,7 @@ class KellyErrorEstimator
                                      * first, class member data is
                                      * not possible because no real
                                      * object is created (all
-                                     * functions are #static#), which
+                                     * functions are @p{static}), which
                                      * is a historical
                                      * reason. Second, if we don't
                                      * collect the data the various
@@ -364,7 +364,7 @@ class KellyErrorEstimator
                                          * on one cell
                                          *
                                          * Let psi be a short name for
-                                         * #a grad u_h#, where the second
+                                         * @p{a grad u_h}, where the second
                                          * index be the component of the
                                          * finite element, and the first
                                          * index the number of the
@@ -419,7 +419,7 @@ class KellyErrorEstimator
                                      * Computates the error on all cells
                                      * of the domain with the number n,
                                      * satisfying
-                                     * #n=this_thread (mod n_threads)#
+                                     * @p{n=this_thread (mod n_threads)}
                                      * This enumeration is chosen to
                                      * generate a random distribution
                                      * of all cells.
@@ -447,7 +447,7 @@ class KellyErrorEstimator
                                      * The meaning of the parameters becomes
                                      * clear when looking at the source
                                      * code. This function is only
-                                     * externalized from #estimate_error#
+                                     * externalized from @p{estimate_error}
                                      * to avoid ending up with a function
                                      * of 500 lines of code.
                                      */
@@ -462,7 +462,7 @@ class KellyErrorEstimator
                                     /**
                                      * The same applies as for the function
                                      * above, except that integration is
-                                     * over face #face_no# of #cell#, where
+                                     * over face @p{face_no} of @p{cell}, where
                                      * the respective neighbor is refined,
                                      * so that the integration is a bit more
                                      * complex.
index 7834338d75235c935e131baa8390a9984e6d8ce5..4dafb4685f4141fc876c6239b5e04340b5b7798a 100644 (file)
  * the values of the finite element field at the centers of the cells
  * are taken. It might therefore only be useful to use this class for
  * discontinuous, piecewise constant elements (i.e. using the
- * #FEDG_Q0# class), since all other finite elements can approximate
+ * @p{FEDG_Q0} class), since all other finite elements can approximate
  * gradients themselves.
  *
  *
- * \section{Refinement indicators based on the gradients}
+ * @sect2{Refinement indicators based on the gradients}
  *
  * If you would like to base a refinement criterion upon this
  * approximation of the gradient, you will have to scale the results
index 922c04b59fc3511922cc9f8ff9c49f5bf823c37d..cf2d5f00f6f3fdf2dc954cf69fb62c832fe86474 100644 (file)
@@ -32,7 +32,7 @@
  * intervals are used for each of them anyway, to make comparison easier.
  *
  *
- * \subsection{Ways to generate the intervals}
+ * @sect3{Ways to generate the intervals}
  *
  * At present, the following schemes for interval spacing are implemented:
  * \begin{itemize}
  * \end{itemize}
  *
  * To keep programs extendible, you can use the two functions
- * #get_interval_spacing_names# and #parse_interval_spacing#, which always
+ * @p{get_interval_spacing_names} and @p{parse_interval_spacing}, which always
  * give you a complete list of spacing formats presently supported and are
- * able to generate the respective value of the #enum#. If you use them,
+ * able to generate the respective value of the @p{enum}. If you use them,
  * you can write your program in a way such that it only needs to be
  * recompiled to take effect of newly added formats, without changing your
  * code.
  *
  *
- * \subsection{Output formats}
+ * @sect3{Output formats}
  *
  * At present, only GNUPLOT output is supported.
  *
@@ -84,25 +84,25 @@ class Histogram
                                      *
                                      * The histograms will be arranged such
                                      * that the computed intervals of the
-                                     * #values[i][j]# form the x-range,
+                                     * @p{values[i][j]} 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
-                                     * plots). For 3d plots, the #y_values#
+                                     * plots). For 3d plots, the @p{y_values}
                                      * parameter is used to assign each
                                      * data set a value in the y direction,
                                      * which is the depth coordinate in the
                                      * resulting plot. For 2d plots,
-                                     * the #y_values# are ignored.
+                                     * the @p{y_values} are ignored.
                                      *
                                      * If you give only one data set, i.e.
-                                     * #values.size()==1#, then the
+                                     * @p{values.size()==1}, then the
                                      * resulting histogram will be a 2d
                                      * one.
                                      *
-                                     * #n_intervals# denotes the number of
+                                     * @p{n_intervals} denotes the number of
                                      * intervals into which the data will be
-                                     * sorted; #interval_spacing# denotes
+                                     * sorted; @p{interval_spacing} denotes
                                      * the way the bounds of the intervals
                                      * are computed. Refer to the general
                                      * documentation for more information
@@ -126,7 +126,7 @@ class Histogram
 
                                     /**
                                      * Write the histogram computed by
-                                     * the #evaluate# function to a
+                                     * the @p{evaluate} function to a
                                      * stream in a format suitable to
                                      * the GNUPLOT program. The function
                                      * generates 2d or 3d histograms.
@@ -144,7 +144,7 @@ class Histogram
                                      * Get a string containing one of the
                                      * names returned by the above function
                                      * and return the respective value of
-                                     * #IntervalSpacing#. Throw an error
+                                     * @p{IntervalSpacing}. Throw an error
                                      * if the string is no valid one.
                                      */
     static IntervalSpacing parse_interval_spacing (const string &name);
@@ -222,8 +222,8 @@ class Histogram
                                      * logarithmic case interval spacing
                                      * scheme.
                                      *
-                                     * Return #true#, if (#n1<n2#,
-                                     * and (#n1>0# or #n2<0#)), or
+                                     * Return @p{true}, if (@p{n1<n2},
+                                     * and (@p{n1>0} or @p{n2<0})), or
                                      * (n2<n1 and n1>0 and n2<=0). This
                                      * in effect sorts all negativ
                                      * numbers to be larger than the
@@ -236,13 +236,13 @@ class Histogram
                                     /**
                                      * Vector holding one set of intervals
                                      * for each data set given to the
-                                     * #evaluate# function.
+                                     * @p{evaluate} function.
                                      */
     vector<vector<Interval> > intervals;
 
                                     /**
                                      * Values for the depth axis of 3d
-                                     * histograms. Stored in the #evaluate#
+                                     * histograms. Stored in the @p{evaluate}
                                      * function.
                                      */
     vector<double>            y_values;
index b8c183e9894b7d6f94a935924894bfd014480163..95982c09bf9ecf624629dde99b80b61c6427f798 100644 (file)
@@ -38,37 +38,37 @@ template <int dim> class Equation;
  * of this type, though you may do so.
  *
  *
- * \subsection{Conventions for all functions}
+ * @sect3{Conventions for all functions}
  *
  * All functions take a sparse matrix object to hold the matrix to be
  * created. The functions assume that the matrix is initialized with a
- * sparsity pattern (#SparsityPattern#) corresponding to the given degree
+ * sparsity pattern (@p{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<dim>::make_sparsity_pattern#
+ * You can do this by calling the @p{DoFHandler<dim>::make_sparsity_pattern}
  * function.
  *
  * Furthermore it is assumed that no relevant data is in the matrix. All
  * entries will be overwritten. Entries which are not needed by the matrix
- * (and were thus added 'by hand' after #make_sparsity_pattern# was called)
+ * (and were thus added 'by hand' after @p{make_sparsity_pattern} was called)
  * are not touched and in special are not set to zero, so you have to care
  * yourself about that if you really need these entries.
  *
  *
- * \subsection{Supported matrices}
+ * @sect3{Supported matrices}
  *
  * At present there are functions to create the following matrices:
  * \begin{itemize}
- * \item #create_mass_matrix#: create the matrix with entries
+ * \item @p{create_mass_matrix}: create the matrix with entries
  *   $m_{ij} = \int_\Omega \phi_i(x) \phi_j(x) dx$. Here, the $\phi_i$
  *   are the basis functions of the finite element space given.
- *   This function uses the #MassMatrix# class.
+ *   This function uses the @p{MassMatrix} class.
  *
  *   Two ways to create this matrix are offered. The first one uses
- *   numerical quadrature and the #MassMatrix# class. In this case,
+ *   numerical quadrature and the @p{MassMatrix} class. In this case,
  *   a coefficient may be given to evaluate
  *   $m_{ij} = \int_\Omega a(x) \phi_i(x) \phi_j(x) dx$ instead.
  *   This way of setting up the mass matrix is quite general, but has
- *   some drawbacks, see the documentation of the #MassMatrix# class.
+ *   some drawbacks, see the documentation of the @p{MassMatrix} class.
  *
  *   The other way uses exact integration, as offered by the finite
  *   element class used. This way you can avoid quadrature errors and
@@ -80,26 +80,26 @@ template <int dim> class Equation;
  *   composed of several subelements. In this case, using the
  *   quadrature free way (without coefficient) results in a matrix
  *   which does not couple the subelements, as described in the
- *   #FESystem::get_local_mass_matrix# documentation, while the
+ *   @p{FESystem::get_local_mass_matrix} documentation, while the
  *   way using quadrature sets up the full matrix, i.e. with the
  *   cross coupling of shape functions belonging to different subelements.
  *
  *   If the finite element for which the mass matrix is to be built
  *   has more than one component, the resulting matrix will not couple
  *   the different components. It will furthermore accept a single
- *   coefficient through the #Function# parameter for all
+ *   coefficient through the @p{Function} parameter for all
  *   components. If you want different coefficients for the different
  *   parameters, you need to pass a function object representing the
  *   respective number of components.
  *
- * \item #create_laplace_matrix#: there are two versions of this; the
- *   one which takes the #Function<dim># object creates
+ * \item @p{create_laplace_matrix}: there are two versions of this; the
+ *   one which takes the @p{Function<dim>} object creates
  *   $a_{ij} = \int_\Omega a(x) \nabla\phi_i(x) \nabla\phi_j(x) dx$,
  *   $a$ being the given function, while the other one assumes that
  *   $a=1$ which enables some optimizations. In fact the two versions
  *   are in one function, the coefficient being given as a defaulted
  *   argument, which is a pointer to a function and defaults to zero.
- *   This function uses the #LaplaceMatrix# class.
+ *   This function uses the @p{LaplaceMatrix} class.
  *
  *   If the finite element in use presently has more than only one
  *   component, this function may not be overly useful and presently
@@ -111,7 +111,7 @@ template <int dim> class Equation;
  * several matrices and could then condense afterwards only once,
  * instead of for every matrix. To actually do computations with these
  * matrices, you have to condense the matrix using the
- * #ConstraintMatrix::condense# function; you also have to condense the
+ * @p{ConstraintMatrix::condense} function; you also have to condense the
  * right hand side accordingly and distribute the solution afterwards.
  *
  * In all cases, the elements of the matrix to be assembled are simply
@@ -119,18 +119,18 @@ template <int dim> class Equation;
  * to clear the matrix before assemblage.
  *
  * If you want to use boundary conditions, you have to use a function
- * like #ProblemBase<>::apply_dirichlet_bc# to matrix and right hand
+ * like @p{ProblemBase<>::apply_dirichlet_bc} to matrix and right hand
  * side.
  *
  *
- * \subsection{Matrices on the boundary}
+ * @sect3{Matrices on the boundary}
  *
- * The #create_boundary_mass_matrix# creates the matrix with entries
+ * The @p{create_boundary_mass_matrix} creates the matrix with entries
  * $m_{ij} = \int_{\Gamma} \phi_i \phi_j dx$, where $\Gamma$ is the union
  * of boundary parts with indicators contained in a set 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 set
- * of #unsigned char#s as parameter #boundary_parts# containing the elements
+ * of @p{unsigned char}s as parameter @p{boundary_parts} containing the elements
  * zero and 2). The $\phi_i$ are the basis functions which have at least
  * part of their support om $\Gamma$. The mapping between row and column
  * indices in the mass matrix and the right hand side and the global degree
@@ -145,21 +145,21 @@ template <int dim> class Equation;
  * This function needs to get passed a matrix object to hold the resulting sparse
  * matrix. This object is supposed to be initialized with a suitable sparsity
  * pattern, which can be created using the
- * #DoFHandler<>::make_boundary_sparsity_pattern# function.
+ * @p{DoFHandler<>::make_boundary_sparsity_pattern} function.
  *
  * The object describing the exact form of the boundary is obtained from the
  * triangulation object.
  *
- * \subsection{Right hand sides}
+ * @sect3{Right hand sides}
  *
  * In many cases, you will not only want to build the matrix, but also
  * a right hand side, which will give a vector with
  * $f_i = \int_\Omega f(x) \phi_i(x) dx$. For this purpose, each function
  * exists in two versions, one only building the matrix and one also
- * building the right hand side vector. (The #create_mass_matrix# function
+ * building the right hand side vector. (The @p{create_mass_matrix} function
  * which does not use quadrature does not offer a version to evaluate a right
  * hand side also, since this needs quadrature anyway. Take look at the
- * #VectorTools# class to find a function to set up a right hand side vector
+ * @p{VectorTools} class to find a function to set up a right hand side vector
  * only.)
  *
  * Creation of the right hand side
@@ -170,12 +170,12 @@ template <int dim> class Equation;
  * penalty, since then many values of a certain finite element have to
  * be computed twice, so it is more economical to  implement it more than
  * once. If you only want to create a right hand side as above, there is
- * a function in the #VectorCreator# class. The use of the latter may be
+ * a function in the @p{VectorCreator} class. The use of the latter may be
  * useful if you want to create many right hand side vectors.
  *
  *
  * All functions in this collection use the finite elemen given to the
- * #DoFHandler# object the last time that the degrees of freedom were
+ * @p{DoFHandler} object the last time that the degrees of freedom were
  * distributed on the triangulation.
  *
  * @author Wolfgang Bangerth, 1998
@@ -191,7 +191,7 @@ class MatrixCreator
                                      * values on this part of the boundary.
                                      * Only one boundary function may be given
                                      * for each boundary indicator, which is
-                                     * guaranteed by the #map# data type.
+                                     * guaranteed by the @p{map} data type.
                                      * 
                                      * See the general documentation of this
                                      * class for more detail.
@@ -274,7 +274,7 @@ class MatrixCreator
                                      *
                                      * The matrix is assumed to already be
                                      * initialized with a suiting sparsity
-                                     * pattern (the #DoFHandler# provides an
+                                     * pattern (the @p{DoFHandler} provides an
                                      * appropriate function).
                                      *
                                      * See the general doc of this class
@@ -342,13 +342,13 @@ class MatrixCreator
  * and others.
  *
  *
- * \subsection{Boundary conditions}
+ * @sect3{Boundary conditions}
  *
- * The #apply_boundary_values# function inserts boundary conditions of
+ * The @p{apply_boundary_values} function inserts boundary conditions of
  * into a system of equations.  To actually do this you have to specify
  * a list of degree of freedom indices along with the values these degrees of
  * freedom shall assume. To see how to get such a list, see the discussion
- * of the #VectorTools::interpolate_boundary_values# function.
+ * of the @p{VectorTools::interpolate_boundary_values} function.
  *
  * The inclusion into the assemblage process is as follows: when the matrix and
  * vectors are set up, a list of nodes subject to dirichlet bc is made and
@@ -375,7 +375,7 @@ class MatrixCreator
  * solver which can handle nonsymmetric matrices in any case, so there
  * may be no need to do the Gauss elimination anyway. In fact, this is
  * the way the function works: it takes a parameter
- * (#elininate_columns#) that specifies whether the sparsity pattern
+ * (@p{elininate_columns}) that specifies whether the sparsity pattern
  * is symmetric; if so, then the column is eliminated and the right
  * hand side is also modified accordingly. If not, then only the row
  * is deleted and the column is not touched at all, and all right hand
@@ -383,21 +383,21 @@ class MatrixCreator
  * remain unchanged.
  *
  * If the sparsity pattern for your matrix is non-symmetric, you must
- * set the value of this parameter to #false# in any case, since then
+ * set the value of this parameter to @p{false} in any case, since then
  * we can't eliminate the column without searching all rows, which
- * would be too expensive (if #N# be the number of rows, and #m# the
+ * would be too expensive (if @p{N} be the number of rows, and @p{m} the
  * number of nonzero elements per row, then eliminating one column is
- * an #O(N*log(m))# operation, since searching in each row takes
- * #log(m)# operations). If your sparsity pattern is symmetric, but
- * your matrix is not, then you might specify #false# as well. If your
+ * an @p{O(N*log(m))} operation, since searching in each row takes
+ * @p{log(m)} operations). If your sparsity pattern is symmetric, but
+ * your matrix is not, then you might specify @p{false} as well. If your
  * sparsity pattern and matrix are both symmetric, you might want to
- * specify #true# (the complexity of eliminating one row is then
- * #O(m*log(m))#, since we only have to search #m# rows for the
- * respective element of the column). Given the fact that #m# is
+ * specify @p{true} (the complexity of eliminating one row is then
+ * @p{O(m*log(m))}, since we only have to search @p{m} rows for the
+ * respective element of the column). Given the fact that @p{m} is
  * roughly constant, irrespective of the discretization, and that the
- * number of boundary nodes is #sqrt(N)# in 2d, the algorithm for
- * symmetric sparsity patterns is #O(sqrt(N)*m*log(m))#, while it
- * would be #O(N*sqrt(N)*log(m))# for the general case; the latter
+ * 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
  * is too expensive to be performed.
  *
  * It seems as if we had to make clear not to overwrite the lines of other
@@ -484,7 +484,7 @@ class MatrixTools : public MatrixCreator<dim>
 
 
 /**
- * Equation class to be passed to the #Assembler# if you want to make up the
+ * Equation class to be passed to the @p{Assembler} if you want to make up the
  * mass matrix for your problem. The mass matrix is the matrix with
  * $m_{ij} = \int_\Omega \phi_i(x) \phi_j(x) dx$.
  *
@@ -501,16 +501,16 @@ class MatrixTools : public MatrixCreator<dim>
  * since it does not depend on the operator.
  *
  * The defaults for both right hand side and coefficient function is a
- * #NULL# pointer. If you need a coefficient but no right hand side object,
- * simply pass a #NULL# pointer to the constructor for its first argument.
+ * @p{NULL} pointer. If you need a coefficient but no right hand side object,
+ * simply pass a @p{NULL} pointer to the constructor for its first argument.
  *
  *
- * \subsection{Other possibilities}
+ * @sect3{Other possibilities}
  *
  * You will usually want to use this object only if you have coefficients
  * which vary over each cell. If you have coefficients which are constant
  * on each cell or even on the whole domain, you can get the local mass
- * matrix easier by calling the #FiniteElement::get_local_mass_matrix# and
+ * matrix easier by calling the @p{FiniteElement::get_local_mass_matrix} and
  * then scaling this one on each cell. This has the additional benefit that
  * the mass matrix is evaluated exactly, i.e. not using a quadrature formula
  * and is normally much faster since it can be precomputed and needs only
@@ -519,7 +519,7 @@ class MatrixTools : public MatrixCreator<dim>
  * The useful use of this object is therefore probable one of the following
  * cases:
  * \begin{itemize}
- * \item Mass lumping: use an #Assembler# object and a special quadrature
+ * \item Mass lumping: use an @p{Assembler} object and a special quadrature
  *   formula to voluntarily evaluate the mass matrix incorrect. For example
  *   by using the trapezoidal formula, the mass matrix will become a
  *   diagonal (at least if no hanging nodes are considered). However, there
@@ -543,9 +543,9 @@ class MatrixTools : public MatrixCreator<dim>
  *    the form $s_{ij} = m_{ij} + \alpha a_{ij}$, for example, with $M$ and
  *    $A$ being the mass and laplace matrix, respectively (this matrix $S$
  *    occurs in the discretization of the heat and the wave equation, amoung
- *    others), once could conceive an equation object in which the #assemble#
+ *    others), once could conceive an equation object in which the @p{assemble}
  *    functions do nothing but sum up the contributions delivered by the
- *    #assemble# functions of the #MassMatrix# and #LaplaceMatrix# classes.
+ *    @p{assemble} functions of the @p{MassMatrix} and @p{LaplaceMatrix} classes.
  *    Since numerical quadrature is necessary here anyway, this way is
  *    justifyable to quickly try something out. In the further process it
  *    may be useful to replace this behaviour by more sophisticated methods,
@@ -636,7 +636,7 @@ class MassMatrix :  public Equation<dim> {
 
 
 /**
- * Equation class to be passed to the #Assembler# if you want to make up the
+ * Equation class to be passed to the @p{Assembler} if you want to make up the
  * laplace matrix for your problem. The laplace matrix is the matrix with
  * $a_{ij} = \int_\Omega \nabla\phi_i(x) \cdot \nabla\phi_j(x) dx$.
  *
@@ -653,8 +653,8 @@ class MassMatrix :  public Equation<dim> {
  * since it does not depend on the operator.
  *
  * The defaults for both right hand side and coefficient function is a
- * #NULL# pointer. If you need a coefficient but no right hand side object,
- * simply pass a #NULL# pointer to the constructor for its first argument.
+ * @p{NULL} pointer. If you need a coefficient but no right hand side object,
+ * simply pass a @p{NULL} pointer to the constructor for its first argument.
  */
 template <int dim>
 class LaplaceMatrix :  public Equation<dim> {
index f3449f7934eeef09959650c2032d711530926379..951dd7bdff470754d927946e977b79585301d1d9 100644 (file)
  * vector is reinitialized to the new size and filled with the interpolated
  * values.
  * 
- * \subsection{Usage}
+ * @sect3{Usage}
  *
  * As the interpolation while
  * coarsening is much more complicated to organize 
  * (see further documentation below) than interpolation while pure refinement,
- * #SolutionTransfer# offers two possible usages.
+ * @p{SolutionTransfer} offers two possible usages.
  * \begin{itemize}
  * \item If the grid will only be purely refined
- * (i.e. not locally coarsened) then use #SolutionTransfer# as follows
+ * (i.e. not locally coarsened) then use @p{SolutionTransfer} as follows
  * \begin{verbatim}
  * SolutionTransfer<dim, double> soltrans(*dof_handler);
  * soltrans.prepare_for_pure_refinement();
@@ -53,7 +53,7 @@
  * ...
  * \end{verbatim}
  * \item If the grid will be coarsenend and refined
- * then use #SolutionTransfer# as follows
+ * then use @p{SolutionTransfer} as follows
  * \begin{verbatim}
  * SolutionTransfer<dim, double> soltrans(*dof_handler);
  *                                     // some refinement e.g.
  * dof_handler->distribute_dofs (fe);
  * soltrans.interpolate(solution, interpolated_solution);
  * \end{verbatim}
+ *
  * Multiple calling of the function 
- * #interpolate (const Vector<number> &in, Vector<number> &out)#
+ * @p{interpolate (const Vector<number> &in, Vector<number> &out)}
  * is NOT allowed. Interpolating several functions can be performed in one step
- * by using #void interpolate (const vector<Vector<number> >&all_in,
- * vector<Vector<number> >&all_out) const#, and
- * using the respective #prepare_for_coarsening_and_refinement# function taking
- * several vectors as input before actually refining and coarsening the
+ * by using 
+ * @p{void interpolate (const vector<Vector<number> >&all_in, vector<Vector<number> >&all_out) const},
+ * and using the respective @p{prepare_for_coarsening_and_refinement} function 
+ * taking several vectors as input before actually refining and coarsening the
  * triangulation (see there).
  * \end{itemize}
  *
- * For deleting all stored data in #SolutionTransfer# and reinitializing it
- * use the #clear()# function.
+ * For deleting all stored data in @p{SolutionTransfer} and reinitializing it
+ * use the @p{clear()} function.
  *
- * Note that the #user_pointer# of some cells are used. 
+ * Note that the @p{user_pointer} of some cells are used. 
  * Be sure that you don't need them otherwise.
  *
- * The template argument #number# denotes the data type of the vectors you want
+ * The template argument @p{number} denotes the data type of the vectors you want
  * to transfer.
  *
  *
- * \subsection{Implementation}
+ * @sect3{Implementation}
  *
  * \begin{itemize}
  * \item Solution transfer while pure refinement. Assume that we have got a
  * solution vector on the current (original) grid.
  * Each entry of this vector belongs to one of the
  * DoFs of the discretisation. If we now refine the grid then the calling of
- * #DoFHandler::distribute_dofs(...)# will change at least some of the
+ * @p{DoFHandler::distribute_dofs(...)} will change at least some of the
  * DoF indices. Hence we need to store the DoF indices of all active cells
- * before the refinement. The #user_pointer# of each active cell
+ * before the refinement. The @p{user_pointer} of each active cell
  * is used to point to the vector of these DoF indices of that cell, all other
- * #user_pointers# are cleared. All this is
- * done by #prepare_for_pure_refinement()#.
+ * @p{user_pointers} are cleared. All this is
+ * done by @p{prepare_for_pure_refinement()}.
  *
- * In the function #refine_interpolate(in,out)# and on each cell where the
- * #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 #in#
+ * In the function @p{refine_interpolate(in,out)} and on each cell where the
+ * @p{user_pointer} is set (i.e. the cells that were active in the original grid)
+ * we can now access the local values of the solution vector @p{in}
  * on that cell by using the stored DoF indices. These local values are
- * interpolated and set into the vector #out# that is at the end the
- * discrete function #in# interpolated on the refined mesh.
+ * interpolated and set into the vector @p{out} that is at the end the
+ * discrete function @p{in} interpolated on the refined mesh.
  *
- * The #refine_interpolate(in,out)# function can be called multiplely for
+ * The @p{refine_interpolate(in,out)} function can be called multiplely for
  * arbitrary many discrete functions (solution vectors) on the original grid. 
  *
  * \item Solution transfer while coarsening and refinement. After 
- * calling #Triangulation::prepare_coarsening_and_refinement# the
+ * calling @p{Triangulation::prepare_coarsening_and_refinement} the
  * coarsen flags of either all or none of the children of a 
  * (father-)cell are set. While coarsening 
- * (#Triangulation::execute_coarsening_and_refinement#)
- * the cells that are not needed any more will be deleted from the #Triangulation#.
+ * (@p{Triangulation::execute_coarsening_and_refinement})
+ * the cells that are not needed any more will be deleted from the @p{Triangulation}.
  * 
  * For the interpolation from the (to be coarsenend) children to their father
  * the children cells are needed. Hence this interpolation
  * and the storing of the interpolated values of each of the discrete functions
  * that we want to interpolate needs to take place before these children cells
- * are coarsened (and deleted!!). Again the #user_pointers# of the cells are
+ * are coarsened (and deleted!!). Again the @p{user_pointers} of the cells are
  * set to point to these values (see below). 
  * Additionally the DoF indices of the cells
  * that will not be coarsened need to be stored according to the solution
  * transfer while pure refinement (cf there). All this is performed by
- * #prepare_for_coarsening_and_refinement(all_in)# where the 
- * #vector<Vector<number> >vector all_in# includes
+ * @p{prepare_for_coarsening_and_refinement(all_in)} where the 
+ * @p{vector<Vector<number> >vector all_in} includes
  * all discrete functions to be interpolated onto the new grid.
  *
- * As we need two different kinds of pointers (#vector<unsigned int> *# for the Dof
- * indices and #vector<Vector<number> > *# for the interpolated DoF values)
- * we use the #Pointerstruct# that includes both of these pointers and
- * the #user_pointer# of each cell points to these #Pointerstructs#
+ * As we need two different kinds of pointers (@p{vector<unsigned int> *} for the Dof
+ * indices and @p{vector<Vector<number> > *} for the interpolated DoF values)
+ * we use the @p{Pointerstruct} that includes both of these pointers and
+ * the @p{user_pointer} of each cell points to these @p{Pointerstructs}
  * On each cell only one of the two different pointers is used at one time 
  * hence we could use the
- * #void * user_pointer# as #vector<unsigned int> *# at one time and as 
- * #vector<Vector<number> > *# at the other but using this #Pointerstruct#
+ * @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}
  * in between makes the use of these pointers more safe and gives better
  * possibility to expand their usage.
  * 
- * In #interpolate(all_in, all_out)# the refined cells are treated according
+ * In @p{interpolate(all_in, all_out)} 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 #all_out# are set to the stored local interpolated values 
+ * functions in @p{all_out} are set to the stored local interpolated values 
  * that are accessible due to the 'vector<Vector<number> > *' pointer in 
- * #Pointerstruct# that is pointed to by the #user_pointer# of that cell.
- * It is clear that #interpolate(all_in, all_out)# only can be called with
- * the #vector<Vector<number> > all_in# that previously was the parameter
- * of the #prepare_for_coarsening_and_refinement(all_in)# function. Hence 
- * #interpolate(all_in, all_out)# can (in contrast to 
- * #refine_interpolate(in, out)#) only be called once.
+ * @p{Pointerstruct} that is pointed to by the @p{user_pointer} of that cell.
+ * It is clear that @p{interpolate(all_in, all_out)} only can be called with
+ * the @p{vector<Vector<number> > all_in} that previously was the parameter
+ * of the @p{prepare_for_coarsening_and_refinement(all_in)} function. Hence 
+ * @p{interpolate(all_in, all_out)} can (in contrast to 
+ * @p{refine_interpolate(in, out)}) only be called once.
  * \end{itemize}
  *
  * @author Ralf Hartmann, 1999
@@ -163,7 +163,7 @@ class SolutionTransfer
   public:
     
                                     /**
-                                     * Constructor, takes the current #DoFHandler#
+                                     * Constructor, takes the current @p{DoFHandler}
                                      * as argument.
                                      */
     SolutionTransfer(const DoFHandler<dim> &dof);
@@ -181,22 +181,22 @@ class SolutionTransfer
     void clear();
 
                                     /**
-                                     * Prepares the #SolutionTransfer# for
+                                     * Prepares the @p{SolutionTransfer} for
                                      * pure refinement. It
                                      * stores the dof indices of each cell.
                                      * After calling this function 
-                                     * only calling the #refine_interpolate#
+                                     * only calling the @p{refine_interpolate}
                                      * functions is allowed.
                                      */
     void prepare_for_pure_refinement();
 
                                     /**
-                                     * Prepares the #SolutionTransfer# for
+                                     * Prepares the @p{SolutionTransfer} for
                                      * coarsening and refinement. It
                                      * stores the dof indices of each cell and
                                      * stores the dof values of the vectors in
-                                     * #all_in# in each cell that'll be coarsened.
-                                     * #all_in# includes all vectors
+                                     * @p{all_in} in each cell that'll be coarsened.
+                                     * @p{all_in} includes all vectors
                                      * that are to be interpolated
                                      * onto the new (refined and/or
                                      * coarsenend) grid.
@@ -212,16 +212,16 @@ class SolutionTransfer
                      
                                     /**
                                      * This function
-                                     * interpolates the discrete function #in#,
+                                     * interpolates the discrete function @p{in},
                                      * which is a vector on the grid before the
-                                     * refinement, to the function #out#
+                                     * refinement, to the function @p{out}
                                      * which then is a vector on the refined grid.
                                      * It assumes the vectors having the
-                                     * right sizes (i.e. #in.size()==n_dofs_old#,
-                                     * #out.size()==n_dofs_refined#)
+                                     * right sizes (i.e. @p{in.size()==n_dofs_old},
+                                     * @p{out.size()==n_dofs_refined})
                                              *
                                      * Calling this function is allowed only
-                                     * if #prepare_for_pure_refinement# is called
+                                     * if @p{prepare_for_pure_refinement} is called
                                      * and the refinement is
                                      * executed before.
                                      * Multiple calling of this function is
@@ -232,9 +232,9 @@ class SolutionTransfer
                             Vector<number> &out) const;
     
                                     /**
-                                     * Same as #interpolate(in,out)#
+                                     * Same as @p{interpolate(in,out)}
                                      * but it interpolates
-                                     * just 'in-place'. Therefore #vec# will be
+                                     * just 'in-place'. Therefore @p{vec} will be
                                      * reinitialized to the new needed vector
                                      * dimension.
                                      */
@@ -243,26 +243,27 @@ class SolutionTransfer
                                     /**
                                      * This function
                                      * interpolates the discrete functions
-                                     * that are stored in #all_out# onto
+                                     * that are stored in @p{all_out} onto
                                      * the refined and/or coarsenend grid.
-                                     * It assumes the vectors in #all_in#
+                                     * It assumes the vectors in @p{all_in}
                                      * denote the same vectors
-                                     * as in #all_in# as parameter of
-                                     * #prepare_for_refinement_and_coarsening(all_in)#.
+                                     * as in @p{all_in} as parameter of
+                                     * @p{prepare_for_refinement_and_coarsening(all_in)}.
                                      * However, there is no way of verifying
                                      * this internally, so be careful here.
                                      *
-                                     * Calling this function is allowed only
-                                     * if first #Triangulation::prepare_coarsening_
-                                     * and_refinement#, second
-                                     * #SolutionTransfer::prepare_for_coarsening_
-                                     * and_refinement#, an then third 
-                                     * #Triangulation::execute_coarsening_
-                                     * and_refinement# are called before.
-                                     * Multiple calling of this function is
+                                     * Calling this function is
+                                     * allowed only if first
+                                     * @p{Triangulation::prepare_coarsening_and_refinement},
+                                     * second
+                                     * @p{SolutionTransfer::prepare_for_coarsening_and_refinement},
+                                     * an then third
+                                     * @p{Triangulation::execute_coarsening_and_refinement}
+                                     * are called before. Multiple
+                                     * calling of this function is
                                      * NOT allowed. Interpolating
-                                     * several functions can be performed
-                                     * in one step.
+                                     * several functions can be
+                                     * performed in one step.
                                      */
     void interpolate (const vector<Vector<number> >&all_in,
                      vector<Vector<number> >      &all_out) const;
@@ -275,7 +276,7 @@ class SolutionTransfer
                                      * NOT allowed. Interpolating
                                      * several functions can be performed
                                      * in one step by using
-                                     * #interpolate (all_out)#
+                                     * @p{interpolate (all_out)}
                                      */
     void interpolate (const Vector<number> &in,
                      Vector<number>       &out) const;
@@ -334,10 +335,10 @@ class SolutionTransfer
 
                                     /**
                                      * Declaration of
-                                     * #PreparationState# that
+                                     * @p{PreparationState} that
                                      * denotes the three possible
                                      * states of the
-                                     * #SolutionTransfer#: being
+                                     * @p{SolutionTransfer}: being
                                      * prepared for 'pure
                                      * refinement', prepared for
                                      * 'coarsening and refinement' or
@@ -354,9 +355,9 @@ class SolutionTransfer
 
 
                                     /**
-                                     * Is used for #prepare_for_refining#
+                                     * Is used for @p{prepare_for_refining}
                                      * (of course also for
-                                     * #repare_for_refining_and_coarsening#)
+                                     * @p{repare_for_refining_and_coarsening})
                                      * and stores all dof indices
                                      * of the cells that'll be refined
                                      */
@@ -367,18 +368,18 @@ class SolutionTransfer
                                      * the dof values)
                                      * should be accessable from each cell.
                                      * As each cell has got only one
-                                     * #user_pointer#, multiple pointers to the
+                                     * @p{user_pointer}, multiple pointers to the
                                      * data need to be packetized in a structure.
                                      * Note that in our case on each cell
                                      * either the
-                                     * #vector<unsigned int> indices# (if the cell
+                                     * @p{vector<unsigned int> indices} (if the cell
                                      * will be refined) or the
-                                     * #vector<double> dof_values# (if the
+                                     * @p{vector<double> dof_values} (if the
                                      * children of this cell will be deleted)
-                                     * is needed, hence one #user_pointer# should
+                                     * is needed, hence one @p{user_pointer} should
                                      * be sufficient, but to allow some errorchecks
                                      * and to preserve the user from making
-                                     * user errors the #user_pointer# will be
+                                     * user errors the @p{user_pointer} will be
                                      * 'multiplied' by this structure.
                                      */
     struct Pointerstruct {
@@ -387,10 +388,10 @@ class SolutionTransfer
     };
 
                                     /**
-                                     * Vector of all #Pointerstructs# (cf. there).
+                                     * Vector of all @p{Pointerstructs} (cf. there).
                                      * It makes it
                                      * easier to delete all these structs
-                                     * (without going over all #cell->user_pointer#)
+                                     * (without going over all @p{cell->user_pointer})
                                      * after they are not used any more, and
                                      * collecting all these structures in a vector
                                      * helps avoiding fraqmentation of the memory.
@@ -399,7 +400,7 @@ class SolutionTransfer
 
                                     /**
                                      * Is used for
-                                     * #prepare_for_refining_and_coarsening#
+                                     * @p{prepare_for_refining_and_coarsening}
                                      * The interpolated dof values
                                      * of all cells that'll be coarsened
                                      * will be stored in this vector.
index 764edcfdf8f8f87584884560363f5d8f101b1770..63ab5416af71df757c64756a846e9a6d9f45ee8f 100644 (file)
@@ -48,7 +48,7 @@
  * use the same setup and therefore this class.
  *
  *
- * \subsection{Overview}
+ * @sect3{Overview}
  *
  * The general structure of a time dependent problem solver using a timestepping
  * scheme is about the following: we have a collection of time step objects
  * stepping scheme which needs to look ahead one time step and needs the
  * data of the last two time steps, the following pseudocode described
  * what the centeral loop function of this class will do when we move
- * from timestep #n-1# to timestep #n#:
+ * from timestep @p{n-1} to timestep @p{n}:
  * \begin{verbatim}
  *   wake up timestep n+1 with signal 1
  *   wake up timestep n with signal 0
  * \end{verbatim}
  * The signal number here denotes the distance of the timestep being sent
  * the signal to the timestep where computations are done on. The calls to
- * the #wake_up# and #sleep# functions with signal 0 could in principle
+ * the @p{wake_up} and @p{sleep} functions with signal 0 could in principle
  * be absorbed into the function doing the computation; we use these
  * redundant signals, however, in order to separate computations and data
  * management from each other, allowing to put all stuff around grid
  * management, data reload and storage into one set of functions and
  * computations into another.
  *
- * In the example above, possible actions might be: timestep #n+1# rebuilds
+ * In the example above, possible actions might be: timestep @p{n+1} rebuilds
  * the computational grid (there is a specialized class which can do this
- * for you); timestep #n# builds matrices sets solution vectors to the right
+ * for you); timestep @p{n} builds matrices sets solution vectors to the right
  * size, maybe using an initial guess; then it does the computations; then
  * it deletes the matrices since they are not needed by subsequent timesteps;
- * timestep #n-1# deletes those data vectors which are only needed by one
- * timestep ahead; timestep #n-2# deletes the remaining vectors and deletes
+ * timestep @p{n-1} deletes those data vectors which are only needed by one
+ * timestep ahead; timestep @p{n-2} deletes the remaining vectors and deletes
  * the computational grid, somewhere storing information how to rebuild it
  * eventually.
  *
  * This pattern is repeated for each loop in each sweep.
  *
  * For the different loops within each sweep, the numbers of timesteps
- * to look ahead (i.e. the maximum signal number to the #wake_up# function)
- * and the look-behind (i.e. the maximum signal number to the #sleep#
+ * to look ahead (i.e. the maximum signal number to the @p{wake_up} function)
+ * and the look-behind (i.e. the maximum signal number to the @p{sleep}
  * function) can be chosen separately. For example, it is usually only
  * needed to look one time step behind when computing error estimation
  * (in some cases, it may vene be possible to not look ahead or back
  *
  * Finally, a note on the direction of look-ahead and look-back is in
  * place: look-ahead always refers to the direction the loop is running
- * in, i.e. for loops running forward, #wake_up# is called for timestep
+ * in, i.e. for loops running forward, @p{wake_up} is called for timestep
  * objects with a greater time value than the one previously computed on,
- * while #sleep# is called for timesteps with a lower time. If the loop
+ * while @p{sleep} is called for timesteps with a lower time. If the loop
  * runs in the opposite direction, e.g. when solving a global dual
  * problem, this order is reversed.
  *
  *
- * \subsection{Implementation}
+ * @sect3{Implementation}
  *
  * The main loop of a program using this class will usually look like
  * the following one, taken modified from the wave program:
  *       timestep_manager.run_sweep (sweep);
  *   };
  * \end{verbatim}
- * Here, #timestep_manager# is an object of type #TimeDependent_Wave#, which
- * is a class derived from #TimeDependent#. #start_sweep#
- * #solve_primal_problem#, #solve_dual_problem#, #postprocess# and #end_sweep#
+ * Here, @p{timestep_manager} is an object of type @p{TimeDependent_Wave}, which
+ * is a class derived from @p{TimeDependent}. @p{start_sweep}
+ * @p{solve_primal_problem}, @p{solve_dual_problem}, @p{postprocess} and @p{end_sweep}
  * are functions inherited from this class. They all do a loop over all 
  * timesteps within this object and call the respective function on each of
  * these objects. For example, here are two of the functions as they are
  *   };
  * \end{verbatim}
  * The latter function shows rather clear how most of the loops are
- * invoked (#solve_primal_problem#, #solve_dual_problem#, #postprocess#,
- * #refine_grids# and #write_statistics# all have this form, where the
+ * invoked (@p{solve_primal_problem}, @p{solve_dual_problem}, @p{postprocess},
+ * @p{refine_grids} and @p{write_statistics} all have this form, where the
  * latter two give functions of the derived timestep class, rather than
- * from the base class). The function #TimeStepBase::init_for_primal_problem#
+ * from the base class). The function @p{TimeStepBase::init_for_primal_problem}
  * and the respective ones for the other operations defined by that class
  * are only used to store the type of operation which the loop presently
  * performed will do.
  *
- * As can be seen, most of the work is done by the #do_loop# function of
+ * As can be seen, most of the work is done by the @p{do_loop} function of
  * this class, which takes the addresses of two functions which are used
  * to initialize all timestep objects for the loop and to actually perform
  * some action. The next parameter gives some information on the look-ahead
  * and look-back and the last one denotes in which direction the loop is
  * to be run.
  *
- * Using function pointers through the #mem_fun# functions provided by
- * the #C++# standard library, it is possible to do neat tricks, like
+ * Using function pointers through the @p{mem_fun} functions provided by
+ * the @p{C++} standard library, it is possible to do neat tricks, like
  * the following, also taken from the wave program, in this case from
- * the function #refine_grids#:
+ * the function @p{refine_grids}:
  * \begin{verbatim}
  *   ...
  *   compute the thresholds for refinement
  *            TimeDependent::TimeSteppingData (0,1),
  *            TimeDependent::forward);
  * \end{verbatim}
- * #TimeStepBase_Wave<dim>::refine_grid# is a function taking an argument, unlike
+ * @p{TimeStepBase_Wave<dim>::refine_grid} is a function taking an argument, unlike
  * all the other functions used above within the loops. However, in this special
  * case the parameter was the same for all timesteps and known before the loop
  * was started, so we fixed it and made a function object which to the outside
  * world does not take parameters.
  *
  * Since it is the central function of this class, we finally present a
- * stripped down version of the #do_loop# method, which is shown in order
+ * stripped down version of the @p{do_loop} method, which is shown in order
  * to provide a better understanding of the internals of this class. For
  * brevity we have omitted the parts that deal with backward running loops
  * as well as the checks whether wake-up and sleep operations act on timesteps
- * outside #0..n_timesteps-1#.
+ * outside @p{0..n_timesteps-1}.
  * \begin{verbatim}
  *   template <typename InitFunctionObject, typename LoopFunctionObject>
  *   void TimeDependent::do_loop (InitFunctionObject      init_function,
@@ -350,7 +350,7 @@ class TimeDependent
                                      * ahead of the present one we shall
                                      * start waking up timestep objects
                                      * and how many timesteps behind
-                                     * we shall call their #sleep#
+                                     * we shall call their @p{sleep}
                                      * method.
                                      */
     struct TimeSteppingData
@@ -389,7 +389,7 @@ class TimeDependent
                                          * The value of this number determines,
                                          * how many time steps ahead the
                                          * time step manager start to call
-                                         * the #wake_up# function for each
+                                         * the @p{wake_up} function for each
                                          * time step.
                                          */
        const unsigned int look_ahead;
@@ -411,7 +411,7 @@ class TimeDependent
                                          * steps after having done
                                          * computations on a tim level
                                          * the time step manager will
-                                         * call the #sleep# function for
+                                         * call the @p{sleep} function for
                                          * each time step.
                                          */
        const unsigned int look_back;
@@ -420,7 +420,7 @@ class TimeDependent
                                     /**
                                      * Enum offering the different directions
                                      * in which a loop executed by
-                                     * #do_loop# may be run.
+                                     * @p{do_loop} may be run.
                                      */
     enum Direction {
          forward, backward
@@ -437,8 +437,8 @@ class TimeDependent
                                     /**
                                      * Destructor. This will delete the
                                      * objects pointed to by the pointers
-                                     * given to the #insert_*# and
-                                     * #add_timestep# functions, i.e.
+                                     * given to the @p{insert_*} and
+                                     * @p{add_timestep} functions, i.e.
                                      * it will delete the objects doing
                                      * the computations on each time step.
                                      */
@@ -449,19 +449,19 @@ class TimeDependent
                                      * position is a pointer to an existing
                                      * time step object, or a null pointer
                                      * denoting the end of the timestep
-                                     * sequence. If #position# is non-null,
+                                     * sequence. If @p{position} is non-null,
                                      * the new time step will be inserted
                                      * before the respective element.
                                      *
                                      * Note that by giving an object
                                      * to this function, the
-                                     * #TimeDependent# object assumes
+                                     * @p{TimeDependent} object assumes
                                      * ownership of the object; it will
                                      * therefore also take care of
                                      * deletion of the objects its manages.
                                      *
                                      * There is another function,
-                                     * #add_timestep#, which inserts a
+                                     * @p{add_timestep}, which inserts a
                                      * time step at the end of the list.
                                      *
                                      * Note that this function does not
@@ -469,7 +469,7 @@ class TimeDependent
                                      * within the other timestep objects,
                                      * nor does it set the timestep number
                                      * of this new timestep. This is only
-                                     * done upon calling the #start_sweep#
+                                     * done upon calling the @p{start_sweep}
                                      * function. In not changing the timestep
                                      * numbers, it is simpler to operate
                                      * on a space-time triangulation since
@@ -480,7 +480,7 @@ class TimeDependent
                          TimeStepBase       *new_timestep);
 
                                     /**
-                                     * Just like #insert_timestep#, but
+                                     * Just like @p{insert_timestep}, but
                                      * insert at the end.
                                      *
                                      * This mechanism usually will result
@@ -508,7 +508,7 @@ class TimeDependent
                                      * numbers stored within the
                                      * other timestep objects. This
                                      * is only done upon calling the
-                                     * #start_sweep# function. In not
+                                     * @p{start_sweep} function. In not
                                      * changing the timestep numbers,
                                      * it is simpler to operate on a
                                      * space-time triangulation since
@@ -520,76 +520,76 @@ class TimeDependent
     
                                     /**
                                      * Solve the primal problem; uses the
-                                     * functions #init_for_primal_problem#
-                                     * and #solve_primal_problem# of the
-                                     * #TimeStepBase# class through the
-                                     * #do_loop# function of this class.
+                                     * functions @p{init_for_primal_problem}
+                                     * and @p{solve_primal_problem} of the
+                                     * @p{TimeStepBase} class through the
+                                     * @p{do_loop} function of this class.
                                      *
                                      * Look ahead and look back are
-                                     * determined by the #timestepping_data_primal#
+                                     * determined by the @p{timestepping_data_primal}
                                      * object given to the constructor.
                                      */
     void solve_primal_problem ();
 
                                     /**
                                      * Solve the dual problem; uses the
-                                     * functions #init_for_dual_problem#
-                                     * and #solve_dual_problem# of the
-                                     * #TimeStepBase# class through the
-                                     * #do_loop# function of this class.
+                                     * functions @p{init_for_dual_problem}
+                                     * and @p{solve_dual_problem} of the
+                                     * @p{TimeStepBase} class through the
+                                     * @p{do_loop} function of this class.
                                      *
                                      * Look ahead and look back are
-                                     * determined by the #timestepping_data_dual#
+                                     * determined by the @p{timestepping_data_dual}
                                      * object given to the constructor.
                                      */
     void solve_dual_problem ();
 
                                     /**
                                      * Do a postprocessing round; uses the
-                                     * functions #init_for_postprocessing#
-                                     * and #postprocess# of the
-                                     * #TimeStepBase# class through the
-                                     * #do_loop# function of this class.
+                                     * functions @p{init_for_postprocessing}
+                                     * and @p{postprocess} of the
+                                     * @p{TimeStepBase} class through the
+                                     * @p{do_loop} function of this class.
                                      *
                                      * Look ahead and look back are
-                                     * determined by the #timestepping_data_postprocess#
+                                     * determined by the @p{timestepping_data_postprocess}
                                      * object given to the constructor.
                                      */
     void postprocess ();
     
                                     /**
                                      * Do a loop over all timesteps, call the
-                                     * #init_function# at the beginning and
-                                     * the #loop_function# of each time step.
-                                     * The #timestepping_data# determine how
+                                     * @p{init_function} at the beginning and
+                                     * the @p{loop_function} of each time step.
+                                     * The @p{timestepping_data} determine how
                                      * many timesteps in front and behind
-                                     * the present one the #wake_up# and
-                                     * #sleep# functions are called.
+                                     * the present one the @p{wake_up} and
+                                     * @p{sleep} functions are called.
                                      *
                                      * To see how this function work, note that
-                                     * the function #solve_primal_problem# only
+                                     * the function @p{solve_primal_problem} only
                                      * consists of a call to
-                                     * #  do_loop (mem_fun(&TimeStepBase::init_for_primal_problem),
+                                     * @p{do_loop (mem_fun(&TimeStepBase::init_for_primal_problem),
                                      *    mem_fun(&TimeStepBase::solve_primal_problem),
-                                     *    timestepping_data_primal, forward);#.
+                                     *    timestepping_data_primal, forward);}.
                                      *
                                      * Note also, that the given class from which
                                      * the two functions are taken needs not
-                                     * necessarily be #TimeStepBase#, but it
+                                     * necessarily be @p{TimeStepBase}, but it
                                      * could also be a derived class, that is
-                                     * #static_cast#able from a #TimeStepBase#.
+                                     * @p{static_cast}able from a @p{TimeStepBase}.
                                      * The function may be a virtual function
                                      * (even a pure one) of that class, which
                                      * should help if the actual class where it
                                      * is implemented is one which is derived
                                      * through virtual base classes and thus
-                                     * unreachable by #static_cast# from the
-                                     * #TimeStepBase# class.
+                                     * unreachable by @p{static_cast} from the
+                                     * @p{TimeStepBase} class.
                                      *
                                      * Instead of using the above form, you can
                                      * equally well use
-                                     * #bind2nd(mem_fun1(&X::unary_function),
-                                     *          arg)# which lets the #do_loop#
+                                     * @p{bind2nd(mem_fun1(&X::unary_function), arg)} 
+                                     * which lets the @p{do_loop}
                                      * function call teh given function with
                                      * the specified parameter. Note that you
                                      * need to bind the second parameter since
@@ -614,7 +614,7 @@ class TimeDependent
                                      * deleted) and transmit the number of
                                      * the present sweep to these objects.
                                      *
-                                     * It also calls the #init_for_sweep#
+                                     * It also calls the @p{init_for_sweep}
                                      * function of each time step object,
                                      * after the numbers above are set.
                                      *
@@ -628,22 +628,22 @@ class TimeDependent
                                      * should be called bottom-up.
                                      *
                                      * The default implementation of this
-                                     * function calls #start_sweep# on all
+                                     * function calls @p{start_sweep} on all
                                      * time step objects.
                                      */
     virtual void start_sweep (const unsigned int sweep_no);
 
                                     /**
                                      * Analogon to the above
-                                     * function, calling #end_sweep#
+                                     * function, calling @p{end_sweep}
                                      * of each time step object. The
                                      * same applies with respect to
-                                     * the #virtual#ness of this
+                                     * the @p{virtual}ness of this
                                      * function as for the previous
                                      * one.
                                      *
                                      * This function does not
-                                     * guarantee that #end_sweep# is
+                                     * guarantee that @p{end_sweep} is
                                      * called for successive time
                                      * steps, rather the order of
                                      * time steps for which the
@@ -653,7 +653,7 @@ class TimeDependent
                                      * function has been called for
                                      * previous time steps
                                      * already. If in multithread
-                                     * mode, the #end_sweep# function
+                                     * mode, the @p{end_sweep} function
                                      * of several time steps is
                                      * called at once, so you should
                                      * use synchronization
@@ -689,14 +689,14 @@ class TimeDependent
 
                                     /**
                                      * Number of the present sweep. This is
-                                     * reset by the #start_sweep# function
+                                     * reset by the @p{start_sweep} function
                                      * called at the outset of each sweep.
                                      */
     unsigned int sweep_no;
 
                                     /**
                                      * Some flags telling the
-                                     * #solve_primal_problem# function what to
+                                     * @p{solve_primal_problem} function what to
                                      * do. See the documentation of this struct
                                      * for more information.
                                      */
@@ -704,7 +704,7 @@ class TimeDependent
 
                                     /**
                                      * Some flags telling the
-                                     * #solve_dual_problem# function what to
+                                     * @p{solve_dual_problem} function what to
                                      * do. See the documentation of this struct
                                      * for more information.
                                      */
@@ -712,7 +712,7 @@ class TimeDependent
 
                                     /**
                                      * Some flags telling the
-                                     * #postprocess# function what to
+                                     * @p{postprocess} function what to
                                      * do. See the documentation of this struct
                                      * for more information.
                                      */
@@ -721,7 +721,7 @@ class TimeDependent
   private:
 
                                     /**
-                                     * Do the work of #end_sweep()#
+                                     * Do the work of @p{end_sweep()}
                                      * for some timesteps only. This
                                      * is useful in multithread mode.
                                      */
@@ -734,7 +734,7 @@ class TimeDependent
 /**
  * Base class for a time step in time dependent problems. This class provides
  * barely more than the basic framework, defining the necessary virtual
- * functions (namely #sleep# and #wake_up#), the interface to previous
+ * functions (namely @p{sleep} and @p{wake_up}), the interface to previous
  * and following grids, and some functions to be called before a new loop
  * over all time steps is started.
  *
@@ -795,7 +795,7 @@ class TimeStepBase : public Subscriptor
 
                                     /**
                                      * This is the opposite function
-                                     * to #wake_up#. It is used to
+                                     * to @p{wake_up}. It is used to
                                      * delete data or save it to disk
                                      * after they are no more needed
                                      * for the present sweep. Typical
@@ -820,7 +820,7 @@ class TimeStepBase : public Subscriptor
                                      * and so on. You should take good care,
                                      * however, not to install large objects,
                                      * which should be deferred until the
-                                     * #wake_up# function is called.
+                                     * @p{wake_up} function is called.
                                      *
                                      * A typical action of this function
                                      * would be sorting out names of
@@ -828,7 +828,7 @@ class TimeStepBase : public Subscriptor
                                      * process of solving, etc.
                                      *
                                      * At the time this function is called,
-                                     * the values of #timestep_no#, #sweep_no#
+                                     * the values of @p{timestep_no}, @p{sweep_no}
                                      * and the pointer to the previous and
                                      * next time step object already have
                                      * their correct value.
@@ -854,7 +854,7 @@ class TimeStepBase : public Subscriptor
                                      * function is called (i.e. before the
                                      * solution takes place on the first
                                      * time level). By default, this function
-                                     * sets the #next_action# variable of
+                                     * sets the @p{next_action} variable of
                                      * this class. You may overload this
                                      * function, but you should call this
                                      * function within your own one.
@@ -878,8 +878,8 @@ class TimeStepBase : public Subscriptor
                                      * manager object when solving the
                                      * primal problem on this time level
                                      * is needed. It is called after
-                                     * the #wake_up# function was
-                                     * called and before the #sleep#
+                                     * the @p{wake_up} function was
+                                     * called and before the @p{sleep}
                                      * function will be called. There
                                      * is no default implementation for
                                      * obvious reasons, so you have
@@ -892,8 +892,8 @@ class TimeStepBase : public Subscriptor
                                      * manager object when solving the
                                      * dual problem on this time level
                                      * is needed. It is called after
-                                     * the #wake_up# function was
-                                     * called and before the #sleep#
+                                     * the @p{wake_up} function was
+                                     * called and before the @p{sleep}
                                      * function will be called. There
                                      * is a default implementation
                                      * doing plain nothing since some
@@ -910,8 +910,8 @@ class TimeStepBase : public Subscriptor
                                      * manager object when postprocessing
                                      * this time level
                                      * is needed. It is called after
-                                     * the #wake_up# function was
-                                     * called and before the #sleep#
+                                     * the @p{wake_up} function was
+                                     * called and before the @p{sleep}
                                      * function will be called. There
                                      * is a default implementation
                                      * doing plain nothing since some
@@ -955,7 +955,7 @@ class TimeStepBase : public Subscriptor
                                      * value to return in that case would
                                      * not be zero, since valid computation
                                      * can be done with that, but would
-                                     * be a denormalized value such as #NaN#.
+                                     * be a denormalized value such as @p{NaN}.
                                      * However, there is not much difference
                                      * in finding that the results of a
                                      * computation are all denormalized values
@@ -1025,7 +1025,7 @@ class TimeStepBase : public Subscriptor
                                      * problem is actual, or any of
                                      * the other actions
                                      * specified. This variable is
-                                     * set by the #init_for_*#
+                                     * set by the @p{init_for_*}
                                      * functions.
                                      */
     unsigned int next_action;
@@ -1103,11 +1103,11 @@ class TimeStepBase : public Subscriptor
 
 
 /**
- * Specialisation of #TimeStepBase# which addresses some aspects of grid handling.
+ * Specialisation of @p{TimeStepBase} which addresses some aspects of grid handling.
  * In particular, this class is thought to make handling of grids available that
  * are adaptively refined on each time step separately or with a loose coupling
  * between time steps. It also takes care of deleting and rebuilding grids when
- * memory resources are a point, through the #sleep# and #wake_up# functions
+ * memory resources are a point, through the @p{sleep} and @p{wake_up} functions
  * declared in the base class.
  *
  * In addition to that, it offers functions which do some rather hairy refinement
@@ -1203,15 +1203,15 @@ class TimeStepBase_Tria :  public TimeStepBase
                                      * stored to disk, etc. By default,
                                      * this function rebuilds the triangulation
                                      * if the respective flag has been set to
-                                     * destroy it in the #sleep# function.
+                                     * destroy it in the @p{sleep} function.
                                      * It does so also the first time we
-                                     * hit this function and #wakeup_level#
-                                     * equals #flags.wakeup_level_to_build_grid#,
+                                     * hit this function and @p{wakeup_level}
+                                     * equals @p{flags.wakeup_level_to_build_grid},
                                      * independently of the value of the
                                      * mentioned flag. (Actually, it does so
                                      * whenever the triangulation pointer
                                      * equals the Null pointer and the
-                                     * value of #wakeup_level# is right.)
+                                     * value of @p{wakeup_level} is right.)
                                      *
                                      * Since this is an important task, you
                                      * should call this function from your
@@ -1226,7 +1226,7 @@ class TimeStepBase_Tria :  public TimeStepBase
 
                                     /**
                                      * This is the opposite function
-                                     * to #wake_up#. It is used to
+                                     * to @p{wake_up}. It is used to
                                      * delete data or save it to disk
                                      * after they are no more needed
                                      * for the present sweep. Typical
@@ -1242,7 +1242,7 @@ class TimeStepBase_Tria :  public TimeStepBase
                                      * in the flags for this object, the
                                      * triangulation is deleted and the
                                      * refinement history saved such that
-                                     * the respective #wake_up# function can
+                                     * the respective @p{wake_up} function can
                                      * rebuild it. You should therefore call
                                      * this function from your overloaded
                                      * version, preferrably at the end so
@@ -1279,8 +1279,8 @@ class TimeStepBase_Tria :  public TimeStepBase
                                      * Respective init function for the
                                      * refinement loop; does nothing in
                                      * the default implementation, apart from
-                                     * setting #next_action# to
-                                     * #grid_refinement# but can
+                                     * setting @p{next_action} to
+                                     * @p{grid_refinement} but can
                                      * be overloaded.
                                      */
     virtual void init_for_refinement ();
@@ -1289,7 +1289,7 @@ class TimeStepBase_Tria :  public TimeStepBase
                                      * Virtual function that should fill
                                      * the vector with the refinement
                                      * criteria for the present triangulation.
-                                     * It is used within the #refine_grid#
+                                     * It is used within the @p{refine_grid}
                                      * function to get the criteria for
                                      * the present time step, since they
                                      * can't be passed through its
@@ -1323,10 +1323,10 @@ class TimeStepBase_Tria :  public TimeStepBase
                                      * base class. Note that the
                                      * triangulation is frequently
                                      * deleted and rebuilt by the
-                                     * functions #sleep# and
-                                     * #wake_up# to save memory, if
+                                     * functions @p{sleep} and
+                                     * @p{wake_up} to save memory, if
                                      * such a behaviour is specified
-                                     * in the #flags# structure.
+                                     * in the @p{flags} structure.
                                      */
     Triangulation<dim>       *tria;
 
@@ -1382,7 +1382,7 @@ class TimeStepBase_Tria :  public TimeStepBase
 
 
 /**
- * This structure is used to tell the #TimeStepBase_Tria# class how grids should
+ * This structure is used to tell the @p{TimeStepBase_Tria} class how grids should
  * be handled. It has flags defining the moments where grids shall be
  * re-made and when they may be deleted. Also, one variable states whether
  * grids should be kept in memory or should be deleted between to uses to
@@ -1408,7 +1408,7 @@ struct TimeStepBase_Tria<dim>::Flags
     
                                     /**
                                      * This flag determines whether the
-                                     * #sleep# and #wake_up# functions shall
+                                     * @p{sleep} and @p{wake_up} functions shall
                                      * delete and rebuild the triangulation.
                                      * While for small problems, this is
                                      * not necessary, for large problems
@@ -1428,22 +1428,22 @@ struct TimeStepBase_Tria<dim>::Flags
 
                                     /**
                                      * This number denotes the parameter to
-                                     * the #wake_up# function at which it
+                                     * the @p{wake_up} function at which it
                                      * shall rebuild the grid. Obviously,
                                      * it shall be less than or equal to the
-                                     * #look_ahead# number passed to the
+                                     * @p{look_ahead} number passed to the
                                      * time step management object; if it
                                      * is equal, then the grid is rebuilt
-                                     * the first time the #wake_up# function
-                                     * is called. If #delete_and_rebuild_tria#
-                                     * is #false#, this number has no meaning.
+                                     * the first time the @p{wake_up} function
+                                     * is called. If @p{delete_and_rebuild_tria}
+                                     * is @p{false}, this number has no meaning.
                                      */
     const unsigned int wakeup_level_to_build_grid;
 
                                     /**
                                      * This is the opposite flag to the one
                                      * above: it determines at which call to
-                                     * #sleep# the grid shall be deleted.
+                                     * @p{sleep} the grid shall be deleted.
                                      */
     const unsigned int sleep_level_to_delete_grid;
 
@@ -1457,7 +1457,7 @@ struct TimeStepBase_Tria<dim>::Flags
 
 
 /**
- * This structure is used to tell the #TimeStepBase_Tria# class how grids should
+ * This structure is used to tell the @p{TimeStepBase_Tria} class how grids should
  * be refined. Before we explain all the different variables, fist some terminology:
  * \begin{itemize}
  * \item Correction: after having flagged some cells of the triangulation for
@@ -1473,10 +1473,10 @@ struct TimeStepBase_Tria<dim>::Flags
  * \end{itemize}
  *
  *
- * \subsection{Description of flags}
+ * @sect3{Description of flags}
  *
  * \begin{itemize}
- * \item #max_refinement_level#: Cut the refinement of cells at a given level.
+ * \item @p{max_refinement_level}: Cut the refinement of cells at a given level.
  *   This flag does not influence the flagging of cells, so not more cells
  *   on the coarser levels are flagged than usual. Rather, the flags are all
  *   set, but when it comes to the actual refinement, the maximum refinement
@@ -1486,7 +1486,7 @@ struct TimeStepBase_Tria<dim>::Flags
  *   refinement with adaptive refinement when you don't want the latter
  *   to refine more than the global refinement.
  *
- * \item #first_sweep_with_correction#: When using cell number correction
+ * \item @p{first_sweep_with_correction}: When using cell number correction
  *   as defined above, it may be worth while to start with this only in
  *   later sweeps, not already in the first one. If this variable is
  *   zero, then start with the first sweep, else with a higher one. The
@@ -1495,21 +1495,21 @@ struct TimeStepBase_Tria<dim>::Flags
  *   the sweeps where we start to be interested in the actual results of
  *   the computations.
  *
- * \item #min_cells_for_correction#: If we want a more free process of
+ * \item @p{min_cells_for_correction}: If we want a more free process of
  *   grid development, we may want to impose less rules for grids with few
  *   cells also. This variable sets a lower bound for the cell number of
  *   grids where corrections are to be performed.
  *
- * \item #cell_number_corridor_top#: Fraction of the number of cells by
+ * \item @p{cell_number_corridor_top}: Fraction of the number of cells by
  *   which the number of cells of one grid may be higher than that on the
  *   previous grid. Common values are 10 per cent (i.e. 0.1). The naming
  *   of the variable results from the goal to define a target corridor
  *   for the number of cells after refinement has taken place.
  *
- * \item #cell_number_corridor_bottom#: Fraction of the number of cells by
+ * \item @p{cell_number_corridor_bottom}: Fraction of the number of cells by
  *   which the number of cells of one grid may be lower than that on the
  *   previous grid. Common values are 5 per cent (i.e. 0.05). Usually this
- *   number will be smaller than #cell_number_corridor_top# since an
+ *   number will be smaller than @p{cell_number_corridor_top} since an
  *   increase of the number of cells is not harmful (though it increases
  *   the numerical amount of work needed to solve the problem) while a
  *   sharp decrease may reduce the accuracy of the final result even if
@@ -1520,28 +1520,28 @@ struct TimeStepBase_Tria<dim>::Flags
  *   direction is reversed, so the two values defining the cell number
  *   corridor should be about equal.
  *
- * \item #correction_relaxations#: This is a list of pairs of number with the
- *   following meaning: just as for #min_cells_for_correction#, it may be
+ * \item @p{correction_relaxations}: This is a list of pairs of number with the
+ *   following meaning: just as for @p{min_cells_for_correction}, it may be
  *   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 #((100 5) (200 3) (500 2))#,
+ *   certain factor. For example, if this list was @p{((100 5) (200 3) (500 2))},
  *   this would mean that for grids with a cell number below 100, the
- *   #cell_number_corridor_*# variables are to be multiplied by 5 before they
+ *   @p{cell_number_corridor_*} 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.
  *
- *   #correction_relaxations# is actually a vector of such list. Each entry
+ *   @p{correction_relaxations} is actually a vector of such list. Each entry
  *   in this vector denotes the relaxation rules for one sweep. The last
  *   entry defines the relaxation rules for all following sweeps. This
  *   scheme is adopted to allow for stricter corrections in later sweeps
  *   while the relaxations may be more generous in the first sweeps.
  *
- *   There is a static variable #default_correction_relaxations# which you
+ *   There is a static variable @p{default_correction_relaxations} which you
  *   can use as a default value. It is an empty list and thus defines no
  *   relaxations.
  *
- * \item #cell_number_correction_steps#: Usually, if you want the number of
+ * \item @p{cell_number_correction_steps}: Usually, if you want the number of
  *   cells to be corrected, the target corridor for the cell number is computed
  *   and some additional cells are flagged or flags are removed. But since
  *   the cell number resulting after flagging and deflagging can not be
@@ -1552,7 +1552,7 @@ struct TimeStepBase_Tria<dim>::Flags
  *   regularly. Setting the variable to zero will result in no correction
  *   steps at all.
  *
- * \item #mirror_flags_to_previous_grid#: If a cell on the present grid is
+ * \item @p{mirror_flags_to_previous_grid}: If a cell on the present grid is
  *   flagged for refinement, also flag the corresponding cell on the previous
  *   grid. This is useful if, for example, error indicators are computed for
  *   space-time cells, but are stored for the second grid only. Now, since the
@@ -1560,7 +1560,7 @@ struct TimeStepBase_Tria<dim>::Flags
  *   may be useful to flag both if necessary. This is done if the present
  *   variable is set.
  *
- * \item #adapt_grids#: adapt the present grid to the previous one in the sense
+ * \item @p{adapt_grids}: adapt the present grid to the previous one in the sense
  *   defined above. What is actually done here is the following: if going from
  *   the previous to the present grid would result in double refinement or
  *   double coarsening of some cells, then we try to flag these cells for
@@ -1713,7 +1713,7 @@ struct TimeStepBase_Tria<dim>::RefinementFlags
  * Structure given to the actual refinement function, telling it which
  * thresholds to take for coarsening and refinement. The actual refinement
  * criteria are loaded by calling the virtual function
- * #get_tria_refinement_criteria#.
+ * @p{get_tria_refinement_criteria}.
  */
 template <int dim>
 struct TimeStepBase_Tria<dim>::RefinementData 
index 3d003a1b58166aaecdb9e90e94524fb5ec27ec2a..6fa410bfc66cdb4a644456720a91dcc9edf2ad0e 100644 (file)
@@ -32,10 +32,10 @@ class ConstraintMatrix;
  *  Denote which norm/integral is to be computed. The following possibilities
  *  are implemented:
  *  \begin{itemize}
- *  \item #mean#: the function or difference of functions is integrated
+ *  \item @p{mean}: the function or difference of functions is integrated
  *    on each cell.
- *  \item #L1_norm#: the absolute value of the function is integrated.
- *  \item #L2_norm#: the square of the function is integrated on each
+ *  \item @p{L1_norm}: the absolute value of the function is integrated.
+ *  \item @p{L2_norm}: the square of the function is integrated on each
  *    cell; afterwards the root is taken of this value.
  *  \end{itemize}
  */
@@ -57,7 +57,7 @@ enum NormType {
  * element space and other operations.
  *
  *
- * \subsection{Description of operations}
+ * @sect3{Description of operations}
  *
  * This collection of methods offers the following operations:
  * \begin{itemize}
@@ -95,14 +95,14 @@ enum NormType {
  *   given function onto the finite element space restricted to the boundary
  *   of the domain, then taking this information and using it to eliminate
  *   the boundary nodes from the mass matrix of the whole domain, using the
- *   #MatrixTools::apply_boundary_values# function. The projection of the
+ *   @p{MatrixTools::apply_boundary_values} function. The projection of the
  *   trace of the function to the boundary is done with the
- *   #VectorTools::project_boundary_values# (see below) function, which is
+ *   @p{VectorTools::project_boundary_values} (see below) function, which is
  *   called with a map of boundary functions in which all boundary indicators
- *   from zero to 254 (255 is used for other purposes, see the #Triangulation#
+ *   from zero to 254 (255 is used for other purposes, see the @p{Triangulation}
  *   class documentation) point to the function to be projected. The projection
  *   to the boundary takes place using a second quadrature formula on the
- *   boundary given to the #project# function. The first quadrature formula is
+ *   boundary given to the @p{project} function. The first quadrature formula is
  *   used to compute the right hand side, while the global projection is done by
  *   exact integration of the mass matrix instead of evaluating it by a quadrature
  *   formula. This is faster in this case and more accurate.
@@ -124,8 +124,8 @@ enum NormType {
  *   reverse should also hold if no projection to the boundary is performed.
  *
  *   The selection whether the projection to the boundary first is needed is
- *   done with the #project_to_boundary_first# flag passed to the function.
- *   If #false# is given, the additional quadrature formula for faces is
+ *   done with the @p{project_to_boundary_first} flag passed to the function.
+ *   If @p{false} is given, the additional quadrature formula for faces is
  *   ignored.
  *
  *   You should be aware of the fact that if no projection to the boundary
@@ -134,8 +134,8 @@ enum NormType {
  *   important case, which tells the function to enforce zero boundary values
  *   on the respective boundary parts. Since enforced zero boundary values
  *   could also have been reached through projection, but are more economically
- *   obtain using other methods, the #project_to_boundary_first# flag is
- *   ignored if the #enforce_zero_boundary# flag is set.
+ *   obtain using other methods, the @p{project_to_boundary_first} flag is
+ *   ignored if the @p{enforce_zero_boundary} flag is set.
  *
  *   The solution of the linear system is presently done using a simple CG
  *   method without preconditioning and without multigrid. This is clearly not
@@ -143,17 +143,17 @@ enum NormType {
  *   detail may change in the future.
  *
  * \item Creation of right hand side vectors:
- *   The #create_right_hand_side# function computes the vector
+ *   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::create_*# functions which take a right hand side do,
+ *   @p{MatrixCreator::create_*} functions which take a right hand side do,
  *   but without assembling a matrix.
  *
  * \item Interpolation of boundary values:
- *   The #MatrixTools::apply_boundary_values# function takes a list
+ *   The @p{MatrixTools::apply_boundary_values} function takes a list
  *   of boundary nodes and their values. You can get such a list by interpolation
- *   of a boundary function using the #interpolate_boundary_values# function.
+ *   of a boundary function using the @p{interpolate_boundary_values} function.
  *   To use it, you have to
- *   specify a list of pairs of boundary indicators (of type #unsigned char#;
+ *   specify a list of pairs of boundary indicators (of type @p{unsigned char};
  *   see the section in the documentation of the \Ref{Triangulation} class for more
  *   details) and the according functions denoting the dirichlet boundary values
  *   of the nodes on boundary faces with this boundary indicator.
@@ -165,7 +165,7 @@ enum NormType {
  *   Within this function, boundary values are interpolated, i.e. a node is given
  *   the point value of the boundary function. In some cases, it may be necessary
  *   to use the L2-projection of the boundary function or any other method. For
- *   this purpose to the #VectorTools::project_boundary_values#
+ *   this purpose to the @p{VectorTools::project_boundary_values}
  *   function below.
  *
  *   You should be aware that the boundary function may be evaluated at nodes
@@ -184,38 +184,38 @@ enum NormType {
  *   the place of the respective boundary point.
  *
  * \item Projection of boundary values:
- *   The #project_boundary_values# function acts similar to the
- *   #interpolate_boundary_values# function, apart from the fact that it does
+ *   The @p{project_boundary_values} function acts similar to the
+ *   @p{interpolate_boundary_values} function, apart from the fact that it does
  *   not get the nodal values of boundary nodes by interpolation but rather
  *   through the $L_2$-projection of the trace of the function to the boundary.
  *
  *   The projection takes place on all boundary parts with boundary indicators
  *   listed in the map of boundary functions. These boundary parts may or may
  *   not be contiguous. For these boundary parts, the mass matrix is assembled
- *   using the #MatrixTools::create_boundary_mass_matrix# function, as well as
+ *   using the @p{MatrixTools::create_boundary_mass_matrix} function, as well as
  *   the appropriate right hand side. Then the resulting system of equations is
  *   solved using a simple CG method (without preconditioning), which is in most
  *   cases sufficient for the present purpose.
  *
  * \item Computing errors:
- *   The function #integrate_difference# performs the calculation of the error
+ *   The function @p{integrate_difference} performs the calculation of the error
  *   between the finite element solution and a given (continuous) reference
  *   function in different norms. The integration is performed using a given
  *   quadrature formulae and assumes that the given finite element objects equals
  *   that used for the computation of the solution.
  * 
- *   The result ist stored in a vector (named #difference#), where each entry
+ *   The result ist stored in a vector (named @p{difference}), where each entry
  *   equals the given norm of the difference on one cell. The order of entries
- *   is the same as a #cell_iterator# takes when started with #begin_active# and
- *   promoted with the #++# operator.
+ *   is the same as a @p{cell_iterator} takes when started with @p{begin_active} and
+ *   promoted with the @p{++} operator.
  * 
- *   You can use the #distribute_cell_to_dof_vector# function of the #DoFHandler#
+ *   You can use the @p{distribute_cell_to_dof_vector} function of the @p{DoFHandler}
  *   class to convert cell based data to a data vector with values on the degrees
- *   of freedom, which can then be attached to a #DataOut# object to be printed.
+ *   of freedom, which can then be attached to a @p{DataOut} object to be printed.
  * 
  *   Presently, there is the possibility to compute the following values from the
- *   difference, on each cell: #mean#, #L1_norm#, #L2_norm#, #Linfty_norm#,
- *   #H1_seminorm#.
+ *   difference, on each cell: @p{mean}, @p{L1_norm}, @p{L2_norm}, @p{Linfty_norm},
+ *   @p{H1_seminorm}.
  *   For the mean difference value, the reference function minus the numerical
  *   solution is computed, not the other way round.
  *
@@ -241,23 +241,23 @@ enum NormType {
  *   The $H_1$ seminorm is the $L_2$ norm of the gradient of the difference. The
  *   full $H_1$ norm is the sum of the seminorm and the $L_2$ norm.
  * 
- *   To get the {\it global} $L_1$ error, you have to sum up the entries in
- *   #difference#, e.g. using #Vector<double>::l1_norm# function.
+ *   To get the @em{global} $L_1$ error, you have to sum up the entries in
+ *   @p{difference}, e.g. using @p{Vector<double>::l1_norm} function.
  *   For the global $L_2$ difference, you have to sum up the squares of the
- *   entries and take the root of the sum, e.g. using #Vector<double>::l2_norm#.
+ *   entries and take the root of the sum, e.g. using @p{Vector<double>::l2_norm}.
  *   These two operations represent the
  *   $l_1$ and $l_2$ norms of the vectors, but you need not take the absolute
  *   value of each entry, since the cellwise norms are already positive.
  *  
  *   To get the global mean difference, simply sum up the elements as above.
  *   To get the $L_\infty$ norm, take the maximum of the vector elements, e.g.
- *   using the #Vector<double>::linfty_norm# function.
+ *   using the @p{Vector<double>::linfty_norm} function.
  *
  *   For the global $H_1$ norm and seminorm, the same rule applies as for the
  *   $L_2$ norm: compute the $l_2$ norm of the cell error vector.
  * \end{itemize}
  *
- * All functions use the finite element given to the #DoFHandler# object the last
+ * All functions use the finite element given to the @p{DoFHandler} object the last
  * time that the degrees of freedom were distributed over the triangulation. Also,
  * if access to an object describing the exact form of the boundary is needed, the
  * pointer stored within the triangulation object is accessed.
@@ -269,12 +269,12 @@ class VectorTools
   public:
                                     /**
                                      * Compute the interpolation of
-                                     * #function# at the support
+                                     * @p{function} at the support
                                      * points to the finite element
                                      * space. It is assumed that the
                                      * number of components of
-                                     * #function# matches that of the
-                                     * finite element used by #dof#.
+                                     * @p{function} matches that of the
+                                     * finite element used by @p{dof}.
                                      *
                                      * See the general documentation of this
                                      * class for further information.
@@ -288,19 +288,19 @@ class VectorTools
                                      * Interpolate different finite
                                      * element spaces. The
                                      * interpolation of vector
-                                     * #data_1# is executed from the
+                                     * @p{data_1} is executed from the
                                      * FE space represented by
-                                     * #dof_1# to the vector #data_2#
-                                     * on FE space #dof_2#. The
+                                     * @p{dof_1} to the vector @p{data_2}
+                                     * on FE space @p{dof_2}. The
                                      * interpolation on each cell is
                                      * represented by the matrix
-                                     * #transfer#. Curved boundaries
+                                     * @p{transfer}. Curved boundaries
                                      * are neglected so far.
                                      *
                                      * Note that you may have to call
-                                     * #hanging_nodes.distribute(data_2)#
+                                     * @p{hanging_nodes.distribute(data_2)}
                                      * with the hanging nodes from
-                                     * space #dof_2# afterwards, to
+                                     * space @p{dof_2} afterwards, to
                                      * make the result continuous
                                      * again.
                                      */
@@ -313,7 +313,7 @@ class VectorTools
                          
                                     /**
                                      * Compute the projection of
-                                     * #function# to the finite element space.
+                                     * @p{function} to the finite element space.
                                      *
                                      * By default, projection to the boundary
                                      * and enforcement of zero boundary values
@@ -328,9 +328,9 @@ class VectorTools
                                      * of the finite element space on the
                                      * present grid. To this end, the mass
                                      * matrix is assembled exactly using the
-                                     * #create_mass_matrix# function in the
-                                     * #MatrixTools# collection. This function
-                                     * uses the #get_local_mass_matrix#
+                                     * @p{create_mass_matrix} function in the
+                                     * @p{MatrixTools} collection. This function
+                                     * uses the @p{get_local_mass_matrix}
                                      * function of the finite element; however,
                                      * this function is not supported by all
                                      * finite elements, in which case we
@@ -372,19 +372,19 @@ class VectorTools
                                      * and the values to be
                                      * assigned to them, by interpolation around
                                      * the boundary. If the
-                                     * #boundary_values# contained values
+                                     * @p{boundary_values} contained values
                                      * before, the new ones are added, or
                                      * the old one overwritten if a node
                                      * of the boundary part to be projected
                                      * on already was in the variable.
                                      *
-                                     * The parameter #boundary_component# corresponds
-                                     * to the number #boundary_indicator# of the face.
+                                     * The parameter @p{boundary_component} corresponds
+                                     * to the number @p{boundary_indicator} of the face.
                                      * 255 is an illegal value, since it is reserved
                                      * for interior faces.
                                      *
                                      * The flags in the last
-                                     * parameter, #component_mask#
+                                     * parameter, @p{component_mask}
                                      * denote which components of the
                                      * finite element space shall be
                                      * interpolated. If it is left as
@@ -401,9 +401,9 @@ class VectorTools
                                      *
                                      * It is assumed that the number
                                      * of components of the function
-                                     * in #boundary_function# matches that
+                                     * in @p{boundary_function} matches that
                                      * of the finite element used by
-                                     * #dof#.
+                                     * @p{dof}.
                                      *
                                      * See the general doc for more
                                      * information.
@@ -418,10 +418,10 @@ class VectorTools
 //TODO: Update project_boundary_values for more components
 //TODO: Replace FunctionMap
                                     /**
-                                     * Project #function# to the boundary
+                                     * Project @p{function} to the boundary
                                      * of the domain, using the given quadrature
                                      * formula for the faces. If the
-                                     * #boundary_values# contained values
+                                     * @p{boundary_values} contained values
                                      * before, the new ones are added, or
                                      * the old one overwritten if a node
                                      * of the boundary part to be projected
@@ -429,9 +429,9 @@ class VectorTools
                                      *
                                      * It is assumed that the number
                                      * of components of
-                                     * #boundary_function#
+                                     * @p{boundary_function}
                                      * matches that of the finite
-                                     * element used by #dof#.
+                                     * element used by @p{dof}.
                                      *
                                      * See the general documentation of this
                                      * class for further information.
@@ -451,16 +451,16 @@ class VectorTools
                                      * object.
                                      *
                                      * Note that this function returns
-                                     * its results in a vector of #float#s,
-                                     * rather than in a vector of #double#s,
+                                     * its results in a vector of @p{float}s,
+                                     * rather than in a vector of @p{double}s,
                                      * since accuracy is not that important
                                      * here and to save memory. During
                                      * computation of the results, the full
-                                     * accuracy of the #double# data type is
+                                     * accuracy of the @p{double} data type is
                                      * used.
                                      *
                                      * The additional argument
-                                     * #weight# allows to evaluate
+                                     * @p{weight} allows to evaluate
                                      * weighted norms.  The weight
                                      * function may be
                                      * one-dimensional, establishing
@@ -485,9 +485,9 @@ class VectorTools
                                      *
                                      * It is assumed that the number
                                      * of components of the function
-                                     * #exact_solution# matches that
+                                     * @p{exact_solution} matches that
                                      * of the finite element used by
-                                     * #dof#.
+                                     * @p{dof}.
                                      *
                                      * See the general documentation of this
                                      * class for more information.
@@ -512,7 +512,7 @@ class VectorTools
                                      * preconditioner and generates
                                      * updates with mean value zero.
                                      *
-                                     * Apart from the vector #v# to
+                                     * Apart from the vector @p{v} to
                                      * operate on, this function
                                      * takes a bit vector. This has a
                                      * true entry for every component
index 7b2d01b05251e42fc334f167d5633b42e5f732c7..6b9a1a7b6e13dd038067293cdcf5f2fd795e88be 100644 (file)
@@ -201,7 +201,7 @@ void ConstraintMatrix::condense (const SparsityPattern &uncondensed,
        {
                                           // this line is constrained
          new_line.push_back (-1);
-                                          // note that #lines# is ordered        
+                                          // note that @p{lines} is ordered      
          ++shift;
          ++next_constraint;
          if (next_constraint == lines.end())
@@ -219,8 +219,8 @@ void ConstraintMatrix::condense (const SparsityPattern &uncondensed,
 
   next_constraint = lines.begin();
                                   // note: in this loop we need not check
-                                  // whether #next_constraint# is a valid
-                                  // iterator, since #next_constraint# is
+                                  // whether @p{next_constraint} is a valid
+                                  // iterator, since @p{next_constraint} is
                                   // only evaluated so often as there are
                                   // entries in new_line[*] which tells us
                                   // which constraints exist
@@ -315,7 +315,7 @@ void ConstraintMatrix::condense (SparsityPattern &sparsity) const
              if (distribute[column] != -1)
                {
                                                   // distribute entry at regular
-                                                  // row #row# and irregular column
+                                                  // row @p{row} and irregular column
                                                   // sparsity.colnums[j]
                  for (unsigned int q=0;
                       q!=lines[distribute[column]].entries.size();
@@ -335,7 +335,7 @@ void ConstraintMatrix::condense (SparsityPattern &sparsity) const
            {
              if (distribute[sparsity.get_column_numbers()[j]] == -1)
                                                 // distribute entry at irregular
-                                                // row #row# and regular column
+                                                // row @p{row} and regular column
                                                 // sparsity.colnums[j]
                for (unsigned int q=0;
                     q!=lines[distribute[row]].entries.size(); ++q) 
@@ -343,7 +343,7 @@ void ConstraintMatrix::condense (SparsityPattern &sparsity) const
                                sparsity.get_column_numbers()[j]);
              else
                                                 // distribute entry at irregular
-                                                // row #row# and irregular column
+                                                // row @p{row} and irregular column
                                                 // sparsity.get_column_numbers()[j]
                for (unsigned int p=0; p!=lines[distribute[row]].entries.size(); ++p)
                  for (unsigned int q=0;
index 6c33e17b3a11d2621f894d8be2a9fa0f13562d84..b4a01efd848491be50a3423967f00894f1bfd41c 100644 (file)
@@ -1244,7 +1244,7 @@ unsigned int DoFHandler<1>::distribute_dofs_on_cell (active_cell_iterator &cell,
       if (neighbor.state() == valid)
        {
                                         // find true neighbor; may be its
-                                        // a child of #neighbor#
+                                        // a child of @p{neighbor}
          while (neighbor->has_children())
            neighbor = neighbor->child(v==0 ? 1 : 0);
 
index 6cbb5db9caeacbf3f92e9361135b06ebe58eea9b..751ec35c95ab436cf141e0f77491e9027947a79e 100644 (file)
@@ -505,7 +505,7 @@ void DoFTools::make_hanging_node_constraints (const DoFHandler<2> &dof_handler,
          
                                           // fill the dofs indices. Use same
                                           // enumeration scheme as in
-                                          // #FiniteElement::constraints()#
+                                          // @p{FiniteElement::constraints()}
          unsigned int next_index = 0;
          for (unsigned int vertex=0; vertex<2; ++vertex)
            for (unsigned int dof=0; dof!=fe.dofs_per_vertex; ++dof)
@@ -598,7 +598,7 @@ void DoFTools::make_hanging_node_constraints (const DoFHandler<3> &dof_handler,
          
                                           // fill the dofs indices. Use same
                                           // enumeration scheme as in
-                                          // #FiniteElement::constraints()#
+                                          // @p{FiniteElement::constraints()}
          unsigned int next_index = 0;
          for (unsigned int vertex=0; vertex<4; ++vertex)
            for (unsigned int dof=0; dof!=fe.dofs_per_vertex; ++dof)
@@ -1306,8 +1306,8 @@ DoFTools::compute_intergrid_constraints (const DoFHandler<dim>              &coa
            global_parameter_representation.clear ();
            
                                             // distribute the representation of
-                                            // #local_parameter_dof# on the
-                                            // parameter grid cell #cell# to
+                                            // @p{local_parameter_dof} on the
+                                            // parameter grid cell @p{cell} to
                                             // the global data space
            coarse_to_fine_grid_map[cell]->
              set_dof_values_by_interpolation (parameter_dofs[local_parameter_dof],
@@ -1318,26 +1318,26 @@ DoFTools::compute_intergrid_constraints (const DoFHandler<dim>              &coa
                                             // non-zero entries in that vector and
                                             // store the result
                                             //
-                                            // what we have learned: if entry #i#
+                                            // what we have learned: if entry @p{i}
                                             // of the global vector holds the value
-                                            // #v[i]#, then this is the weight with
+                                            // @p{v[i]}, then this is the weight with
                                             // which the present dof contributes
-                                            // to #i#. there may be several such
-                                            // #i#s and their weights' sum should
-                                            // be one. Then, #v[i]# should be
-                                            // equal to #\sum_j w_{ij} p[j]# with
-                                            // #p[j]# be the values of the degrees
+                                            // to @p{i}. there may be several such
+                                            // @p{i}s and their weights' sum should
+                                            // be one. Then, @p{v[i]} should be
+                                            // equal to @p{\sum_j w_{ij} p[j]} with
+                                            // @p{p[j]} be the values of the degrees
                                             // of freedom on the coarse grid. we
                                             // can thus compute constraints which
-                                            // link the degrees of freedom #v[i]#
+                                            // link the degrees of freedom @p{v[i]}
                                             // on the fine grid to those on the
-                                            // coarse grid, #p[j]#. Now to use
+                                            // coarse grid, @p{p[j]}. Now to use
                                             // these as real constraints, rather
                                             // than as additional equations, we
                                             // have to identify representants
-                                            // among the #i# for each #j#. this will
+                                            // among the @p{i} for each @p{j}. this will
                                             // be done by simply taking the first
-                                            // #i# for which #w_{ij}==1#.
+                                            // @p{i} for which @p{w_{ij}==1}.
            for (unsigned int i=0; i<global_parameter_representation.size(); ++i)
                                               // set this weight if it belongs
                                               // to a parameter dof.
index 3a58b3a0b23ead8ec038e85282ee185d955b0c0a..6a2c7fbfb938f2ca3b7b26a002f2d67dd9e17627 100644 (file)
@@ -276,7 +276,7 @@ void FESystem<dim>::build_interface_constraints ()
                                   // described in the FiniteElement class. you
                                   // may want to look there first before trying
                                   // to understand the following, especially
-                                  // the mapping of the #n# index.
+                                  // the mapping of the @p{n} index.
                                   //
                                   // in order to map it to the fe-system class,
                                   // we have to know which base element a
index 0aef5bdfbee72e669d3401183b53bf1fc60f1e0d..b048988e4f9e8e96c84f39be0b3a9c7f50117f9b 100644 (file)
@@ -524,7 +524,7 @@ FEFaceValues<dim>::FEFaceValues (const FiniteElement<dim> &fe,
 
                                   // set up an array of the unit points
                                   // on the given face, but in coordinates
-                                  // of the space with #dim# dimensions.
+                                  // of the space with @p{dim} dimensions.
                                   // the points are still on the unit
                                   // cell, not on the real cell.
   for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
@@ -685,7 +685,7 @@ FESubfaceValues<dim>::FESubfaceValues (const FiniteElement<dim> &fe,
 
                                   // set up an array of the unit points
                                   // on the given face, but in coordinates
-                                  // of the space with #dim# dimensions.
+                                  // of the space with @p{dim} dimensions.
                                   // the points are still on the unit
                                   // cell, not on the real cell.
   for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
index de161840b3e52348a24068ec18997da3c43caa52..c7cbe07d1bf5739a54866fd56b8af3daf6992366 100644 (file)
@@ -54,7 +54,7 @@ void TriangulationLevel<0>::reserve_space (const unsigned int total_cells,
                                   // so only allocate new space if needed.
                                   //
                                   // note that all arrays should have equal
-                                  // sizes (checked by #monitor_memory#
+                                  // sizes (checked by @p{monitor_memory}
   if (total_cells > refine_flags.size()) 
     {
       refine_flags.reserve (total_cells);
@@ -103,7 +103,7 @@ void TriangulationLevel<1>::reserve_space (const unsigned int new_lines)
                                          lines.used.end(),
                                          bind2nd (equal_to<bool>(), true));
 
-                                  // same as in #reserve_space<0>#: only
+                                  // same as in @p{reserve_space<0>}: only
                                   // allocate space if necessary
   if (new_size>lines.lines.size()) 
     {
index afef5916beee2802dc169af36d50263eb035e0fd..8bdc92e9603927b6ece1e1c7f7b61f5b688bcd0e 100644 (file)
@@ -215,7 +215,7 @@ void Triangulation<1>::create_triangulation (const vector<Point<1> >    &v,
                                             const SubCellData &subcelldata) {
                                   // note: since no boundary information
                                   // can be given in one dimension, the
-                                  // #subcelldata# field is ignored. (only
+                                  // @p{subcelldata} field is ignored. (only
                                   // used for error checking, which is a
                                   // good idea in any case)
   
@@ -800,10 +800,10 @@ void Triangulation<3>::create_triangulation (const vector<Point<3> >    &v,
                                       // of four numbers denoting the index
                                       // of the four lines bounding th
                                       // quad. we can get this index by
-                                      // asking #needed_lines# for an
+                                      // asking @p{needed_lines} for an
                                       // iterator to this line, dereferencing
                                       // it and thus return an iterator into
-                                      // the #lines# array of the
+                                      // the @p{lines} array of the
                                       // triangulation, which is already set
                                       // up. we can then ask this iterator
                                       // for its index within the present
@@ -3304,7 +3304,7 @@ Triangulation<dim>::refine_and_coarsen_fixed_number (const Vector<number> &crite
                                                     const double         bottom_fraction)
 {
                                   // correct number of cells is
-                                  // checked in #refine#
+                                  // checked in @p{refine}
   Assert ((top_fraction>=0) && (top_fraction<=1), ExcInvalidParameterValue());
   Assert ((bottom_fraction>=0) && (bottom_fraction<=1), ExcInvalidParameterValue());
   Assert (top_fraction+bottom_fraction <= 1, ExcInvalidParameterValue());
@@ -3348,7 +3348,7 @@ Triangulation<dim>::refine_and_coarsen_fixed_fraction (const Vector<number> &cri
                                                       const double         top_fraction,
                                                       const double         bottom_fraction) {
                                   // correct number of cells is
-                                  // checked in #refine#
+                                  // checked in @p{refine}
   Assert ((top_fraction>=0) && (top_fraction<=1), ExcInvalidParameterValue());
   Assert ((bottom_fraction>=0) && (bottom_fraction<=1), ExcInvalidParameterValue());
   Assert (top_fraction+bottom_fraction <= 1, ExcInvalidParameterValue());
@@ -3356,7 +3356,7 @@ Triangulation<dim>::refine_and_coarsen_fixed_fraction (const Vector<number> &cri
                                   // let tmp be the cellwise square of the
                                   // error, which is what we have to sum
                                   // up and compare with
-                                  // #fraction_of_error*total_error#.
+                                  // @p{fraction_of_error*total_error}.
   Vector<number> tmp(criteria);
   const double total_error = tmp.l1_norm();
 
@@ -3877,7 +3877,7 @@ void Triangulation<2>::execute_refinement () {
    
    First:
    Set up an array of the 3x3 vertices, which are distributed on the cell
-   (the array consists of indices into the #vertices# vector
+   (the array consists of indices into the @p{vertices} vector
    
      6--5--4
      |  |  |
@@ -3927,7 +3927,7 @@ void Triangulation<2>::execute_refinement () {
    be replaced and because that also is the number of the subline which
    will be the interface between that neighbor and the to be created cell.
    We will store this number (between 0 and 3) in the field
-   #neighbors_neighbor#.
+   @p{neighbors_neighbor}.
 
    It would be sufficient to use the children of the common line to the
    neighbor, if we only wanted to get the new sublines and the new vertex,
@@ -3960,9 +3960,9 @@ void Triangulation<2>::execute_refinement () {
                                              cell->neighbor(3)};
            int               neighbors_neighbor[8] = {-1,-1,-1,-1,-1,-1,-1,-1};
 
-                                            // remember: the #i#th line
+                                            // remember: the @p{i}th line
                                             // is the common line to the
-                                            // #i#th neighbor
+                                            // @p{i}th neighbor
            for (unsigned int nb=0; nb<4; ++nb)
              {
                bool neighbor_refined=false;
@@ -5532,7 +5532,7 @@ void Triangulation<dim>::execute_coarsening () {
                                   // used, to avoid confusion and because
                                   // non-active cells can't be flagged for
                                   // coarsening. Note that because of the
-                                  // effects of #prepare_coarsening#, of a
+                                  // effects of @p{prepare_coarsening}, of a
                                   // cell either all or no children must
                                   // be flagged for coarsening, so it is
                                   // ok to only check the first child
@@ -5742,8 +5742,8 @@ void Triangulation<dim>::fix_coarsen_flags () {
                                   // no mother cell, i.e. on the
                                   // coarsest level are deleted explicitely.
   clear_user_flags ();
-                                  // number of active children of #cell#.
-                                  // number of children of #cell# which are
+                                  // number of active children of @p{cell}.
+                                  // number of children of @p{cell} which are
                                   // flagged for coarsening
   unsigned int flagged_children;
       
@@ -5866,7 +5866,7 @@ bool Triangulation<dim>::prepare_coarsening_and_refinement () {
                                   // which case we would have to re-run
                                   // the loop. the other possibility to
                                   // find this out would be to set a
-                                  // flag #something_changed# to true
+                                  // flag @p{something_changed} to true
                                   // each time we change something.
                                   // however, sometimes one change in
                                   // one of the parts of the loop is
@@ -6547,7 +6547,7 @@ bool Triangulation<dim>::prepare_coarsening_and_refinement () {
 
                                   // find out whether something was really
                                   // changed in this function. Note that
-                                  // #flags_before_loop# represents the
+                                  // @p{flags_before_loop} represents the
                                   // state after the last loop, i.e.
                                   // the present state
   return ((flags_before[0] != flags_before_loop[0]) ||
@@ -6670,7 +6670,7 @@ void Triangulation<2>::delete_children (cell_iterator &cell) {
                                   // of this cell (the case that the
                                   // neighbors are more refined than
                                   // the children was eliminated in
-                                  // #prepare_coarsening#
+                                  // @p{prepare_coarsening}
   for (unsigned int child=0; child<GeometryInfo<dim>::children_per_cell; ++child)
     for (unsigned int n=0; n<GeometryInfo<dim>::faces_per_cell;
         ++n)
@@ -6685,7 +6685,7 @@ void Triangulation<2>::delete_children (cell_iterator &cell) {
                ExcInternalError());
        
                                         // if the neighbor's level is the
-                                        // same as that of #cell#, then
+                                        // same as that of @p{cell}, then
                                         // it's neighbor pointers points
                                         // to this cell rather than to
                                         // this cell's child. In that
@@ -6800,7 +6800,7 @@ void Triangulation<3>::delete_children (cell_iterator &cell) {
                                   // of this cell (the case that the
                                   // neighbors are more refined than
                                   // the children was eliminated in
-                                  // #prepare_coarsening#
+                                  // @p{prepare_coarsening}
   for (unsigned int child=0; child<GeometryInfo<dim>::children_per_cell; ++child)
     for (unsigned int n=0; n<GeometryInfo<dim>::faces_per_cell; ++n)
       {
@@ -6814,7 +6814,7 @@ void Triangulation<3>::delete_children (cell_iterator &cell) {
                ExcInternalError());
        
                                         // if the neighbor's level is the
-                                        // same as that of #cell#, then
+                                        // same as that of @p{cell}, then
                                         // it's neighbor pointers points
                                         // to this cell rather than to
                                         // this cell's child. In that
index 04da87f36ee244e030177d0b353a9e6b347522c2..4737700a830f75255a7d58ae967654ae5f8e36df 100644 (file)
@@ -95,7 +95,7 @@ void Assembler<dim>::assemble (const Equation<dim> &equation) {
   get_dof_indices (dofs);
 
                                   // one could use the
-                                  // #distribute_local_to_global# functions
+                                  // @p{distribute_local_to_global} functions
                                   // here, but they would require getting the
                                   // dof indices twice, so we leave it the
                                   // way it was originally programmed.
index 551c7f529228dc4ea5746d4e7856077fd13e8a7e..54259002dc475310f985afeb41f7003e40792acd 100644 (file)
@@ -1050,13 +1050,13 @@ void DataOut_Old<2>::write_eps (ostream &out, const EpsOutputData &eod) const {
           cells2.insert(cd);
         };
 
-                                       // since we don't need #cells# any
+                                       // since we don't need @p{cells} any
                                        // more, delete it now
        cells.clear ();
      }
    else 
-                                     // copy #cells# to #cells2#. since
-                                     // we don't need #cells# any
+                                     // copy @p{cells} to @p{cells2}. since
+                                     // we don't need @p{cells} any
                                      // more, we use a trick for copying
                                      // that is significantly faster
      cells2.swap (cells);
index 38e470d4ac58d5aa67c8736ca1cbb67790c3dc48..0bf77b4719cc1aeff415834c305cb9a09ddf1dc5 100644 (file)
@@ -34,7 +34,7 @@ void DataOutStack<dim>::new_parameter_value (const double p,
   parameter      = p;
   parameter_step = dp;
 
-                                  // check whether the user called #finish_...#
+                                  // check whether the user called @p{finish_...}
                                   // at the end of the previous parameter step
                                   //
                                   // this is to prevent serious waste of
index d0dc99d44c64d1948ee20b860b7e27b4b7801e29..8b1fb6dc4e352f34813d89ee60ad92260915bce1 100644 (file)
@@ -579,7 +579,7 @@ integrate_over_regular_face (Data                       &data,
       Assert (neighbor_neighbor<GeometryInfo<dim>::faces_per_cell, ExcInternalError());
       
                                       // get restriction of finite element
-                                      // function of #neighbor# to the
+                                      // function of @p{neighbor} to the
                                       // common face.
       fe_face_values_neighbor.reinit (neighbor, neighbor_neighbor);
       
@@ -719,8 +719,8 @@ integrate_over_irregular_face (Data                       &data,
                                   // index the number of the
                                   // quadrature point
   
-                                  // store which number #cell# has in the
-                                  // list of neighbors of #neighbor#
+                                  // store which number @p{cell} has in the
+                                  // list of neighbors of @p{neighbor}
   const unsigned int neighbor_neighbor = cell->neighbor_of_neighbor (face_no);
   Assert (neighbor_neighbor<GeometryInfo<dim>::faces_per_cell, ExcInternalError());
   
@@ -748,8 +748,8 @@ integrate_over_irregular_face (Data                       &data,
       fe_subface_values.get_function_grads (data.solution, data.psi[this_thread]);
 
                                       // restrict the finite element on the
-                                      // neighbor cell to the common #subface#.
-                                      // store the gradient in #neighbor_psi#
+                                      // neighbor cell to the common @p{subface}.
+                                      // store the gradient in @p{neighbor_psi}
       
       fe_face_values.reinit (neighbor_child, neighbor_neighbor);
       fe_face_values.get_function_grads (data.solution, data.neighbor_psi[this_thread]);
index 6a9648598b3598d7e90ff5a04fae3f6635f03839..0e8213c06fcd95f720ac3c7cee76474bcaf5e2f3 100644 (file)
@@ -342,7 +342,7 @@ void MatrixCreator<dim>::create_boundary_mass_matrix (const DoFHandler<dim>    &
                                           // determine whether dof[i] is a
                                           // dof on the present face. We do so
                                           // by getting the dofs on the
-                                          // face into #dofs_on_face_vector#,
+                                          // face into @p{dofs_on_face_vector},
                                           // a vector as always. Usually,
                                           // searching in a vector is
                                           // inefficient, so we copy the dofs
@@ -871,11 +871,11 @@ MatrixTools<dim>::apply_boundary_values (const map<unsigned int,double> &boundar
                                           // present row.
                                           //
                                           // note that if we check
-                                          // whether row #row# in
+                                          // whether row @p{row} in
                                           // block (r,c) is non-zero,
                                           // then we have to check
                                           // for the existence of
-                                          // column #row# in block
+                                          // column @p{row} in block
                                           // (c,r), i.e. of the
                                           // transpose block
          for (unsigned int block_row=0; block_row<blocks; ++block_row)
index 6602941f16da8148adcc72ad4d17733ddcfc3c63..c06003518e9003df08d8f4b4b92ec5845a8f4162 100644 (file)
@@ -206,7 +206,7 @@ prepare_for_coarsening_and_refinement(const vector<Vector<number> > &all_in)
                                   // the 'to_stay_or_refine' cells 'n_sr',
                                   // the 'coarsen_fathers' cells 'n_cf',
                                   // and all the cells where a
-                                  // #Pointerstruct# is needed 'n'
+                                  // @p{Pointerstruct} is needed 'n'
   unsigned int n_sr=0, n_cf=0, n=0;
   DoFHandler<dim>::cell_iterator cell = dof_handler->begin();  
   for (; cell!=endc; ++cell) 
index 59fbfb76ed8dc06834685df5088249340945a283..b82cbe520752ae8bf75f8143d963896bf86a77a7 100644 (file)
@@ -805,7 +805,7 @@ void TimeStepBase_Tria<dim>::refine_grid (const RefinementData refinement_data)
              previous_cells -= (GeometryInfo<dim>::children_per_cell-1) /
                                GeometryInfo<dim>::children_per_cell;
            
-                                        // #previous_cells# now gives the
+                                        // @p{previous_cells} now gives the
                                         // number of cells which would result
                                         // from the flags on the previous grid
                                         // if we refined it now. However, some
@@ -858,7 +858,7 @@ void TimeStepBase_Tria<dim>::refine_grid (const RefinementData refinement_data)
                                         // note that for each cell that
                                         // we unflag we have to diminish the
                                         // estimated number of cells by
-                                        // #children_per_cell#.
+                                        // @p{children_per_cell}.
        if (estimated_cells > previous_cells*(1.+delta_up)) 
          {
                                             // only limit the cell number
@@ -921,7 +921,7 @@ void TimeStepBase_Tria<dim>::refine_grid (const RefinementData refinement_data)
                                               // new grid is to be enlarged
              double delta_cells = previous_cells*(1.-delta_down)-estimated_cells;
                                               // heuristics: usually, if we
-                                              // add #delta_cells# to the
+                                              // add @p{delta_cells} to the
                                               // present state, we end up
                                               // with much more than only
                                               // (1-delta_down)*prev_cells
index 2d2062a377080cb1642fcc6eb5cdfbc82819b1b4..38f8712d7db7eaa865d228f7253674aadae0f21d 100644 (file)
@@ -77,7 +77,7 @@ void VectorTools::interpolate (const DoFHandler<dim> &dof,
   fe.get_unit_support_points(unit_support_points);
 
                                   // The following works well
-                                  // if #dofs_per_x<=1 (x=vertex,line,cell)#
+                                  // if @p{dofs_per_x<=1 (x=vertex,line,cell)}
                                   // as then
                                   // the multiple support_points
                                   // are placed one after another.
@@ -85,12 +85,12 @@ void VectorTools::interpolate (const DoFHandler<dim> &dof,
                                   // find the support points 
                                   // on a cell that
                                   // are multiply mentioned in 
-                                  // #unit_support_points#.
+                                  // @p{unit_support_points}.
                                   // Mark the first representative
                                   // of each multiply mentioned
                                   // support point by setting
-                                  // #true# in the boolean vector 
-                                  // #is_representative_point#.
+                                  // @p{true} in the boolean vector 
+                                  // @p{is_representative_point}.
 //   vector<bool>  is_representative_point(fe.dofs_per_cell, false);
 //   is_representative_point[0]=true;
 //   unsigned int n_rep_points=1;
@@ -136,7 +136,7 @@ void VectorTools::interpolate (const DoFHandler<dim> &dof,
 //                                    // whole vector
 //       int last_rep_point = -1;
 //                                    // it holds `is_representative_point[0]=true'
-//                                    // therefore the first #last_rep_point# is 0
+//                                    // therefore the first @p{last_rep_point} is 0
 //                                    // and we need to start with
 //                                    // `last_rep_point = -1'
 //       for (unsigned int i=0; i<fe.dofs_per_cell; ++i)
@@ -152,7 +152,7 @@ void VectorTools::interpolate (const DoFHandler<dim> &dof,
 //     }
 
                                   // The following is more general.
-                                  // It also works if #dofs_per_x>1#,
+                                  // It also works if @p{dofs_per_x>1},
                                   // i.e. it is usable also for systems
                                   // including
                                   // FEQ3, FEQ4, FEDG_Qx.
@@ -160,14 +160,14 @@ void VectorTools::interpolate (const DoFHandler<dim> &dof,
                                   // Find the support points 
                                   // on a cell that
                                   // are multiply mentioned in 
-                                  // #unit_support_points#.
+                                  // @p{unit_support_points}.
                                   // Mark the first representative
                                   // of each multiply mentioned
                                   // support point by appending its
-                                  // dof index to #dofs_of_rep_points#.
+                                  // dof index to @p{dofs_of_rep_points}.
                                   // Each multiple point gets to know
                                   // the dof index of its representative
-                                  // point by the #dof_to_rep_dof_table#.
+                                  // point by the @p{dof_to_rep_dof_table}.
 
                                   // the following vector collects all dofs i,
                                   // 0<=i<fe.dofs_per_cell, for that
@@ -398,7 +398,7 @@ void VectorTools::project (const DoFHandler<dim>    &dof,
       {
                                         // set up a list of boundary functions for
                                         // the different boundary parts. We want the
-                                        // #function# to hold on all parts of the
+                                        // @p{function} to hold on all parts of the
                                         // boundary
        map<unsigned char,const Function<dim>*> boundary_functions;
        for (unsigned char c=0; c<255; ++c)
@@ -560,7 +560,7 @@ VectorTools::interpolate_boundary_values (const DoFHandler<1>      &dof,
 
                                   // set the component mask to either
                                   // the original value or a vector
-                                  // of #true#s
+                                  // of @p{true}s
   const vector<bool> component_mask ((component_mask_.size() == 0) ?
                                     vector<bool> (fe.n_components(), true) :
                                     component_mask_);
@@ -570,7 +570,7 @@ VectorTools::interpolate_boundary_values (const DoFHandler<1>      &dof,
                                   // check whether boundary values at
                                   // the left or right boundary of
                                   // the line are
-                                  // requested. #direction# denotes
+                                  // requested. @p{direction} denotes
                                   // the neighboring direction in
                                   // which we seek the boundary,
                                   // i.e. 0 is left boundary and 1 is
@@ -638,7 +638,7 @@ VectorTools::interpolate_boundary_values (const DoFHandler<dim>    &dof,
 
                                   // set the component mask to either
                                   // the original value or a vector
-                                  // of #true#s
+                                  // of @p{true}s
   const vector<bool> component_mask ((component_mask_.size() == 0) ?
                                     vector<bool> (fe.n_components(), true) :
                                     component_mask_);
@@ -727,7 +727,7 @@ VectorTools::project_boundary_values (const DoFHandler<dim>    &dof,
                                   // to be condensed and the solution is to
                                   // be distributed afterwards, which is not
                                   // yet implemented. The reason for this is
-                                  // that we cannot simply use the #condense#
+                                  // that we cannot simply use the @p{condense}
                                   // family of functions, since the matrices
                                   // and vectors do not use the global
                                   // numbering but rather the boundary
@@ -772,8 +772,8 @@ VectorTools::project_boundary_values (const DoFHandler<dim>    &dof,
                                       // this dof is on one of the
                                       // interesting boundary parts
                                       //
-                                      // remember: #i# is the global dof
-                                      // number, #dof_to_boundary_mapping[i]#
+                                      // remember: @p{i} is the global dof
+                                      // number, @p{dof_to_boundary_mapping[i]}
                                       // is the number on the boundary and
                                       // thus in the solution vector
       boundary_values[i] = boundary_projection(dof_to_boundary_mapping[i]);
@@ -1034,7 +1034,7 @@ VectorTools::integrate_difference (const DoFHandler<dim>    &dof,
                                             // H1_norm starts at the previous
                                             // case statement, but continues
                                             // here!
-                                            // Until now, #diff# includes the
+                                            // Until now, @p{diff} includes the
                                             // square of the L2_norm.
 
                                             // in praxi: first compute
@@ -1043,7 +1043,7 @@ VectorTools::integrate_difference (const DoFHandler<dim>    &dof,
                                             // try to be a little clever
                                             // to avoid recursive virtual
                                             // function calls when calling
-                                            // #gradient_list# for functions
+                                            // @p{gradient_list} for functions
                                             // that are really scalar
                                             // functions
            if (fe_is_system)
index cc0886488dd9bc18e230f69ed973071b572a0257..32c49217eb6e1ac13e50570493353e7a9a6929a5 100644 (file)
@@ -13,7 +13,9 @@ include $D/common/Make.global_options
 ifeq ($(kdocversion),1)
 KDOCFLAGS=-I$(kdocdir) $(kdocdir)/kdoc -a -p -L $D/doc/auto/kdoc
 else
-KDOCFLAGS=-I$(kdocdir) $(kdocdir)/kdoc -a -p -L $D/doc/auto/kdoc -n 
+KDOCFLAGS=-I$(kdocdir) $(kdocdir)/kdoc -a -p \
+          --html-logo ../../../pictures/deal.II_3.0_1.150.jpg \
+          -L $D/doc/auto/kdoc -n
 endif
 
 kdoc.base     = $(shell echo $D/base/include/base/*.h)
@@ -57,27 +59,59 @@ kdoc-installed:
            echo "========================================" ; \
         fi
 
+
+# now for the generation of the documentation of the sublibraries.
+# first let kdoc generate the whole thing, then loop over all output
+# files and fix the #include<...> directives to only contain the 
+# paths that are needed inside the programs instead of the global
+# paths
+
 base.kdoc: kdoc-installed $(kdoc.base)
        @$(PERL) $(KDOCFLAGS) $(subst .kdoc,,$@) -d $(subst .kdoc,,$@) \
        $(^:kdoc-installed=)
+       for htmlfile in $(subst .kdoc,,$@)/*html ; do \
+           echo "Fixing include paths in $$htmlfile..." ; \
+           perl -pi -e 's,(#include &lt;<A HREF=\"[^\"]+\">)$D/?[^/]+/include/,$$1,g;' "$$htmlfile" ;\
+       done
+               
 
 lac.kdoc: kdoc-installed $(kdoc.lac)
        @$(PERL) $(KDOCFLAGS) $(subst .kdoc,,$@) -d $(subst .kdoc,,$@) \
        -l base $(^:kdoc-installed=)
+       for htmlfile in $(subst .kdoc,,$@)/*html ; do \
+           echo "Fixing include paths in $$htmlfile..." ; \
+           perl -pi -e 's,(#include &lt;<A HREF=\"[^\"]+\">)$D/?[^/]+/include/,$$1,g;' "$$htmlfile" ;\
+       done
 
 grid.kdoc: kdoc-installed $(kdoc.grid)
        @$(PERL) $(KDOCFLAGS) $(subst .kdoc,,$@) -d $(subst .kdoc,,$@) \
-       -l base $(^:kdoc-installed=)
+       -l base -llac $(^:kdoc-installed=)
+       for htmlfile in $(subst .kdoc,,$@)/*html ; do \
+           echo "Fixing include paths in $$htmlfile..." ; \
+           perl -pi -e 's,(#include &lt;<A HREF=\"[^\"]+\">)$D/?[^/]+/include/,$$1,g;' "$$htmlfile" ;\
+       done
 
 dof.kdoc: kdoc-installed $(kdoc.dof)
-       $(PERL) $(KDOCFLAGS) $(subst .kdoc,,$@) -d $(subst .kdoc,,$@) \
+       @$(PERL) $(KDOCFLAGS) $(subst .kdoc,,$@) -d $(subst .kdoc,,$@) \
        -l base -llac -lgrid $(^:kdoc-installed=)
+       for htmlfile in $(subst .kdoc,,$@)/*html ; do \
+           echo "Fixing include paths in $$htmlfile..." ; \
+           perl -pi -e 's,(#include &lt;<A HREF=\"[^\"]+\">)$D/?[^/]+/include/,$$1,g;' "$$htmlfile" ;\
+       done
 
 numerics.kdoc: kdoc-installed $(kdoc.numerics)
        @$(PERL) $(KDOCFLAGS) $(subst .kdoc,,$@) -d $(subst .kdoc,,$@) \
        -l base -llac -lgrid -ldof $(^:kdoc-installed=)
+       for htmlfile in $(subst .kdoc,,$@)/*html ; do \
+           echo "Fixing include paths in $$htmlfile..." ; \
+           perl -pi -e 's,(#include &lt;<A HREF=\"[^\"]+\">)$D/?[^/]+/include/,$$1,g;' "$$htmlfile" ;\
+       done
 
 multigrid.kdoc: kdoc-installed $(kdoc.multigrid)
        @$(PERL) $(KDOCFLAGS) $(subst .kdoc,,$@) -d $(subst .kdoc,,$@) \
        -l base -llac -lgrid -ldof -lnumerics $(^:kdoc-installed=)
+       for htmlfile in $(subst .kdoc,,$@)/*html ; do \
+           echo "Fixing include paths in $$htmlfile..." ; \
+           perl -pi -e 's,(#include &lt;<A HREF=\"[^\"]+\">)$D/?[^/]+/include/,$$1,g;' "$$htmlfile" ;\
+       done
 
index 4a7a1df17fcf9ebe6c802f6e704f8458bdab195f..10c249ffa8e32baeb000798973dbf28bbd44064f 100644 (file)
@@ -66,7 +66,7 @@
     JavaDoc</a> standard, with some small additions which we will
     explain below. The patched version of kdoc is included into the
     library and can be found in the
-    <code>deal.II/doc/auto/script/kdoc</code> directory.
+    <code>deal.II/contrib/kdoc</code> directory.
     </p>
 
     <p>
     <li> <em>Typewriter font:</em>
          <p>
         One would often like to use a typewriter font for variable,
-        function, or class names. For this, Doc++ has the special
-        sequence <code>#...#</code>, which generates output in which
-        the content inside the <code>#</code> characters is set in
-        typewriter font. We have extended kdoc for this feature as well.
+        function, or class names. For this, the <code>@p{...}</code>
+        tag is used, which generates output in which the content
+        inside the braces is set in typewriter font.
         </p>
 
         <p>
         As a convention, we always enclose variable and function
-        names into <code>#...#</code> in order to give them a visible
+        names into <code>@p{...}</code> in order to give them a visible
         distinction.
         </p>
 
+    <li> <em>Emphasis:</em>
+         <p>
+        To generate output in italics, use the <code>@em{...}</code> tag.
+        </p>
+
     <li> <em>Sections:</em>
          <p>
-        Sections can be generated using 
-        <code>\section{...}, \subsection{...},
-        \subsubsection{...}</code> tags.
+        Sections can be generated using <code>@sect1{...},
+        @sect2{...}, @sect3{...}, @sect4{...}</code> tags. We don't
+        normally use <code>@sect1{...}</code> as it produces section
+        titles that are overly large compared to the rest of a page.
         </p>
     </ul>
     </p>
     <h4>Future directions</h4>
 
     <p>
-    In the not-so-far future, we hope to be able to switch to 
-    <a href="http://www.ph.unimelb.edu.au/~ssk/kde/kdoc/" target="_top">kdoc2</a>,
-    which offers a much nicer output and a greatly improved parser. At
-    present, this program is still in alpha stage, but once stable we
-    will use for the generation of documentation. In particular, we
-    will then start thinking about using kdoc also for the generation
-    of printable documentation, through its DocBook SGML backend.
-    </p>
-
-    <p>
-    Speaking of SGML, we are considering switching to DocBook SGML
-    altogether. At present, printing of some documentation, most
+    We are considering switching to DocBook SGML instead of Latex for
+    printed output. At present, printing of some documentation, most
     notably the example programs is not really supported, and we
     consider ways to convert them to SGML along with most other
     documentation, since SGML is readily convertible into many other
-    formats, for example HTML and Postscript.
+    formats, for Postscript.
     </p>
 
     <p>
index cd7837109b9715ac4dcd8003f06ad29aaa658140..7ca5cee26b0040068fe2b3ae03956bd0b8f8f3bf 100644 (file)
@@ -1547,12 +1547,14 @@ void LaplaceProblem<dim>::run ()
                                   // GMV format.
   data_out.write_gmv (output);
 
-                                  // In each cycle values were added to
-                                  // the TableHandler. Now write the table
-                                  // to #cout#. Note, that the output in
-                                  // text format is a quite simple one
-                                  // and the captions may not be printed
-                                  // directly above the specific columns.
+                                  // In each cycle values were added
+                                  // to the TableHandler. Now write
+                                  // the table to the standard output
+                                  // stream cout. Note, that the
+                                  // output in text format is a quite
+                                  // simple one and the captions may
+                                  // not be printed directly above
+                                  // the specific columns.
   convergence_table.write_text(cout);
                                   // The table can also be written
                                   // into a tex file.  The (nicely)
index f64fb4ea0b8d72dda09b16b26810b96558a806e5..c127e83cbab3c64e86852259e8fb6a539862c51f 100644 (file)
@@ -45,7 +45,7 @@ class BlockIndices
                                      * block from the given
                                      * argument. The size of the
                                      * vector shall be equal to
-                                     * #n_blocks#.
+                                     * @p{n_blocks}.
                                      */
     BlockIndices (const vector<unsigned int> &n);
     
@@ -54,14 +54,14 @@ class BlockIndices
                                      * within each block from the
                                      * given argument. The size of
                                      * the vector shall be equal to
-                                     * #n_blocks#.
+                                     * @p{n_blocks}.
                                      */
     void reinit (const vector<unsigned int> &n);
     
                                     /**
                                      * Return the block and the
                                      * index within that block
-                                     * for the global index #i#. The
+                                     * for the global index @p{i}. The
                                      * first element of the pair is
                                      * the block, the second the
                                      * index within that.
@@ -71,7 +71,7 @@ class BlockIndices
 
                                     /**
                                      * Return the global index of
-                                     * #index# in block #block#.
+                                     * @p{index} in block @p{block}.
                                      */
     unsigned int local_to_global (const unsigned int block,
                                  const unsigned int index) const;
@@ -231,7 +231,7 @@ BlockIndices<n_blocks>::swap (BlockIndices<n_blocks> &b)
 
 
 /**
- * Global function #swap# which overloads the default implementation
+ * Global function @p{swap} which overloads the default implementation
  * of the C++ standard library which uses a temporary object. The
  * function simply exchanges the data of the two objects.
  *
index 1277069d67793d09cad8259718eeb4c137e78412..1391733c38a29285d4642b3082b02723f32709a1 100644 (file)
@@ -21,22 +21,22 @@ template <int n_blocks, typename Number> class BlockVector;
 
 /**
  * Blocked sparse matrix. The behaviour of objects of this type is
- * almost as for the #SparseMatrix<...># objects, with most of the
+ * almost as for the @p{SparseMatrix<...>} objects, with most of the
  * functions being implemented in both classes. The main difference is
  * that the matrix represented by this object is composed of an array
- * of sparse matrices (i.e. of type #SparseMatrix<number>#) and all
+ * of sparse matrices (i.e. of type @p{SparseMatrix<number>}) and all
  * accesses to the elements of this object are relayed to accesses of
  * the base matrices.
  *
  * In addition to the usual matrix access and linear algebra
- * functions, there are functions #block# which allow access to the
+ * functions, there are functions @p{block} which allow access to the
  * different blocks of the matrix. This may, for example, be of help
  * when you want to implement Schur complement methods, or block
  * preconditioners, where each block belongs to a specific component
  * of the equation you are presently discretizing.
  *
  *
- * \section{On template instantiations}
+ * @sect2{On template instantiations}
  *
  * Member functions of this class are either implemented in this file
  * or in a file of the same name with suffix ``.templates.h''. For the
@@ -72,7 +72,7 @@ class BlockSparseMatrix : public Subscriptor
                                      *
                                      * You have to initialize
                                      * the matrix before usage with
-                                     * #reinit(BlockSparsityPattern)#.
+                                     * @p{reinit(BlockSparsityPattern)}.
                                      */
     BlockSparseMatrix ();
 
@@ -82,7 +82,7 @@ class BlockSparseMatrix : public Subscriptor
                                      * represent the sparsity pattern
                                      * of this matrix. You can change
                                      * the sparsity pattern later on
-                                     * by calling the #reinit#
+                                     * by calling the @p{reinit}
                                      * function.
                                      *
                                      * This constructor initializes
@@ -94,7 +94,7 @@ class BlockSparseMatrix : public Subscriptor
                                      * lifetime of the sparsity
                                      * structure is at least as long
                                      * as that of this matrix or as
-                                     * long as #reinit# is not called
+                                     * long as @p{reinit} is not called
                                      * with a new sparsity structure.
                                      */
     BlockSparseMatrix (const BlockSparsityPattern<rows,columns> &sparsity);
@@ -113,10 +113,10 @@ class BlockSparseMatrix : public Subscriptor
                                      * Reinitialize the object but
                                      * keep to the sparsity pattern
                                      * previously used.  This may be
-                                     * necessary if you #reinit#'d
+                                     * necessary if you @p{reinit}'d
                                      * the sparsity structure and
                                      * want to update the size of the
-                                     * matrix. It only calls #reinit#
+                                     * matrix. It only calls @p{reinit}
                                      * on the sub-matrices.
                                      *
                                      * If the sparsity pattern has
@@ -136,7 +136,7 @@ class BlockSparseMatrix : public Subscriptor
                                      * reserved.
                                      *
                                      * Basically, this function only
-                                     * calls #reinit# of the
+                                     * calls @p{reinit} of the
                                      * sub-matrices with the block
                                      * sparsity patterns of the
                                      * parameter.
@@ -173,7 +173,7 @@ class BlockSparseMatrix : public Subscriptor
                                      * the sparsity pattern it was
                                      * previously tied to.
                                      *
-                                     * This calls #clear# on all
+                                     * This calls @p{clear} on all
                                      * sub-matrices.
                                      */
     virtual void clear ();
@@ -182,7 +182,7 @@ class BlockSparseMatrix : public Subscriptor
                                      * Return whether the object is
                                      * empty. It is empty if either
                                      * both dimensions are zero or no
-                                     * #SparsityPattern# is
+                                     * @p{SparsityPattern} is
                                      * associated.
                                      */
     bool empty () const;
@@ -216,7 +216,7 @@ class BlockSparseMatrix : public Subscriptor
     unsigned int n_nonzero_elements () const;
     
                                     /**
-                                     * Set the element #(i,j)# to #value#.
+                                     * Set the element @p{(i,j)} to @p{value}.
                                      * Throws an error if the entry does
                                      * not exist. Still, it is allowed to store
                                      * zero values in non-existent fields.
@@ -226,8 +226,8 @@ class BlockSparseMatrix : public Subscriptor
              const number value);
     
                                     /**
-                                     * Add #value# to the element
-                                     * #(i,j)#.  Throws an error if
+                                     * Add @p{value} to the element
+                                     * @p{(i,j)}.  Throws an error if
                                      * the entry does not
                                      * exist. Still, it is allowed to
                                      * store zero values in
@@ -247,7 +247,7 @@ class BlockSparseMatrix : public Subscriptor
                                      * cheaper. Since this operation
                                      * is notheless not for free, we
                                      * do not make it available
-                                     * through #operator =#, since
+                                     * through @p{operator =}, since
                                      * this may lead to unwanted
                                      * usage, e.g. in copy arguments
                                      * to functions, which should
@@ -261,15 +261,15 @@ class BlockSparseMatrix : public Subscriptor
                                      * of this matrix.
                                      *
                                      * The function returns a
-                                     * reference to #this#.
+                                     * reference to @p{this}.
                                      */
     template <typename somenumber>
     BlockSparseMatrix<number,rows,columns> &
     copy_from (const BlockSparseMatrix<somenumber,rows,columns> &source);
 
                                     /**
-                                     * Add #matrix# scaled by
-                                     * #factor# to this matrix. The
+                                     * Add @p{matrix} scaled by
+                                     * @p{factor} to this matrix. The
                                      * function throws an error if
                                      * the sparsity patterns of the
                                      * two involved matrices do not
@@ -312,7 +312,7 @@ class BlockSparseMatrix : public Subscriptor
                                      * let $dst = M^T*src$ with $M$
                                      * being this matrix. This
                                      * function does the same as
-                                     * #vmult# but takes the
+                                     * @p{vmult} but takes the
                                      * transposed matrix.
                                      */
     template <typename somenumber>
@@ -334,7 +334,7 @@ class BlockSparseMatrix : public Subscriptor
                                      * multiplication. Add $M^T*src$
                                      * to $dst$ with $M$ being this
                                      * matrix. This function does the
-                                     * same as #vmult_add# but takes
+                                     * same as @p{vmult_add} but takes
                                      * the transposed matrix.
                                      */
     template <typename somenumber>
@@ -379,13 +379,13 @@ class BlockSparseMatrix : public Subscriptor
     
                                     /**
                                      * Compute the residual of an
-                                     * equation #Ax=b#, where the
+                                     * equation @p{Ax=b}, where the
                                      * residual is defined to be
-                                     * #r=b-Ax# with #x# typically
+                                     * @p{r=b-Ax} with @p{x} typically
                                      * being an approximate of the
                                      * true solution of the
                                      * equation. Write the residual
-                                     * into #dst#.
+                                     * into @p{dst}.
                                      */
     template <typename somenumber>
     somenumber residual (BlockVector<rows,somenumber>          &dst,
@@ -396,11 +396,11 @@ class BlockSparseMatrix : public Subscriptor
                                      * Apply the Jacobi
                                      * preconditioner, which
                                      * multiplies every element of
-                                     * the #src# vector by the
+                                     * the @p{src} vector by the
                                      * inverse of the respective
                                      * diagonal element and
                                      * multiplies the result with the
-                                     * damping factor #omega#.
+                                     * damping factor @p{omega}.
                                      *
                                      * The matrix needs to be square
                                      * for this operation.
@@ -416,7 +416,7 @@ class BlockSparseMatrix : public Subscriptor
                                      * pattern of this matrix.
                                      *
                                      * Though the return value is
-                                     * declared #const#, you should
+                                     * declared @p{const}, you should
                                      * be aware that it may change if
                                      * you call any nonconstant
                                      * function of objects which
@@ -437,7 +437,7 @@ class BlockSparseMatrix : public Subscriptor
                                      * matrix. In order to guarantee
                                      * that it is not deleted while
                                      * still in use, we subscribe to
-                                     * it using the #SmartPointer#
+                                     * it using the @p{SmartPointer}
                                      * class.
                                      */
     SmartPointer<const BlockSparsityPattern<rows,columns> > sparsity_pattern;
@@ -700,9 +700,9 @@ residual (BlockVector<rows,somenumber>          &dst,
          const BlockVector<rows,somenumber>    &b) const
 {
                                   // in block notation, the residual is
-                                  // #r_i = b_i - \sum_j A_ij x_j#.
+                                  // @p{r_i = b_i - \sum_j A_ij x_j}.
                                   // this can be written as
-                                  // #r_i = b_i - A_i0 x_0 - \sum_{j>0} A_ij x_j#.
+                                  // @p{r_i = b_i - A_i0 x_0 - \sum_{j>0} A_ij x_j}.
                                   //
                                   // for the first two terms, we can
                                   // call the residual function of
index 621400829e12574d20e9de165f31cd8382c8b809..ac71ff37d8b202b737823a5b3286f784601fa4f6 100644 (file)
  * This is a block version of the sparsity pattern class. It has not
  * much functionality, but only administrated an array of sparsity
  * pattern objects and delegates work to them. It has mostly the same
- * interface as has the #SparsityPattern# class, and simply transforms
+ * interface as has the @p{SparsityPattern} class, and simply transforms
  * calls to its member functions to calls to the respective member
  * functions of the member sparsity patterns.
  *
- * The largest difference between the #SparsityPattern# class and this
+ * The largest difference between the @p{SparsityPattern} class and this
  * class is probably the absence of several of the constructors as
- * well as the absenceof the #reinit# functions. The reason is that
+ * well as the absenceof the @p{reinit} functions. The reason is that
  * mostly, the matrices have different properties and you will want to
  * initialize the blocks making up the matrix separately. You can
- * access the different blocks using the #block(row,col)# function.
+ * access the different blocks using the @p{block(row,col)} 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
- * #collect_sizes()# function of this class! Note that, of course, all
+ * @p{collect_sizes()} function of this class! Note that, of course, all
  * sub-matrices in a row have to have the same number of rows, and
  * that all sub-matrices in a column have to have the same number of
  * columns.
  *
  *
- * \section{On template instantiations}
+ * @sect2{On template instantiations}
  *
  * Member functions of this class are either implemented in this file
  * or in a file of the same name with suffix ``.templates.h''. For the
@@ -64,14 +64,14 @@ class BlockSparsityPattern : public Subscriptor
                                     /**
                                      * Define a value which is used
                                      * to indicate that a certain
-                                     * value in the #colnums# array
+                                     * value in the @p{colnums} array
                                      * is unused, i.e. does not
                                      * represent a certain column
                                      * number index.
                                      *
                                      * This value is only an alias to
                                      * the respective value of the
-                                     * #SparsityPattern# class.
+                                     * @p{SparsityPattern} class.
                                      */
     static const unsigned int invalid_entry = SparsityPattern::invalid_entry;
     
@@ -83,7 +83,7 @@ class BlockSparsityPattern : public Subscriptor
                                      * member variables in other
                                      * classes. You can make the
                                      * structure usable by calling
-                                     * the #reinit# function.
+                                     * the @p{reinit} function.
                                      */
     BlockSparsityPattern ();
 
@@ -149,7 +149,7 @@ class BlockSparsityPattern : public Subscriptor
                                      * This function compresses the
                                      * sparsity structures that this
                                      * object represents. It simply
-                                     * calls #compress# for all
+                                     * calls @p{compress} for all
                                      * sub-objects.
                                      */
     void compress ();
@@ -186,7 +186,7 @@ class BlockSparsityPattern : public Subscriptor
                                      * bad happens.
                                      *
                                      * This function simply finds out
-                                     * to which block #(i,j)# belongs
+                                     * to which block @p{(i,j)} belongs
                                      * and then relays to that block.
                                      */
     void add (const unsigned int i, const unsigned int j);
@@ -287,8 +287,8 @@ class BlockSparsityPattern : public Subscriptor
                                     /**
                                      * Make the block sparse matrix a
                                      * friend, so that it can use our
-                                     * #row_indices# and
-                                     * #column_indices# objects.
+                                     * @p{row_indices} and
+                                     * @p{column_indices} objects.
                                      */
     template <typename number, int r, int c>
     friend class BlockSparseMatrix;
@@ -350,7 +350,7 @@ BlockSparsityPattern<rows,columns>::add (const unsigned int i,
 {
                                   // if you get an error here, are
                                   // you sure you called
-                                  // #collect_sizes()# before?
+                                  // @p{collect_sizes()} before?
   const pair<unsigned int,unsigned int>
     row_index = row_indices.global_to_local (i),
     col_index = column_indices.global_to_local (j);
index bc6400f5e45b48b3e418384ef0a014f2c98c6555..a18d16ab4c000dfadd53193b5a835921679a1881 100644 (file)
 /**
  * Several vectors of data. 
  *
- * The BlockVector is a collection of normal LAC-#Vector#s. Each of
+ * The BlockVector is a collection of normal LAC-@p{Vector}s. Each of
  * the vectors inside can have a different size.
  *
- * The functionality of #BlockVector# includes everything a #Vector#
- * can do, plus the access to a single #Vector# inside the
- * #BlockVector# by #block(i)#.
+ * The functionality of @p{BlockVector} includes everything a @p{Vector}
+ * can do, plus the access to a single @p{Vector} inside the
+ * @p{BlockVector} by @p{block(i)}.
  *
  *
- * \section{On template instantiations}
+ * @sect2{On template instantiations}
  *
  * Member functions of this class are either implemented in this file
  * or in a file of the same name with suffix ``.templates.h''. For the
@@ -52,10 +52,10 @@ class BlockVector
                                     /**
                                      * Declare standard types used in
                                      * all containers. These types
-                                     * parallel those in the #C++#
+                                     * parallel those in the @p{C++}
                                      * standard libraries
-                                     * #vector<...># class. The
-                                     * #iterator# types are not
+                                     * @p{vector<...>} class. The
+                                     * @p{iterator} types are not
                                      * declared at present, since
                                      * there are no iterators
                                      * implemented that cycle through
@@ -89,7 +89,7 @@ class BlockVector
 //                                   * Copy constructor taking a BlockVector of
 //                                   * another data type. This will fail if
 //                                   * there is no conversion path from
-//                                   * #OtherNumber# to #Number#. Note that
+//                                   * @p{OtherNumber} to @p{Number}. Note that
 //                                   * you may lose accuracy when copying
 //                                   * to a BlockVector with data elements with
 //                                   * less accuracy.
@@ -99,7 +99,7 @@ class BlockVector
 //     BlockVector (const BlockVector<OtherNumber> &v);
     
                                     /**
-                                     * Constructor. Set dimension to #n# and
+                                     * Constructor. Set dimension to @p{n} and
                                      * initialize all elements with zero.
                                      */
     BlockVector (const vector<unsigned int> &n);
@@ -111,19 +111,19 @@ class BlockVector
 
                                     /**
                                      * Change the dimension of the vector to
-                                     * #N#. The reserved memory for this vector
+                                     * @p{N}. The reserved memory for this vector
                                      * remains unchanged if possible, to make
                                      * things faster, but this may waste some
                                      * memory, so take this in the back of your
                                      * head.
-                                     * However, if #N==0# all memory is freed,
+                                     * However, if @p{N==0} all memory is freed,
                                      * i.e. if you want to resize the vector
                                      * and release the memory not needed, you
-                                     * have to first call #reinit(0)# and then
-                                     * #reinit(N)#. This cited behaviour is
+                                     * have to first call @p{reinit(0)} and then
+                                     * @p{reinit(N)}. This cited behaviour is
                                      * analogous to that of the STL containers.
                                      *
-                                     * On #fast==false#, the vector is filled by
+                                     * On @p{fast==false}, the vector is filled by
                                      * zeros.
                                      */ 
     void reinit (const vector<unsigned int> &N,
@@ -131,29 +131,29 @@ class BlockVector
     
                                     /**
                                      * Change the dimension to that of the
-                                     * vector #V#. The same applies as for
-                                     * the other #reinit# function.
+                                     * vector @p{V}. The same applies as for
+                                     * the other @p{reinit} function.
                                      *
-                                     * The elements of #V# are not copied, i.e.
+                                     * The elements of @p{V} are not copied, i.e.
                                      * this function is the same as calling
-                                     * #reinit (V.size(), fast)#.
+                                     * @p{reinit (V.size(), fast)}.
                                      */
     void reinit (const BlockVector<n_blocks,Number> &V,
                 const bool                          fast=false);
     
                                     /**
                                      * Set all entries to zero. Equivalent to
-                                     * #v = 0#, but more obvious and faster.
+                                     * @p{v = 0}, but more obvious and faster.
                                      * Note that this function does not change
                                      * the size of the vector, unlike the
-                                     * STL's #vector<>::clear# function.
+                                     * STL's @p{vector<>::clear} function.
                                      */
     void clear ();
     
                                     /**
                                      * Swap the contents of this
                                      * vector and the other vector
-                                     * #v#. One could do this
+                                     * @p{v}. One could do this
                                      * operation with a temporary
                                      * variable and copying over the
                                      * data elements, but this
@@ -166,11 +166,11 @@ class BlockVector
                                      * data around.
                                      *
                                      * This function is analog to the
-                                     * the #swap# function of all C++
+                                     * the @p{swap} function of all C++
                                      * standard containers. Also,
                                      * there is a global function
-                                     * #swap(u,v)# that simply calls
-                                     * #u.swap(v)#, again in analogy
+                                     * @p{swap(u,v)} that simply calls
+                                     * @p{u.swap(v)}, again in analogy
                                      * to standard functions.
                                      */
     void swap (BlockVector<n_blocks,Number> &v);
@@ -289,29 +289,29 @@ class BlockVector
                                     //@{
                                     /**
                                      * Addition operator.
-                                     * Fast equivalent to #U.add(1, V)#.
+                                     * Fast equivalent to @p{U.add(1, V)}.
                                      */
     BlockVector<n_blocks,Number> &
     operator += (const BlockVector<n_blocks,Number> &V);
 
                                     /**
                                      * Subtraction operator.
-                                     * Fast equivalent to #U.add(-1, V)#.
+                                     * Fast equivalent to @p{U.add(-1, V)}.
                                      */
     BlockVector<n_blocks,Number> &
     operator -= (const BlockVector<n_blocks,Number> &V);
 
                                     /**
                                      * $U(0-DIM)+=s$.
-                                     * Addition of #s# to all components. Note
-                                     * that #s# is a scalar and not a vector.
+                                     * Addition of @p{s} to all components. Note
+                                     * that @p{s} is a scalar and not a vector.
                                      */
     void add (const Number s);
     
                                     /**
                                      * U+=V.
                                      * Simple vector addition, equal to the
-                                     * #operator +=#.
+                                     * @p{operator +=}.
                                      */
     void add (const BlockVector<n_blocks,Number>& V);
     
@@ -360,7 +360,7 @@ class BlockVector
                                     /**
                                      * Scale each element of the vector by the
                                      * given factor. This function was
-                                     * previously called #equ(Number)#, which
+                                     * previously called @p{equ(Number)}, which
                                      * in my eyes is an extremely unintuitive
                                      * naming and was thus replaced.
                                      */
@@ -546,7 +546,7 @@ BlockVector<n_blocks,Number>::get_block_indices () const
 
 
 /**
- * Global function #swap# which overloads the default implementation
+ * Global function @p{swap} which overloads the default implementation
  * of the C++ standard library which uses a temporary object. The
  * function simply exchanges the data of the two vectors.
  *
index 0a4a9bf4b6c834cfe69b0daf70d521bfd4ba7096..fd574f84d5447c33ffeb5154fb4012a98eaa0b0b 100644 (file)
@@ -30,14 +30,14 @@ template<typename number> class Vector;
  *
  * Implementation of a classical rectangular scheme of numbers. The
  * data type of the entries is provided in the template argument
- * #number#.  The interface is quite fat and in fact has grown every
+ * @p{number}.  The interface is quite fat and in fact has grown every
  * time a new feature was needed. So, a lot of functions are provided.
  *
  * Since the instantiation of this template is quite an effort,
  * standard versions are precompiled into the library. These include
- * all combinations of #float# and #double# for matrices and
+ * all combinations of @p{float} and @p{double} for matrices and
  * vectors. If you need more data types, the implementation of
- * non-inline functions is in #fullmatrix.templates.h#. Driver files
+ * non-inline functions is in @p{fullmatrix.templates.h}. Driver files
  * are in the source tree.
  *
  * Internal calculations are usually done with the accuracy of the
@@ -45,7 +45,7 @@ template<typename number> class Vector;
  * type, the matrix number type is used.
  *
  *
- * \section{On template instantiations}
+ * @sect2{On template instantiations}
  *
  * Member functions of this class are either implemented in this file
  * or in a file of the same name with suffix ``.templates.h''. For the
@@ -64,12 +64,12 @@ class FullMatrix : public Subscriptor
   public:
                                     /**
                                      * Constructor. Initialize the matrix as
-                                     * a square matrix with dimension #n#.
+                                     * a square matrix with dimension @p{n}.
                                      *
                                      * In order to avoid the implicit
                                      * conversion of integers and other types
                                      * to a matrix, this constructor is
-                                     * declared #explicit#.
+                                     * declared @p{explicit}.
                                      *
                                      * By default, no memory is allocated.
                                      */
@@ -105,7 +105,7 @@ class FullMatrix : public Subscriptor
 
                                     /**
                                      * Assignment operator.
-                                     * Copy all elements of #src#
+                                     * Copy all elements of @p{src}
                                      * into the matrix. The size is
                                      * adjusted if needed.
                                      *
@@ -119,7 +119,7 @@ class FullMatrix : public Subscriptor
 
                                     /**
                                      * Assignment operator.
-                                     * Copy all elements of #src#
+                                     * Copy all elements of @p{src}
                                      * into the matrix. The size is
                                      * adjusted if needed.
                                      */
@@ -130,16 +130,16 @@ class FullMatrix : public Subscriptor
                                     /**
                                      * Fill rectangular block.
                                      *
-                                     * The matrix #src# is copied
+                                     * The matrix @p{src} is copied
                                      * into the target. The optional
-                                     * values #i# and #j# determine the
+                                     * values @p{i} and @p{j} determine the
                                      * upper left corner of the image
-                                     * of #src#.
+                                     * of @p{src}.
                                      *
                                      * This function requires that
-                                     * #i+src.m()<=m()# and
-                                     * #j+src.n()<=n()#, that is, the
-                                     * image fits into the space of #this#.
+                                     * @p{i+src.m()<=m()} and
+                                     * @p{j+src.n()<=n()}, that is, the
+                                     * image fits into the space of @p{this}.
                                      */
     template<typename number2>
     void fill (const FullMatrix<number2> &src,
@@ -166,7 +166,7 @@ class FullMatrix : public Subscriptor
                                      * allocate memory if necessary. Forget
                                      * the previous content of the matrix.
                                      * However, this function does not copy
-                                     * the contents of #B#.
+                                     * the contents of @p{B}.
                                      */
     template<typename number2>
     void reinit (const FullMatrix<number2> &B);
@@ -196,8 +196,8 @@ class FullMatrix : public Subscriptor
     bool all_zero () const;
 
                                     /**
-                                     * Return the value of the element #(i,j)#.
-                                     * Does the same as the private #el(i,j)#
+                                     * Return the value of the element @p{(i,j)}.
+                                     * Does the same as the private @p{el(i,j)}
                                      * function but does bounds checking in
                                      * debug mode.
                                      */
@@ -206,8 +206,8 @@ class FullMatrix : public Subscriptor
     
                                     /**
                                      * Return a read-write reference to
-                                     * the element #(i,j)#.
-                                     * Does the same as the private #el(i,j)#
+                                     * the element @p{(i,j)}.
+                                     * Does the same as the private @p{el(i,j)}
                                      * function but does bounds checking in
                                      * debug mode.
                                      */
@@ -222,7 +222,7 @@ class FullMatrix : public Subscriptor
 
                                     /**
                                      * Weighted addition. The matrix
-                                     * #s*B# is added to #this#.
+                                     * @p{s*B} is added to @p{this}.
                                      *
                                      * $A += sB$
                                      */
@@ -232,7 +232,7 @@ class FullMatrix : public Subscriptor
 
                                     /**
                                      * Weighted addition of the
-                                     * transpose of #B# to #this#.
+                                     * transpose of @p{B} to @p{this}.
                                      *
                                      * $A += s B^T$
                                      */
@@ -244,8 +244,8 @@ class FullMatrix : public Subscriptor
                                      * Matrix-matrix-multiplication.
                                      * $C=A*B$.
                                      *
-                                     * Assumes that #A# and #B# have
-                                     * compatible sizes and thet #C#
+                                     * Assumes that @p{A} and @p{B} have
+                                     * compatible sizes and thet @p{C}
                                      * already has the right size.
                                      */
     template<typename number2>
@@ -254,11 +254,11 @@ class FullMatrix : public Subscriptor
     
                                     /**
                                      * Matrix-matrix-multiplication using
-                                     * transpose of #this#.
+                                     * transpose of @p{this}.
                                      * $C=A^T*B$.
                                      *
-                                     * Assumes that #A# and #B# have
-                                     * compatible sizes and thet #C#
+                                     * Assumes that @p{A} and @p{B} have
+                                     * compatible sizes and thet @p{C}
                                      * already has the right size.
                                      */
     template<typename number2>
@@ -269,9 +269,9 @@ class FullMatrix : public Subscriptor
                                      * Matrix-vector-multiplication.
                                      *
                                      * The optional parameter
-                                     * #adding# determines, whether the
-                                     * result is stored in #w# or added
-                                     * to #w#.
+                                     * @p{adding} determines, whether the
+                                     * result is stored in @p{w} or added
+                                     * to @p{w}.
                                      *
                                      * if (adding)
                                      *  $w += A*v$
@@ -286,7 +286,7 @@ class FullMatrix : public Subscriptor
     
                                     /**
                                      * Transpose matrix-vector-multiplication.
-                                     * See #vmult# above.
+                                     * See @p{vmult} above.
                                      */
     template<typename number2>
     void Tvmult (Vector<number2>       &w,
@@ -295,7 +295,7 @@ class FullMatrix : public Subscriptor
 
                                     /**
                                      * Return the square of the norm
-                                     * of the vector #v# with respect
+                                     * of the vector @p{v} with respect
                                      * to the norm induced by this
                                      * matrix,
                                      * i.e. $\left(v,Mv\right)$. This
@@ -316,7 +316,7 @@ class FullMatrix : public Subscriptor
 
                                     /**
                                      * Build the matrix scalar product
-                                     * #u^T M v#. This function is mostly
+                                     * @p{u^T M v}. This function is mostly
                                      * useful when building the cellwise
                                      * scalar product of two functions in
                                      * the finite element context.
@@ -385,7 +385,7 @@ class FullMatrix : public Subscriptor
 
                                     /**
                                      * Assign the inverse of the given
-                                     * matrix to #*this#. This function is
+                                     * matrix to @p{*this}. This function is
                                      * only implemented (hardcoded) for
                                      * square matrices of dimension one,
                                      * two, three and four, since the
@@ -402,10 +402,10 @@ class FullMatrix : public Subscriptor
                                      *
                                      * For all other sizes than the ones given
                                      * above, an exception of type
-                                     * #ExcNotImplemented(dim_range)# is
+                                     * @p{ExcNotImplemented(dim_range)} is
                                      * thrown, which you can catch and use
                                      * some other method to invert the matrix,
-                                     * e.g. the #gauss_jordan# function.
+                                     * e.g. the @p{gauss_jordan} function.
                                      */
     void invert (const FullMatrix<number> &M);
 
@@ -537,11 +537,11 @@ class FullMatrix : public Subscriptor
                                      * Each entry is printed in scientific
                                      * format, with one pre-comma digit and
                                      * the number of digits given by
-                                     * #precision# after the comma, with one
+                                     * @p{precision} after the comma, with one
                                      * space following.
                                      * The precision defaults to four, which
                                      * suffices for most cases. The precision
-                                     * and output format are {\it not}
+                                     * and output format are @em{not}
                                      * properly reset to the old values
                                      * when the function exits.
                                      *
@@ -622,14 +622,14 @@ class FullMatrix : public Subscriptor
                                      * size of the matrix is increased.
                                      * Therefore, if the matrix size was
                                      * decreased somewhen in the past,
-                                     * #val_size# will be larger than
-                                     * #dim_range * dim_image#.
+                                     * @p{val_size} will be larger than
+                                     * @p{dim_range * dim_image}.
                                      */
     unsigned int val_size;
     
                                     /**
                                      * Return a read-write reference to the
-                                     * element #(i,j)#.
+                                     * element @p{(i,j)}.
                                      *
                                      * This function does no bounds
                                      * checking and is only to be used
@@ -639,7 +639,7 @@ class FullMatrix : public Subscriptor
     number & el (const unsigned int i, const unsigned int j);
     
                                     /**
-                                     * Return the value of the element #(i,j)#.
+                                     * Return the value of the element @p{(i,j)}.
                                      *
                                      * This function does no bounds checking
                                      * and is only to be used
index 410465e54aae9b7d6c2cce5e249c62abb246d237..78389b5ad5e21c9569477ace1544fb5671802c25 100644 (file)
@@ -60,9 +60,9 @@ class PreconditionIdentity
  * classes.
  *
  * It seems that all builtin preconditioners have a relaxation
- * parameter, so please use #PreconditionRelaxation# for these.
+ * parameter, so please use @p{PreconditionRelaxation} for these.
  *
- * \subsection{Use}
+ * @sect3{Use}
  * You will usually not want to create a named object of this type,
  * although possible. The most common use is like this:
  * \begin{verbatim}
@@ -74,8 +74,8 @@ class PreconditionIdentity
  *                (matrix,&SparseMatrix<double>::template precondition_Jacobi));
  * \end{verbatim}
  * This creates an unnamed object to be passed as the fourth parameter to
- * the solver function of the #SolverGMRES# class. It assumes that the
- * #SparseMatrix# class has a function #precondition_Jacobi# taking two
+ * the solver function of the @p{SolverGMRES} class. It assumes that the
+ * @p{SparseMatrix} class has a function @p{precondition_Jacobi} taking two
  * vectors (source and destination) as parameters. (Actually, there is no
  * function like that, the existing function takes a third parameter,
  * denoting the relaxation parameter; this example is therefore only meant to
@@ -258,8 +258,8 @@ class PreconditionSSOR : public PreconditionRelaxation<MATRIX>
  * inverse of the matrix. Naturally, this solver needs another
  * preconditionig method.
  *
- * Usually, the use of #ReductionControl# is preferred over the use of
- * the basic #SolverControl# in defining this solver.
+ * Usually, the use of @p{ReductionControl} is preferred over the use of
+ * the basic @p{SolverControl} in defining this solver.
  *
  * @author Guido Kanschat, 1999
  */
index af9d1be944d4f7fb3b5e39505480d1253f57c5ef..33f5d530955210f9325fa9fe3d80d0c89e370231 100644 (file)
@@ -26,38 +26,42 @@ template <typename number> class Vector;
 
 
 /**
- * Base class for #PreconditionBlockJacobi#, #PreconditionBlockSOR#, ...
- * This class assumes the #SparseMatrix<number># consisting of invertible blocks 
- * of #blocksize# on the diagonal and provides the inversion of the diagonal blocks
- * of the matrix. NOT only block diagonal matrices are allowed but all
- * matrices of arbitrary structure with the minimal property of having
- * invertible blocks on the diagonal!
+ * Base class for @p{PreconditionBlockJacobi},
+ * @p{PreconditionBlockSOR}, ...  This class assumes the
+ * @p{SparseMatrix<number>} consisting of invertible blocks of
+ * @p{blocksize} on the diagonal and provides the inversion of the
+ * diagonal blocks of the matrix. NOT only block diagonal matrices are
+ * allowed but all matrices of arbitrary structure with the minimal
+ * property of having invertible blocks on the diagonal!
  *
- * This block matrix structure is given e.g. for the DG method
- * for the transport equation. For a downstream numbering the matrices
- * even have got a block lower left matrix structure, i.e. the matrices
- * are empty above the diagonal blocks.
+ * This block matrix structure is given e.g. for the DG method for the
+ * transport equation. For a downstream numbering the matrices even
+ * have got a block lower left matrix structure, i.e. the matrices are
+ * empty above the diagonal blocks.
  *
- * For all matrices that are empty above and below the diagonal
- * blocks (i.e. for all block diagonal matrices) the #BlockJacobi# preconditioner
- * is a direct solver. For all matrices that are empty only above the diagonal blocks
- * (e.g. the matrices one gets by the DG method with downstream numbering)
- * #BlockSOR# is a direct solver.
+ * For all matrices that are empty above and below the diagonal blocks
+ * (i.e. for all block diagonal matrices) the @p{BlockJacobi}
+ * preconditioner is a direct solver. For all matrices that are empty
+ * only above the diagonal blocks (e.g. the matrices one gets by the
+ * DG method with downstream numbering) @p{BlockSOR} is a direct
+ * solver.
  * 
- * This first implementation of the #PreconditionBlock# assumes the
- * matrix has blocks each of the same block size. Varying
- * block sizes within the matrix must still be implemented if needed.
+ * This first implementation of the @p{PreconditionBlock} assumes the
+ * matrix has blocks each of the same block size. Varying block sizes
+ * within the matrix must still be implemented if needed.
  *
- * 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 #invert_diagblocks()#. 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, #number==double, inverse_type=float# might be a viable choice.
+ * 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
+ * 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
+ * choice.
  *
  *
- * \section{On template instantiations}
+ * @sect2{On template instantiations}
  *
  * Member functions of this class are either implemented in this file
  * or in a file of the same name with suffix ``.templates.h''. For the
@@ -97,11 +101,11 @@ class PreconditionBlock: public Subscriptor
                     const unsigned int block_size);
 
                                     /**
-                                     * Deletes the inverse diagonal block
-                                     * matrices if existent, sets the
-                                     * blocksize to 0, hence leaves the
-                                     * class in the state that it had 
-                                     * directly after
+                                     * Deletes the inverse diagonal
+                                     * block matrices if existent,
+                                     * sets the blocksize to 0, hence
+                                     * leaves the class in the state
+                                     * that it had directly after
                                      * calling the constructor.
                                      */
     virtual void clear();
@@ -122,28 +126,31 @@ class PreconditionBlock: public Subscriptor
     void set_same_diagonal ();
     
                                     /**
-                                     * Stores the inverse of
-                                     * the diagonal blocks
-                                     * in #inverse#. This costs some 
+                                     * Stores the inverse of the
+                                     * diagonal blocks in
+                                     * @p{inverse}. This costs some
                                      * additional memory - for DG
-                                     * methods about 1/3 (for double inverses) 
-                                     * or 1/6 (for float inverses) of that
-                                     * used for the matrix - but it
-                                     * makes the preconditioning much faster.
+                                     * methods about 1/3 (for double
+                                     * inverses) or 1/6 (for float
+                                     * inverses) of that used for the
+                                     * matrix - but it makes the
+                                     * preconditioning much faster.
                                      *
-                                     * It is not allowed to call this function
-                                     * twice (will produce an error) before
-                                     * a call of #clear(..)#
-                                     * because at the second time there already
+                                     * It is not allowed to call this
+                                     * function twice (will produce
+                                     * an error) before a call of
+                                     * @p{clear(...)}  because at the
+                                     * second time there already
                                      * exist the inverse matrices.
                                      *
-                                     * After this function is called, the
-                                     * lock on the matrix given through the
-                                     * #use_matrix# function is released,
-                                     * i.e. you may overwrite of delete it.
-                                     * You may want to do this in case
-                                     * you use this matrix to precondition
-                                     * another matrix.
+                                     * After this function is called,
+                                     * the lock on the matrix given
+                                     * through the @p{use_matrix}
+                                     * function is released, i.e. you
+                                     * may overwrite of delete it.
+                                     * You may want to do this in
+                                     * case you use this matrix to
+                                     * precondition another matrix.
                                      */
     void invert_diagblocks();
 
@@ -188,37 +195,43 @@ class PreconditionBlock: public Subscriptor
    
   protected:
                                     /**
-                                     * Access to the inverse diagonal blocks.
-                                     * 
+                                     * Access to the inverse diagonal
+                                     * blocks.
                                      */
     const FullMatrix<inverse_type>& inverse (unsigned int i) const;
     
                                     /**
-                                     * Size of the blocks. Each diagonal
-                                     * block is assumed to be of the
-                                     * same size.
+                                     * Size of the blocks. Each
+                                     * diagonal block is assumed to
+                                     * be of the same size.
                                      */
     unsigned int blocksize;
 
                                     /**
-                                     * Pointer to the matrix. Make sure that
-                                     * the matrix exists as long as this class
-                                     * needs it, i.e. until calling #invert_diagblocks#,
-                                     * or (if the inverse matrices should not be
-                                     * stored) until the last call of the 
-                                     * preconditoining #vmult# function of the
+                                     * Pointer to the matrix. Make
+                                     * sure that the matrix exists as
+                                     * long as this class needs it,
+                                     * i.e. until calling
+                                     * @p{invert_diagblocks}, or (if
+                                     * the inverse matrices should
+                                     * not be stored) until the last
+                                     * call of the preconditoining
+                                     * @p{vmult} function of the
                                      * derived classes.
                                      */
     SmartPointer<const SparseMatrix<number> > A;
 
   private:
                                     /**
-                                     * Storage of the inverse matrices of
-                                     * the diagonal blocks matrices as
-                                     * #FullMatrix<inverse_type># matrices.
-                                     * For BlockSOR as preconditioning
-                                     * using #inverse_type=float# saves memory
-                                     * in comparison with #inverse_type=double#.
+                                     * Storage of the inverse
+                                     * matrices of the diagonal
+                                     * blocks matrices as
+                                     * @p{FullMatrix<inverse_type>}
+                                     * matrices.  For BlockSOR as
+                                     * preconditioning using
+                                     * @p{inverse_type=float} saves
+                                     * memory in comparison with
+                                     * @p{inverse_type=double}.
                                      */
     vector<FullMatrix<inverse_type> > _inverse;
 
@@ -230,43 +243,46 @@ class PreconditionBlock: public Subscriptor
 };
 
 
+
 /**
  * Block Jacobi preconditioning.
  */
-template<typename number,
-         typename inverse_type = number>
+template<typename number, typename inverse_type = number>
 class PreconditionBlockJacobi : public PreconditionBlock<number,inverse_type>
 {
   public:
                                     /**
-                                     * Execute block Jacobi preconditioning.
+                                     * Execute block Jacobi
+                                     * preconditioning.
                                      *
-                                     * This function will automatically use the
-                                     * inverse matrices if they exist, if not
-                                     * then BlockJacobi will need much time
-                                     * inverting the diagonal block
-                                     * matrices in each preconditioning step.
+                                     * This function will
+                                     * automatically use the inverse
+                                     * matrices if they exist, if not
+                                     * then BlockJacobi will need
+                                     * much time inverting the
+                                     * diagonal block matrices in
+                                     * each preconditioning step.
                                      */
     template <typename number2>
     void vmult (Vector<number2>&, const Vector<number2>&) const;
 
                                     /**
-                                     * Same as #vmult#, since Jacobi is symmetric.
+                                     * Same as @p{vmult}, since Jacobi is symmetric.
                                      */
     template <typename number2>
     void Tvmult (Vector<number2>&, const Vector<number2>&) const;
 };
 
 
+
 /**
  * Block SOR preconditioning.
  *
  * The diagonal blocks and the elements 
  * (of arbitray structure) below the diagonal blocks are used
- * in the #operator ()# function of this class.
+ * in the @p{operator ()} function of this class.
  */
-template<typename number,
-         typename inverse_type = number>
+template<typename number, typename inverse_type = number>
 class PreconditionBlockSOR : public PreconditionBlock<number,inverse_type>
 {
   public:
@@ -287,16 +303,19 @@ class PreconditionBlockSOR : public PreconditionBlock<number,inverse_type>
     void set_omega(number omega);
     
                                     /**
-                                     * Execute block SOR preconditioning.
+                                     * Execute block SOR
+                                     * preconditioning.
                                      *
-                                     * This function will automatically use the
-                                     * inverse matrices if they exist, if not
-                                     * then BlockSOR will waste much time
-                                     * inverting the diagonal block
-                                     * matrices in each preconditioning step.
+                                     * This function will
+                                     * automatically use the inverse
+                                     * matrices if they exist, if not
+                                     * then BlockSOR will waste much
+                                     * time inverting the diagonal
+                                     * block matrices in each
+                                     * preconditioning step.
                                      *
-                                     * For matrices which are
-                                     * empty above the diagonal blocks
+                                     * For matrices which are empty
+                                     * above the diagonal blocks
                                      * BlockSOR is a direct solver.
                                      */
     template <typename number2>
index 69f75a238f8241086df2df501f28d16d38377fce..b71ed8f3e1d001a68f3e22108a657bfd356fd5a1 100644 (file)
@@ -141,7 +141,7 @@ void PreconditionBlock<number,inverse_type>::invert_diagblocks()
                                       // row, column are the global numbering
                                       // of the unkowns.
 
-                                      // set the #_inverse# array to the right
+                                      // set the @p{_inverse} array to the right
                                       // size. we could do it like this:
                                       // _inverse = vector<>(n_cells,FullMatrix<>())
                                       // but this would involve copying many
index 81d0dad85fd0aac1844ac15b97f8ab2000c66ced..b186150418f2d467646abf2c46f3c35cb63cba96 100644 (file)
 /**
  * Selects the preconditioner. The constructor of this class takes 
  * the name of the preconditioning and the damping parameter 
- * #omega# of the preconditioning and the #use_matrix# function takes
+ * @p{omega} of the preconditioning and the @p{use_matrix} function takes
  * the matrix that is used
- * by the matrix-builtin precondition functions. Each time, the #operator()# function
+ * by the matrix-builtin precondition functions. Each time, the @p{operator()} function
  * is called, this preselected preconditioner, this matrix and
- * this #omega# is used
+ * this @p{omega} is used
  * for the preconditioning. This class is designed for being used as
- * argument of the #solve# function of a #Solver# and it covers the
+ * argument of the @p{solve} function of a @p{Solver} and it covers the
  * selection of all matrix-builtin precondition functions. The selection
  * of other preconditioners, like BlockSOR or ILU should be handled in
  * derived classes by the user.
  *
- * \subsection{Usage}
+ * @sect3{Usage}
  * The simplest use of this class is the following:
  * \begin{verbatim}
- *                                  // generate a #SolverControl# and
- *                                  // a #VectorMemory#
+ *                                  // generate a @p{SolverControl} and
+ *                                  // a @p{VectorMemory}
  * SolverControl control;
  * VectorMemory<Vector<double> > memory;
  *                                  // generate a solver
  * SolverCG<SparseMatrix<double>, Vector<double> > solver(control, memory);
- *                                  // generate a #PreconditionSelector#
+ *                                  // generate a @p{PreconditionSelector}
  * PreconditionSelector<SparseMatrix<double>, Vector<double> >
  *   preconditioning("jacobi", 1.);
  *                                  // give a matrix whose diagonal entries
  *                                  // Generally the matrix of the linear
  *                                  // equation system Ax=b.
  * preconditioning.use_matrix(A);
- *                                  // call the #solve# function with this
+ *                                  // call the @p{solve} function with this
  *                                  // preconditioning as last argument
  * solver.solve(A,x,b,preconditioning);
  * \end{verbatim}
- * The same example where also the #SolverSelector# class is used reads
+ * The same example where also the @p{SolverSelector} class is used reads
  * \begin{verbatim}
- *                                  // generate a #SolverControl# and
- *                                  // a #VectorMemory#
+ *                                  // generate a @p{SolverControl} and
+ *                                  // a @p{VectorMemory}
  * SolverControl control;
  * VectorMemory<Vector<double> > memory;
- *                                  // generate a #SolverSelector# that
- *                                  // calls the #SolverCG#
+ *                                  // generate a @p{SolverSelector} that
+ *                                  // calls the @p{SolverCG}
  * SolverSelector<SparseMatrix<double>, Vector<double> > 
  *   solver_selector("cg", control, memory);
- *                                  // generate a #PreconditionSelector#
+ *                                  // generate a @p{PreconditionSelector}
  * PreconditionSelector<SparseMatrix<double>, Vector<double> >
  *   preconditioning("jacobi", 1.);
  *
@@ -70,7 +70,7 @@
  *
  * solver_selector.solve(A,x,b,preconditioning);
  * \end{verbatim}
- * Now the use of the #SolverSelector# in combination with the #PreconditionSelector#
+ * Now the use of the @p{SolverSelector} in combination with the @p{PreconditionSelector}
  * allows the user to select both, the solver and the preconditioner, at the
  * beginning of his program and each time the
  * solver is started (that is several times e.g. in a nonlinear iteration) this
@@ -85,7 +85,7 @@ class PreconditionSelector
   public:
     
                                     /**
-                                     * Constructor. #omega# denotes
+                                     * Constructor. @p{omega} denotes
                                      * the damping parameter of
                                      * the preconditioning.
                                      */
@@ -100,8 +100,8 @@ class PreconditionSelector
                                     /**
                                      * Takes the matrix that is needed
                                      * for preconditionings that involves a
-                                     * matrix. e.g. for #precondition_jacobi#,
-                                     * #~_sor#, #~_ssor#.
+                                     * matrix. e.g. for @p{precondition_jacobi},
+                                     * @p{~_sor}, @p{~_ssor}.
                                      */
     void use_matrix(const Matrix &M);
 
@@ -136,7 +136,7 @@ class PreconditionSelector
                                     /**
                                      * Matrix that is used for the
                                      * matrix-builtin preconditioning function.
-                                     * cf. also #PreconditionUseMatrix#.
+                                     * cf. also @p{PreconditionUseMatrix}.
                                      */
     SmartPointer<const Matrix> A;
     
index cd90d8a030af1f2ac7bf11adc7410b807bcddcf7..a245f31b1f94b390fd0d4b9ef0d06e426368dfa7 100644 (file)
@@ -28,7 +28,7 @@ class SolverControl;
  * pool and the control object.
  *
  *
- * \subsection{Requirements for template classes}
+ * @sect3{Requirements for template classes}
  *
  * The class is templated to allow for different matrix and vector
  * classes, since iterative solvers do not rely on any special structure
@@ -98,15 +98,15 @@ class SolverControl;
  * \end{verbatim}
  *
  *
- * \subsection{AdditionalData}
+ * @sect3{AdditionalData}
  *
- * Several solvers need additional data, like the damping parameter #omega# of the
- * #SolverRichardson# class or the maximum number of temporary vectors of the #SolverGMRES#.
- * To have a standardized constructor for each solver class the #struct AdditionalData#
+ * Several solvers need additional data, like the damping parameter @p{omega} of the
+ * @p{SolverRichardson} class or the maximum number of temporary vectors of the @p{SolverGMRES}.
+ * To have a standardized constructor for each solver class the @p{struct AdditionalData}
  * has been introduced to each solver class. Some solvers need no additional data, like
- * #SolverCG# or #SolverBicgstab#. For these solvers the struct #AdditionalData# is empty
+ * @p{SolverCG} or @p{SolverBicgstab}. For these solvers the struct @p{AdditionalData} is empty
  * and calling the constructor may be done without giving the additional structure as
- * an argument as a default #AdditionalData# is set by default. 
+ * an argument as a default @p{AdditionalData} is set by default. 
  *
  * Now the generating of a solver looks like
  * \begin{verbatim}
@@ -123,10 +123,10 @@ class SolverControl;
  * \end{verbatim}
  *
  * Using a unified constructor parameter list for all solvers was introduced when the
- * #SolverSelector# class was written; the unified interface enabled us to use this
+ * @p{SolverSelector} class was written; the unified interface enabled us to use this
  * class unchanged even if the number of types of parameters to a certain solver
  * changes and it is still possible in a simple way to give these additional data to
- * the #SolverSelector# object for each solver which it may use.
+ * the @p{SolverSelector} object for each solver which it may use.
  *
  * @author Wolfgang Bangerth, Guido Kanschat, Ralf Hartmann, 1997, 1998, 1999
  */
index dd23b001f6ab416c50ae92039e204e77f96a3826..3c4dc60351800d9beb02d13e8cea2e96c3504e55 100644 (file)
  * Bicgstab algorithm by van der Vorst.
  *
  * Like all other solver classes, this class has a local structure called
- * #AdditionalData# which is used to pass additional parameters to the
+ * @p{AdditionalData} which is used to pass additional parameters to the
  * solver, like damping parameters or the number of temporary vectors. We
  * use this additional structure instead of passing these values directly
- * to the constructor because this makes the use of the #SolverSelector# and
+ * to the constructor because this makes the use of the @p{SolverSelector} and
  * other classes much easier and guarantees that these will continue to
  * work even if number or type of the additional parameters for a certain
  * solver changes.
index 0b2d344ce1d410e73e62f58665840b970cd7f682..f46afc73ed8d0ceef04f24e93dd53d291125d329 100644 (file)
  * Preconditioned cg method.
  *
  * Like all other solver classes, this class has a local structure called
- * #AdditionalData# which is used to pass additional parameters to the
+ * @p{AdditionalData} which is used to pass additional parameters to the
  * solver, like damping parameters or the number of temporary vectors. We
  * use this additional structure instead of passing these values directly
- * to the constructor because this makes the use of the #SolverSelector# and
+ * to the constructor because this makes the use of the @p{SolverSelector} and
  * other classes much easier and guarantees that these will continue to
  * work even if number or type of the additional parameters for a certain
  * solver changes.
@@ -102,7 +102,7 @@ class SolverCG : private Solver<VECTOR>
 
                                     /**
                                      * Temporary vectors, allocated through
-                                     * the #VectorMemory# object at the start
+                                     * the @p{VectorMemory} object at the start
                                      * of the actual solution process and
                                      * deallocated at the end.
                                      */
@@ -115,11 +115,11 @@ class SolverCG : private Solver<VECTOR>
                                      * Within the iteration loop, the
                                      * square of the residual vector is
                                      * stored in this variable. The
-                                     * function #criterion# uses this
+                                     * function @p{criterion} uses this
                                      * variable to compute the convergence
                                      * value, which in this class is the
                                      * norm of the residual vector and thus
-                                     * the square root of the #res2# value.
+                                     * the square root of the @p{res2} value.
                                      */
     double res2;
 };
index 7662cc2fac5afdab88f27f176736895f8dfbd1e2..e8ff1b7ac224d6ef46b8054a30ecdd2f22050478 100644 (file)
@@ -23,29 +23,29 @@ class ParameterHandler;
  *
  * Used by iterative methods to
  * determine whether the iteration should be continued. To this respect,
- * the virtual function #check()# is called in each iteration
+ * the virtual function @p{check()} is called in each iteration
  * with the current iteration
  * step and the value indicating convergence (usually the residual).
  *
- * After the iteration has terminated, the functions #last_value# and
- * #last_step# can be used to obtain information about the final state
+ * After the iteration has terminated, the functions @p{last_value} and
+ * @p{last_step} can be used to obtain information about the final state
  * of the iteration.
  *
- * #check()# can be replaced in derived classes to allow for more
+ * @p{check()} can be replaced in derived classes to allow for more
  * sophisticated tests.
  *
  *
- * \section{State}
- * The return states of the check function are of type #State#, which is an
+ * @sect2{State}
+ * The return states of the check function are of type @p{State}, which is an
  * enum local to this class. It indicates the state the
  * solver is in.
  *
  * The possible values of State are
  * \begin{itemize}
- * \item #iterate = 0#: continue the iteration.
- * \item #success#: the goal is reached, the iterative method can terminate
+ * \item @p{iterate = 0}: continue the iteration.
+ * \item @p{success}: the goal is reached, the iterative method can terminate
  *       successfully.
- * \item #failure#: the iterative method should stop because convergence 
+ * \item @p{failure}: the iterative method should stop because convergence 
  *       could not be achieved or at least was not achieved within the given
  *       maximal number of iterations.
  * \end{itemize}
@@ -55,7 +55,7 @@ class SolverControl : public Subscriptor
   public:
 
                                     /**
-                                     * #Enum# denoting the different
+                                     * @p{Enum} denoting the different
                                      * states a solver can be in. See
                                      * the general documentation of
                                      * this class for more
@@ -67,21 +67,21 @@ class SolverControl : public Subscriptor
     
                                     /**
                                      * Constructor. The parameters
-                                     * #n# and #tol# are the
+                                     * @p{n} and @p{tol} are the
                                      * maximum number of iteration
                                      * steps before failure and the
                                      * tolerance to determine success
                                      * of the iteration.
                                      *
-                                     * #log_history# specifies whether
+                                     * @p{log_history} specifies whether
                                      * the history (i.e. the value to
                                      * be checked and the number of
                                      * the iteration step) shall be
-                                     * printed to #deallog# stream.
+                                     * printed to @p{deallog} stream.
                                      * Default is: do not print. Similarly,
-                                     *  #log_result#
+                                     *  @p{log_result}
                                      * specifies the whether the final result is logged
-                                     * to #deallog#. Default is yes.
+                                     * to @p{deallog}. Default is yes.
                                      */
     SolverControl (const unsigned int n = 100,
                   const double tol = 1.e-10,
@@ -112,32 +112,32 @@ class SolverControl : public Subscriptor
                                      * to determine, whether the
                                      * allowed number of steps has
                                      * been exceeded and returns
-                                     * #failure# in this case. If
-                                     * #check_value# is below the
+                                     * @p{failure} in this case. If
+                                     * @p{check_value} is below the
                                      * prescribed tolerance, it
-                                     * returns #success#. In all
-                                     * other cases #iterate# is
+                                     * returns @p{success}. In all
+                                     * other cases @p{iterate} is
                                      * returned to suggest
                                      * continuation of the iterative
                                      * procedure.
                                      *
-                                     * #check()# additionally
-                                     * preserves #step# and
-                                     * #check_value#. These
+                                     * @p{check()} additionally
+                                     * preserves @p{step} and
+                                     * @p{check_value}. These
                                      * values are accessible by
-                                     * #last_value()# and
-                                     * #last_step()#.
+                                     * @p{last_value()} and
+                                     * @p{last_step()}.
                                      *
                                      * Derived classes may overload this
                                      * function, e.g. to log the convergence
-                                     * indicators (#check_value#) or to do
+                                     * indicators (@p{check_value}) or to do
                                      * other computations.
                                      */
     virtual State check (const unsigned int step, const double check_value);
 
                                     /**
                                      * Return the convergence value of last
-                                     * iteration step for which #check# was
+                                     * iteration step for which @p{check} was
                                      * called by the solver.
                                      */
     double last_value() const;
@@ -206,7 +206,7 @@ class SolverControl : public Subscriptor
     unsigned int       lstep;
 
                                     /**
-                                     * Log convergence history to #deallog#.
+                                     * Log convergence history to @p{deallog}.
                                      */
     bool         _log_history;
                                     /**
@@ -216,18 +216,18 @@ class SolverControl : public Subscriptor
     
                                     /**
                                      * Log iteration result to
-                                     * #deallog#.  If true, after
+                                     * @p{deallog}.  If true, after
                                      * finishing the iteration, a
                                      * statement about failure or
-                                     * success together with #lstep#
-                                     * and #lvalue# are logged.
+                                     * success together with @p{lstep}
+                                     * and @p{lvalue} are logged.
                                      */
     bool         _log_result;
 };
 
 
 /**
- * Specialization of #SolverControl# which returns #success# if either
+ * Specialization of @p{SolverControl} which returns @p{success} if either
  * the specified tolerance is achieved or if the initial residual (or
  * whatever criterion was chosen by the solver class) is reduced by a
  * given factor. This is useful in cases where you don't want to solve
@@ -275,7 +275,7 @@ class ReductionControl : public SolverControl
                                      * of an iteration.  This function
                                      * calls the one in the base
                                      * class, but sets the tolerance
-                                     * to #reduction * initial value#
+                                     * to @p{reduction * initial value}
                                      * upon the first iteration.
                                      */
     virtual State check (const unsigned int step,
index d264fdb8ad9f1f4956b9659771ee258dd73f488a..a05ea9620494cb32db3d02b40f06b08c01b368a9 100644 (file)
@@ -34,7 +34,7 @@
  * the number of iterations needed to solve the problem to the given
  * criterion, an intermediate solution is computed and a restart is
  * performed. If you don't want to use the restarted method, you can
- * limit the number of iterations (stated in the #SolverControl#
+ * limit the number of iterations (stated in the @p{SolverControl}
  * object given to the constructor) to be below the number of
  * temporary vectors minus three. Note the subtraction, which is due
  * to the fact that three vectors are used for other purposes, so the
  * possibilities is to use a good preconditioner.
  *
  * Like all other solver classes, this class has a local structure called
- * #AdditionalData# which is used to pass additional parameters to the
+ * @p{AdditionalData} which is used to pass additional parameters to the
  * solver, like damping parameters or the number of temporary vectors. We
  * use this additional structure instead of passing these values directly
- * to the constructor because this makes the use of the #SolverSelector# and
+ * to the constructor because this makes the use of the @p{SolverSelector} and
  * other classes much easier and guarantees that these will continue to
  * work even if number or type of the additional parameters for a certain
  * solver changes.
  *
- * For the GMRes method, the #AdditionalData# structure contains the number
+ * For the GMRes method, the @p{AdditionalData} structure contains the number
  * of temporary vectors as commented upon above. By default, the number
  * of these vectors is set to 30.
  *
@@ -298,7 +298,7 @@ unsigned int dim = 0;
                                       // many steps as there are temporary
                                       // vectors. the number of steps actually
                                       // been done is propagated outside
-                                      // through the #dim# variable
+                                      // through the @p{dim} variable
       for (unsigned int inner_iteration=0;
           ((inner_iteration < n_tmp_vectors-2)
            &&
index 100c05740c9db6e55e0e49c99ba53250e3929b7d..1119e34a339f22af7dccdaf0bb08bbe96a3aa86f 100644 (file)
  * Preconditioned MinRes method.
  *
  * Like all other solver classes, this class has a local structure called
- * #AdditionalData# which is used to pass additional parameters to the
+ * @p{AdditionalData} which is used to pass additional parameters to the
  * solver, like damping parameters or the number of temporary vectors. We
  * use this additional structure instead of passing these values directly
- * to the constructor because this makes the use of the #SolverSelector# and
+ * to the constructor because this makes the use of the @p{SolverSelector} and
  * other classes much easier and guarantees that these will continue to
  * work even if number or type of the additional parameters for a certain
  * solver changes.
@@ -43,7 +43,7 @@
  * The algorithm is taken from the Master thesis of Astrid Batterman
  * with some changes.
  * The full text can be found at
- * #http://scholar.lib.vt.edu/theses/public/etd-12164379662151/etd-title.html#
+ * @p{http://scholar.lib.vt.edu/theses/public/etd-12164379662151/etd-title.html}
  *
  * @author Thomas Richter, 2000
  */
@@ -109,7 +109,7 @@ class SolverMinRes : private Solver<VECTOR>
 
                                     /**
                                      * Temporary vectors, allocated through
-                                     * the #VectorMemory# object at the start
+                                     * the @p{VectorMemory} object at the start
                                      * of the actual solution process and
                                      * deallocated at the end.
                                      */
@@ -121,11 +121,11 @@ class SolverMinRes : private Solver<VECTOR>
                                      * Within the iteration loop, the
                                      * square of the residual vector is
                                      * stored in this variable. The
-                                     * function #criterion# uses this
+                                     * function @p{criterion} uses this
                                      * variable to compute the convergence
                                      * value, which in this class is the
                                      * norm of the residual vector and thus
-                                     * the square root of the #res2# value.
+                                     * the square root of the @p{res2} value.
                                      */
     double res2;
 };
index 31946803a8218a6176432dfe1d61cb4c79e59fd0..2a8d273aeaec319fb8089cc9b754ebe6d16c2f43 100644 (file)
  * inverse.
  *
  * Like all other solver classes, this class has a local structure called
- * #AdditionalData# which is used to pass additional parameters to the
+ * @p{AdditionalData} which is used to pass additional parameters to the
  * solver, like damping parameters or the number of temporary vectors. We
  * use this additional structure instead of passing these values directly
- * to the constructor because this makes the use of the #SolverSelector# and
+ * to the constructor because this makes the use of the @p{SolverSelector} and
  * other classes much easier and guarantees that these will continue to
  * work even if number or type of the additional parameters for a certain
  * solver changes.
@@ -60,7 +60,7 @@ class SolverQMRS : private Solver<VECTOR>
                                      *
                                      * There are two possibilities to compute
                                      * the residual: one is an estimate using
-                                     * the computed value #tau#. The other
+                                     * the computed value @p{tau}. The other
                                      * is exact computation using another matrix
                                      * vector multiplication.
                                      *
@@ -131,7 +131,7 @@ class SolverQMRS : private Solver<VECTOR>
     
                                     /**
                                      * Temporary vectors, allocated through
-                                     * the #VectorMemory# object at the start
+                                     * the @p{VectorMemory} object at the start
                                      * of the actual solution process and
                                      * deallocated at the end.
                                      */
@@ -153,11 +153,11 @@ class SolverQMRS : private Solver<VECTOR>
                                      * Within the iteration loop, the
                                      * square of the residual vector is
                                      * stored in this variable. The
-                                     * function #criterion# uses this
+                                     * function @p{criterion} uses this
                                      * variable to compute the convergence
                                      * value, which in this class is the
                                      * norm of the residual vector and thus
-                                     * the square root of the #res2# value.
+                                     * the square root of the @p{res2} value.
                                      */
     double res2;
                                     /**
index fc6ad64a472cb77ebe34dc449fbbf3dafc19cd58..6aa55bc75547bb872e7e87c0e4e45656fa592bc8 100644 (file)
  * is the norm of the residual.
  *
  * Like all other solver classes, this class has a local structure called
- * #AdditionalData# which is used to pass additional parameters to the
+ * @p{AdditionalData} which is used to pass additional parameters to the
  * solver, like damping parameters or the number of temporary vectors. We
  * use this additional structure instead of passing these values directly
- * to the constructor because this makes the use of the #SolverSelector# and
+ * to the constructor because this makes the use of the @p{SolverSelector} and
  * other classes much easier and guarantees that these will continue to
  * work even if number or type of the additional parameters for a certain
  * solver changes.
  *
  * For the Richardson method, the additional data is the damping parameter,
- * which is the only content of the #AdditionalData# structure. By default,
+ * which is the only content of the @p{AdditionalData} structure. By default,
  * the constructor of the structure sets it to one.
  *
  * @author Ralf Hartmann
@@ -108,7 +108,7 @@ class SolverRichardson : private Solver<VECTOR>
     
                                     /**
                                      * Temporary vectors, allocated through
-                                     * the #VectorMemory# object at the start
+                                     * the @p{VectorMemory} object at the start
                                      * of the actual solution process and
                                      * deallocated at the end.
                                      */
@@ -124,11 +124,11 @@ class SolverRichardson : private Solver<VECTOR>
                                      * Within the iteration loop, the
                                      * norm of the residual is
                                      * stored in this variable. The
-                                     * function #criterion# uses this
+                                     * function @p{criterion} uses this
                                      * variable to compute the convergence
                                      * value, which in this class is the
                                      * norm of the residual vector and thus
-                                     * the square root of the #res2# value.
+                                     * the square root of the @p{res2} value.
                                      */
     double res;
 };
index 2c1aa5087b27307e3f776448b320685bd4d5c3f5..b80618209b19d4af848e05f283a68aebf61a7b98 100644 (file)
 
 
 /**
- * By calling the #solve# function of this #SolverSelector#, it selects
- * the #solve# function of that #Solver# that was specified in the constructor
+ * By calling the @p{solve} function of this @p{SolverSelector}, it selects
+ * the @p{solve} function of that @p{Solver} that was specified in the constructor
  * of this class.
  *
- * \subsection{Usage}
+ * @sect3{Usage}
  * The simplest use of this class is the following:
  * \begin{verbatim}
- *                                  // generate a #SolverControl# and
- *                                  // a #VectorMemory#
+ *                                  // generate a @p{SolverControl} and
+ *                                  // a @p{VectorMemory}
  * SolverControl control;
  * VectorMemory<Vector<double> > memory;
  *                                  // Line 3:
  *                                  //
- *                                  // generate a #SolverSelector# that
- *                                  // calls the #SolverCG#
+ *                                  // generate a @p{SolverSelector} that
+ *                                  // calls the @p{SolverCG}
  * SolverSelector<SparseMatrix<double>, Vector<double> > 
  *   solver_selector("cg", control, memory);
- *                                  // generate e.g. a #PreconditionRelaxation#
+ *                                  // generate e.g. a @p{PreconditionRelaxation}
  * PreconditionRelaxation<SparseMatrix<double>, Vector<double> >
  *   preconditioning(A, &SparseMatrix<double>
  *                   ::template precondition_SSOR<double>,0.8);
- *                                  // call the #solve# function with this
+ *                                  // call the @p{solve} function with this
  *                                  // preconditioning as last argument
  * solver_selector.solve(A,x,b,preconditioning);
  * \end{verbatim}
- * But the full usefulness of the #SolverSelector# class is not clear
- * until the presentation of the following
- * example that assumes the user using the #ParameterHandler# class and having
- * declared a "solver" entry, e.g. with
+ * But the full usefulness of the @p{SolverSelector} class is not
+ * clear until the presentation of the following example that assumes
+ * the user using the @p{ParameterHandler} class and having declared a
+ * "solver" entry, e.g. with
  * \begin{verbatim}
  * Parameter_Handler prm;
  * prm.declare_entry ("solver", "none",
  *
  *
  * If at some time there exists a new solver "xyz" then the user does not need
- * to change his program. Only in the implementation of the #SolverSelector#
+ * to change his program. Only in the implementation of the @p{SolverSelector}
  * the calling of this solver has to be added and each user with program lines
  * quoted above only needs to 'set solver = xyz' in his parameter file to get
  * access to that new solver.  :-)
  *
- * (By the way, thanks to Wolfgang for implementing the #ParameterHandler#.)
+ * (By the way, thanks to Wolfgang for implementing the @p{ParameterHandler}.)
  * 
  * @author Ralf Hartmann, 1999
  */
@@ -90,9 +90,9 @@ class SolverSelector
   public:
 
                                     /**
-                                     * Constructor. Takes the #SolverName#,
-                                     * the #SolverControl# and the 
-                                     * #VectorMemory# as argument.
+                                     * Constructor. Takes the @p{SolverName},
+                                     * the @p{SolverControl} and the 
+                                     * @p{VectorMemory} as argument.
                                      */
     SolverSelector(const string solvername,
                   SolverControl &control,
@@ -104,9 +104,9 @@ class SolverSelector
     ~SolverSelector();
 
                                     /**
-                                     * Solver procedure. Calls the #solve#
+                                     * Solver procedure. Calls the @p{solve}
                                      * function
-                                     * of the #solver# whose #SolverName#
+                                     * of the @p{solver} whose @p{SolverName}
                                      * was specified in the constructor.
                                      * 
                                      */
@@ -118,28 +118,28 @@ class SolverSelector
     
                                     /**
                                      * Set the additional data. For more
-                                     * info see the #Solver# class.
+                                     * info see the @p{Solver} class.
                                      */
     void set_data(const typename SolverRichardson<Vector>
                  ::AdditionalData &data);
 
                                     /**
                                      * Set the additional data. For more
-                                     * info see the #Solver# class.
+                                     * info see the @p{Solver} class.
                                      */
     void set_data(const typename SolverCG<Vector>
                  ::AdditionalData &data);
 
                                     /**
                                      * Set the additional data. For more
-                                     * info see the #Solver# class.
+                                     * info see the @p{Solver} class.
                                      */
     void set_data(const typename SolverBicgstab<Vector>
                  ::AdditionalData &data); 
 
                                     /**
                                      * Set the additional data. For more
-                                     * info see the #Solver# class.
+                                     * info see the @p{Solver} class.
                                      */
     void set_data(const typename SolverGMRES<Vector>
                  ::AdditionalData &data);
@@ -164,16 +164,16 @@ class SolverSelector
     string solver_name;
     
                                     /**
-                                     * Stores the #SolverControl# that
+                                     * Stores the @p{SolverControl} that
                                      * is needed in the constructor of
-                                     * each #Solver# class.
+                                     * each @p{Solver} class.
                                      */
     SmartPointer<SolverControl> control;
 
                                     /**
-                                     * Stores the #VectorMemory# that
+                                     * Stores the @p{VectorMemory} that
                                      * is needed in the constructor of
-                                     * each #Solver# class.
+                                     * each @p{Solver} class.
                                      */
     SmartPointer<VectorMemory<Vector> > vector_memory;
 
index 2dae4fe8237258844bb6147483887aa67dd46051..e2631e9e29422d887e8d8ae303b31f287d86a459 100644 (file)
@@ -24,8 +24,8 @@
  * in the decomposition that do not fit into the sparsity structure of this
  * object are discarded.
  *
- * The algorithm used by this class is as follows (indices run from #0#
- * to #N-1#):
+ * The algorithm used by this class is as follows (indices run from @p{0}
+ * to @p{N-1}):
  * \begin{verbatim}
  * copy original matrix into a[i,j]
  * 
  * \end{verbatim}
  * Using this algorithm, we store the decomposition as a sparse matrix, for
  * which the user has to give a sparsity pattern and which is why this
- * class is derived from the #SparseMatrix#. Since it is not a matrix in
- * the usual sense, the derivation is #protected# rather than #public#.
+ * class is derived from the @p{SparseMatrix}. Since it is not a matrix in
+ * the usual sense, the derivation is @p{protected} rather than @p{public}.
  *
  * Note that in the algorithm given, the lower left part of the matrix base
- * class is used to store the #L# part of the decomposition, while 
- * the upper right part is used to store #U#. The diagonal is used to
+ * class is used to store the @p{L} part of the decomposition, while 
+ * the upper right part is used to store @p{U}. The diagonal is used to
  * store the inverses of the diagonal elements of the decomposition; the
  * latter makes the application of the decomposition faster, since inversion
  * by the diagonal element has to be done only once, rather than at each
  * application (multiplication is much faster than division).
  *
  *
- * \subsection{Fill-in}
+ * @sect3{Fill-in}
  *
  * The sparse ILU is frequently used with additional fill-in, i.e. the
  * sparsity structure of the decomposition is denser than that of the matrix
- * to be decomposed. The #decompose# function of this class allows this fill-in
+ * to be decomposed. The @p{decompose} function of this class allows this fill-in
  * as long as all entries present in the original matrix are present in the
  * decomposition also, i.e. the sparsity pattern of the decomposition is a
  * superset of the sparsity pattern in the original matrix.
  *
  * Such fill-in can be accomplished by various ways, one of which is a
- * copy-constructor of the #SparsityPattern# class which allows the addition
+ * copy-constructor of the @p{SparsityPattern} class which allows the addition
  * of side-diagonals to a given sparsity structure.
  *
  *
- * \subsection{Use as a preconditioner}
+ * @sect3{Use as a preconditioner}
  *
  * If you want to use an object of this class as a preconditioner for another
  * matrix, you can do so by calling the solver function using the following
- * sequence, for example (#ilu_sparsity# is some sparsity pattern to be used
+ * sequence, for example (@p{ilu_sparsity} is some sparsity pattern to be used
  * for the decomposition, which you have to create beforehand):
  * \begin{verbatim}
  *   SparseILU<double> ilu (ilu_sparsity);
@@ -83,7 +83,7 @@
  * \end{verbatim}
  *
  *
- * \section{On template instantiations}
+ * @sect2{On template instantiations}
  *
  * Member functions of this class are either implemented in this file
  * or in a file of the same name with suffix ``.templates.h''. For the
@@ -113,7 +113,7 @@ class SparseILU : protected SparseMatrix<number>
                                      *
                                      * You have to initialize
                                      * the matrix before usage with
-                                     * #reinit(SparsityPattern)#.
+                                     * @p{reinit(SparsityPattern)}.
                                      */
     SparseILU ();
 
@@ -122,12 +122,12 @@ class SparseILU : protected SparseMatrix<number>
                                      * sparsity structure to represent the
                                      * sparsity pattern of this decomposition.
                                      * You can change the sparsity pattern later
-                                     * on by calling the #reinit# function.
+                                     * on by calling the @p{reinit} function.
                                      *
                                      * You have to make sure that the lifetime
                                      * of the sparsity structure is at least
                                      * as long as that of this object or as
-                                     * long as #reinit# is not called with a
+                                     * long as @p{reinit} is not called with a
                                      * new sparsity structure.
                                      */
     SparseILU (const SparsityPattern &sparsity);
@@ -135,7 +135,7 @@ class SparseILU : protected SparseMatrix<number>
                                     /**
                                      * Reinitialize the object but keep to
                                      * the sparsity pattern previously used.
-                                     * This may be necessary if you #reinit#'d
+                                     * This may be necessary if you @p{reinit}'d
                                      * the sparsity structure and want to
                                      * update the size of the matrix.
                                      *
@@ -189,7 +189,7 @@ class SparseILU : protected SparseMatrix<number>
                              const Vector<somenumber> &src) const;
 
                                     /**
-                                     * Same as #apply_decomposition#, format for LAC.
+                                     * Same as @p{apply_decomposition}, format for LAC.
                                      */
     template <typename somenumber>
     void vmult (Vector<somenumber>       &dst,
index 0ee8eaa3a9e5cc56c4b75f929780b91e4491443c..15a1f059f9032bbea542b9c4d937319a217dfba0 100644 (file)
@@ -64,10 +64,10 @@ void SparseILU<number>::decompose (const SparseMatrix<somenumber> &matrix,
 
 
                                   // first thing: copy over all elements
-                                  // of #matrix# to the present object
+                                  // of @p{matrix} to the present object
                                   //
                                   // note that some elements in this
-                                  // matrix may not be in #matrix#,
+                                  // matrix may not be in @p{matrix},
                                   // so we need to preset our matrix
                                   // by zeroes.
   if (true)
index 4f8904cede615621132cbf0ddad32bad1bbac378..7c8f1e4c31dd734d10e9d303c30790dd0fa1bf00 100644 (file)
@@ -28,7 +28,7 @@ template<typename number> class Vector;
  * Sparse matrix.
  *
  *
- * \section{On template instantiations}
+ * @sect2{On template instantiations}
  *
  * Member functions of this class are either implemented in this file
  * or in a file of the same name with suffix ``.templates.h''. For the
@@ -64,7 +64,7 @@ class SparseMatrix : public Subscriptor
                                      *
                                      * You have to initialize
                                      * the matrix before usage with
-                                     * #reinit(SparsityPattern)#.
+                                     * @p{reinit(SparsityPattern)}.
                                      */
     SparseMatrix ();
 
@@ -73,12 +73,12 @@ class SparseMatrix : public Subscriptor
                                      * only allowed to be called if the matrix
                                      * to be copied is empty. This is for the
                                      * same reason as for the
-                                     * #SparsityPattern#, see there for the
+                                     * @p{SparsityPattern}, see there for the
                                      * details.
                                      *
                                      * If you really want to copy a whole
                                      * matrix, you can do so by using the
-                                     * #copy_from# function.
+                                     * @p{copy_from} function.
                                      */
     SparseMatrix (const SparseMatrix &);
 
@@ -87,12 +87,12 @@ class SparseMatrix : public Subscriptor
                                      * sparsity structure to represent the
                                      * sparsity pattern of this matrix. You
                                      * can change the sparsity pattern later
-                                     * on by calling the #reinit# function.
+                                     * on by calling the @p{reinit} function.
                                      *
                                      * You have to make sure that the lifetime
                                      * of the sparsity structure is at least
                                      * as long as that of this matrix or as
-                                     * long as #reinit# is not called with a
+                                     * long as @p{reinit} is not called with a
                                      * new sparsity structure.
                                      */
     SparseMatrix (const SparsityPattern &sparsity);
@@ -114,7 +114,7 @@ class SparseMatrix : public Subscriptor
                                      * Reinitialize the object but
                                      * keep to the sparsity pattern
                                      * previously used.  This may be
-                                     * necessary if you #reinit#'d
+                                     * necessary if you @p{reinit}'d
                                      * the sparsity structure and
                                      * want to update the size of the
                                      * matrix.
@@ -153,7 +153,7 @@ class SparseMatrix : public Subscriptor
                                      * lifetime of the sparsity
                                      * structure is at least as long
                                      * as that of this matrix or as
-                                     * long as #reinit# is not called
+                                     * long as @p{reinit} is not called
                                      * with a new sparsity structure.
                                      *
                                      * The elements of the matrix are
@@ -175,7 +175,7 @@ class SparseMatrix : public Subscriptor
                                      * Return whether the object is
                                      * empty. It is empty if either
                                      * both dimensions are zero or no
-                                     * #SparsityPattern# is
+                                     * @p{SparsityPattern} is
                                      * associated.
                                      */
     bool empty () const;
@@ -209,7 +209,7 @@ class SparseMatrix : public Subscriptor
     unsigned int n_nonzero_elements () const;
     
                                     /**
-                                     * Set the element #(i,j)# to #value#.
+                                     * Set the element @p{(i,j)} to @p{value}.
                                      * Throws an error if the entry does
                                      * not exist. Still, it is allowed to store
                                      * zero values in non-existent fields.
@@ -218,8 +218,8 @@ class SparseMatrix : public Subscriptor
              const number value);
     
                                     /**
-                                     * Add #value# to the element
-                                     * #(i,j)#.  Throws an error if
+                                     * Add @p{value} to the element
+                                     * @p{(i,j)}.  Throws an error if
                                      * the entry does not
                                      * exist. Still, it is allowed to
                                      * store zero values in
@@ -239,7 +239,7 @@ class SparseMatrix : public Subscriptor
                                      * cheaper. Since this operation
                                      * is notheless not for free, we
                                      * do not make it available
-                                     * through #operator =#, since
+                                     * through @p{operator =}, since
                                      * this may lead to unwanted
                                      * usage, e.g. in copy arguments
                                      * to functions, which should
@@ -252,15 +252,15 @@ class SparseMatrix : public Subscriptor
                                      * data type of this matrix.
                                      *
                                      * The function returns a reference to
-                                     * #this#.
+                                     * @p{this}.
                                      */
     template <typename somenumber>
     SparseMatrix<number> &
     copy_from (const SparseMatrix<somenumber> &source);
 
                                     /**
-                                     * Add #matrix# scaled by
-                                     * #factor# to this matrix. The
+                                     * Add @p{matrix} scaled by
+                                     * @p{factor} to this matrix. The
                                      * function throws an error if
                                      * the sparsity patterns of the
                                      * two involved matrices do not
@@ -292,7 +292,7 @@ class SparseMatrix : public Subscriptor
                                      * that returns zero instead (for
                                      * entries that are not in the
                                      * sparsity pattern of the
-                                     * matrix), use the #el#
+                                     * matrix), use the @p{el}
                                      * function.
                                      */
     number operator () (const unsigned int i,
@@ -300,9 +300,9 @@ class SparseMatrix : public Subscriptor
 
                                     /**
                                      * This function is mostly like
-                                     * #operator()# in that it
+                                     * @p{operator()} in that it
                                      * returns the value of the
-                                     * matrix entry #(i,j)#. The only
+                                     * matrix entry @p{(i,j)}. The only
                                      * difference is that if this
                                      * entry does not exist in the
                                      * sparsity pattern, then instead
@@ -320,11 +320,11 @@ class SparseMatrix : public Subscriptor
 
                                     /**
                                      * Return the main diagonal element in
-                                     * the #i#th row. This function throws an
+                                     * the @p{i}th row. This function throws an
                                      * error if the matrix is not square.
                                      *
                                      * This function is considerably
-                                     * faster than the #operator()#,
+                                     * faster than the @p{operator()},
                                      * since for square matrices, the
                                      * diagonal entry is always the
                                      * first to be stored in each row
@@ -344,8 +344,8 @@ class SparseMatrix : public Subscriptor
                                     /**
                                      * Access to values in internal
                                      * mode.  Returns the value of
-                                     * the #index#th entry in
-                                     * #row#. Here, #index# refers to
+                                     * the @p{index}th entry in
+                                     * @p{row}. Here, @p{index} refers to
                                      * the internal representation of
                                      * the matrix, not the column. Be
                                      * sure to understand what you are
@@ -355,10 +355,10 @@ class SparseMatrix : public Subscriptor
     
                                     /**
                                      * This is for hackers. Get
-                                     * access to the #i#th element of
+                                     * access to the @p{i}th element of
                                      * this matrix. The elements are
                                      * stored in a consecutive way,
-                                     * refer to the #SparsityPattern#
+                                     * refer to the @p{SparsityPattern}
                                      * class for more details.
                                      *
                                      * You should use this interface
@@ -395,7 +395,7 @@ class SparseMatrix : public Subscriptor
                                      * let $dst = M^T*src$ with $M$
                                      * being this matrix. This
                                      * function does the same as
-                                     * #vmult# but takes the
+                                     * @p{vmult} but takes the
                                      * transposed matrix.
                                      */
     template <typename somenumber>
@@ -415,7 +415,7 @@ class SparseMatrix : public Subscriptor
                                      * multiplication. Add $M^T*src$
                                      * to $dst$ with $M$ being this
                                      * matrix. This function does the
-                                     * same as #vmult_add# but takes
+                                     * same as @p{vmult_add} but takes
                                      * the transposed matrix.
                                      */
     template <typename somenumber>
@@ -479,13 +479,13 @@ class SparseMatrix : public Subscriptor
 
                                     /**
                                      * Compute the residual of an
-                                     * equation #Ax=b#, where the
+                                     * equation @p{Ax=b}, where the
                                      * residual is defined to be
-                                     * #r=b-Ax# with #x# typically
+                                     * @p{r=b-Ax} with @p{x} typically
                                      * being an approximate of the
                                      * true solution of the
                                      * equation. Write the residual
-                                     * into #dst#.
+                                     * into @p{dst}.
                                      */
     template <typename somenumber>
     somenumber residual (Vector<somenumber>       &dst,
@@ -496,11 +496,11 @@ class SparseMatrix : public Subscriptor
                                      * Apply the Jacobi
                                      * preconditioner, which
                                      * multiplies every element of
-                                     * the #src# vector by the
+                                     * the @p{src} vector by the
                                      * inverse of the respective
                                      * diagonal element and
                                      * multiplies the result with the
-                                     * damping factor #omega#.
+                                     * damping factor @p{omega}.
                                      */
     template <typename somenumber>
     void precondition_Jacobi (Vector<somenumber>       &dst,
@@ -509,7 +509,7 @@ class SparseMatrix : public Subscriptor
 
                                     /**
                                      * Apply SOR preconditioning to
-                                     * #src#.
+                                     * @p{src}.
                                      */
     template <typename somenumber>
     void precondition_SSOR (Vector<somenumber>       &dst,
@@ -517,7 +517,7 @@ class SparseMatrix : public Subscriptor
                            const number              om = 1.) const;
 
                                     /**
-                                     * Apply SOR preconditioning matrix to #src#.
+                                     * Apply SOR preconditioning matrix to @p{src}.
                                      * The result of this method is
                                      * $dst = (om D - L)^{-1} src$.
                                      */
@@ -531,7 +531,7 @@ class SparseMatrix : public Subscriptor
                                      * in-place.  Apply the
                                      * preconditioner matrix without
                                      * copying to a second vector.
-                                     * #omega# is the relaxation
+                                     * @p{omega} is the relaxation
                                      * parameter.
                                      */
     template <typename somenumber>
@@ -541,16 +541,16 @@ class SparseMatrix : public Subscriptor
                                     /**
                                      * Perform an SOR preconditioning in-place.
                                      * The result is $v = (\omega D - L)^{-1} v$.
-                                     * #omega# is the damping parameter.
+                                     * @p{omega} is the damping parameter.
                                      */
     template <typename somenumber>
     void SOR (Vector<somenumber> &v,
              const number        om = 1.) const;
 
                                     /**
-                                     * Do one SOR step on #v#.
+                                     * Do one SOR step on @p{v}.
                                      * Performs a direct SOR step
-                                     * with right hand side #b#.
+                                     * with right hand side @p{b}.
                                      */
     template <typename somenumber>
     void SOR_step (Vector<somenumber> &v,
@@ -559,8 +559,8 @@ class SparseMatrix : public Subscriptor
 
                                     /**
                                      * Do one adjoint SOR step on
-                                     * #v#.  Performs a direct TSOR
-                                     * step with right hand side #b#.
+                                     * @p{v}.  Performs a direct TSOR
+                                     * step with right hand side @p{b}.
                                      */
     template <typename somenumber>
     void TSOR_step (Vector<somenumber> &v,
@@ -569,8 +569,8 @@ class SparseMatrix : public Subscriptor
 
                                     /**
                                      * Do one adjoint SSOR step on
-                                     * #v#.  Performs a direct SSOR
-                                     * step with right hand side #b#
+                                     * @p{v}.  Performs a direct SSOR
+                                     * step with right hand side @p{b}
                                      * by performing TSOR after SOR.
                                      */
     template <typename somenumber>
@@ -584,7 +584,7 @@ class SparseMatrix : public Subscriptor
                                      * pattern of this matrix.
                                      *
                                      * Though the return value is
-                                     * declared #const#, you should
+                                     * declared @p{const}, you should
                                      * be aware that it may change if
                                      * you call any nonconstant
                                      * function of objects which
@@ -595,7 +595,7 @@ class SparseMatrix : public Subscriptor
                                     /**
                                      * Print the matrix to the given
                                      * stream, using the format
-                                     * #(line,col) value#, i.e. one
+                                     * @p{(line,col) value}, i.e. one
                                      * nonzero entry of the matrix
                                      * per line.
                                      */
@@ -615,12 +615,12 @@ class SparseMatrix : public Subscriptor
                                      *
                                      * The parameters allow for a
                                      * flexible setting of the output
-                                     * format: #precision# and
-                                     * #scientific# are used to
+                                     * format: @p{precision} and
+                                     * @p{scientific} are used to
                                      * determine the number format,
-                                     * where #scientific# = #false#
+                                     * where @p{scientific} = @p{false}
                                      * means fixed point notation.  A
-                                     * zero entry for #width# makes
+                                     * zero entry for @p{width} makes
                                      * the function compute a width,
                                      * but it may be changed to a
                                      * positive value, if output is
@@ -700,7 +700,7 @@ class SparseMatrix : public Subscriptor
                                      * matrix. In order to guarantee
                                      * that it is not deleted while
                                      * still in use, we subscribe to
-                                     * it using the #SmartPointer#
+                                     * it using the @p{SmartPointer}
                                      * class.
                                      */
     SmartPointer<const SparsityPattern> cols;
@@ -720,7 +720,7 @@ class SparseMatrix : public Subscriptor
     number *val;
 
                                     /**
-                                     * Allocated size of #val#. This
+                                     * Allocated size of @p{val}. This
                                      * can be larger than the
                                      * actually used part if the size
                                      * of the matrix was reduced
@@ -728,16 +728,16 @@ class SparseMatrix : public Subscriptor
                                      * associating a sparsity pattern
                                      * with a smaller size to this
                                      * object somewhen, using the
-                                     * #reinit# function.
+                                     * @p{reinit} function.
                                      */
     unsigned int max_len;
 
                                     /**
-                                     * Version of #vmult# which only
+                                     * Version of @p{vmult} which only
                                      * performs its actions on the
                                      * region defined by
-                                     * #[begin_row,end_row)#. This
-                                     * function is called by #vmult#
+                                     * @p{[begin_row,end_row)}. This
+                                     * function is called by @p{vmult}
                                      * in the case of enabled
                                      * multithreading.
                                      */
@@ -749,12 +749,12 @@ class SparseMatrix : public Subscriptor
 
                                     /**
                                      * Version of
-                                     * #matrix_norm_square# which
+                                     * @p{matrix_norm_square} which
                                      * only performs its actions on
                                      * the region defined by
-                                     * #[begin_row,end_row)#. This
+                                     * @p{[begin_row,end_row)}. This
                                      * function is called by
-                                     * #matrix_norm_square# in the
+                                     * @p{matrix_norm_square} in the
                                      * case of enabled
                                      * multithreading.
                                      */
@@ -766,12 +766,12 @@ class SparseMatrix : public Subscriptor
 
                                     /**
                                      * Version of
-                                     * #matrix_scalar_product# which
+                                     * @p{matrix_scalar_product} which
                                      * only performs its actions on
                                      * the region defined by
-                                     * #[begin_row,end_row)#. This
+                                     * @p{[begin_row,end_row)}. This
                                      * function is called by
-                                     * #matrix_scalar_product# in the
+                                     * @p{matrix_scalar_product} in the
                                      * case of enabled
                                      * multithreading.
                                      */
@@ -783,13 +783,13 @@ class SparseMatrix : public Subscriptor
                                         somenumber               *partial_sum) const;
 
                                     /**
-                                     * Version of #residual# which
+                                     * Version of @p{residual} which
                                      * only performs its actions on
                                      * the region defined by
-                                     * #[begin_row,end_row)# (these
+                                     * @p{[begin_row,end_row)} (these
                                      * numbers are the components of
-                                     * #interval#). This function is
-                                     * called by #residual# in the
+                                     * @p{interval}). This function is
+                                     * called by @p{residual} in the
                                      * case of enabled
                                      * multithreading.
                                      */
index bffe5898ac123960ae0ea9253618c2c4345c90ed..533687942a70b3090fcfc1345b8c941f5b7c734f 100644 (file)
@@ -51,9 +51,9 @@ template <typename number> class Vector;
  * For each selected degree of freedom, a local system of equations is built
  * by the degree of freedom itself and all other values coupling immediately,
  * i.e. the set of degrees of freedom considered for the local system of
- * equations for degree of freedom #i# is #i# itself and all #j# such that
- * the element #(i,j)# is a nonzero entry in the sparse matrix under 
- * consideration. The elements #(j,i)# are not considered. We now pick all
+ * equations for degree of freedom @p{i} is @p{i} itself and all @p{j} such that
+ * the element @p{(i,j)} is a nonzero entry in the sparse matrix under 
+ * consideration. The elements @p{(j,i)} are not considered. We now pick all
  * matrix entries from rows and columns out of the set of degrees of freedom
  * 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
@@ -78,7 +78,7 @@ template <typename number> class Vector;
  * Remark: the Vanka method is a non-symmetric preconditioning method.
  *
  *
- * \subsection{Example of Use}
+ * @sect3{Example of Use}
  * This little example is taken from a program doing parameter optimization.
  * The Lagrange multiplier is the third component of the finite element
  * used. The system is solved by the GMRES method.
@@ -105,7 +105,7 @@ template <typename number> class Vector;
  * \end{verbatim}
  *
  *
- * \subsubsection{Implementor's remark}
+ * @sect4{Implementor's remark}
  * At present, the local matrices are built up such that the degree of freedom
  * associated with the local Lagrange multiplier is the first one. Thus, usually
  * the upper left entry in the local matrix is zero. It is not clear to me (W.B.)
@@ -113,7 +113,7 @@ template <typename number> class Vector;
  * Maybe someone would like to check this.
  *
  *
- * \section{On template instantiations}
+ * @sect2{On template instantiations}
  *
  * Member functions of this class are either implemented in this file
  * or in a file of the same name with suffix ``.templates.h''. For the
@@ -133,7 +133,7 @@ class SparseVanka
                                     /**
                                      * Constructor. Gets the matrix
                                      * for preconditioning and a bit
-                                     * vector with entries #true# for
+                                     * vector with entries @p{true} for
                                      * all rows to be updated. A
                                      * reference to this vector will
                                      * be stored, so it must persist
@@ -141,7 +141,7 @@ class SparseVanka
                                      * object. The same is true for
                                      * the matrix.
                                      *
-                                     * The matrix #M# which is passed
+                                     * The matrix @p{M} which is passed
                                      * here may or may not be the
                                      * same matrix for which this
                                      * object shall act as
@@ -154,27 +154,27 @@ class SparseVanka
                                      * where the matrix changes in
                                      * each step slightly.
                                      *
-                                     * If #conserve_mem# is #false#,
+                                     * If @p{conserve_mem} is @p{false},
                                      * then the inverses of the local
                                      * systems are computed now, if
-                                     * the flag is #true#, then they
+                                     * the flag is @p{true}, then they
                                      * are computed every time the
                                      * preconditioner is
                                      * applied. This saves some
                                      * memory, but makes
                                      * preconditioning very
                                      * slow. Note also, that if the
-                                     * flag is #false#, the the
-                                     * contents of the matrix #M# at
+                                     * flag is @p{false}, the the
+                                     * contents of the matrix @p{M} at
                                      * the time of calling this
                                      * constructor are used, while if
-                                     * the flag is #true#, then the
-                                     * values in #M# at the time of
+                                     * the flag is @p{true}, then the
+                                     * values in @p{M} at the time of
                                      * preconditioning are used. This
                                      * may lead to different results,
-                                     * obviously, of #M# changes.
+                                     * obviously, of @p{M} changes.
                                      *
-                                     * The parameter #n_threads#
+                                     * The parameter @p{n_threads}
                                      * determines how many threads
                                      * shall be used in parallel when
                                      * building the inverses of the
@@ -183,7 +183,7 @@ class SparseVanka
                                      * multithreaded mode. By
                                      * default, this variable is set
                                      * to the value of
-                                     * #multithread_info.n_default_threads#.
+                                     * @p{multithread_info.n_default_threads}.
                                      */
     SparseVanka(const SparseMatrix<number> &M,
                const vector<bool>         &selected,
@@ -199,8 +199,8 @@ class SparseVanka
                                     /**
                                      * Do the preconditioning.
                                      * This function takes the residual
-                                     * in #src# and returns the resulting
-                                     * update vector in #dst#.
+                                     * in @p{src} and returns the resulting
+                                     * update vector in @p{dst}.
                                      */
     template<typename number2>
     void vmult (Vector<number2>       &dst,
@@ -222,12 +222,12 @@ class SparseVanka
                                     /**
                                      * Apply the inverses
                                      * corresponding to those degrees
-                                     * of freedom that have a #true#
-                                     * value in #dof_mask#, to the
-                                     * #src# vector and move the
-                                     * result into #dst#. Actually,
+                                     * of freedom that have a @p{true}
+                                     * value in @p{dof_mask}, to the
+                                     * @p{src} vector and move the
+                                     * result into @p{dst}. Actually,
                                      * only values for allowed
-                                     * indices are written to #dst#,
+                                     * indices are written to @p{dst},
                                      * so the application of this
                                      * function only does what is
                                      * announced in the general
@@ -242,21 +242,21 @@ class SparseVanka
                                      * parallelize the
                                      * application. Then, it is
                                      * important to only write to
-                                     * some slices of #dst#, in order
+                                     * some slices of @p{dst}, in order
                                      * to eliminate the dependencies
                                      * of threads of each other.
                                      *
                                      * If a null pointer is passed
                                      * instead of a pointer to the
-                                     * #dof_mask# (as is the default
+                                     * @p{dof_mask} (as is the default
                                      * value), then it is assumed
                                      * that we shall work on all
                                      * degrees of freedom. This is
                                      * then equivalent to calling the
                                      * function with a
-                                     * #vector<bool>(n_dofs,true)#.
+                                     * @p{vector<bool>(n_dofs,true)}.
                                      *
-                                     * The #vmult# of this class
+                                     * The @p{vmult} of this class
                                      * of course calls this function
                                      * with a null pointer
                                      */
@@ -294,7 +294,7 @@ class SparseVanka
                                      * Array of inverse matrices,
                                      * one for each degree of freedom.
                                      * Only those elements will be used
-                                     * that are tagged in #selected#.
+                                     * that are tagged in @p{selected}.
                                      */
     mutable vector<SmartPointer<FullMatrix<float> > > inverses;
 
@@ -307,9 +307,9 @@ class SparseVanka
                                     /**
                                      * Compute the inverses at
                                      * positions in the range
-                                     * #[begin,end)#. In
+                                     * @p{[begin,end)}. In
                                      * non-multithreaded mode,
-                                     * #compute_inverses()# calls
+                                     * @p{compute_inverses()} calls
                                      * this function with the whole
                                      * range, but in multithreaded
                                      * mode, several copies of this
@@ -321,7 +321,7 @@ class SparseVanka
                                     /**
                                      * Compute the inverse of the
                                      * block located at position
-                                     * #row#. Since the vector is
+                                     * @p{row}. Since the vector is
                                      * used quite often, it is
                                      * generated only once in the
                                      * caller of this function and
@@ -350,7 +350,7 @@ class SparseVanka
  *
  * This class is probably useless if you don't have a multiprocessor
  * system, since then the amount of work per preconditioning step is
- * the same as for the #SparseVanka# class, but preconditioning
+ * the same as for the @p{SparseVanka} class, but preconditioning
  * properties are worse. On the other hand, if you have a
  * multiprocessor system, the worse preconditioning quality (leading
  * to more iterations of the linear solver) usually is well balanced
@@ -363,18 +363,18 @@ class SparseVanka
  *
  * To facilitate writing portable code, if the number of blocks into
  * which the matrix is to be subdivided, is set to one, then this
- * class acts just like the #SparseVanka# class. You may therefore
+ * class acts just like the @p{SparseVanka} class. You may therefore
  * want to set the number of blocks equal to the number of processors
  * you have.
  *
- * Note that the parallelization is done if #deal.II# was configured
+ * Note that the parallelization is done if @p{deal.II} 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
  * mentioned, this reduces the preconditioning properties.
  *
  *
- * \subsection{Splitting the matrix into blocks}
+ * @sect3{Splitting the matrix into blocks}
  *
  * Splitting the matrix into blocks is always done in a way such that
  * the blocks are not necessarily of equal size, but such that the
@@ -382,7 +382,7 @@ class SparseVanka
  * to be solved is equal between blocks. The reason for this strategy
  * to subdivision is load-balancing for multithreading. There are
  * several possibilities to actually split the matrix into blocks,
- * which are selected by the flag #blocking_strategy# that is passed
+ * which are selected by the flag @p{blocking_strategy} that is passed
  * to the constructor. By a block, we will in the sequel denote a list
  * of indices of degrees of freedom; the algorithm will work on each
  * block separately, i.e. the solutions of the local systems
@@ -392,12 +392,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 #[0,N)#, where #N# is the number of
+ * blocks equals the interval @p{[0,N)}, where @p{N} is the number of
  * degrees of freedom of the system of equations.
  *
  * \begin{itemize}
- * \item #index_intervals#:
- *    Here, we chose the blocks to be intervals #[a_i,a_{i+1})#,
+ * \item @p{index_intervals}:
+ *    Here, we chose the blocks to be intervals @p{[a_i,a_{i+1})},
  *    i.e. consecutive degrees of freedom are usually also within the
  *    same block. This is a reasonable strategy, if the degrees of
  *    freedom have, for example, be re-numbered using the
@@ -406,7 +406,7 @@ class SparseVanka
  *    the matrix is usually restricted to the vicinity of the diagonal
  *    as well, and we can simply cut the matrix into blocks.
  *
- *    The bounds of the intervals, i.e. the #a_i# above, are chosen
+ *    The bounds of the intervals, i.e. the @p{a_i} above, are chosen
  *    such that the number of degrees of freedom on which we shall
  *    work (i.e. usually the degrees of freedom corresponding to
  *    Lagrange multipliers) is about the same in each block; this does
@@ -424,7 +424,7 @@ class SparseVanka
  *    preconditioner useless if the degrees of freedom are numbered by
  *    component, i.e. all Lagrange multipliers en bloc.
  *
- * \item #adaptive#: This strategy is a bit more clever in cases where
+ * \item @p{adaptive}: This strategy is a bit more clever in cases where
  *    the Langrange DoFs are clustered, as in the example above. It
  *    works as follows: it first groups the Lagrange DoFs into blocks,
  *    using the same strategy as above. However, instead of grouping
@@ -449,14 +449,14 @@ class SparseVanka
  * \end{itemize}
  *
  *
- * \subsection{Typical results}
+ * @sect3{Typical results}
  *
  * As a prototypical test case, we use a nonlinear problem from
  * optimization, which leads to a series of saddle point problems,
  * each of which is solved using GMRES with Vanka as
  * preconditioner. The equation had approx. 850 degrees of
- * freedom. With the non-blocked version #SparseVanka# (or
- * #SparseBlockVanka# with #n_blocks==1#), the following numbers of
+ * freedom. With the non-blocked version @p{SparseVanka} (or
+ * @p{SparseBlockVanka} with @p{n_blocks==1}), the following numbers of
  * iterations is needed to solver the linear system in each nonlinear
  * step:
  * \begin{verbatim}
@@ -503,7 +503,7 @@ class SparseBlockVanka : public SparseVanka<number>
                                     /**
                                      * Constructor. Pass all
                                      * arguments except for
-                                     * #n_blocks# to the base class.
+                                     * @p{n_blocks} to the base class.
                                      */
     SparseBlockVanka (const SparseMatrix<number> &M,
                      const vector<bool>         &selected,
@@ -529,11 +529,11 @@ class SparseBlockVanka : public SparseVanka<number>
                                      * In this field, we precompute
                                      * for each block which degrees
                                      * of freedom belong to it. Thus,
-                                     * if #dof_masks[i][j]==true#,
-                                     * then DoF #j# belongs to block
-                                     * #i#. Of course, no other
-                                     * #dof_masks[l][j]# may be
-                                     * #true# for #l!=i#. This
+                                     * if @p{dof_masks[i][j]==true},
+                                     * 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
                                      * computation is done in the
                                      * constructor, to avoid
                                      * recomputing each time the
@@ -543,7 +543,7 @@ class SparseBlockVanka : public SparseVanka<number>
 
                                     /**
                                      * Compute the contents of the
-                                     * field #dof_masks#. This
+                                     * field @p{dof_masks}. This
                                      * function is called from the
                                      * constructor.
                                      */
index b3d0df796d8587c3dc42c81b0ccd11d415aed935..8386d6da6d0ce382c6a8f9aba77547f9e7823280 100644 (file)
@@ -160,7 +160,7 @@ SparseVanka<number>::compute_inverse (const unsigned int    row,
                                         row_length); 
 
                                   // collect the dofs that couple
-                                  // with #row#
+                                  // with @p{row}
   local_indices.resize (row_length);
   for (unsigned int i=0; i<row_length; ++i)
     local_indices[i] = structure.column_number(row, i);
@@ -276,7 +276,7 @@ SparseVanka<number>::apply_preconditioner (Vector<number2>       &dst,
                                         // patterns, the first element
                                         // of each entry simply denotes
                                         // all degrees of freedom that
-                                        // couple with #row#.
+                                        // couple with @p{row}.
        local_index.clear ();
        for (unsigned int i=0; i<row_length; ++i)
          local_index.insert(pair<unsigned int, unsigned int>
@@ -290,7 +290,7 @@ SparseVanka<number>::apply_preconditioner (Vector<number2>       &dst,
                                             // couple with the present DoF
            const unsigned int irow = is->first;
                                             // index of DoF irow in the matrix
-                                            // row corresponding to DoF #row#.
+                                            // row corresponding to DoF @p{row}.
                                             // runs between 0 and row_length
            const unsigned int i = is->second;
                                             // number of DoFs coupling to
@@ -308,10 +308,10 @@ SparseVanka<number>::apply_preconditioner (Vector<number2>       &dst,
                                                 // this dof
                const unsigned int col = structure.column_number(irow, j);
                                                 // find out whether this DoF
-                                                // (that couples with #irow#,
+                                                // (that couples with @p{irow},
                                                 // which itself couples with
-                                                // #row#) also couples with
-                                                // #row#.
+                                                // @p{row}) also couples with
+                                                // @p{row}.
                const map<unsigned int, unsigned int>::const_iterator js
                  = local_index.find(col);
                                                 // if not, then still use
@@ -498,11 +498,11 @@ SparseBlockVanka<number>::compute_dof_masks (const SparseMatrix<number> &M,
                ++access_count[block_number][structure.column_number(row, i)];
            };
 
-                                        // now we know that block #i#
-                                        // wants to write to DoF #j#
+                                        // now we know that block @p{i}
+                                        // wants to write to DoF @p{j}
                                         // as often as
-                                        // #access_count[i][j]#
-                                        // times. Let #j# be allotted
+                                        // @p{access_count[i][j]}
+                                        // times. Let @p{j} be allotted
                                         // to the block which
                                         // accesses it most often.
                                         //
index b4e07c66edb68fa9e74c2d6b1fa80c179d661ed1..b6d579cd5c01e1051f51f454b95f5090b7bf625c 100644 (file)
@@ -26,7 +26,7 @@ template <typename number> class SparseMatrix;
  * Structure representing the sparsity pattern of a sparse matrix.
  * 
  * The following picture will illustrate the relation between the
- * #SparsityPattern# an the #SparseMatrix#.
+ * @p{SparsityPattern} an the @p{SparseMatrix}.
  *
  * \begin{verbatim}
  *  SparsityPattern:                               \
@@ -87,13 +87,13 @@ template <typename number> class SparseMatrix;
  *                                                /
  * \end{verbatim}
  *
- * If you want to get the #3# you need to get its position in the
+ * If you want to get the @p{3} you need to get its position in the
  * table above and its value by returning the value of the element on
- * which the pointer shows, using #*val#.  For example #val[8]=3#. Its
- * position is #colnums[8]# so #row=2#. In other words, if you want to get
- * the element #a_{24}# you know that #row=2#. To get the element, a
- * search of #4# form #colnums[rowstart[2]]# to #colnums[rowstart[3]]# is
- * needed. Then #a_{24}=val[number of the found element] = 3#.
+ * which the pointer shows, using @p{*val}.  For example @p{val[8]=3}. Its
+ * position is @p{colnums[8]} so @p{row=2}. In other words, if you want to get
+ * the element @p{a_{24}} you know that @p{row=2}. To get the element, a
+ * search of @p{4} form @p{colnums[rowstart[2]]} to @p{colnums[rowstart[3]]} is
+ * needed. Then @p{a_{24}=val[number of the found element] = 3}.
  *
  *
  * @author Wolfgang Bangerth and others
@@ -104,7 +104,7 @@ class SparsityPattern : public Subscriptor
                                     /**
                                      * Define a value which is used
                                      * to indicate that a certain
-                                     * value in the #colnums# array
+                                     * value in the @p{colnums} array
                                      * is unused, i.e. does not
                                      * represent a certain column
                                      * number index.
@@ -112,9 +112,9 @@ class SparsityPattern : public Subscriptor
                                      * Indices with this invalid
                                      * value are used to insert new
                                      * entries to the sparsity
-                                     * pattern using the #add# member
+                                     * pattern using the @p{add} member
                                      * function, and are removed when
-                                     * calling #compress#.
+                                     * calling @p{compress}.
                                      *
                                      * You should not assume that the
                                      * variable declared here has a
@@ -135,7 +135,7 @@ class SparsityPattern : public Subscriptor
                                      * member variables in other
                                      * classes. You can make the
                                      * structure usable by calling
-                                     * the #reinit# function.
+                                     * the @p{reinit} function.
                                      */
     SparsityPattern ();
     
@@ -150,8 +150,8 @@ class SparsityPattern : public Subscriptor
                                      * if yo want to use the STL data types
                                      * on classes like this, e.g. to write
                                      * such statements like
-                                     * #v.push_back (SparsityPattern());#,
-                                     * with #v# a vector of #SparsityPattern#
+                                     * @p{v.push_back (SparsityPattern());},
+                                     * with @p{v} a vector of @p{SparsityPattern}
                                      * objects.
                                      *
                                      * Usually, it is sufficient to use the
@@ -168,8 +168,8 @@ class SparsityPattern : public Subscriptor
 
                                     /**
                                      * Initialize a rectangular matrix with
-                                     * #m# rows and #n# columns.
-                                     * The matrix may contain at most #max_per_row#
+                                     * @p{m} rows and @p{n} columns.
+                                     * The matrix may contain at most @p{max_per_row}
                                      * nonzero entries per row.
                                      */
     SparsityPattern (const unsigned int m,
@@ -178,11 +178,11 @@ class SparsityPattern : public Subscriptor
 
                                     /**
                                      * Initialize a rectangular
-                                     * matrix with #m# rows and #n#
+                                     * matrix with @p{m} rows and @p{n}
                                      * columns.  The maximal number
                                      * of nonzero entries for each
                                      * row is given by the
-                                     * #row_lengths# array.
+                                     * @p{row_lengths} array.
                                      */
     SparsityPattern (const unsigned int          m,
                     const unsigned int          n,
@@ -190,7 +190,7 @@ class SparsityPattern : public Subscriptor
     
                                     /**
                                      * Initialize a square matrix of dimension
-                                     * #n# with at most #max_per_row#
+                                     * @p{n} with at most @p{max_per_row}
                                      * nonzero entries per row.
                                      */
     SparsityPattern (const unsigned int n,
@@ -198,11 +198,11 @@ class SparsityPattern : public Subscriptor
 
                                     /**
                                      * Initialize a square
-                                     * matrix with #m# rows and #m#
+                                     * matrix with @p{m} rows and @p{m}
                                      * columns.  The maximal number
                                      * of nonzero entries for each
                                      * row is given by the
-                                     * #row_lengths# array.
+                                     * @p{row_lengths} array.
                                      */
     SparsityPattern (const unsigned int          m,
                     const vector<unsigned int> &row_lengths);
@@ -223,27 +223,27 @@ class SparsityPattern : public Subscriptor
                                      * or other incomplete decompositions.
                                      * Therefore, additional to the original
                                      * entry structure, space for
-                                     * #extra_off_diagonals#
+                                     * @p{extra_off_diagonals}
                                      * side-diagonals is provided on both
                                      * sides of the main diagonal.
                                      *
-                                     * #max_per_row# is the maximum number of
+                                     * @p{max_per_row} is the maximum number of
                                      * nonzero elements per row which this
                                      * structure is to hold. It is assumed
                                      * that this number is sufficiently large
                                      * to accomodate both the elements in
-                                     * #original# as well as the new
+                                     * @p{original} as well as the new
                                      * off-diagonal elements created by this
                                      * constructor. You will usually want to
                                      * give the same number as you gave for
-                                     * #original# plus the number of side
+                                     * @p{original} plus the number of side
                                      * diagonals times two. You may however
                                      * give a larger value if you wish to add
                                      * further nonzero entries for the
                                      * decomposition based on other criteria
                                      * than their being on side-diagonals.
                                      *
-                                     * This function requires that #original#
+                                     * This function requires that @p{original}
                                      * refer to a square matrix structure.
                                      * It shall be compressed. The matrix 
                                      * structure is not compressed
@@ -261,13 +261,13 @@ class SparsityPattern : public Subscriptor
                                     /**
                                      * Reallocate memory and set up data
                                      * structures for a new matrix with
-                                     * #m# rows and #n# columns,
-                                     * with at most #max_per_row#
+                                     * @p{m} rows and @p{n} columns,
+                                     * with at most @p{max_per_row}
                                      * nonzero entries per row.
                                      *
                                      * This function simply maps its
                                      * operations to the other
-                                     * #reinit# function.
+                                     * @p{reinit} function.
                                      */
     void reinit (const unsigned int m,
                 const unsigned int n,
@@ -275,14 +275,14 @@ class SparsityPattern : public Subscriptor
 
                                     /**
                                      * Reallocate memory for a matrix
-                                     * of size #m \times n#. The
+                                     * of size @p{m \times n}. The
                                      * number of entries for each row
                                      * is taken from the array
-                                     * #row_lengths# which has to
+                                     * @p{row_lengths} which has to
                                      * give this number of each row
-                                     * #i=1...m#.
+                                     * @p{i=1...m}.
                                      *
-                                     * If #m*n==0# all memory is freed,
+                                     * If @p{m*n==0} all memory is freed,
                                      * resulting in a total reinitialization
                                      * of the object. If it is nonzero, new
                                      * memory is only allocated if the new
@@ -308,8 +308,8 @@ class SparsityPattern : public Subscriptor
                                      * The memory which is no more
                                      * needed is released.
                                      *
-                                     * #SparseMatrix# objects require the
-                                     * #SparsityPattern# objects they are
+                                     * @p{SparseMatrix} objects require the
+                                     * @p{SparsityPattern} objects they are
                                      * initialized with to be compressed, to
                                      * reduce memory requirements.
                                      */
@@ -335,14 +335,14 @@ class SparsityPattern : public Subscriptor
 
                                     /**
                                      * Return the index of the matrix
-                                     * element with row number #i# and
-                                     * column number #j#. If the matrix
+                                     * element with row number @p{i} and
+                                     * column number @p{j}. If the matrix
                                      * element is not a nonzero one,
-                                     * return #SparsityPattern::invalid_entry#.
+                                     * return @p{SparsityPattern::invalid_entry}.
                                      *
                                      * This function is usually called
-                                     * by the #operator()# of the
-                                     * #SparseMatrix#. It shall only be
+                                     * by the @p{operator()} of the
+                                     * @p{SparseMatrix}. It shall only be
                                      * called for compressed sparsity
                                      * patterns, since in this case
                                      * searching whether the entry
@@ -365,11 +365,11 @@ class SparsityPattern : public Subscriptor
     
                                     /**
                                      * Print the sparsity of the matrix
-                                     * in a format that #gnuplot# understands
+                                     * in a format that @p{gnuplot} understands
                                      * and which can be used to plot the
                                      * sparsity pattern in a graphical
                                      * way. The format consists of pairs
-                                     * #i j# of nonzero elements, each
+                                     * @p{i j} of nonzero elements, each
                                      * representing one entry of this
                                      * matrix, one per line of the output
                                      * file. Indices are counted from
@@ -378,14 +378,14 @@ class SparsityPattern : public Subscriptor
                                      * way as matrices are displayed, we
                                      * print the negative of the column
                                      * index, which means that the
-                                     * #(0,0)# element is in the top left
+                                     * @p{(0,0)} element is in the top left
                                      * rather than in the bottom left
                                      * corner.
                                      *
                                      * Print the sparsity pattern in
                                      * gnuplot by setting the data style
                                      * to dots or points and use the
-                                     * #plot# command.
+                                     * @p{plot} command.
                                      */
     void print_gnuplot (ostream &out) const;
 
@@ -411,7 +411,7 @@ class SparsityPattern : public Subscriptor
                                     /**
                                      * Access to column number field.
                                      * Return the column number of
-                                     * the #index#th entry in #row#.
+                                     * the @p{index}th entry in @p{row}.
                                      */
     unsigned int column_number (const unsigned int row,
                                const unsigned int index) const;
@@ -452,11 +452,11 @@ class SparsityPattern : public Subscriptor
                                      * read-only.
                                      *
                                      * Use of this function is highly
-                                     * deprecated. Use #row_length#
-                                     * and #column_number# instead.
+                                     * deprecated. Use @p{row_length}
+                                     * and @p{column_number} instead.
                                      *
                                      * Though the return value is declared
-                                     * #const#, you should be aware that it
+                                     * @p{const}, you should be aware that it
                                      * may change if you call any nonconstant
                                      * function of objects which operate on
                                      * it.
@@ -478,11 +478,11 @@ class SparsityPattern : public Subscriptor
                                      * readonly.
                                      *
                                      * Use of this function is highly
-                                     * deprecated. Use #row_length#
-                                     * and #column_number# instead.
+                                     * deprecated. Use @p{row_length}
+                                     * and @p{column_number} instead.
                                      *
                                      * Though the return value is declared
-                                     * #const#, you should be aware that it
+                                     * @p{const}, you should be aware that it
                                      * may change if you call any nonconstant
                                      * function of objects which operate on
                                      * it.
@@ -554,13 +554,13 @@ class SparsityPattern : public Subscriptor
   private:
                                     /**
                                      * Maximum number of rows that can
-                                     * be stored in the #row_start# array.
+                                     * be stored in the @p{row_start} array.
                                      * Since reallocation of that array
                                      * only happens if the present one is
                                      * too small, but never when the size
                                      * of this matrix structure shrinks,
-                                     * #max_dim# might be larger than
-                                     * #rows# and in this case #row_start#
+                                     * @p{max_dim} might be larger than
+                                     * @p{rows} and in this case @p{row_start}
                                      * has more elements than are used.
                                      */
     unsigned int max_dim;
@@ -579,8 +579,8 @@ class SparsityPattern : public Subscriptor
 
                                     /**
                                      * Size of the actually allocated array
-                                     * #colnums#. Here, the same applies as
-                                     * for the #rowstart# array, i.e. it
+                                     * @p{colnums}. Here, the same applies as
+                                     * for the @p{rowstart} array, i.e. it
                                      * may be larger than the actually used
                                      * part of the array.
                                      */
@@ -589,7 +589,7 @@ class SparsityPattern : public Subscriptor
                                     /**
                                      * Maximum number of elements per
                                      * row. This is set to the value
-                                     * given to the #reinit# function
+                                     * given to the @p{reinit} function
                                      * (or to the constructor), or to
                                      * the maximum row length
                                      * computed from the vectors in
@@ -597,32 +597,32 @@ class SparsityPattern : public Subscriptor
                                      * constructors or reinit
                                      * versions are called. Its value
                                      * is more or less meaningsless
-                                     * after #compress()# has been
+                                     * after @p{compress()} has been
                                      * called.
                                      */
     unsigned int max_row_length;
 
                                     /**
                                      * Array which hold for each row which
-                                     * is the first element in #colnums#
+                                     * is the first element in @p{colnums}
                                      * belonging to that row. Note that
                                      * the size of the array is one larger
                                      * than the number of rows, because
                                      * the last element is used for
-                                     * #row=rows#, i.e. the row past the
+                                     * @p{row=rows}, i.e. the row past the
                                      * last used one. The value of
-                                     * #rowstart[rows]# equals the index
+                                     * @p{rowstart[rows]} equals the index
                                      * of the element past the end in
-                                     * #colnums#; this way, we are able to
+                                     * @p{colnums}; this way, we are able to
                                      * write loops like
-                                     * #for (i=rowstart[k]; i<rowstart[k+1]; ++i)#
+                                     * @p{for (i=rowstart[k]; i<rowstart[k+1]; ++i)}
                                      * also for the last row.
                                      *
                                      * Note that the actual size of the
                                      * allocated memory may be larger than
                                      * the region that is used. The actual
                                      * number of elements that was allocated
-                                     * is stored in #max_dim#.
+                                     * is stored in @p{max_dim}.
                                      */
     unsigned int *rowstart;
 
@@ -630,21 +630,21 @@ class SparsityPattern : public Subscriptor
                                      * Array of column numbers. In this array,
                                      * we store for each non-zero element its
                                      * column number. The column numbers for
-                                     * the elements in row #r# are stored
+                                     * the elements in row @p{r} are stored
                                      * within the index range
-                                     * #rowstart[r]...rowstart[r+1]#. Therefore
+                                     * @p{rowstart[r]...rowstart[r+1]}. Therefore
                                      * to find out whether a given element
-                                     * #(r,c)# exists, we have to check
-                                     * whether the column number #c# exists in
+                                     * @p{(r,c)} exists, we have to check
+                                     * whether the column number @p{c} exists in
                                      * the abovementioned range within this
                                      * array. If it exists, say at position
-                                     * #p# within this array, the value of
+                                     * @p{p} within this array, the value of
                                      * the respective element in the sparse
-                                     * matrix will also be at position #p#
+                                     * matrix will also be at position @p{p}
                                      * of the values array of that class.
                                      *
                                      * At the beginning, all elements of
-                                     * this array are set to #-1# indicating
+                                     * this array are set to @p{-1} indicating
                                      * invalid (unused) column numbers
                                      * (however, note that if this object
                                      * refers to a square matrix, the diagonal
@@ -654,7 +654,7 @@ class SparsityPattern : public Subscriptor
                                      * after the other is set to the column
                                      * number of the added element. When
                                      * compress is called, unused elements
-                                     * (indicated by column numbers #-1#)
+                                     * (indicated by column numbers @p{-1})
                                      * are eliminated by copying the column
                                      * number of subsequent rows and the
                                      * column numbers within each row (with
@@ -667,12 +667,12 @@ class SparsityPattern : public Subscriptor
                                      * matrix, the first element in each
                                      * row always denotes the diagonal
                                      * element, i.e.
-                                     * #colnums[rowstart[r]]==r#.
+                                     * @p{colnums[rowstart[r]]==r}.
                                      */
     unsigned int *colnums;
 
                                     /**
-                                     * Store whether the #compress# function
+                                     * Store whether the @p{compress} function
                                      * was called for this object.
                                      */
     bool compressed;
index c910898029eb20b842f4f119f7e96e95781d8558..7131812eac20e52c549a97d55b4cc25396d0a7fb 100644 (file)
 
 
 /**
- * This class is a wrapper to the #Vector# class which allows to swap
+ * This class is a wrapper to the @p{Vector} class which allows to swap
  * out the data to a file and reload it later on. It handles the
  * management of the name of the file where the data is to be stored
  * temporarily and removes the file is necessary at the end of the
  * lifetime of the vector.
  *
  * There are functions to swap the data to a file, and to reload
- * it. There is also a function #alert# that can be used to signal to
+ * it. There is also a function @p{alert} that can be used to signal to
  * an object of this class that the data will be needed shortly, so
  * the object can initiate that the data be loaded already. While in
- * non-multithreading mode, this function has no effect since #reload#
+ * non-multithreading mode, this function has no effect since @p{reload}
  * has to be called afterwards anyway. On the other hand, in
  * multithreading mode, the data is preloaded in the background using
  * a thread on its own, and may already be available at the time when
- * #reload# is called. If it is not available, #reload# waits until
+ * @p{reload} is called. If it is not available, @p{reload} waits until
  * the detached thread has loaded the data.
  *
  *
- * \section{On template instantiations}
+ * @sect2{On template instantiations}
  *
  * Member functions of this class are either implemented in this file
  * or in a file of the same name with suffix ``.templates.h''. For the
@@ -66,15 +66,15 @@ class SwappableVector : public Vector<number>
 
                                     /**
                                      * Copy constructor. Copies the
-                                     * data if #v# contains some, but
-                                     * does not do so if #v# is empty
+                                     * data if @p{v} contains some, but
+                                     * does not do so if @p{v} is empty
                                      * or has its data swapped
                                      * out. In the latter case, warn
                                      * about that. In particular do
                                      * not take over ownership of any
-                                     * files that #v# might own (as,
-                                     * for example, #C++#'s
-                                     * #auto_ptr# objects would do).
+                                     * files that @p{v} might own (as,
+                                     * for example, @p{C++}'s
+                                     * @p{auto_ptr} objects would do).
                                      */
     SwappableVector (const SwappableVector &v);
 
@@ -104,7 +104,7 @@ class SwappableVector : public Vector<number>
                                      * ownership of this file is
                                      * assumed by this object. The
                                      * file is deleted either upon
-                                     * calling #kill_file#, or on
+                                     * calling @p{kill_file}, or on
                                      * destruction of this object.
                                      *
                                      * The content of the vector is
@@ -113,7 +113,7 @@ class SwappableVector : public Vector<number>
                                      *
                                      * If this object owns another
                                      * file, for example when
-                                     * #swap_out# but no #kill_file#
+                                     * @p{swap_out} but no @p{kill_file}
                                      * has previously been called,
                                      * then that is deleted first.
                                      */
@@ -123,9 +123,9 @@ class SwappableVector : public Vector<number>
                                      * Reload the data of this vector
                                      * from the file to which it has
                                      * been stored previously using
-                                     * #swap_out#. Since the file is
+                                     * @p{swap_out}. Since the file is
                                      * not deleted after reloading,
-                                     * you can call #reload# multiple
+                                     * you can call @p{reload} multiple
                                      * times, in between you may do
                                      * everything with the vector,
                                      * including changing its size.
@@ -133,7 +133,7 @@ class SwappableVector : public Vector<number>
                                      * This function resets the size
                                      * of the vector to the number of
                                      * elements there were upon
-                                     * calling #swap_out# before.
+                                     * calling @p{swap_out} before.
                                      */
     void reload ();
 
@@ -150,7 +150,7 @@ class SwappableVector : public Vector<number>
                                      * that reads the data in
                                      * parallel to the usual
                                      * execution of the program, such
-                                     * that when #reload# is called,
+                                     * that when @p{reload} is called,
                                      * the data may eventually be
                                      * available already. It might
                                      * therefore be wirthwhile to
@@ -163,7 +163,7 @@ class SwappableVector : public Vector<number>
                                      * a local tmp directory.
                                      *
                                      * Calling this function multiple
-                                     * times before calling #reload#
+                                     * times before calling @p{reload}
                                      * is allowed and has no effect
                                      * for subsequent calls. Calling
                                      * this function while the data
@@ -179,12 +179,12 @@ class SwappableVector : public Vector<number>
                                      * time. After this, the object
                                      * does not own any file any
                                      * more, so of course you can't
-                                     * call #reload# no more.
+                                     * call @p{reload} no more.
                                      *
                                      * If this object does not own a
                                      * file, for example since
-                                     * #swap_out# was not called, or
-                                     * because #kill_file# has been
+                                     * @p{swap_out} was not called, or
+                                     * because @p{kill_file} has been
                                      * called previously, then this
                                      * function does nothing.
                                      */
@@ -194,9 +194,9 @@ class SwappableVector : public Vector<number>
                                      * Return the name of the file to
                                      * which the data was stored the
                                      * last time you called
-                                     * #swap_out#. If #swap_out# was
+                                     * @p{swap_out}. If @p{swap_out} was
                                      * not called, or if in between
-                                     * #kill_file# was called, then
+                                     * @p{kill_file} was called, then
                                      * the filename is an empty
                                      * string.
                                      */
@@ -228,8 +228,8 @@ class SwappableVector : public Vector<number>
                                      * was swapped out. If no data is
                                      * presently swapped out
                                      * (i.e. before calling
-                                     * #swap_out# and after
-                                     * #kill_file#), the string is
+                                     * @p{swap_out} and after
+                                     * @p{kill_file}), the string is
                                      * empty, indicating no ownership
                                      * of files.
                                      */
@@ -237,9 +237,9 @@ class SwappableVector : public Vector<number>
 
                                     /**
                                      * If in multithread mode, then
-                                     * the #alert# function has
+                                     * the @p{alert} function has
                                      * functionality, but needs to
-                                     * coordinate with the #reload#
+                                     * coordinate with the @p{reload}
                                      * function. This is done through
                                      * the following lock.
                                      *
@@ -253,7 +253,7 @@ class SwappableVector : public Vector<number>
                                     /**
                                      * Declare a thread manager that
                                      * is used to spawn threads in
-                                     * #alert# detached.
+                                     * @p{alert} detached.
                                      *
                                      * If not in MT mode, then the
                                      * class used here is empty, and
@@ -263,23 +263,23 @@ class SwappableVector : public Vector<number>
     static Threads::ThreadManager thread_manager;
 
                                     /**
-                                     * Flag by which the #alert#
+                                     * Flag by which the @p{alert}
                                      * function signifies that the
                                      * data has been preloaded
                                      * already. This flag is always
-                                     * #false# in non-MT mode.
+                                     * @p{false} in non-MT mode.
                                      */
     bool data_is_preloaded;
 
                                     /**
                                      * Internal function that
                                      * actually reloads the
-                                     * vector. Called from #reload#
-                                     * and #alert#.
+                                     * vector. Called from @p{reload}
+                                     * and @p{alert}.
                                      *
                                      * The parameter specifies
                                      * whether the function shall set
-                                     * #data_is_preloaded# or
+                                     * @p{data_is_preloaded} or
                                      * not. The calling functions
                                      * can't sometimes do this
                                      * themselves, since they call
index 8cc77a9674eba102ee7aa0d51795af46936a992b..3def940779f404d409c6b7933f16e1d2b5a81dad 100644 (file)
@@ -113,8 +113,8 @@ void SwappableVector<number>::swap_out (const string &name)
 #endif
   
                                   //  check that we have not called
-                                  //  #alert# without the respective
-                                  //  #reload# function
+                                  //  @p{alert} without the respective
+                                  //  @p{reload} function
   Assert (data_is_preloaded == false, ExcInternalError());
   
   ofstream tmp_out(filename.c_str());
@@ -134,7 +134,7 @@ template <typename number>
 void SwappableVector<number>::reload () 
 {
                                   // if in MT mode: synchronise with
-                                  // possibly existing #alert# calls
+                                  // possibly existing @p{alert} calls
 #ifdef DEAL_II_USE_MT
   lock.acquire ();
 #endif
index 6bf0f45b27a8e54d90c53b1099545a98e29b1cef..b3cf685bd35db41945e0640a4a5a4d9642c80f3d 100644 (file)
 
 
 /**
- *  Numerical Vector of data.  For this class there are different
- * types of functions available. The first type of function mesures
- * the norm of the vector in order to mesure its length in a suitable
- * norm. The second type support the abgebraic operation for
- * vectors. The third und last type helps us to manipulate the
- * components of the vector.
- * As opposed to the array of the C++ standard library called #vector#, this class implements
- * an element of a vector space suitable for numerical computations.
+ * Numerical vector of data.  For this class there are different types
+ * of functions available. The first type of function mesures the norm
+ * of the vector in order to mesure its length in a suitable norm. The
+ * second type support the abgebraic operation for vectors. The third
+ * und last type helps us to manipulate the components of the vector.
+ * As opposed to the array of the C++ standard library called
+ * @p{vector} (with a lowercase "v"), this class implements an element
+ * of a vector space suitable for numerical computations.
  *
  *
- * \section{On template instantiations}
+ * @sect2{On template instantiations}
  *
  * Member functions of this class are either implemented in this file
  * or in a file of the same name with suffix ``.templates.h''. For the
@@ -48,8 +48,8 @@ class Vector {
                                     /**
                                      * Declare standard types used in all
                                      * containers. These types parallel
-                                     * those in the #C++# standard libraries
-                                     * #vector<...># class.
+                                     * those in the @p{C++} standard libraries
+                                     * @p{vector<...>} class.
                                      */
     typedef Number value_type;
     typedef value_type* pointer;
@@ -86,7 +86,7 @@ class Vector {
 //                                   * Copy constructor taking a vector of
 //                                   * another data type. This will fail if
 //                                   * there is no conversion path from
-//                                   * #OtherNumber# to #Number#. Note that
+//                                   * @p{OtherNumber} to @p{Number}. Note that
 //                                   * you may lose accuracy when copying
 //                                   * to a vector with data elements with
 //                                   * less accuracy.
@@ -96,7 +96,7 @@ class Vector {
 //     Vector (const Vector<OtherNumber> &v);
     
                                     /**
-                                     * Constructor. Set dimension to #n# and
+                                     * Constructor. Set dimension to @p{n} and
                                      * initialize all elements with zero.
                                      */
     Vector (const unsigned int n);
@@ -111,28 +111,28 @@ class Vector {
 
                                     /**
                                      * Set all entries to zero. Equivalent to
-                                     * #v = 0#, but more obvious and faster.
+                                     * @p{v = 0}, but more obvious and faster.
                                      * Note that this function does not change
                                      * the size of the vector, unlike the
-                                     * STL's #vector<>::clear# function.
+                                     * STL's @p{vector<>::clear} function.
                                      */
     void clear ();    
 
                                     /**
                                      * Change the dimension of the vector to
-                                     * #N#. The reserved memory for this vector
+                                     * @p{N}. The reserved memory for this vector
                                      * remains unchanged if possible, to make
                                      * things faster, but this may waste some
                                      * memory, so take this in the back of your
                                      * head.
-                                     * However, if #N==0# all memory is freed,
+                                     * However, if @p{N==0} all memory is freed,
                                      * i.e. if you want to resize the vector
                                      * and release the memory not needed, you
-                                     * have to first call #reinit(0)# and then
-                                     * #reinit(N)#. This cited behaviour is
+                                     * have to first call @p{reinit(0)} and then
+                                     * @p{reinit(N)}. This cited behaviour is
                                      * analogous to that of the STL containers.
                                      *
-                                     * On #fast==false#, the vector is filled by
+                                     * On @p{fast==false}, the vector is filled by
                                      * zeros.
                                      */ 
     void reinit (const unsigned int N,
@@ -140,12 +140,12 @@ class Vector {
     
                                     /**
                                      * Change the dimension to that of the
-                                     * vector #V#. The same applies as for
-                                     * the other #reinit# function.
+                                     * vector @p{V}. The same applies as for
+                                     * the other @p{reinit} function.
                                      *
-                                     * The elements of #V# are not copied, i.e.
+                                     * The elements of @p{V} are not copied, i.e.
                                      * this function is the same as calling
-                                     * #reinit (V.size(), fast)#.
+                                     * @p{reinit (V.size(), fast)}.
                                      */
     void reinit (const Vector<Number> &V,
                 const bool            fast=false);
@@ -153,7 +153,7 @@ class Vector {
                                     /**
                                      * Swap the contents of this
                                      * vector and the other vector
-                                     * #v#. One could do this
+                                     * @p{v}. One could do this
                                      * operation with a temporary
                                      * variable and copying over the
                                      * data elements, but this
@@ -166,11 +166,11 @@ class Vector {
                                      * data around.
                                      *
                                      * This function is analog to the
-                                     * the #swap# function of all C++
+                                     * the @p{swap} function of all C++
                                      * standard containers. Also,
                                      * there is a global function
-                                     * #swap(u,v)# that simply calls
-                                     * #u.swap(v)#, again in analogy
+                                     * @p{swap(u,v)} that simply calls
+                                     * @p{u.swap(v)}, again in analogy
                                      * to standard functions.
                                      */
     void swap (Vector<Number> &v);
@@ -229,10 +229,10 @@ class Vector {
 
                                     /**
                                      * Return dimension of the vector. This
-                                     * function was formerly called #n()#, but
-                                     * was renamed to get the #Vector# class
+                                     * function was formerly called @p{n()}, but
+                                     * was renamed to get the @p{Vector} class
                                      * closer to the C++ standard library's
-                                     * #vector# container.
+                                     * @p{vector} container.
                                      */
     unsigned int size () const;
 
@@ -247,8 +247,8 @@ class Vector {
     bool all_zero () const;
     
                                     /**
-                                     * Make the #Vector# class a bit like the
-                                     * #vector<># class of the C++ standard
+                                     * Make the @p{Vector} class a bit like the
+                                     * @p{vector<>} class of the C++ standard
                                      * library by returning iterators to
                                      * the start and end of the elements of this
                                      * vector.
@@ -298,27 +298,27 @@ class Vector {
                                     //@{
                                     /**
                                      * Addition operator.
-                                     * Fast equivalent to #U.add(1, V)#.
+                                     * Fast equivalent to @p{U.add(1, V)}.
                                      */
     Vector<Number> & operator += (const Vector<Number> &V);
 
                                     /**
                                      * Subtraction operator.
-                                     * Fast equivalent to #U.add(-1, V)#.
+                                     * Fast equivalent to @p{U.add(-1, V)}.
                                      */
     Vector<Number> & operator -= (const Vector<Number> &V);
 
                                     /**
                                      * $U(0-DIM)+=s$.
-                                     * Addition of #s# to all components. Note
-                                     * that #s# is a scalar and not a vector.
+                                     * Addition of @p{s} to all components. Note
+                                     * that @p{s} is a scalar and not a vector.
                                      */
     void add (const Number s);
     
                                     /**
                                      * U+=V.
                                      * Simple vector addition, equal to the
-                                     * #operator +=#.
+                                     * @p{operator +=}.
                                      */
     void add (const Vector<Number>& V);
     
@@ -383,7 +383,7 @@ class Vector {
                                     /**
                                      * Compute the elementwise ratio of the
                                      * two given vectors, that is let
-                                     * #this[i] = a[i]/b[i]#. This is useful
+                                     * @p{this[i] = a[i]/b[i]}. This is useful
                                      * for example if you want to compute
                                      * the cellwise ratio of true to estimated
                                      * error.
@@ -391,7 +391,7 @@ class Vector {
                                      * This vector is appropriately scaled to
                                      * hold the result.
                                      *
-                                     * If any of the #b[i]# is zero, the result
+                                     * If any of the @p{b[i]} is zero, the result
                                      * is undefined. No attempt is made to
                                      * catch such situations.
                                      */
@@ -481,16 +481,16 @@ class Vector {
                                     /**
                                      * Dimension. Actual number of components
                                      * contained in the vector.
-                                     * Get this number by calling #size()#.
+                                     * Get this number by calling @p{size()}.
                                      */
     unsigned int dim;
 
                                     /**
                                      * Amount of memory actually reserved for
                                      * this vector. This number may be greater
-                                     * than #dim# if a #reinit# was called with
+                                     * than @p{dim} if a @p{reinit} was called with
                                      * less memory requirements than the vector
-                                     * needed last time. At present #reinit#
+                                     * needed last time. At present @p{reinit}
                                      * does not free memory when the number of
                                      * needed elements is reduced.
                                      */
@@ -562,7 +562,7 @@ Number& Vector<Number>::operator() (const unsigned int i)
 
 
 /**
- * Global function #swap# which overloads the default implementation
+ * Global function @p{swap} which overloads the default implementation
  * of the C++ standard library which uses a temporary object. The
  * function simply exchanges the data of the two vectors.
  *
index f9084da451a0c2fd0377dc1a2c19317da7cc34ab..daca93e7e2ffcacb9242c3da51ada2dcf6b46ad9 100644 (file)
@@ -101,7 +101,7 @@ class PrimitiveVectorMemory : public VectorMemory<Vector>
 
 
 /**
- * Memory keeping allocated vectors.  This #VectorMemory# is able to
+ * Memory keeping allocated vectors.  This @p{VectorMemory} is able to
  * grow infinitely (according to computer memory).  A vector once
  * allocated will stay in the memory pool, though, and it will be
  * reused in later allocation.
index bde08cc7995713c8c83154f127690efba819efe4..e0618a084c7cef0686910625d9a38d23e7aa385b 100644 (file)
@@ -125,7 +125,7 @@ SparsityPattern::SparsityPattern (const SparsityPattern &original,
                                       //
                                       // we do the copying in two steps:
                                       // first we note that the elements in
-                                      // #original# are sorted, so we may
+                                      // @p{original} are sorted, so we may
                                       // first copy all the elements up to
                                       // the first side-diagonal one which
                                       // is to be filled in. then we insert
@@ -136,7 +136,7 @@ SparsityPattern::SparsityPattern (const SparsityPattern &original,
       const unsigned int * const
        original_row_start = &original.colnums[original.rowstart[row]] + 1;
                                       // the following requires that
-                                      // #original# be compressed since
+                                      // @p{original} be compressed since
                                       // otherwise there might be invalid_entry's
       const unsigned int * const
        original_row_end   = &original.colnums[original.rowstart[row+1]];
@@ -147,7 +147,7 @@ SparsityPattern::SparsityPattern (const SparsityPattern &original,
                                       // bottom of matrix, then set
                                       // these pointers such that no
                                       // copying is necessary (see
-                                      // the #copy# commands)
+                                      // the @p{copy} commands)
       const unsigned int * const
        original_last_before_side_diagonals
        = (row > extra_off_diagonals ?
@@ -232,7 +232,7 @@ SparsityPattern::reinit (const unsigned int m,
                         const unsigned int max_per_row)
 {
                                   // simply map this function to the
-                                  // other #reinit# function
+                                  // other @p{reinit} function
   const vector<unsigned int> row_lengths (m, max_per_row);
   reinit (m, n, row_lengths);
 };
@@ -267,9 +267,9 @@ SparsityPattern::reinit (const unsigned int m,
     };
 
                                   // find out how many entries we
-                                  // need in the #colnums# array. if
+                                  // need in the @p{colnums} array. if
                                   // this number is larger than
-                                  // #max_vec_len#, then we will need
+                                  // @p{max_vec_len}, then we will need
                                   // to reallocate memory
                                   //
                                   // note that the number of elements
@@ -366,7 +366,7 @@ SparsityPattern::compress ()
          tmp_entries[row_length] = colnums[j];
        else
          break;
-                                      // now #rowstart# is
+                                      // now @p{rowstart} is
                                       // the number of entries in
                                       // this line
 

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.