]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Make doxygen happy.
authorhartmann <hartmann@0785d39b-7218-0410-832d-ea1e28bc413d>
Mon, 15 Mar 2004 11:54:26 +0000 (11:54 +0000)
committerhartmann <hartmann@0785d39b-7218-0410-832d-ea1e28bc413d>
Mon, 15 Mar 2004 11:54:26 +0000 (11:54 +0000)
git-svn-id: https://svn.dealii.org/trunk@8733 0785d39b-7218-0410-832d-ea1e28bc413d

22 files changed:
deal.II/base/include/base/polynomials_p.h
deal.II/deal.II/include/dofs/dof_accessor.h
deal.II/deal.II/include/dofs/dof_constraints.h
deal.II/deal.II/include/dofs/dof_renumbering.h
deal.II/deal.II/include/dofs/dof_tools.h
deal.II/deal.II/include/fe/fe_tools.h
deal.II/deal.II/include/grid/filtered_iterator.h
deal.II/deal.II/include/grid/grid_generator.h
deal.II/deal.II/include/grid/tria.h
deal.II/deal.II/include/grid/tria_accessor.h
deal.II/deal.II/include/grid/tria_iterator.h
deal.II/deal.II/include/grid/tria_levels.h
deal.II/deal.II/include/multigrid/mg_dof_accessor.h
deal.II/deal.II/include/multigrid/mg_level_object.h
deal.II/deal.II/include/numerics/data_out_rotation.h
deal.II/deal.II/include/numerics/derivative_approximation.h
deal.II/deal.II/include/numerics/error_estimator.h
deal.II/deal.II/include/numerics/matrices.h
deal.II/deal.II/include/numerics/time_dependent.h
deal.II/lac/include/lac/block_sparsity_pattern.h
deal.II/lac/include/lac/sparsity_pattern.h
deal.II/lac/include/lac/vector.h

index ececf8dbf1fccbfcb3baf7420c7c2f52bdf97bbf..e24b8b009792f4984c2d8352d4c3a5779cf4f8a2 100644 (file)
@@ -82,9 +82,9 @@ class PolynomialsP: public PolynomialSpace<dim>
     void create_polynomial_ordering(std::vector<unsigned int> &index_map) const;
 
                                     /**
-                                     * Degree <tt>p<tt> of the
+                                     * Degree <tt>p</tt> of the
                                      * polynomial space $P_p$,
-                                     * i.e. the number <tt>p<tt>
+                                     * i.e. the number <tt>p</tt>
                                      * which was given to the
                                      * constructor.
                                      */
index 3cb1fb02f4a27790147d9da3bd8c2a8809f1d079..56770658d8427e41d0c89ca110417cb283c098d2 100644 (file)
@@ -403,16 +403,20 @@ class DoFObjectAccessor : public DoFAccessor<dim>,
     TriaIterator<dim,DoFObjectAccessor<celldim, dim> > child (const unsigned int) const;
 
                                     /**
-                                     * Distribute a local (cell based) vector
-                                     * to a global one by mapping the local
-                                     * numbering of the degrees of freedom to
-                                     * the global one and entering the local
-                                     * values into the global vector.
+                                     * Distribute a local (cell
+                                     * based) vector to a global one
+                                     * by mapping the local numbering
+                                     * of the degrees of freedom to
+                                     * the global one and entering
+                                     * the local values into the
+                                     * global vector.
                                      *
-                                     * The elements are @em{added} up to the
-                                     * elements in the global vector, rather
-                                     * than just set, since this is usually
-                                     * what one wants.
+                                     * The elements are
+                                     * <em>added</em> up to the
+                                     * elements in the global vector,
+                                     * rather than just set, since
+                                     * this is usually what one
+                                     * wants.
                                      */
     template <typename number, typename OutputVector>
     void
@@ -648,10 +652,12 @@ class DoFObjectAccessor<1, dim> :  public DoFAccessor<dim>,
                                      * the global one and entering the local
                                      * values into the global vector.
                                      *
-                                     * The elements are @em{added} up to the
-                                     * elements in the global vector, rather
-                                     * than just set, since this is usually
-                                     * what one wants.
+                                     * The elements are
+                                     * <em>added</em> up to the
+                                     * elements in the global vector,
+                                     * rather than just set, since
+                                     * this is usually what one
+                                     * wants.
                                      */
     template <typename number, typename OutputVector>
     void
@@ -848,10 +854,12 @@ class DoFObjectAccessor<2, dim> :  public DoFAccessor<dim>,
                                      * the global one and entering the local
                                      * values into the global vector.
                                      *
