* individual blocks.
*
*
- * @section Inheritance Inheriting from this class
+ * <h3>Inheriting from this class</h3>
*
* Since this class simply forwards its calls to the subobjects (if necessary
* after adjusting indices denoting which subobject is meant), this class is
* type the block vector is built on.
*
*
- * @section BlockVectorAccess Accessing individual blocks, and resizing vectors
+ * <h3>Accessing individual blocks, and resizing vectors</h3>
*
* Apart from using this object as a whole, you can use each block
* separately as a vector, using the block() function. There
* class. These comments apply here as well.
*
*
- * @section Partitioning Partitioning of matrices
+ * <h3>Partitioning of matrices</h3>
*
* PETSc partitions parallel matrices so that each MPI process "owns" a
* certain number of rows (i.e. only this process stores the respective
* functions). Only the functions creating a vector of specific type differ,
* and are implemented in this particular class.
*
- * @section PETScParVec1 Parallel communication model
+ * <h3>Parallel communication model</h3>
*
* The parallel functionality of PETSc is built on top of the Message Passing
* Interface (MPI). MPI's communication model is built on collective
* discussed below.
*
*
- * @section PETScParVec2 Accessing individual elements of a vector
+ * <h3>Accessing individual elements of a vector</h3>
*
* PETSc does allow read access to individual elements of a vector, but in the
* distributed case only to elements that are stored locally. We implement
* It seems that all builtin preconditioners have a relaxation
* parameter, so please use PreconditionRelaxation for these.
*
- * @section PrecUMU Usage
- *
* You will usually not want to create a named object of this type,
* although possible. The most common use is like this:
* @code
* <tt>MATRIX</tt> class used is required to have a function
* <tt>precondition_Jacobi(VECTOR&, const VECTOR&, double</tt>)
*
- * @section PrecJU Usage
- *
* @code
* // Declare related objects
*
* <tt>precondition_SOR(VECTOR&, const VECTOR&, double)</tt> and
* <tt>precondition_TSOR(VECTOR&, const VECTOR&, double)</tt>.
*
- *
- * @section PrexSORU Usage
* @code
* // Declare related objects
*
* <tt>MATRIX</tt> class used is required to have a function
* <tt>precondition_SSOR(VECTOR&, const VECTOR&, double)</tt>
*
- *
- * @section PrexSSORU Usage
* @code
* // Declare related objects
*
* <tt>PSOR(VECTOR&, const VECTOR&, double)</tt> and
* <tt>TPSOR(VECTOR&, const VECTOR&, double)</tt>.
*
- *
- * @section PrecPSORU Usage
* @code
* // Declare related objects
*
* Usually, the use of ReductionControl is preferred over the use of
* the basic SolverControl in defining this solver.
*
- * @section PrecItU Usage
- *
* Krylov space methods like SolverCG or SolverBicgstab
* become inefficient if soution down to machine accuracy is
* needed. This is due to the fact, that round-off errors spoil the
* the configure script is looking for and how to provide it.
*
*
- * @section SPDMA1 Interface and Method
+ * <h3>Interface and Method</h3>
*
* For the meaning of the three functions initialize(), factorize(),
* and solve(), as well as for the method used in MA27, please see the
* which is significantly less costly than the decomposition process.
*
*
- * @section SPDMA2 Parameters to the constructor
+ * <h3>Parameters to the constructor</h3>
*
* The constructor of this class takes several arguments. The meaning
* is the following: the MA27 functions require the user to allocate
* indicated value is far too small and can not be relied upon.
*
*
- * @section SPDMA3 Note on parallelization
+ * <h3>Note on parallelization</h3>
*
- * @subsection SPDMA4 Synchronisation
+ * <h4>Synchronisation</h4>
*
* Due to the use of global variables through COMMON blocks, the calls
* to the sparse direct solver routines are not multithreading-safe,
* Since such cross-function synchronisation can only be performed
* from outside, it is left to the user of this class to do so.
*
- * @subsection SPDMA5 Detached mode
+ * <h4>Detached mode</h4>
*
* As an alternative, you can call the function set_detached_mode()
* right after calling the constructor. This lets the program fork, so
* you probably wanted.
*
*
- * @subsection SPDMA6 Internals of the detached mode
+ * <h5>Internals of the detached mode</h5>
*
* The program that actually runs the detached solver is called
* <tt>detached_ma27</tt>, and will show up under this name in the process
* the configure script is looking for and how to provide it.
*
*
- * @section SPDMA47a Interface and Method
+ * <h3>Interface and Method</h3>
*
* For the meaning of the three functions initialize(), factorize(),
* and solve(), as well as for the method used in MA47, please see the
* which is significantly less costly than the decomposition process.
*
*
- * @section SPDMA47b Parameters to the constructor
+ * <h3>Parameters to the constructor</h3>
*
* The constructor of this class takes several arguments. Their
* meaning is equivalent to those of the constructor of the
* SparseDirectMA27 class; see there for more information.
*
*
- * @section SPDMA47c Note on parallelization
+ * <h3>Note on parallelization</h3>
*
* Due to the use of global variables through COMMON blocks, the calls
* to the sparse direct solver routines is not multithreading-capable,
projects / dealii-svn.git / commitdiff