From 4cbaafdb935d14b03a37509eb5d351e27013062b Mon Sep 17 00:00:00 2001 From: Wolfgang Bangerth Date: Thu, 22 Jun 2000 14:53:22 +0000 Subject: [PATCH] Change many things, mostly docs, for the switch from kdoc1 to kdoc2. git-svn-id: https://svn.dealii.org/trunk@3064 0785d39b-7218-0410-832d-ea1e28bc413d --- deal.II/base/include/base/convergence_table.h | 74 +- deal.II/base/include/base/data_out_base.h | 304 ++++---- deal.II/base/include/base/exceptions.h | 118 +-- deal.II/base/include/base/function.h | 126 ++-- deal.II/base/include/base/function_time.h | 24 +- deal.II/base/include/base/job_identifier.h | 4 +- deal.II/base/include/base/logstream.h | 52 +- deal.II/base/include/base/multithread_info.h | 8 +- deal.II/base/include/base/parameter_handler.h | 228 +++--- deal.II/base/include/base/point.h | 46 +- deal.II/base/include/base/quadrature.h | 46 +- deal.II/base/include/base/smartpointer.h | 20 +- deal.II/base/include/base/subscriptor.h | 10 +- deal.II/base/include/base/table_handler.h | 104 +-- deal.II/base/include/base/tensor.h | 42 +- deal.II/base/include/base/tensor_base.h | 44 +- deal.II/base/include/base/tensor_function.h | 18 +- deal.II/base/include/base/thread_management.h | 110 +-- deal.II/base/include/base/timer.h | 10 +- deal.II/base/source/data_out_base.cc | 2 +- deal.II/base/source/parameter_handler.cc | 2 +- deal.II/base/source/thread_management.cc | 2 +- deal.II/deal.II/include/dofs/dof_accessor.h | 286 ++++---- .../deal.II/include/dofs/dof_constraints.h | 80 +- .../include/dofs/dof_constraints.templates.h | 40 +- deal.II/deal.II/include/dofs/dof_handler.h | 284 ++++---- deal.II/deal.II/include/dofs/dof_levels.h | 20 +- deal.II/deal.II/include/dofs/dof_tools.h | 104 +-- deal.II/deal.II/include/fe/fe.h | 246 +++---- .../deal.II/include/fe/fe_lib.criss_cross.h | 34 +- deal.II/deal.II/include/fe/fe_lib.dg.h | 46 +- deal.II/deal.II/include/fe/fe_lib.dgp.h | 56 +- deal.II/deal.II/include/fe/fe_lib.lagrange.h | 134 ++-- deal.II/deal.II/include/fe/fe_system.h | 106 +-- deal.II/deal.II/include/fe/fe_tools.h | 82 +-- deal.II/deal.II/include/fe/fe_update_flags.h | 12 +- deal.II/deal.II/include/fe/fe_values.h | 284 ++++---- deal.II/deal.II/include/fe/q1_mapping.h | 18 +- deal.II/deal.II/include/grid/geometry_info.h | 24 +- deal.II/deal.II/include/grid/grid_generator.h | 22 +- deal.II/deal.II/include/grid/grid_in.h | 10 +- deal.II/deal.II/include/grid/grid_out.h | 110 +-- deal.II/deal.II/include/grid/intergrid_map.h | 26 +- .../deal.II/include/grid/persistent_tria.h | 34 +- deal.II/deal.II/include/grid/tria.h | 688 +++++++++--------- deal.II/deal.II/include/grid/tria_accessor.h | 274 +++---- .../include/grid/tria_accessor.templates.h | 4 +- deal.II/deal.II/include/grid/tria_boundary.h | 12 +- .../deal.II/include/grid/tria_boundary_lib.h | 12 +- deal.II/deal.II/include/grid/tria_hex.h | 14 +- deal.II/deal.II/include/grid/tria_iterator.h | 254 +++---- deal.II/deal.II/include/grid/tria_levels.h | 102 +-- deal.II/deal.II/include/grid/tria_line.h | 10 +- deal.II/deal.II/include/grid/tria_quad.h | 12 +- deal.II/deal.II/include/multigrid/mg_base.h | 92 +-- .../include/multigrid/mg_dof_accessor.h | 154 ++-- .../include/multigrid/mg_dof_handler.h | 234 +++--- .../deal.II/include/multigrid/mg_dof_tools.h | 10 +- .../deal.II/include/multigrid/mg_smoother.h | 36 +- deal.II/deal.II/include/multigrid/multigrid.h | 40 +- deal.II/deal.II/include/numerics/assembler.h | 12 +- deal.II/deal.II/include/numerics/base.h | 34 +- deal.II/deal.II/include/numerics/data_io.h | 138 ++-- deal.II/deal.II/include/numerics/data_out.h | 96 +-- .../deal.II/include/numerics/data_out_stack.h | 54 +- .../numerics/derivative_approximation.h | 4 +- .../include/numerics/dof_print_solver_step.h | 4 +- .../include/numerics/dof_renumbering.h | 34 +- .../include/numerics/error_estimator.h | 44 +- .../include/numerics/gradient_estimator.h | 4 +- deal.II/deal.II/include/numerics/histogram.h | 32 +- deal.II/deal.II/include/numerics/matrices.h | 106 +-- .../include/numerics/solution_transfer.h | 171 ++--- .../deal.II/include/numerics/time_dependent.h | 260 +++---- deal.II/deal.II/include/numerics/vectors.h | 128 ++-- .../deal.II/source/dofs/dof_constraints.cc | 12 +- deal.II/deal.II/source/dofs/dof_handler.cc | 2 +- deal.II/deal.II/source/dofs/dof_tools.cc | 30 +- deal.II/deal.II/source/fe/fe_system.cc | 2 +- deal.II/deal.II/source/fe/fe_values.cc | 4 +- .../source/grid/tria.all_dimensions.cc | 4 +- deal.II/deal.II/source/grid/tria.cc | 38 +- deal.II/deal.II/source/numerics/assembler.cc | 2 +- deal.II/deal.II/source/numerics/data_io.cc | 6 +- .../deal.II/source/numerics/data_out_stack.cc | 2 +- .../source/numerics/error_estimator.cc | 10 +- deal.II/deal.II/source/numerics/matrices.cc | 6 +- .../source/numerics/solution_transfer.cc | 2 +- .../deal.II/source/numerics/time_dependent.cc | 6 +- deal.II/deal.II/source/numerics/vectors.cc | 36 +- deal.II/doc/auto/kdoc/Makefile.in | 40 +- .../development/writing-documentation.html | 39 +- deal.II/examples/step-7/step-7.cc | 14 +- deal.II/lac/include/lac/block_indices.h | 10 +- deal.II/lac/include/lac/block_sparse_matrix.h | 60 +- .../lac/include/lac/block_sparsity_pattern.h | 28 +- deal.II/lac/include/lac/block_vector.h | 64 +- deal.II/lac/include/lac/full_matrix.h | 82 +-- deal.II/lac/include/lac/precondition.h | 12 +- deal.II/lac/include/lac/precondition_block.h | 191 ++--- .../lac/precondition_block.templates.h | 2 +- .../lac/include/lac/precondition_selector.h | 40 +- deal.II/lac/include/lac/solver.h | 18 +- deal.II/lac/include/lac/solver_bicgstab.h | 4 +- deal.II/lac/include/lac/solver_cg.h | 10 +- deal.II/lac/include/lac/solver_control.h | 64 +- deal.II/lac/include/lac/solver_gmres.h | 10 +- deal.II/lac/include/lac/solver_minres.h | 12 +- deal.II/lac/include/lac/solver_qmrs.h | 12 +- deal.II/lac/include/lac/solver_richardson.h | 12 +- deal.II/lac/include/lac/solver_selector.h | 56 +- deal.II/lac/include/lac/sparse_ilu.h | 34 +- .../lac/include/lac/sparse_ilu.templates.h | 4 +- deal.II/lac/include/lac/sparse_matrix.h | 128 ++-- deal.II/lac/include/lac/sparse_vanka.h | 104 +-- .../lac/include/lac/sparse_vanka.templates.h | 20 +- deal.II/lac/include/lac/sparsity_pattern.h | 146 ++-- deal.II/lac/include/lac/swappable_vector.h | 64 +- .../include/lac/swappable_vector.templates.h | 6 +- deal.II/lac/include/lac/vector.h | 88 +-- deal.II/lac/include/lac/vector_memory.h | 2 +- deal.II/lac/source/sparsity_pattern.cc | 14 +- 122 files changed, 4063 insertions(+), 4010 deletions(-) diff --git a/deal.II/base/include/base/convergence_table.h b/deal.II/base/include/base/convergence_table.h index d4c26aea14..6682431b27 100644 --- a/deal.II/base/include/base/convergence_table.h +++ b/deal.II/base/include/base/convergence_table.h @@ -18,32 +18,32 @@ /** - * 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); diff --git a/deal.II/base/include/base/data_out_base.h b/deal.II/base/include/base/data_out_base.h index 32f0bd62e0..90908defdc 100644 --- a/deal.II/base/include/base/data_out_base.h +++ b/deal.II/base/include/base/data_out_base.h @@ -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; diff --git a/deal.II/base/include/base/exceptions.h b/deal.II/base/include/base/exceptions.h index 276fd3fa65..86518c7064 100644 --- a/deal.II/base/include/base/exceptions.h +++ b/deal.II/base/include/base/exceptions.h @@ -29,12 +29,12 @@ * 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 @@ -60,30 +60,30 @@ * 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: @@ -100,16 +100,16 @@ * #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 - * #nm, 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)) @@ -124,45 +124,45 @@ * 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} @@ -181,18 +181,18 @@ * 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) @@ -205,8 +205,8 @@ * }; * \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} @@ -214,14 +214,14 @@ * \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: @@ -272,7 +272,7 @@ * -------------------------------------------------------- * \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 diff --git a/deal.II/base/include/base/function.h b/deal.II/base/include/base/function.h index 2be2230aee..6f801d2709 100644 --- a/deal.II/base/include/base/function.h +++ b/deal.II/base/include/base/function.h @@ -62,15 +62,15 @@ template 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 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 &p, Vector &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 > &points, vector &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 > &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 > &points, vector > &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 &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 &p, Vector &values) const; @@ -303,12 +303,12 @@ class ZeroFunction : public Function Vector &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 > &points, @@ -316,12 +316,12 @@ class ZeroFunction : public Function 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 > &points, @@ -345,27 +345,27 @@ class ZeroFunction : public Function vector > &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 > &points, vector > &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 * 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 Vector &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 > &points, @@ -444,12 +444,12 @@ class ConstantFunction : public ZeroFunction 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 > &points, @@ -494,12 +494,12 @@ class ComponentSelectFunction : public ConstantFunction Vector &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 > &points, diff --git a/deal.II/base/include/base/function_time.h b/deal.II/base/include/base/function_time.h index 8a8e8b13ba..0e1254c9a1 100644 --- a/deal.II/base/include/base/function_time.h +++ b/deal.II/base/include/base/function_time.h @@ -25,33 +25,33 @@ * 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); diff --git a/deal.II/base/include/base/job_identifier.h b/deal.II/base/include/base/job_identifier.h index 3aa60ce7a0..72babfc175 100644 --- a/deal.II/base/include/base/job_identifier.h +++ b/deal.II/base/include/base/job_identifier.h @@ -17,9 +17,9 @@ #include /** - * 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. */ diff --git a/deal.II/base/include/base/logstream.h b/deal.II/base/include/base/logstream.h index 7b4ce1a9ad..31dd87ca0a 100644 --- a/deal.II/base/include/base/logstream.h +++ b/deal.II/base/include/base/logstream.h @@ -31,15 +31,15 @@ * \end{itemize} * * The usual usage of this class is through the pregenerated object - * #deallog#. Typical steps are + * @p{deallog}. Typical steps are *
    - *
  1. #deallog.attach(ostream)#: write logging information into a file. - *
  2. #deallog.depth_console(n)#: restrict output on screen to outer loops. + *
  3. @p{deallog.attach(ostream)}: write logging information into a file. + *
  4. @p{deallog.depth_console(n)}: restrict output on screen to outer loops. *
  5. Before entering a new phase of your program, e.g. a new loop, - * #deallog.push("loopname")#. - *
  6. #deallog << anything << endl;# to write logging information - * (Usage of #endl# is mandatory!). - *
  7. #deallog.pop()# when leaving that stage entered with #push#. + * @p{deallog.push("loopname")}. + *
  8. @p{deallog << anything << endl;} to write logging information + * (Usage of @p{endl} is mandatory!). + *
  9. @p{deallog.pop()} when leaving that stage entered with @p{push}. *
