]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Last few doxygen markups.
authorwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Mon, 19 Apr 2004 20:08:26 +0000 (20:08 +0000)
committerwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Mon, 19 Apr 2004 20:08:26 +0000 (20:08 +0000)
git-svn-id: https://svn.dealii.org/trunk@9062 0785d39b-7218-0410-832d-ea1e28bc413d

12 files changed:
deal.II/deal.II/include/dofs/dof_levels.h
deal.II/deal.II/include/dofs/dof_tools.h
deal.II/deal.II/include/grid/grid_reordering.h
deal.II/deal.II/include/grid/persistent_tria.h
deal.II/deal.II/include/grid/tria.h
deal.II/deal.II/include/grid/tria_boundary_lib.h
deal.II/deal.II/include/grid/tria_levels.h
deal.II/deal.II/include/numerics/data_out_faces.h
deal.II/deal.II/include/numerics/error_estimator.h
deal.II/deal.II/include/numerics/matrices.h
deal.II/deal.II/include/numerics/solution_transfer.h
deal.II/deal.II/include/numerics/vectors.h

index c587d38a1581e3bfe87b3aca05be9a289c2fc7c3..7a755d96efcc36e904ddf73912ee42388f613bf6 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
@@ -45,7 +45,7 @@ class DoFLevel
  *
  * @sect3{Information for all DoFLevel classes}
  *
- * The DoFLevel<tt><N></tt> classes 
+ * The <tt>DoFLevel<N></tt> classes 
  * store the global indices of the degrees of freedom for each cell on a
  * certain level. The index or number of a degree of freedom is the zero-based
  * index of the according value in the solution vector and the row and column
@@ -63,19 +63,19 @@ 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<tt>::make_hanging_node_constraints ()</tt>
+ * constraint matrix returned by 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<tt><dim></tt> classes for the different dimensions which
+ * DoFLevel<dim> classes for the different dimensions which
  * have objects named @p line_dofs, @p quad_dofs and so on, in which
  * the indices of DoFs located on lines and quads, respectively, are
  * stored. The indices are stored levelwise. The layout in these
  * arrays is as follows: if for a selected finite element (use
- * DoFHandler<tt>::distribute_dofs()</tt> to select a finite element)
+ * 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 ith
index 24ff517b5cd31396554de0872c4d31ebce0d305c..dffee2e726dff3e12d897bf7a5eef0a2949e5fe1 100644 (file)
@@ -183,11 +183,11 @@ class DoFTools
                                      * of hanging nodes.  They have
                                      * to be taken care of by a call
                                      * to
-                                     * ConstraintMatrix<tt>::condense()</tt>
+                                     * ConstraintMatrix::condense()
                                      * afterwards.
                                      *
                                      * Remember using
-                                     * SparsityPattern<tt>::compress()</tt>
+                                     * SparsityPattern::compress()
                                      * after generating the pattern.
                                      *
                                      * The actual type of the
@@ -316,14 +316,14 @@ class DoFTools
                                      * nodes.  The sparsity pattern
                                      * is not compressed, since if
                                      * you want to call
-                                     * ConstraintMatrix<tt>::condense(1)</tt>
+                                     * ConstraintMatrix::condense()
                                      * afterwards, new entries have
                                      * to be added. However, if you
                                      * don't want to call
-                                     * ConstraintMatrix<tt>::condense(1)</tt>,
+                                     * ConstraintMatrix::condense(),
                                      * you have to compress the
                                      * matrix yourself, using
-                                     * SparsityPattern<tt>::compress()</tt>.
+                                     * SparsityPattern::compress()
                                      *
                                      * The actual type of the
                                      * sparsity pattern may be
index b9a772417e47a0f03b6f65987c41cd087a636c5c..f81c7b875d0f64550c615ddef5bfd64d31c12be3 100644 (file)
  * smaller (for example by one order of magnitude) than the time
  * needed to read the data from a file, and also to actually generate
  * the triangulation from this data using the
- * Triangulation<tt><dim>::create_triangulation</tt> function.
+ * Triangulation::create_triangulation() function.
  *
  * @author Wolfgang Bangerth, 2000, Michael Anderson 2003
  */
index 4c9baf73b2e6339dafaf52065b8ca436a58279a6..07a15833d8ff163d64b517a5cac8a0df8e4cd544 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
  * constitute a triangulation; it only becomes one after @p restore is first
  * called. Note also that the @p execute_coarsening_and_refinement stores
  * all necessary flags for later reconstruction using the @p restore function.