-                                     * The elements are @em{added} up to the
-                                     * elements in the global vector, rather
-                                     * than just set, since this is usually
-                                     * what one wants.
+                                     * The elements are
+                                     * <em>added</em> up to the
+                                     * elements in the global vector,
+                                     * rather than just set, since
+                                     * this is usually what one
+                                     * wants.
                                      */
     template <typename number, typename OutputVector>
     void
@@ -1048,16 +1056,20 @@ class DoFObjectAccessor<3, dim> :  public DoFAccessor<dim>,
     TriaIterator<dim,DoFObjectAccessor<3, dim> > child (const unsigned int) const;
 
                                     /**
-                                     * Distribute a local (cell based) vector
-                                     * to a global one by mapping the local
-                                     * numbering of the degrees of freedom to
-                                     * the global one and entering the local
-                                     * values into the global vector.
+                                     * Distribute a local (cell
+                                     * based) vector to a global one
+                                     * by mapping the local numbering
+                                     * of the degrees of freedom to
+                                     * the global one and entering
+                                     * the local values into the
+                                     * global vector.
                                      *
-                                     * The elements are @em{added} up to the
-                                     * elements in the global vector, rather
-                                     * than just set, since this is usually
-                                     * what one wants.
+                                     * The elements are
+                                     * <em>added</em> up to the
+                                     * elements in the global vector,
+                                     * rather than just set, since
+                                     * this is usually what one
+                                     * wants.
                                      */
     template <typename number, typename OutputVector>
     void
index e14179b5bb451e8bff9f4a09ecd5060c222609bd..cd4b7a687e60105c5927393290bce9b314812f87 100644 (file)
@@ -76,8 +76,8 @@ 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
- *   @em{all} entries of the matrix have to be copied, not only those which are
- *   subject to constraints.
+ *   <em>all</em> entries of the matrix have to be copied, not only
+ *   those which are subject to constraints.
  *
  * @item Use only one sparsity pattern and one matrix: doing it this way, the
  *   condense functions add nonzero entries to the sparsity pattern of the
@@ -126,7 +126,7 @@ class BlockIndices;
  * in the already condensed form.
  * 
  * 
- * @section3{Condensing vectors}
+ * @sect3{Condensing vectors}
  * 
  * Condensing vectors works exactly as described above for matrices. Note that
  * condensation is an idempotent operation, i.e. doing it more than once on a
@@ -140,7 +140,7 @@ class BlockIndices;
  * techniques as mentioned above to avoid their use.
  * 
  *
- * @section3{Distributing constraints}
+ * @sect3{Distributing constraints}
  * 
  * After solving the condensed system of equations, the solution vector has to
  * be redistributed. This is done by the two @p{distribute} function, one
index b3e138faa0db58a87b4e760425e768956502762a..ebb9f4e7d950d21d5694a96e31ab88b5a0de4485 100644 (file)
  * degrees of freedom. This renumbering may only exchange whole blocks
  * and must not destroy the block structure.
  *
- * Given an ordered vector of cells, the function @p{cell_wise_dg}
+ * Given an ordered vector of cells, the function cell_wise_dg()
  * accomplishes this. Inside the cells, the previous ordering will be
- * preserved, so it may be useful to apply @component_wise} first.
+ * preserved, so it may be useful to apply component_wise() first.
  *
  *
  * @sect2{Random renumbering}
index 1f860573e7353b0581bbde6651f062d7b0411600..b531765ed853b37ed70637400c8dbda53bdb6b40 100644 (file)
@@ -627,12 +627,12 @@ class DoFTools
                                      * shape functions cannot be
                                      * associated with a single
                                      * vector component. In this
-                                     * case, if @em{one} shape vector
-                                     * component of this element is
-                                     * flagged in
+                                     * case, if <em>one</em> shape
+                                     * vector component of this
+                                     * element is flagged in
                                      * @p{component_select}, then
                                      * this is equivalent to
-                                     * selecting @em{all} vector
+                                     * selecting <em>all</em> vector
                                      * components corresponding to
                                      * this non-primitive base
                                      * element.
index 1ab3d595b3edda58f92e31b1ad0723d301c4f587..a8fcd2aff6a5a0bca0513f00a3dd918dbf7863c8 100644 (file)
@@ -2,7 +2,7 @@
 //    $Id$
 //    Version: $Name$
 //
-//    Copyright (C) 2000, 2001, 2002, 2003 by the deal.II authors
+//    Copyright (C) 2000, 2001, 2002, 2003, 2004 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -528,13 +528,13 @@ class FETools
                                      * @p{FE_Q<2>}, you can omit the
                                      * dimension argument altogether,
                                      * or replace it with the string
