]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
further adaption to doxygen
authorguido <guido@0785d39b-7218-0410-832d-ea1e28bc413d>
Tue, 26 Jul 2005 11:36:43 +0000 (11:36 +0000)
committerguido <guido@0785d39b-7218-0410-832d-ea1e28bc413d>
Tue, 26 Jul 2005 11:36:43 +0000 (11:36 +0000)
git-svn-id: https://svn.dealii.org/trunk@11206 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/deal.II/include/numerics/data_out.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/histogram.h
deal.II/deal.II/include/numerics/matrices.h
deal.II/deal.II/include/numerics/solution_transfer.h
deal.II/deal.II/include/numerics/time_dependent.h

index 2c8aefc248ac20d49e06c40b893219c587f52d3e..3c4471d8a9805155c81e9315d12cbadc669f6f81 100644 (file)
 
 template <int>      class FEValuesBase;
 
+//TODO: Most of the documentation of DataOut_DoFData applies to DataOut.
 
 /**
- * This is an abstract class which provides the functionality to generate
- * patches for output by base classes from data vectors on a grid. It allows
- * to store a pointer to a DoFHandler object and one or more pointers to
- * node and cell data denoting functions on the grid which shall later
- * be written in any of the implemented data formats.
+ * This is an abstract class which provides the functionality to
+ * generate patches for output by base classes from data vectors on a
+ * grid. It allows to store a pointer to a DoFHandler object and one
+ * or more pointers to node and cell data denoting functions on the
+ * grid which shall later be written in any of the implemented data
+ * formats.
  *
  *
  * <h3>User visible interface</h3>
@@ -43,7 +45,7 @@ template <int>      class FEValuesBase;
  * vectors which will later be written to a file in some format. Instead of
  * pondering about the different functions, an example is probably the best
  * way:
- * @verbatim
+ * @code
  *   ...
  *   ...   // compute solution, which contains nodal values
  *   ...
@@ -64,32 +66,34 @@ template <int>      class FEValuesBase;
  *   data_out.write_xxx (output_file);
  *
  *   data_out.clear();
- * @endverbatim
+ * @endcode
  *
- * @p attach_dof_handler tells this class that all future operations are to take
- * place with the DoFHandler object and the triangulation it lives on. We then
- * add the solution vector and the error estimator; note that they have different
- * dimensions, because the solution is a nodal vector, here consisting of two
- * components ("x-displacement" and "y-displacement") while the error estimator
- * probably is a vector holding cell data. When attaching a data vector, you have
- * to give a name to each component of the vector, which is done through an object
- * of type <tt>vector<string></tt> as second argument; if only one component is in the
- * vector, for example if we are adding cell data as in the second case, or if
- * the finite element used by the DoFHandler has only one component, then you
- * can use the second @p add_data_vector function which takes a @p string instead
- * of the <tt>vector<string></tt>.
+ * attach_dof_handler() tells this class that all future operations
+ * are to take place with the DoFHandler object and the triangulation
+ * it lives on. We then add the solution vector and the error
+ * estimator; note that they have different dimensions, because the
+ * solution is a nodal vector, here consisting of two components
+ * ("x-displacement" and "y-displacement") while the error estimator
+ * probably is a vector holding cell data. When attaching a data
+ * vector, you have to give a name to each component of the vector,
+ * which is done through an object of type <tt>vector<string></tt> as
+ * second argument; if only one component is in the vector, for
+ * example if we are adding cell data as in the second case, or if the
+ * finite element used by the DoFHandler has only one component, then
+ * you can use the second add_data_vector() function which takes a @p
+ * string instead of the <tt>vector<string></tt>.
  *
  * You should note that this class does not copy the vector given to it through
- * the @p add_data_vector functions, for memory consumption reasons. It only
+ * the add_data_vector() functions, for memory consumption reasons. It only
  * stores a reference to it, so it is in your responsibility to make sure that
  * the data vectors exist long enough.
  *
  * After adding all data vectors, you need to call a function which generates
  * the patches for output from the stored data. This function is here called
- * @p build_patches, but the naming is up to the derived class that actually
+ * build_patches(), but the naming is up to the derived class that actually
  * implements this.
  *
- * Finally, you write the data in one format or other, indicated by @p write_xxx,
+ * Finally, you write() the data in one format or other,
  * to a file and may want to clear this object as soon as possible to reduce
  * memory requirements.
  *
@@ -98,16 +102,17 @@ template <int>      class FEValuesBase;
  * class does not provide means to actually generate the patches, only aids to
  * store and access data.
  *
- * Note that the base class of this class, DataOutInterface offers several
- * functions to ease programming with run-time determinable output formats
- * (i.e. you need not use a fixed format by calling @p write_xxx in the above
- * example, but you can select it by a run-time parameter without having
- * to write the <tt>if () ... else ...</tt> clauses yourself), and also functions
- * and classes offering ways to control the appearance of the output by
- * setting flags for each output format.
+ * Note that the base class of this class, DataOutInterface offers
+ * several functions to ease programming with run-time determinable
+ * output formats (i.e. you need not use a fixed format by calling
+ * DataOutInterface::write_xxx in the above example, but you can
+ * select it by a run-time parameter without having to write the
+ * <tt>if () ... else ...</tt> clauses yourself), and also functions
+ * and classes offering ways to control the appearance of the output
+ * by setting flags for each output format.
  * 
  *
- * @sect3{Information for derived classes}
+ * <h3>Information for derived classes</h3>
  *
  * What is actually missing this class is a way to produce the patches
  * for output itself, from the stored data and degree of freedom
@@ -125,8 +130,8 @@ template <int>      class FEValuesBase;
  * possible in this respect.
  *
  * For this reason, it is left to a derived class to provide a
- * function, named usually @p build_patches or the like, which fills
- * the @p patches array of this class.
+ * function, named usually build_patches() or the like, which fills
+ * the #patches array of this class.
  *
  * Regarding the templates of this class, it needs three values: first
  * the space dimension in which the triangulation and the DoF handler
@@ -173,15 +178,20 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
                                      * triangulation underlying the
                                      * DoFHandler object (such
                                      * as error per cell data). The
-                                     * value @p type_automatic tells
+                                     * value #type_automatic tells
                                      * add_data_vector() to find
                                      * out itself (see the
                                      * documentation of
-                                     * @p add_data_vector for the
+                                     * add_data_vector() for the
                                      * method used).
                                      */
     enum DataVectorType {
-         type_dof_data, type_cell_data, type_automatic
+                                          /// Data vector entries are associated to degrees of freedom
+         type_dof_data,
+                                          /// Data vector entries are one per grid cell
+         type_cell_data,
+                                          /// Find out automatically
+         type_automatic
     };
     
                                     /**
@@ -244,8 +254,8 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
                                      * case, you can change the last
                                      * argument of the function from
                                      * its default value
-                                     * @p type_automatic to either
-                                     * @p type_dof_data or @p type_cell_data,
+                                     * #type_automatic to either
+                                     * #type_dof_data or #type_cell_data,
                                      * depending on what the vector
                                      * represents. Apart from this
                                      * corner case, you can leave the
@@ -270,16 +280,16 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
                                      * shall only contain characters
                                      * which are letters, underscore
                                      * and a few other ones. Refer to
-                                     * the @p ExcInvalidCharacter
+                                     * the ExcInvalidCharacter
                                      * exception declared in this
                                      * class to see which characters
                                      * are valid and which are not.
                                      *
                                      * The actual type for the template
                                      * argument may be any vector type from
-                                     * which FEValue can extract values
+                                     * which FEValues can extract values
                                      * on a cell using the
-                                     * @p get_function_values function.
+                                     * FEValuesBase::get_function_values() function.
                                      */
     template <class VECTOR>
     void add_data_vector (const VECTOR                   &data,
@@ -299,7 +309,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
                                      * after a conversion of the
                                      * @p name to a vector of
                                      * strings, to the other
-                                     * @p add_data_vector function
+                                     * add_data_vector() function
                                      * above.
                                      *
                                      * If @p data is a vector with
@@ -312,9 +322,9 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
                                      *
                                      * The actual type for the template
                                      * argument may be any vector type from
-                                     * which FEValue can extract values
+                                     * which FEValues can extract values
                                      * on a cell using the
-                                     * @p get_function_values function.
+                                     * FEValuesBase::get_function_values() function.
                                      */
     template <class VECTOR>
     void add_data_vector (const VECTOR         &data,
@@ -414,7 +424,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
                                      * data vectors and the DoF
                                      * handler. You have to set all
                                      * data entries again using the
-                                     * @p add_data_vector
+                                     * add_data_vector()
                                      * function. The pointer to the
                                      * dof handler is cleared as
                                      * well, along with all other
@@ -528,7 +538,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
         get_cell_data_value (const unsigned int cell_number) const = 0;
 
                                          /**
-                                          * Given a @p FEValuesBase object,
+                                          * Given a FEValuesBase object,
                                           * extract the values on the present
                                           * cell from the vector we actually
                                           * store.
@@ -539,7 +549,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
                              std::vector<double>             &patch_values) const = 0;
         
                                          /**
-                                          * Given a @p FEValuesBase object,
+                                          * Given a FEValuesBase object,
                                           * extract the values on the present
                                           * cell from the vector we actually
                                           * store. This function does the same
@@ -602,7 +612,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
         get_cell_data_value (const unsigned int cell_number) const;
 
                                          /**
-                                          * Given a @p FEValuesBase object,
+                                          * Given a FEValuesBase object,
                                           * extract the values on the present
                                           * cell from the vector we actually
                                           * store.
@@ -613,7 +623,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
                              std::vector<double>             &patch_values) const;
         
                                          /**
-                                          * Given a @p FEValuesBase object,
+                                          * Given a FEValuesBase object,
                                           * extract the values on the present
                                           * cell from the vector we actually
                                           * store. This function does the same
@@ -652,7 +662,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
 
                                     /**
                                      * Abbreviate the somewhat lengthy
-                                     * name for the @p Patch class.
+                                     * name for the Patch class.
                                      */
     typedef ::DataOutBase::Patch<patch_dim,patch_space_dim> Patch;
 
@@ -675,7 +685,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
 
                                     /**
                                      * This is a list of patches that is
-                                     * created each time @p build_patches
+                                     * created each time build_patches()
                                      * is called. These patches are used
                                      * in the output routines of the base
                                      * classes.
@@ -702,7 +712,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
                                     /**
                                      * Make all template siblings
                                      * friends. Needed for the
-                                     * @p merge_patches function.
+                                     * merge_patches() function.
                                      */
     template <int,int,int> friend class DataOut_DoFData;
 
@@ -737,7 +747,7 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
 
 /**
  * This class is an actual implementation of the functionality proposed by
- * the DataOut_DoFData() class. It offers a function @p build_patches that
+ * the DataOut_DoFData class. It offers a function build_patches() that
  * generates the patches to be written in some graphics format from the data
  * stored in the base class. Most of the interface and an example of its
  * use is described in the documentation of the base class.
@@ -759,8 +769,8 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
  * output is to subdivide each cell of the mesh into several cells for
  * graphical output.
  *
- * Note that after having called @p build_patches once, you can call one or
- * more of the <tt>write_*</tt> functions of the base classes. You can therefore
+ * Note that after having called build_patches() once, you can call one or
+ * more of the write() functions of DataOutInterface. You can therefore
  * output the same data in more than one format without having to rebuild
  * the patches.
  *
@@ -786,9 +796,9 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
  * region of the domain (for example in parallel programs such as the step-18
  * example program), or for some other reason.
  *
- * For this, internally the @p build_patches function does not generate
+ * For this, internally build_patches() does not generate
  * the sequence of cells to be converted into patches itself, but relies
- * on the two functions @p first_cell and @p next_cell. By default, they
+ * on the two functions first_cell() and next_cell(). By default, they
  * return the first active cell, and the next active cell, respectively.
  * Since they are @p virtual functions, you may overload them to select other
  * cells for output. If cells are not active, interpolated values are taken
@@ -800,8 +810,8 @@ class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
  * determine the next one.
  *
  * There is one caveat, however: if you have cell data (in contrast to nodal,
- * or dof, data) such as error indicators, then you must make sure that the @p
- * first_cell and @p next_cell only walk over active cells, since cell data
+ * or dof, data) such as error indicators, then you must make sure that
+ * first_cell() and next_cell() only walk over active cells, since cell data
  * cannot be interpolated to a coarser cell. If you do have cell data and use
  * this pair of functions and they return a non-active cell, then an exception
  * will be thrown.
@@ -888,7 +898,7 @@ class DataOut : public DataOut_DoFData<dim,dim>
                                      * Return the next cell after
                                      * @p cell which we want output
                                      * for.  If there are no more
-                                     * cells, <tt>dofs->end()</tt> shall
+                                     * cells, <tt>#dofs->end()</tt> shall
                                      * be returned.
                                      *
                                      * The default implementation
@@ -899,7 +909,7 @@ class DataOut : public DataOut_DoFData<dim,dim>
                                      * implementation assumes that
                                      * the given @p cell is active,
                                      * which is guaranteed as long as
-                                     * @p first_cell is also used
+                                     * first_cell() is also used
                                      * from the default
                                      * implementation. Overloading
                                      * only one of the two functions
@@ -924,7 +934,7 @@ class DataOut : public DataOut_DoFData<dim,dim>
                                      * globally to avoid allocation
                                      * of memory in the threads.
                                      *
-                                     * The @p index_to_patch_map is
+                                     * The #index_to_patch_map is
                                      * an array that stores for index
                                      * <tt>[i][j]</tt> the number of the
                                      * patch that associated with the
index 653f6f5d9d0fc8fcbe365565e2df60f48e62fe36..a19944c5cd086ee45e566e64f1bdb5b33cb8c901 100644 (file)
@@ -79,7 +79,7 @@
  * gradients themselves.
  *
  *
- * @sect2{Approximation of higher derivatives}
+ * <h3>Approximation of higher derivatives</h3>
  *
  * Similar to the reasoning above, approximations to higher
  * derivatives can be computed in a similar fashion. For example, the
  * same lines as exposed above.
  *
  *
- * @sect2{Refinement indicators based on the derivatives}
+ * <h3>Refinement indicators based on the derivatives</h3>
  *
  * If you would like to base a refinement criterion upon these
  * approximation of the derivatives, you will have to scale the results
  * the mesh size $h$ one higher than for the gradient.
  *
  *
- * @sect2{Implementation}
+ * <h3>Implementation</h3>
  *
  * The formulae for the computation of approximations to the gradient
  * and to the tensor of second derivatives shown above are very much
index f0cb4435ff525f73547201d3108052cc433b75ee..5ca9f0be907f433363f644192d63f71f6540a9ba 100644 (file)
@@ -55,7 +55,7 @@ template <int dim> class FESubfaceValues;
  *  a lot of memory, when using many cells.
  *
  *  
- *  @sect3{Implementation}
+ *  <h3>Implementation</h3>
  *
  *  In principle, the implementation of the error estimation is simple: let
  *  \f[
@@ -97,7 +97,7 @@ template <int dim> class FESubfaceValues;
  *  the diameter of the cell.
  *  
  *
- *  @sect3{Vector-valued functions}
+ *  <h3>Vector-valued functions</h3>
  *
  *  If the finite element field for which the error is to be estimated
  *  is vector-valued, i.e. the finite element has more than one
@@ -119,7 +119,7 @@ template <int dim> class FESubfaceValues;
  *  a scalar coefficient which will then be used for all components.
  *
  *
- *  @sect3{Boundary values}
+ *  <h3>Boundary values</h3>
  *  
  *  If the face is at the boundary, i.e. there is no neighboring cell to which
  *  the jump in the gradiend could be computed, there are two possibilities:
@@ -157,7 +157,7 @@ template <int dim> class FESubfaceValues;
  *  conditions.
  *
  *  
- *  @sect3{Handling of hanging nodes}
+ *  <h3>Handling of hanging nodes</h3>
  *  
  *  The integration along faces with hanging nodes is quite tricky, since one
  *  of the elements has to be shifted one level up or down. See the
@@ -182,7 +182,7 @@ template <int dim> class FESubfaceValues;
  *  above.
  *
  *
- *  @sect3{Multiple solution vectors}
+ *  <h3>Multiple solution vectors</h3>
  *
  *  In some cases, for example in time-dependent problems, one would
  *  like to compute the error estimates for several solution vectors
index 23ef4afef4814cb58e981832690658c23ccb673a..c9d63d642c3f23137857fe39e94c3814277d1311 100644 (file)
@@ -33,7 +33,7 @@
  * intervals are used for each of them anyway, to make comparison easier.
  *
  *
- * @sect3{Ways to generate the intervals}
+ * <h3>Ways to generate the intervals</h3>
  *
  * At present, the following schemes for interval spacing are implemented:
  * <ul>
@@ -54,7 +54,7 @@
  * code.
  *
  *
- * @sect3{Output formats}
+ * <h3>Output formats</h3>
  *
  * At present, only GNUPLOT output is supported.
  *
index 255d1e2e4861c83d1fa556cb7ef54e68a92defdf..dd0711a0b4afe3b3853d0c319586be195fe04948 100644 (file)
@@ -57,7 +57,7 @@ namespace PETScWrappers
  * necessary to create an object of this type, though you may do so.
  *
  *
- * @sect3{Conventions for all functions}
+ * <h3>Conventions for all functions</h3>
  *
  * There exist two versions of each function. One with a Mapping
  * argument and one without. If a code uses a mapping different from
@@ -104,7 +104,7 @@ namespace PETScWrappers
  * side.
  *
  *
- * @sect3{Supported matrices}
+ * <h3>Supported matrices</h3>
  *
  * At present there are functions to create the following matrices:
  * <ul>
@@ -144,7 +144,7 @@ namespace PETScWrappers
  * finite element.
  *
  *
- * @sect3{Matrices on the boundary}
+ * <h3>Matrices on the boundary</h3>
  *
  * The @p create_boundary_mass_matrix creates the matrix with entries
  * $m_{ij} = \int_{\Gamma} \phi_i \phi_j dx$, where $\Gamma$ is the
@@ -173,7 +173,7 @@ namespace PETScWrappers
  * triangulation object.
  *
  *
- * @sect3{Right hand sides}
+ * <h3>Right hand sides</h3>
  *
  * In many cases, you will not only want to build the matrix, but also
  * a right hand side, which will give a vector with
@@ -565,7 +565,7 @@ class MatrixCreator
  * and others.
  *
  *
- * @sect3{Boundary conditions}
+ * <h3>Boundary conditions</h3>
  *
  * The apply_boundary_values() function inserts boundary conditions
  * into a system of equations.  To actually do this you have to
@@ -578,7 +578,7 @@ class MatrixCreator
  * nodes into a linear system, as discussed below.
  * 
  *
- * @sect3{Global elimination}
+ * <h3>Global elimination</h3>
  *
  * In the first method, we first assemble the global linear system without
  * respect for fixed degrees of freedom, and in a second step eliminate them
@@ -677,7 +677,7 @@ class MatrixCreator
  * values.
  *
  *
- * @sect3{Local elimination}
+ * <h3>Local elimination</h3>
  *
  * The second way of handling boundary values is to modify the local
  * matrix and vector contributions appropriately before transferring
index b8a60335e4f1e053f018956840193d45a10669e0..1f316c5a647057344ebdb7d626e6d0f1422c5a43 100644 (file)
@@ -32,7 +32,7 @@
  * vector is reinitialized to the new size and filled with the interpolated
  * values.
  * 
- * @sect3{Usage}
+ * <h3>Usage</h3>
  *
  * As the interpolation while
  * coarsening is much more complicated to organize 
  * to transfer.
  *
  *
- * @sect3{Implementation}
+ * <h3>Implementation</h3>
  *
  * <ul>
  * <li> Solution transfer while pure refinement. Assume that we have got a
index 3d2b71e98dcc6b181b2d68296e42158784150bb6..a61b06bb5e6774baa923d2a67e78c4845f7fc38e 100644 (file)
@@ -52,7 +52,7 @@ template <int dim> class Triangulation;
  * use the same setup and therefore this class.
  *
  *
- * @sect3{Overview}
+ * <h3>Overview</h3>
  *
  * The general structure of a time dependent problem solver using a timestepping
  * scheme is about the following: we have a collection of time step objects
@@ -180,7 +180,7 @@ template <int dim> class Triangulation;
  * problem, this order is reversed.
  *
  *
- * @sect3{Implementation}
+ * <h3>Implementation</h3>
  *
  * The main loop of a program using this class will usually look like
  * the following one, taken modified from an application program that
@@ -1245,7 +1245,7 @@ namespace TimeStepBase_Tria_Flags
  * </ul>
  *
  *
- * @sect3{Description of flags}
+ * <h3>Description of flags</h3>
  *
  * <ul>
  * <li> @p max_refinement_level: Cut the refinement of cells at a given level.

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.