- * Triangulation<tt><dim>::clear ()</tt> resets the underlying triangulation to a
+ * Triangulation::clear() resets the underlying triangulation to a
  * virgin state, but does not affect the stored refinement flags needed for
  * later reconstruction and does also not touch the coarse grid which is
- * used withing <tt>restore()</tt>.
+ * used within restore().
  *
  * @author Wolfgang Bangerth, 1999
  */
index 0257ee3cb92c04256853a53264de9c18bbec3456..0ded2fd825142c982cfe9af834d5e1460625e7fc 100644 (file)
@@ -41,7 +41,7 @@ template <int dim> class MGDoFHandler;
 
 /**
  *  Structure which is passed to the
- *  Triangulation<tt><dim>::create_triangulation</tt> function. It
+ *  <tt>Triangulation<dim>::create_triangulation</tt> function. It
  *  contains all data needed to construct a cell, namely the indices
  *  of the vertices and the material indicator.
  */
@@ -102,7 +102,7 @@ struct CellData
 
 
 /**
- *  Structure to be passed to the Triangulation<tt><dim>::create_triangulation</tt>
+ *  Structure to be passed to the Triangulation<dim>::create_triangulation
  *  function to describe boundary information.
  *
  *  This structure is the same for all dimensions, since we use an input
@@ -819,8 +819,8 @@ struct TriaNumberCache<3> : public TriaNumberCache<2>
  *        by providing a list of vertices and a list of cells. Each such cell
  *        consists of a vector storing the indices of the vertices of this cell
  *        in the vertex list. To see how this works, you can take a look at the
- *        GridIn<tt><dim>::read_*</tt> functions. The appropriate function to be
- *        called is <tt>Triangulation<dim>::create_triangulation ()</tt>.
+ *        GridIn<dim>::read_* functions. The appropriate function to be
+ *        called is create_triangulation().
  *
  *        Creating the hierarchical information needed for this
  *        library from cells storing only vertex information can be
index 8f6a9419f57f8f34ca40d30a2ff042177dacdc7c..8b2c7c92168fc232d48581b389c1368dc1394c2d 100644 (file)
  * @p cylinder function of GridGenerator. It should be used for
  * the hull of the cylinder only (boundary indicator 0).
  *
- *   This class is derived from StraightBoundary rather than from
- *   Boundary, which would seem natural, since this way we can use the
- *   StraightBoundary<tt><dim>::in_between(neighbors)</tt> function.
+ * This class is derived from StraightBoundary rather than from
+ * Boundary, which would seem natural, since this way we can use the
+ * StraightBoundary::in_between() function.
  *
- *   @author Guido Kanschat, 2001
+ * @author Guido Kanschat, 2001
  */
 template <int dim>
 class CylinderBoundary : public StraightBoundary<dim>
@@ -151,7 +151,7 @@ class CylinderBoundary : public StraightBoundary<dim>
  *
  *   This class is derived from StraightBoundary rather than from
  *   Boundary, which would seem natural, since this way we can use the
- *   StraightBoundary<tt><dim>::in_between(neighbors)</tt> function.
+ *   StraightBoundary::in_between() function.
  *
  *   @author Wolfgang Bangerth, 1998, Ralf Hartmann, 2001
  */
index fd39a5505125a436ebfe8cd0fd78d58846e83ef9..f5c4694670c130e9ed146730ab4110d3dda38644 100644 (file)
@@ -239,7 +239,7 @@ class TriangulationLevel<1> : public TriangulationLevel<0>
                                          *  stored in this list. A line is
                                          *  called active if it has no
                                          *  children. The function
-                                         *  TriaIterator<tt>::active()</tt>
+                                         *  TriaAccessor::has_children()
                                          *  tests for this.
                                          */
        std::vector<int>  children;
@@ -267,7 +267,7 @@ class TriangulationLevel<1> : public TriangulationLevel<0>
                                          *  already been processed.
                                          *
                                          *  You can clear all used flags using
-                                         *  Triangulation<tt>::clear_user_flags()</tt>.
+                                         *  Triangulation::clear_user_flags().
                                          */
        std::vector<bool> user_flags;
 
index 72790424bff45aecf85804ffc4877ef373ae9f5a..820a19a1c6f3013c951dd00b543cfae8265a5176 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
@@ -109,7 +109,7 @@ class DataOutFaces : public DataOut_DoFData<dim,dim-1,dim>
                                      * generate output for. The usual
                                      * way would, of course, be to
                                      * use an object of type