-                                     * @p{<dim>}. The reason is that
-                                     * the dimension argument may be
-                                     * cumbersome if the name of a
-                                     * finite element is given in an
-                                     * input file that may be used to
-                                     * control operation of the
-                                     * program in different space
+                                     * <tt>@<dim@></tt>. The reason
+                                     * is that the dimension argument
+                                     * may be cumbersome if the name
+                                     * of a finite element is given
+                                     * in an input file that may be
+                                     * used to control operation of
+                                     * the program in different space
                                      * dimensions. Running the
                                      * program in another space
                                      * dimension would then require
index 23dc48aa366e47574d2f50bb5c34e47321532403..f778fd4fe5d26a7f28e2e06ea2aecaf866ef9f26 100644 (file)
@@ -2,7 +2,7 @@
 //    $Id$
 //    Version: $Name$
 //
-//    Copyright (C) 2002, 2003 by the deal.II authors
+//    Copyright (C) 2002, 2003, 2004 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -182,9 +182,9 @@ namespace IteratorFilters
 /**
  * This class provides a certain view on a range of triangulation or
  * DoFHandler iterators by only iterating over elements that satisfy a
- * given filter (called a @em{predicate}, following the notation of
- * the C++ standard library). Once initialized with a predicate and a
- * value for the iterator, a filtered iterator hops to the next or
+ * given filter (called a <em>predicate</em>, following the notation
+ * of the C++ standard library). Once initialized with a predicate and
+ * value for the iterator, a filtered iterator hops to the next or
  * previous element that satisfies the predicate if operators ++ or --
  * are invoked. Intermediate iterator values that lie in between but
  * do not satisfy the predicate are skipped. It is thus very simple to
@@ -283,9 +283,9 @@ namespace IteratorFilters
  * iterators a nightmare, we rather give the predicate as an
  * unchangeable entity to the constructor. Note that one can assign a
  * filtered iterator with one predicate to another filtered iterator
- * with another type; yet, this does @em{not} change the predicate of
- * the assigned-to iterator, only the pointer indicating the iterator
- * is changed.
+ * with another type; yet, this does <em>not</em> change the predicate
+ * of the assigned-to iterator, only the pointer indicating the
+ * iterator is changed.
  *
  * If a filtered iterator is not assigned a value of the underlying
  * (unfiltered) iterator type, the default value is taken. If,
index 2e2e7233ebaceae1543fcef6d2d346ae8f06b863..c8698a9027efea527dc1cda7ae0740044a7b0d3b 100644 (file)
@@ -2,7 +2,7 @@
 //    $Id$
 //    Version: $Name$
 //
-//    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 by the deal.II authors
+//    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -34,9 +34,10 @@ template <typename number> class SparseMatrix;
  *       domain which is the tensor product of an interval $[a,b]$ in
  *       the given number of spatial dimensions. If you want to create such
  *       a domain, which is a common test case for model problems, call
- *       @ref{GridGenerator}@p{::hyper_cube (tria, a,b)}, which produces a
- *       hypercube domain triangulated with exactly one element. You can
- *       get tensor product meshes by successive refinement of this cell.
+ *       GridGenerator::hyper_cube(tria, a,b), which produces a
+ *       hypercube domain triangulated with exactly one element. You
+ *       can get tensor product meshes by successive refinement of
+ *       this cell.
  *
  *       If you want the hypercube subdivided a certain number of
  *       times (and if this is not achievable by hierarchic
@@ -46,17 +47,17 @@ template <typename number> class SparseMatrix;
  *
  *    @item Rectangular coordinate-parallel domains as a generalization
  *      of hypercubes are generated by
- *      @ref{GridGenerator}@p{::hyper_rectangle (tria, p1, p2)}, with two
+ *      GridGenerator::hyper_rectangle (tria, p1, p2), with two
  *      opposite corner points @p{p1} and @p{p2}.
  *
  *    @item Rectangular coordinate-parallel domains with different numbers of
  *     cells in each coordinate direction are generated by 
- *      @ref{GridGenerator}@p{::subdivided_hyper_rectangle 
- *     (tria, int[dim] repetitions, p1, p2, colorize)}, with two
+ *      GridGenerator::subdivided_hyper_rectangle
+ *     (tria, int[dim] repetitions, p1, p2, colorize), with two
  *      opposite corner points @p{p1} and @p{p2}.
  *
  *    @item Generalized L-shape domain:
- *      using the @ref{GridGenerator}@p{::hyper_L (tria, a,b)} function produces
+ *      using the GridGenerator::hyper_L (tria, a,b) function produces
  *      the hypercube with the interval $[a,b]$ without the hypercube
  *      made out of the interval $[(a+b)/2,b]$. Let, for example, be $a=-1$
  *      and $b=1$, then the hpyer-L in two dimensions is the region
@@ -64,13 +65,14 @@ template <typename number> class SparseMatrix;
  *      an error. The function is also implemented for three space dimensions.
  *
  *    @item Hyper ball:
- *      You get the circle or ball (or generalized: hyperball) around origin
- *      @p{p} and with radius @p{r} by calling
- *      @ref{GridGenerator}@p{::hyper_ball (tria, p, r)}. The circle is triangulated
- *      by five cells, the ball by seven cells. The diameter of the center cell is
- *      chosen so that the aspect ratio of the boundary cells after one refinement
- *      is minimized in some way. To create a hyperball in one dimension results in
- *      an error.
+ *      You get the circle or ball (or generalized: hyperball) around
+ *      origin @p{p} and with radius @p{r} by calling
+ *      GridGenerator::hyper_ball (tria, p, r). The circle is
+ *      triangulated by five cells, the ball by seven cells. The
+ *      diameter of the center cell is chosen so that the aspect ratio
+ *      of the boundary cells after one refinement is minimized in
+ *      some way. To create a hyperball in one dimension results in an
+ *      error.
  *
  *      Do not forget to also attach a suitable boundary approximation object
  *      to the triangulation object you passed to this function if you later want
@@ -79,7 +81,7 @@ template <typename number> class SparseMatrix;
  *    @item Half Hyper ball:
  *      You get half of the circle generated by Hyper ball.
  *      with center @p{p} and with radius @p{r} by calling
- *      @ref{GridGenerator}@p{::half_hyper_ball (tria, p, r)}. The half-circle is 
+ *      GridGenerator::half_hyper_ball (tria, p, r). The half-circle is 
  *      triangulated by four cells. The diameter of the center cell is
  *      chosen to be the same as for the Hyper ball class. 
  *      To create a half-hyperball in one dimension results in
@@ -88,12 +90,12 @@ template <typename number> class SparseMatrix;
  *      Do not forget to also attach a suitable boundary approximation object
  *      to the triangulation object you passed to this function if you later want
  *      the triangulation to be refined at the outer boundaries. The class
- *      @ref{HalfHyperBallBoundary} will provide a boundary object.
+ *      HalfHyperBallBoundary will provide a boundary object.
  *
  *    @item Hyper shell: A hyper shell is the region between two hyper
  *      sphere with the same origin. Therefore, it is a ring in two
  *      spatial dimensions. To triangulation it, call the function
- *      @ref{GridGenerator}@p{::hyper_shell (tria, origin, inner_radius, outer_radius, N)},
+ *      GridGenerator::hyper_shell (tria, origin, inner_radius, outer_radius, N),
  *      where the center of the spheres as well as
  *      the inner and outer radius of the two spheres are given as
  *      shown.
index 92029dab06099e3ce54f783808e3c0358e8b0c96..c60189dcc31b652332f79845cf34597a558b5b46 100644 (file)
@@ -714,7 +714,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *  Usage of these iterators works mostly like with the STL iterators. Some
  *  examples taken from the @ref{Triangulation} source code follow.
  *  @begin{itemize}
- *  @item @em{Counting the number of cells on a specific level}
+ *  @item <em>Counting the number of cells on a specific level</em>
  *    @begin{verbatim}
  *     template <int dim>
  *     int Triangulation<dim>::n_cells (const int level) const {
@@ -740,7 +740,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *      };  
  *    @end{verbatim}
  *    
- *  @item @em{Refining all cells of a triangulation}
+ *  @item <em>Refining all cells of a triangulation</em>
  *    @begin{verbatim}
  *      template <int dim>
  *      void Triangulation<dim>::refine_global () {
@@ -1235,7 +1235,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   and read the flags of all used lines, quads, etc, not only of the
  *   active ones (well, activity is a concept which really only applies to
  *   cells, not for example to lines in 2D, so the abovementioned generalization
- *   to @em{all} lines, quads, etc seems plausible).
+ *   to <em>all</em> lines, quads, etc seems plausible).
  *
  *   If you want to store more specific user flags, you can use the functions
  *   @p{save_user_flags_line} and @p{load_user_flags_line} and the generalizations
@@ -1341,7 +1341,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   at the old grid and the refinement flags for each cell.
  *
  *   @begin{itemize}
- *   @item @em{Regularization:} The algorithm walks over all cells checking
+ *   @item <em>Regularization:</em> The algorithm walks over all cells checking
  *     whether the present cell is flagged for refinement and a neighbor of the
  *     present cell is refined once less than the present one. If so, flag the
  *     neighbor for refinement. Because of the induction above, there may be no
@@ -1355,7 +1355,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *     on lower levels, but if these induce more refinement needed, this is
  *     performed later on when we visit them in out backward running loop.
  *
- *   @item @em{Smoothing:}
+ *   @item <em>Smoothing:</em>
  *     @begin{itemize}
  *     @item @p{limit_level_difference_at_vertices}:
  *       First a list is set up which stores for each vertex
@@ -1567,7 +1567,7 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *     *-------*        *-------*
  *   @end{verbatim}
  *
- *   The @em{standard} direction of the faces is determined by the
+ *   The <em>standard</em> direction of the faces is determined by the
  *   numbers the lines have within a given face. This is like follows:
  *   @begin{itemize}
  *   @item Faces 0 and 1:
@@ -1650,17 +1650,17 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *   all faces that are consistent with this convention.
  *
  *   For this reason, above convention is only what we call the
- *   @em{standard orientation}. deal.II actually allows faces in 3d to
- *   have either the standard direction, or its opposite, in which
- *   case the lines that make up a cell would have reverted orders,
- *   and the above line equivalences would not hold any more. You can
- *   ask a cell whether a given face has standard orientation by
- *   calling @p{cell->face_orientation(face_no)}: if the result is
- *   @p{true}, then the face has standard orientation, otherwise its
- *   normal vector is pointing the other direction. There are not very
- *   many places in application programs where you need this
- *   information actually, but a few places in the library make use of
- *   this.
+ *   <em>standard orientation</em>. deal.II actually allows faces in
+ *   3d to have either the standard direction, or its opposite, in
+ *   which case the lines that make up a cell would have reverted
+ *   orders, and the above line equivalences would not hold any
+ *   more. You can ask a cell whether a given face has standard
+ *   orientation by calling @p{cell->face_orientation(face_no)}: if
+ *   the result is @p{true}, then the face has standard orientation,
+ *   otherwise its normal vector is pointing the other
+ *   direction. There are not very many places in application programs
+ *   where you need this information actually, but a few places in the
+ *   library make use of this.
  *
  *   @sect4{Children}
  *
index 2d7ab14f773fd3771526239d76ae269dbbb70398..1e6f00320ec497b756862431d4b3c978e627817e 100644 (file)
@@ -1709,24 +1709,23 @@ class TriaObjectAccessor<2, dim> :  public TriaAccessor<dim>
 
   private:
                                     /**
-                                     *  Copy operator. This is
-                                     *  normally used in a context
-                                     *  like @p{iterator a,b;
-                                     *  *a=*b;}. Since the meaning is
-                                     *  to copy the object pointed to
-                                     *  by @p{b} to the object
-                                     *  pointed to by @p{a} and since
-                                     *  accessors are not real but
-                                     *  virtual objects, this
-                                     *  operation is not useful for
-                                     *  iterators on
-                                     *  triangulations. We declare
-                                     *  this function here private,
-                                     *  thus it may not be used from
-                                     *  outside.  Furthermore it is
-                                     *  not implemented and will give
-                                     *  a linker error if used
-                                     *  anyway.
+                                     * Copy operator. This is
+                                     * normally used in a context
+                                     * like <tt>iterator a,b;
+                                     * *a=*b;</tt>. Since the meaning
+                                     * is to copy the object pointed
+                                     * to by @p{b} to the object
+                                     * pointed to by @p{a} and since
+                                     * accessors are not real but
+                                     * virtual objects, this
+                                     * operation is not useful for
+                                     * iterators on
+                                     * triangulations. We declare
+                                     * this function here private,
+                                     * thus it may not be used from
+                                     * outside.  Furthermore it is
+                                     * not implemented and will give
+                                     * a linker error if used anyway.
                                      */
     void operator = (const TriaObjectAccessor<2, dim> &);
 