* * @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. * diff --git a/deal.II/base/include/base/multithread_info.h b/deal.II/base/include/base/multithread_info.h index 6fe02600cd..c9f5a54d06 100644 --- a/deal.II/base/include/base/multithread_info.h +++ b/deal.II/base/include/base/multithread_info.h @@ -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. */ diff --git a/deal.II/base/include/base/parameter_handler.h b/deal.II/base/include/base/parameter_handler.h index 3c1de8e8dd..f4ae625853 100644 --- a/deal.II/base/include/base/parameter_handler.h +++ b/deal.II/base/include/base/parameter_handler.h @@ -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 &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 different_values; diff --git a/deal.II/base/include/base/point.h b/deal.II/base/include/base/point.h index 309a43e919..a5f09cba67 100644 --- a/deal.II/base/include/base/point.h +++ b/deal.II/base/include/base/point.h @@ -19,23 +19,23 @@ /** - * 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 &p)#. + * using functions like @p{double f(double x)} and @p{double f(double x, double y)}, + * you use double @p{f(Point &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 gradient_of_f (const Point &x)#. #Point#s have all + * gradient of a function be a @p{point} vector: + * @p{Point gradient_of_f (const Point &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 operator + (const Point &) 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 operator - (const Point &) 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 operator / (const double) const; diff --git a/deal.II/base/include/base/quadrature.h b/deal.II/base/include/base/quadrature.h index 92dc1529a3..63d4bca1de 100644 --- a/deal.II/base/include/base/quadrature.h +++ b/deal.II/base/include/base/quadrature.h @@ -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 @@ -32,22 +32,22 @@ * 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# formulae includes $2^dim$ quadrature points in #dim# + * @p{QGauss2} 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. * @@ -55,12 +55,12 @@ * 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 & point (const unsigned int i) const; @@ -111,7 +111,7 @@ class Quadrature const vector > & 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 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 * 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 * 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 @@ -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. */ diff --git a/deal.II/base/include/base/smartpointer.h b/deal.II/base/include/base/smartpointer.h index ff1fdc6383..4f2a5d68e5 100644 --- a/deal.II/base/include/base/smartpointer.h +++ b/deal.II/base/include/base/smartpointer.h @@ -20,16 +20,16 @@ /** * 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 = new T; * \end{verbatim} @@ -43,10 +43,10 @@ * delete p; * \end{verbatim} * - * Note that a smart pointer can handle #const#ness of an object, i.e. - * a #SmartPointer# 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} really behaves as if it were a pointer to * a constant object (disallowing write access when dereferenced), while - * #SmartPointer# is a mutable pointer. + * @p{SmartPointer} is a mutable pointer. */ template 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 &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. diff --git a/deal.II/base/include/base/subscriptor.h b/deal.II/base/include/base/subscriptor.h index 2a799718bc..5e2a829549 100644 --- a/deal.II/base/include/base/subscriptor.h +++ b/deal.II/base/include/base/subscriptor.h @@ -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. */ diff --git a/deal.II/base/include/base/table_handler.h b/deal.II/base/include/base/table_handler.h index fb62247815..481e3c4ee8 100644 --- a/deal.II/base/include/base/table_handler.h +++ b/deal.II/base/include/base/table_handler.h @@ -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# with a non-common value + * a @p{TableEntry} 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 @@ -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 &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# class + * templated @p{TableEntry} 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 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 &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 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 tex_supercaptions; }; diff --git a/deal.II/base/include/base/tensor.h b/deal.II/base/include/base/tensor.h index 83ddcba199..7541b23d55 100644 --- a/deal.II/base/include/base/tensor.h +++ b/deal.II/base/include/base/tensor.h @@ -23,7 +23,7 @@ template 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 & operator -= (const Tensor &); /** - * 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 & operator *= (const double &factor); /** - * Scale the vector by #1/factor#. + * Scale the vector by @p{1/factor}. */ Tensor & 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 operator + (const Tensor &) 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 operator - (const Tensor &) 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 &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 */ diff --git a/deal.II/base/include/base/tensor_base.h b/deal.II/base/include/base/tensor_base.h index 934fcd98b5..d34c4f3f5a 100644 --- a/deal.II/base/include/base/tensor_base.h +++ b/deal.II/base/include/base/tensor_base.h @@ -32,11 +32,11 @@ template class Tensor; /** - * This class is a specialized version of the #Tensor# class. + * This class is a specialized version of the @p{Tensor} 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 @@ -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 ostream & operator << (ostream &out, const Tensor<1,dim> &p); diff --git a/deal.II/base/include/base/tensor_function.h b/deal.II/base/include/base/tensor_function.h index b98a1285d6..50ae2d13e5 100644 --- a/deal.II/base/include/base/tensor_function.h +++ b/deal.II/base/include/base/tensor_function.h @@ -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 value (const Point &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 > &points, @@ -85,11 +85,11 @@ class TensorFunction : public FunctionTime, virtual Tensor gradient (const Point &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 > &points, vector > &gradients) const; diff --git a/deal.II/base/include/base/thread_management.h b/deal.II/base/include/base/thread_management.h index c1e099b24a..7a0d984ab2 100644 --- a/deal.II/base/include/base/thread_management.h +++ b/deal.II/base/include/base/thread_management.h @@ -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 vector > @@ -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 diff --git a/deal.II/base/include/base/timer.h b/deal.II/base/include/base/timer.h index 2476258816..a160d1c576 100644 --- a/deal.II/base/include/base/timer.h +++ b/deal.II/base/include/base/timer.h @@ -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; diff --git a/deal.II/base/source/data_out_base.cc b/deal.II/base/source/data_out_base.cc index 8828de0e1a..058441847b 100644 --- a/deal.II/base/source/data_out_base.cc +++ b/deal.II/base/source/data_out_base.cc @@ -1652,7 +1652,7 @@ void DataOutBase::write_gmv (const vector > &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) diff --git a/deal.II/base/source/parameter_handler.cc b/deal.II/base/source/parameter_handler.cc index 7d7c3edd09..a7daf6b6fc 100644 --- a/deal.II/base/source/parameter_handler.cc +++ b/deal.II/base/source/parameter_handler.cc @@ -757,7 +757,7 @@ ParameterHandler::Section* ParameterHandler::get_present_defaults_subsection () const ParameterHandler::Section* ParameterHandler::get_present_defaults_subsection () const { Section* sec = const_cast(&defaults); // not nice, but needs to be and - // after all: we do not change #sec# + // after all: we do not change @p{sec} vector::const_iterator SecName = subsection_path.begin(); while (SecName != subsection_path.end()) diff --git a/deal.II/base/source/thread_management.cc b/deal.II/base/source/thread_management.cc index 9d50b6a4e4..0ce3df3d18 100644 --- a/deal.II/base/source/thread_management.cc +++ b/deal.II/base/source/thread_management.cc @@ -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 diff --git a/deal.II/deal.II/include/dofs/dof_accessor.h b/deal.II/deal.II/include/dofs/dof_accessor.h index 95cdffd9c1..9cff7b3681 100644 --- a/deal.II/deal.II/include/dofs/dof_accessor.h +++ b/deal.II/deal.II/include/dofs/dof_accessor.h @@ -37,14 +37,14 @@ template 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 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 & @@ -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 *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# derives from - * the #typedef# in the general #DoFObjectAccessor_Inheritance# - * class, which is #TriaObjectAccessor#, - * but if #celldim==dim#, then the specialization #DoFObjectAccessor_Inheritance# - * is used which declares its local type to be #CellAccessor#. 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} derives from + * the @p{typedef} in the general @p{DoFObjectAccessor_Inheritance} + * class, which is @p{TriaObjectAccessor}, + * but if @p{celldim==dim}, then the specialization @p{DoFObjectAccessor_Inheritance} + * is used which declares its local type to be @p{CellAccessor}. Therefore, + * the inheritance is automatically chosen to be from @p{CellAccessor} if the * object under consideration has full dimension, i.e. constitutes a cell. * * @author Wolfgang Bangerth, 1999 @@ -146,7 +146,7 @@ template 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# derives from - * the #typedef# in the general #DoFObjectAccessor_Inheritance# - * class, which is #TriaObjectAccessor#, - * but if #celldim==dim#, then the specialization #DoFObjectAccessor_Inheritance# - * is used which declares its local type to be #CellAccessor#. 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} derives from + * the @p{typedef} in the general @p{DoFObjectAccessor_Inheritance} + * class, which is @p{TriaObjectAccessor}, + * but if @p{celldim==dim}, then the specialization @p{DoFObjectAccessor_Inheritance} + * is used which declares its local type to be @p{CellAccessor}. Therefore, + * the inheritance is automatically chosen to be from @p{CellAccessor} if the * object under consideration has full dimension, i.e. constitutes a cell. * * @author Wolfgang Bangerth, 1999 @@ -171,7 +171,7 @@ template class DoFObjectAccessor_Inheritance { /** - * Declaration of the #typedef#. + * Declaration of the @p{typedef}. * See the full documentation for * more information. */ @@ -189,7 +189,7 @@ class DoFObjectAccessor_Inheritance * 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 * 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 * 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, DoFObjectAccessor (); /** - * Constructor. The #local_data# + * Constructor. The @p{local_data} * argument is assumed to be a pointer - * to a #DoFHandler# object. + * to a @p{DoFHandler} object. */ DoFObjectAccessor (Triangulation *tria, const int level, @@ -253,28 +253,28 @@ class DoFObjectAccessor : public DoFAccessor, DoFObjectAccessor_Inheritance::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, * active cells. * * The input vector may be either - * a #Vector#, - * #Vector#, or a - * #BlockVector<...,double>#. It + * a @p{Vector}, + * @p{Vector}, 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, /** * 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, * to this function. * * The output vector may be either - * a #Vector#, - * #Vector#, or a - * #BlockVector<...,double>#. It + * a @p{Vector}, + * @p{Vector}, 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, OutputVector &values) const; /** - * Pointer to the #i#th line + * Pointer to the @p{i}th line * bounding this Object. */ TriaIterator > line (const unsigned int i) const; /** - * Pointer to the #i#th quad + * Pointer to the @p{i}th quad * bounding this Object. */ TriaIterator > 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, * 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, /** * 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, * 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, * 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, DoFObjectAccessor (); /** - * Constructor. The #local_data# + * Constructor. The @p{local_data} * argument is assumed to be a pointer - * to a #DoFHandler# object. + * to a @p{DoFHandler} object. */ DoFObjectAccessor (Triangulation *tria, const int level, @@ -507,28 +507,28 @@ class DoFObjectAccessor<1, dim> : public DoFAccessor, 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, * cells. * * The input vector may be either - * a #Vector#, - * #Vector#, or a - * #BlockVector<...,double>#. It + * a @p{Vector}, + * @p{Vector}, 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, /** * 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, * have the right size beforehand. * * The output vector may be either - * a #Vector#, - * #Vector#, or a - * #BlockVector<...,double>#. It + * a @p{Vector}, + * @p{Vector}, 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, 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, * 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, /** * 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, DoFObjectAccessor (); /** - * Constructor. The #local_data# + * Constructor. The @p{local_data} * argument is assumed to be a pointer - * to a #DoFHandler# object. + * to a @p{DoFHandler} object. */ DoFObjectAccessor (Triangulation *tria, const int level, @@ -695,28 +695,28 @@ class DoFObjectAccessor<2, dim> : public DoFAccessor, 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, * cells. * * The input vector may be either - * a #Vector#, - * #Vector#, or a - * #BlockVector<...,double>#. It + * a @p{Vector}, + * @p{Vector}, 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, /** * 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, * have the right size beforehand. * * The output vector may be either - * a #Vector#, - * #Vector#, or a - * #BlockVector<...,double>#. It + * a @p{Vector}, + * @p{Vector}, 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, 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 > 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, * 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, /** * 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, DoFObjectAccessor (); /** - * Constructor. The #local_data# + * Constructor. The @p{local_data} * argument is assumed to be a pointer - * to a #DoFHandler# object. + * to a @p{DoFHandler} object. */ DoFObjectAccessor (Triangulation *tria, const int level, @@ -892,28 +892,28 @@ class DoFObjectAccessor<3, dim> : public DoFAccessor, 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, * cells. * * The input vector may be either - * a #Vector#, - * #Vector#, or a - * #BlockVector<...,double>#. It + * a @p{Vector}, + * @p{Vector}, 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, /** * 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, * have the right size beforehand. * * The output vector may be either - * a #Vector#, - * #Vector#, or a - * #BlockVector<...,double>#. It + * a @p{Vector}, + * @p{Vector}, 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, 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 > 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 > 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, * 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, /** * 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, /** * 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# 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# class). + * together by deriving from the appropriate @p{DoF*Accessor} and the + * right @p{CellAccessor} and finally adding two functions which give + * access to the neighbors and children as @p{DoFCellAccessor} objects + * rather than @p{CellAccessor} objects (the latter function was inherited + * from the @p{CellAccessor} class). * - * Note that since for the class we derive from, i.e. #DoFObjectAccessor#, + * Note that since for the class we derive from, i.e. @p{DoFObjectAccessor}, * the two template parameters are equal, the base class is actually derived from - * #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 DoFObjectAccessor (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 TriaIterator > 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 TriaIterator > 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 * 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 * 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 /** * 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 * 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 * 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 * objects. * * The output vector may be either - * a #Vector#, - * #Vector#, or a - * #BlockVector<...,double>#. It + * a @p{Vector}, + * @p{Vector}, or a + * @p{BlockVector<...,double>}. It * is in the responsibility of * the caller to assure that the * types of the numbers stored in diff --git a/deal.II/deal.II/include/dofs/dof_constraints.h b/deal.II/deal.II/include/dofs/dof_constraints.h index 71ec847299..3707e11c22 100644 --- a/deal.II/deal.II/include/dofs/dof_constraints.h +++ b/deal.II/deal.II/include/dofs/dof_constraints.h @@ -44,7 +44,7 @@ template class BlockIndices; * operation. * * Condensation is done in four steps: first the large matrix sparsity pattern - * is created (e.g. using #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 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 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 &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#, - * #Vector#, - * #BlockVector<...>#, or any + * The @p{VectorType} may be a + * @p{Vector}, + * @p{Vector}, + * @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#, - * #Vector#, - * #BlockVector<...>#, or any + * in-place. The @p{VectorType} may + * be a @p{Vector}, + * @p{Vector}, + * @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#, - * #Vector#, - * #BlockVector<...>#, or any + * The @p{VectorType} may be a + * @p{Vector}, + * @p{Vector}, + * @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#, - * #Vector#, - * #BlockVector<...>#, or any + * @p{VectorType} may be a + * @p{Vector}, + * @p{Vector}, + * @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#, - * #Vector#, - * #BlockVector<...>#, or any + * @p{VectorType} may be a + * @p{Vector}, + * @p{Vector}, + * @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 > 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 diff --git a/deal.II/deal.II/include/dofs/dof_constraints.templates.h b/deal.II/deal.II/include/dofs/dof_constraints.templates.h index f39cb8877e..129fbcd98d 100644 --- a/deal.II/deal.II/include/dofs/dof_constraints.templates.h +++ b/deal.II/deal.II/include/dofs/dof_constraints.templates.h @@ -88,7 +88,7 @@ void ConstraintMatrix::condense (BlockSparsityPattern &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 &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 &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 &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 &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 &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 &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 &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 &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 &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 &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 diff --git a/deal.II/deal.II/include/dofs/dof_handler.h b/deal.II/deal.II/include/dofs/dof_handler.h index 5aa4eddf70..b3273c782d 100644 --- a/deal.II/deal.II/include/dofs/dof_handler.h +++ b/deal.II/deal.II/include/dofs/dof_handler.h @@ -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)# function is called, which actually + * @p{renumber_dofs(vector)} 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)# with the array, which converts old + * @p{renumber_dofs(vector)} 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*> FunctionMap; @@ -318,7 +318,7 @@ class DoFHandler : public Subscriptor, static const unsigned int invalid_dof_index = static_cast(-1); /** - * Constructor. Take #tria# as the + * Constructor. Take @p{tria} as the * triangulation to work on. */ DoFHandler (Triangulation &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*> levels; diff --git a/deal.II/deal.II/include/dofs/dof_levels.h b/deal.II/deal.II/include/dofs/dof_levels.h index 4bbdab445c..2f6439efe8 100644 --- a/deal.II/deal.II/include/dofs/dof_levels.h +++ b/deal.II/deal.II/include/dofs/dof_levels.h @@ -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# classes + * The @p{DoFLevel} 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# 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} 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> { diff --git a/deal.II/deal.II/include/dofs/dof_tools.h b/deal.II/deal.II/include/dofs/dof_tools.h index 2a0fa4cfcd..362bdc1dbd 100644 --- a/deal.II/deal.II/include/dofs/dof_tools.h +++ b/deal.II/deal.II/include/dofs/dof_tools.h @@ -33,9 +33,9 @@ template