-                                     * DoFHandler<tt><dim>::fec_iterator</tt>,
+                                     * <tt>DoFHandler<dim>::face_iterator</tt>,
                                      * but since we have to describe
                                      * faces to objects of type
                                      * FEValues, we can only
index 8cc8b3f5fe4ecbfcbaa39dcba089e0e9c89c25c2..bb98eee9896de3e9c05ba8749e40214483bf6f63 100644 (file)
@@ -49,7 +49,7 @@ template <int dim> class FESubfaceValues;
  *  the conormal derivative $a\frac{du}{dn} = g$.
  *
  *  The error estimator returns a vector of estimated errors per cell which
- *  can be used to feed the Triangulation<tt><dim>::refine_*</tt> functions. This
+ *  can be used to feed the <tt>Triangulation<dim>::refine_*</tt> functions. This
  *  vector contains elements of data type @p float, rather than @p double,
  *  since accuracy is not so important here, and since this can save rather
  *  a lot of memory, when using many cells.
index a2d1a8a2f86fd29d5d535508275ac947151bd486..4d8ba71df8719c57ab49b75d0d39eea4501377ef 100644 (file)
@@ -74,7 +74,7 @@ namespace PETScWrappers
  * created. The functions assume that the matrix is initialized with a
  * sparsity pattern (SparsityPattern) corresponding to the given degree
  * of freedom handler, i.e. the sparsity structure is already as needed.
- * You can do this by calling the DoFHandler<tt><dim>::make_sparsity_pattern</tt>
+ * You can do this by calling the DoFTools::make_sparsity_pattern()
  * function.
  *
  * Furthermore it is assumed that no relevant data is in the matrix. All
index 893648602b170838cfb9874388c2cf85ed95bbee..2a0d297a54022efb945524e3d69c12081617636d 100644 (file)
  * solution vector on the current (original) grid.
  * Each entry of this vector belongs to one of the
  * DoFs of the discretisation. If we now refine the grid then the calling of
- * DoFHandler<tt>::distribute_dofs(...)</tt> will change at least some of the
+ * DoFHandler::distribute_dofs() will change at least some of the
  * DoF indices. Hence we need to store the DoF indices of all active cells
  * before the refinement. The @p user_pointer of each active cell
  * is used to point to the vector of these DoF indices of that cell, all other
  * @p user_pointers are cleared. All this is
- * done by <tt>prepare_for_pure_refinement()</tt>.
+ * done by prepare_for_pure_refinement().
  *
  * In the function <tt>refine_interpolate(in,out)</tt> and on each cell where the
  * @p user_pointer is set (i.e. the cells that were active in the original grid)
index 86e78e04020472fd6bc38feab5e9593f5632328c..2a0584c1628c0c564d31886fcf6e08a496179fe7 100644 (file)
@@ -153,7 +153,7 @@ class ConstraintMatrix;
  * <li> Creation of right hand side vectors:
  *   The @p create_right_hand_side function computes the vector
  *   $f_i = \int_\Omega f(x) \phi_i(x) dx$. This is the same as what the
- *   MatrixCreator<tt>::create_*</tt> functions which take a right hand side do,
+ *   <tt>MatrixCreator::create_*</tt> functions which take a right hand side do,
  *   but without assembling a matrix.
  *
  * <li> Creation of boundary right hand side vectors: The
@@ -268,17 +268,17 @@ class ConstraintMatrix;
  * 
  *   To get the global <i>L<sup>1</sup></i> error, you have to sum up the
  *   entries in @p difference, e.g. using
- *   Vector<tt><double>::l1_norm</tt> function.  For the global <i>L<sup>2</sup></i>
+ *   <tt>Vector<double>::l1_norm</tt> function.  For the global <i>L<sup>2</sup></i>
  *   difference, you have to sum up the squares of the entries and
  *   take the root of the sum, e.g. using
- *   Vector<tt><double>::l2_norm</tt>.  These two operations
+ *   <tt>Vector<double>::l2_norm</tt>.  These two operations
  *   represent the $l_1$ and $l_2$ norms of the vectors, but you need
  *   not take the absolute value of each entry, since the cellwise
  *   norms are already positive.
  *  
  *   To get the global mean difference, simply sum up the elements as above.
  *   To get the $L_\infty$ norm, take the maximum of the vector elements, e.g.
- *   using the Vector<tt><double>::linfty_norm</tt> function.
+ *   using the <tt>Vector<double>::linfty_norm</tt> function.
  *
  *   For the global <i>H<sup>1</sup></i> norm and seminorm, the same rule applies as for the
  *   <i>L<sup>2</sup></i> norm: compute the $l_2$ norm of the cell error vector.

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.