@@ -2290,9 +2289,9 @@ class TriaObjectAccessor<3, dim> :  public TriaAccessor<dim>
  *
  * The following refers to any space dimension:
  * 
- * This class allows access to a @em{cell}, which is a line in 1D and
- * a quad in 2D. Cells have more functionality than lines or quads by
- * themselves, for example they can be flagged for refinement, they
+ * This class allows access to a <tt>cell</tt>, which is a line in 1D
+ * and a quad in 2D. Cells have more functionality than lines or quads
+ * by themselves, for example they can be flagged for refinement, they
  * have neighbors, they have the possibility to check whether they are
  * at the boundary etc. This class offers access to all this data.
  *
@@ -2613,8 +2612,8 @@ class CellAccessor :  public TriaObjectAccessor<dim,dim>
                                     /**
                                      *  Copy operator. This is
                                      *  normally used in a context
-                                     *  like @p{iterator a,b;
-                                     *  *a=*b;}. Since the meaning is
+                                     *  like <tt>iterator a,b;
+                                     *  *a=*b;</tt>. Since the meaning is
                                      *  to copy the object pointed to
                                      *  by @p{b} to the object
                                      *  pointed to by @p{a} and since
index 91c4e1fb62c5d51bfecb8264f31a08e4509e3a80..821de54d5d0b1e475e393fbfff7fe308844d2f16 100644 (file)
@@ -500,8 +500,8 @@ class TriaRawIterator :
 
 
 /**
- *   This specialization of @ref{TriaRawIterator} provides access only to the
- *   @em{used} lines, quads, cells, etc.
+ *   This specialization of TriaRawIterator provides access only to
+ *   the <em>used</em> lines, quads, cells, etc.
  */
 template <int dim, typename Accessor>
 class TriaIterator : public TriaRawIterator<dim,Accessor> 
@@ -646,9 +646,10 @@ class TriaIterator : public TriaRawIterator<dim,Accessor>
 
 
 /**
- *   This specialization of @ref{TriaIterator} provides access only to the
- *   @em{active} lines, quads, cells, etc. An active cell is a cell which is not
- *   refined and thus a cell on which calculations on the finest level are done.
+ *   This specialization of TriaIterator provides access only to the
+ *   <em>active</em> lines, quads, cells, etc. An active cell is a
+ *   cell which is not refined and thus a cell on which calculations
+ *   on the finest level are done.
  */
 template <int dim, typename Accessor>
 class TriaActiveIterator : public TriaIterator<dim,Accessor> 
index c33ea800b8cde5587c41030dd31dadf9e738928d..3febb1c641c746fad26b8c3240f6a1f677a4f2c8 100644 (file)
@@ -96,10 +96,11 @@ class TriangulationLevel<0>
                                      *  at the boundary), @p{level=index=-1}
                                      *  is set.
                                      *
-                                     *  @em{Conventions:} The @p{i}th neighbor
-                                     *  of a cell is the one which shares
-                                     *  the @p{i}th face (@p{Line} in 2D, @p{Quad}
-                                     *  in 3D) of this cell.
+                                     *  <em>Conventions:</em> The
+                                     *  @p{i}th neighbor of a cell is
+                                     *  the one which shares the
+                                     *  @p{i}th face (@p{Line} in 2D,
+                                     *  @p{Quad} in 3D) of this cell.
                                      *
                                      *  The neighbor of a cell has at most the
                                      *  same level as this cell, i.e. it may
index 6431d818cb95c1c373718675bd556bb53a210e4d..b1b5396b2aedd234623b385fd12c96381eabb2e0 100644 (file)
@@ -2,7 +2,7 @@
 //    $Id$
 //    Version: $Name$
 //
-//    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 by the deal.II authors
+//    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -341,7 +341,7 @@ class MGDoFObjectAccessor<1, dim> :  public MGDoFAccessor<dim>,
 /**
  * Grant access to the multilevel degrees of freedom located on quads.
  *
- * @ref DoFLineAccessor
+ * DoFLineAccessor
  */
 template <int dim>
 class MGDoFObjectAccessor<2, dim> :  public MGDoFAccessor<dim>,
@@ -466,7 +466,7 @@ class MGDoFObjectAccessor<2, dim> :  public MGDoFAccessor<dim>,
 /**
  * Grant access to the multilevel degrees of freedom located on hexhedra.
  *
- * @ref DoFLineAccessor
+ * DoFLineAccessor
  */
 template <int dim>
 class MGDoFObjectAccessor<3, dim> :  public MGDoFAccessor<dim>,
index d593d9757c55cc6b85daa561831391484a1dc980..431c77a2e87aba1edb48a14dc008912d39b173d3 100644 (file)
@@ -73,11 +73,11 @@ class MGLevelObject : public Subscriptor
                                      * for some @p{Object} classes,
                                      * most notably for vectors and
                                      * matrices. Note that if
-                                     * @p{Object==Vector<T>}, @p{clear}
-                                     * will set all entries to zero,
-                                     * while if
-                                     * @p{Object==vector<T>},
-                                     * @p{clear} deletes the elements
+                                     * <tt>Object==Vector@<T@></tt>,
+                                     * clear() will set all entries
+                                     * to zero, while if
+                                     * <tt>Object==vector@<T@></tt>,
+                                     * clear() deletes the elements
                                      * of the vectors. This class
                                      * might therefore not be useful
                                      * for STL vectors.
index 520ebb0ffc400b5585b81e0fb548936fe2519559..e2e44647e2707fd44a7b2d97d31e73cca0bf4d60 100644 (file)
@@ -2,7 +2,7 @@
 //    $Id$
 //    Version: $Name$
 //
-//    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 by the deal.II authors
+//    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -39,7 +39,7 @@ template <int dim> class DoFHandler;
  * intervals as well; the number of these intervals must be given to
  * the @p{build_patches} function. It is noted, however, that while
  * this function generates nice pictures of the whole domain, it often
- * produces @em{very} large output files.
+ * produces <em>very</em> large output files.
  *
  *
  * @sect3{Interface}
index 8e5c758404a25b13e30d252cd93ecbf79524583e..d2e134ee5bc294e761aeaa698111c9a69d4ee0ab 100644 (file)
@@ -195,7 +195,7 @@ class DerivativeApproximation
                                     /**
                                      * Calls the @p{interpolate}
                                      * function, see above, with
-                                     * @p{mapping=MappingQ1<dim>()}.
+                                     * <tt>mapping=MappingQ1@<dim@>()</tt>.
                                      */
     template <int dim, class InputVector>
     static void
@@ -242,7 +242,7 @@ class DerivativeApproximation
                                     /**
                                      * Calls the @p{interpolate}
                                      * function, see above, with
-                                     * @p{mapping=MappingQ1<dim>()}.
+                                     * <tt>mapping=MappingQ1@<dim@>()</tt>.
                                      */
     template <int dim, class InputVector>
     static void
index 34fdf6293f40ccd69d3557db7a5685a1e0b91f3a..6a03541f7db9f35f199bc65aa01f1393c975e546 100644 (file)
@@ -273,7 +273,7 @@ class KellyErrorEstimator
                                     /**
                                      * Calls the @p{estimate}
                                      * function, see above, with
-                                     * @p{mapping=MappingQ1<dim>()}.
+                                     * <tt>mapping=MappingQ1@<dim@>()</tt>.
                                      */    
     template <typename InputVector>
     static void estimate (const DoFHandler<dim>   &dof,
@@ -326,7 +326,7 @@ class KellyErrorEstimator
                                     /**
                                      * Calls the @p{estimate}
                                      * function, see above, with
-                                     * @p{mapping=MappingQ1<dim>()}.
+                                     * <tt>mapping=MappingQ1@<dim@>()</tt>.
                                      */
     template <typename InputVector>
     static void estimate (const DoFHandler<dim>       &dof,
index 582a19565536aae83b30a35a3b2ff2ba3867ed9f..f982a0c8b5d5c3f25c1f9411061c2750cb2d217b 100644 (file)
@@ -2,7 +2,7 @@
 //    $Id$
 //    Version: $Name$
 //
-//    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 by the deal.II authors
+//    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -49,10 +49,10 @@ template <int dim> class FEValues;
  *
  * There exist two versions of each function. One with a @ref{Mapping}
  * argument and one without. If a code uses a mapping different from
- * @ref{MappingQ1} the functions @em{with} mapping argument should be
- * used. Code that uses only @ref{MappingQ1} may also use the
- * functions @em{without} @ref{Mapping} argument. Each of these latter
- * functions create a @ref{MappingQ1} object and just call the
+ * @ref{MappingQ1} the functions <em>with</em> mapping argument should
+ * be used. Code that uses only @ref{MappingQ1} may also use the
+ * functions <em>without</em> @ref{Mapping} argument. Each of these
+ * latter functions create a @ref{MappingQ1} object and just call the
  * respective functions with that object as mapping argument. The
  * functions without @ref{Mapping} argument still exist to ensure
  * backward compatibility. Nevertheless it is advised to change the
@@ -211,9 +211,9 @@ class MatrixCreator
                                    const Function<dim> * const a = 0);
 
                                     /**
-                                     * Calls the @p{create_mass_matrix}
+                                     * Calls the create_mass_matrix()
                                      * function, see above, with
-                                     * @p{mapping=MappingQ1<dim>()}.
+                                     * <tt>mapping=MappingQ1@<dim@>()</tt>.
                                      */
     template <int dim, typename number>
     static void create_mass_matrix (const DoFHandler<dim>    &dof,
@@ -244,9 +244,9 @@ class MatrixCreator
                                    const Function<dim> * const a = 0);
 
                                     /**
-                                     * Calls the @p{create_mass_matrix}
+                                     * Calls the create_mass_matrix()
                                      * function, see above, with
-                                     * @p{mapping=MappingQ1<dim>()}.
+                                     * <tt>mapping=MappingQ1@<dim@>()</tt>.
                                      */
     template <int dim, typename number>
     static void create_mass_matrix (const DoFHandler<dim>    &dof,
@@ -303,9 +303,9 @@ class MatrixCreator
 
                                     /**
                                      * Calls the
-                                     * @p{create_boundary_mass_matrix}
+                                     * create_boundary_mass_matrix()
                                      * function, see above, with
-                                     * @p{mapping=MappingQ1<dim>()}.
+                                     * <tt>mapping=MappingQ1@<dim@>()</tt>.
                                      */
     template <int dim>
     static
@@ -338,9 +338,10 @@ class MatrixCreator
                                       const Function<dim> * const a = 0);
     
                                     /**
-                                     * Calls the @p{create_laplace_matrix}
+                                     * Calls the
+                                     * create_laplace_matrix()
                                      * function, see above, with
-                                     * @p{mapping=MappingQ1<dim>()}.
+                                     * <tt>mapping=MappingQ1@<dim@>()</tt>.
                                      */
     template <int dim>
     static void create_laplace_matrix (const DoFHandler<dim>    &dof,
@@ -372,9 +373,10 @@ class MatrixCreator
                                       const Function<dim> * const a = 0);
 
                                     /**
-                                     * Calls the @p{create_laplace_matrix}
+                                     * Calls the
+                                     * create_laplace_matrix()
                                      * function, see above, with
-                                     * @p{mapping=MappingQ1<dim>()}.
+                                     * <tt>mapping=MappingQ1@<dim@>()</tt>.
                                      */
     template <int dim>
     static void create_laplace_matrix (const DoFHandler<dim>    &dof,
index a2b914bc913a3c06ce2627c8d5bb6ff4d6ef1099..040bb5aaec7437d89523be9ac1999ca690386fa7 100644 (file)
@@ -2,7 +2,7 @@
 //    $Id$
 //    Version: $Name$
 //
-//    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 by the deal.II authors
+//    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -574,9 +574,9 @@ class TimeDependent
                                      * To see how this function work, note that
                                      * the function @p{solve_primal_problem} only
                                      * consists of a call to
-                                     * @p{do_loop (mem_fun(&TimeStepBase::init_for_primal_problem),
+                                     * <tt>do_loop (mem_fun(&TimeStepBase::init_for_primal_problem),
                                      *    mem_fun(&TimeStepBase::solve_primal_problem),
-                                     *    timestepping_data_primal, forward);}.
+                                     *    timestepping_data_primal, forward);</tt>.
                                      *
                                      * Note also, that the given class from which
                                      * the two functions are taken needs not
index 65dbbc9a0cf62f30d611f53a2c8cc81babb19495..77fb0726fc5c891d9c9a43dc22687a44a5ab5192 100644 (file)
@@ -322,7 +322,7 @@ class BlockSparsityPatternBase : public Subscriptor
                                      * one line per row of the format
                                      * <tt>[i,j1,j2,j3,...]</tt>. <i>i</i>
                                      * is the row number and
-                                     * <i>jn</n> are the allocated
+                                     * <i>jn</i> are the allocated
                                      * columns in this row.
                                      */
     void print (std::ostream &out) const;
index a92886edf3153992ca8f6e327b61d0b97dda0a34..0e1253df48612ebea3e3b707eea8ded48e43b40e 100644 (file)
@@ -843,7 +843,7 @@ class SparsityPattern : public Subscriptor
                                      * one line per row of the format
                                      * <tt>[i,j1,j2,j3,...]</tt>. <i>i</i>
                                      * is the row number and
-                                     * <i>jn</n> are the allocated
+                                     * <i>jn</i> are the allocated
                                      * columns in this row.
                                      */
     void print (std::ostream &out) const;
index 4f9eaee96d5e664e8cfea091eabb7cfaf500f8e8..ef69dff3d7991fc329cef7f95405f59916c751fa 100644 (file)
@@ -127,14 +127,17 @@ class Vector
                                      * @p{n} and initialize all
                                      * elements with zero.
                                      *
-                                     * The constructor is made explicit to
-                                     * avoid accidents like this:
-                                     * @p{v=0;}. Presumably, the user wants
-                                     * to set every element of the vector to
-                                     * zero, but instead, what happens is
-                                     * this call: @p{v=Vector<number>(0);},
-                                     * i.e. the vector is replaced by one of
-                                     * length zero.
+                                     * The constructor is made
+                                     * explicit to avoid accidents
+                                     * like this:
+                                     * @p{v=0;}. Presumably, the user
+                                     * wants to set every element of
+                                     * the vector to zero, but
+                                     * instead, what happens is this
+                                     * call:
+                                     * <tt>v=Vector@<number@>(0);</tt>,
+                                     * i.e. the vector is replaced by
+                                     * one of length zero.
                                      */
     explicit Vector (const unsigned int n);
 

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

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.