* This class contains as static members information on vertices and
* faces of a @p dim-dimensional grid cell. The interface is the same
* for all dimensions. If a value is of no use in a low dimensional
- * cell, it is (correctly) set to zero, e.g. @p subfaces_per_cell in
+ * cell, it is (correctly) set to zero, e.g. #subfaces_per_cell in
* 1d.
*
* This information should always replace hard-coded numbers of
* children, return any one of
* their indices. The result is
* always less than
- * <tt>GeometryInfo<dimension>::children_per_cell</tt>.
+ * GeometryInfo<dimension>::children_per_cell.
*
* The order of child cells is
* described the documentation of
/**
* Get path list for a certain
* class. Used to set up
- * @p my_path_list in constructor.
+ * #my_path_list in constructor.
*/
static std::vector<std::string>& get_path_list(const std::string& cls);
* this class.
*
*
- * @ref Instantiations: some (<tt>@<float@> @<double@></tt>). Most of the
- * functions take a vector or block vector argument. These functions can, in
- * general, only successfully be compiled if the individual blocks of this
- * matrix implement the respective functions operating on the vector type in
- * question. For example, if you have a block sparse matrix over deal.II
- * SparseMatrix objects, then you will likely not be able to form the
- * matrix-vector multiplication with a block vector over
- * PETScWrappers::SparseMatrix objects. If you attempt anyway, you will likely
- * get a number of compiler errors.
+ * Most of the functions take a vector or block vector argument. These
+ * functions can, in general, only successfully be compiled if the
+ * individual blocks of this matrix implement the respective functions
+ * operating on the vector type in question. For example, if you have
+ * a block sparse matrix over deal.II SparseMatrix objects, then you
+ * will likely not be able to form the matrix-vector multiplication
+ * with a block vector over PETScWrappers::SparseMatrix objects. If
+ * you attempt anyway, you will likely get a number of compiler
+ * errors.
*
+ * @ref Instantiations: some (<tt>@<float@> @<double@></tt>).
* @author Wolfgang Bangerth, 2000, 2004
*/
template <typename MatrixType>
* matrix. In order to guarantee
* that it is not deleted while
* still in use, we subscribe to
- * it using the @p SmartPointer
+ * it using the SmartPointer
* class.
*/
SmartPointer<const BlockSparsityPattern> sparsity_pattern;
// $Id$
// Version: $Name$
//
-// Copyright (C) 2002, 2003, 2004 by the deal.II authors
+// Copyright (C) 2002, 2003, 2004, 2005 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
/**
- * A block matrix consisting of blocks of type @p SparseMatrixEZ.
+ * A block matrix consisting of blocks of type SparseMatrixEZ.
*
* Like the other Block-objects, this matrix can be used like a
- * @p SparseMatrixEZ, when it comes to access to entries. Then, there
- * are functions for the multiplication with @p BlockVector and
+ * SparseMatrixEZ, when it comes to access to entries. Then, there
+ * are functions for the multiplication with BlockVector and
* access to the individual blocks.
*
* @author Guido Kanschat, 2002, 2003
* let $dst = M^T*src$ with $M$
* being this matrix. This
* function does the same as
- * @p vmult but takes the
+ * vmult() but takes the
* transposed matrix.
*/
template <typename somenumber>
* multiplication. Add $M^T*src$
* to $dst$ with $M$ being this
* matrix. This function does the
- * same as @p vmult_add but takes
+ * same as vmult_add() but takes
* the transposed matrix.
*/
template <typename somenumber>
*
* This value is only an alias to
* the respective value of the
- * @p SparsityPattern class.
+ * SparsityPattern class.
*/
static const unsigned int invalid_entry = SparsityPattern::invalid_entry;
* member variables in other
* classes. You can make the
* structure usable by calling
- * the @p reinit function.
+ * the reinit() function.
*/
BlockSparsityPatternBase ();
* given number of block rows and
* columns. The blocks themselves
* are still empty, and you have
- * to call @p collect_sizes after
+ * to call collect_sizes() after
* you assign them sizes.
*/
BlockSparsityPatternBase (const unsigned int n_block_rows,
* are no block allocated at
* present. This is for the same
* reason as for the
- * @p SparsityPattern, see there
+ * SparsityPattern, see there
* for the details.
*/
BlockSparsityPatternBase (const BlockSparsityPatternBase &bsp);
* unitialized ones, i.e. ones
* for which also the sizes are
* not yet set. You have to do
- * that by calling the @p reinit
+ * that by calling the reinit()
* functions of the blocks
* themselves. Do not forget to
- * call @p collect_sizes after
+ * call collect_sizes() after
* that on this object.
*
* The reason that you have to
* of elements per row may be
* varying, etc. It is simpler
* not to reproduce the interface
- * of the @p SparsityPattern
+ * of the SparsityPattern
* class here but rather let the
* user call whatever function
* she desires.
/**
* Make the block sparse matrix a
* friend, so that it can use our
- * @p row_indices and
- * @p column_indices objects.
+ * #row_indices and
+ * #column_indices objects.
*/
template <typename number>
friend class BlockSparseMatrix;
* member variables in other
* classes. You can make the
* structure usable by calling
- * the @p reinit function.
+ * the reinit() function.
*/
BlockSparsityPattern ();
* given number of block rows and
* columns. The blocks themselves
* are still empty, and you have
- * to call @p collect_sizes after
+ * to call collect_sizes() after
* you assign them sizes.
*/
BlockSparsityPattern (const unsigned int n_rows,
* member variables in other
* classes. You can make the
* structure usable by calling
- * the @p reinit function.
+ * the reinit() function.
*/
CompressedBlockSparsityPattern ();
* given number of block rows and
* columns. The blocks themselves
* are still empty, and you have
- * to call @p collect_sizes after
+ * to call collect_sizes() after
* you assign them sizes.
*/
CompressedBlockSparsityPattern (const unsigned int n_rows,
* first have to provide an empty sparsity pattern object with a fixed
* maximal number of entries per row. To find out about this maximal
* row length, one usually calls the function
- * DoFHandler@p ::max_couplings_per_dof which returns an
- * estimate for that quantity. While this estimate is usually quite
- * good in 2d and exact in 1d, it is often significantly too large in
- * 3d and especially for higher order elements. Furthermore, normally
- * only a small fraction of the rows of a matrix will end up having
- * the maximal number of nonzero entries per row (usually those nodes
- * adjacent to hanging nodes), most have much less. In effect, the
- * empty SparsityPattern object has allocated much too much
+ * DoFHandler::max_couplings_between_dofs() which returns an estimate for
+ * that quantity or DoFTools::compute_row_length_vector(), which gives
+ * a better estimate for each row. While this estimate is usually
+ * quite good in 2d and exact in 1d, it is often significantly too
+ * large in 3d and especially for higher order elements. Furthermore,
+ * normally only a small fraction of the rows of a matrix will end up
+ * having the maximal number of nonzero entries per row (usually those
+ * nodes adjacent to hanging nodes), most have much less. In effect,
+ * the empty SparsityPattern object has allocated much too much
* memory. Although this unnecessarily allocated memory is later freed
- * when SparsityPattern@p ::compress is called, this
- * overallocation has, with higher order elements and in 3d, sometimes
- * been so large that the program aborted due to lack of memory.
+ * when SparsityPattern::compress() is called, this overallocation
+ * has, with higher order elements and in 3d, sometimes been so large
+ * that the program aborted due to lack of memory.
*
* This class therefore provides an alternative representation of a
* sparsity pattern: we don't specify a maximal row length initially,
* member variables in other
* classes. You can make the
* structure usable by calling
- * the @p reinit function.
+ * the reinit() function.
*/
CompressedSparsityPattern ();
* data structures for a new
* matrix with @p m rows and
* @p n columns, with at most
- * @p max_per_row nonzero
+ * max_entries_per_row() nonzero
* entries per row.
*/
void reinit (const unsigned int m,
* describing which entries of this row
* are nonzero. Data is organized as
* follows: if an entry is added to a
- * row, it is first added to the @p cache
+ * row, it is first added to the #cache
* variable, irrespective of whether an
* entry with same column number has
* already been added. Only if the cache
* Since some functions that are @p const
* need to access the data of this
* object, but need to flush caches
- * before, the @p flush_cache function is
+ * before, the flush_cache() function is
* marked const, and the data members are
* marked @p mutable.
*
/**
* Cache of entries that have not yet
- * been written to @p entries;
+ * been written to #entries;
*/
mutable unsigned int cache[cache_size];
/**
* Flush the cache my merging it with
- * the @p entries array.
+ * the #entries array.
*/
void flush_cache () const;
};
* norm of the residual $A x - l x$ is computed. Since this might not
* converge to zero for non-symmetric matrices with non-trivial Jordan
* blocks, it can be replaced by checking the difference of successive
- * eigenvalues. Use @p AdditionalData::use_residual for switching
+ * eigenvalues. Use AdditionalData::use_residual for switching
* this option.
*
* Usually, the initial guess entering this method is updated after
* each step, replacing it with the new approximation of the
- * eigenvalue. Using a parameter @p AdditionalData::relaxation
+ * eigenvalue. Using a parameter AdditionalData::relaxation
* between 0 and 1, this update can be damped. With relaxation
* parameter 0, no update is performed. This damping allows for slower
* adaption of the shift value to make sure that the method converges
* to the eigenvalue closest to the initial guess. This can be aided
- * by the parameter @p AdditionalData::start_adaption, which
+ * by the parameter AdditionalData::start_adaption, which
* indicates the first iteration step in which the shift value should
* be adapted.
*
*
* <h3>Connection to other classes</h3>
*
- * The function @p MatrixTools::apply_boundary_values does exactly
+ * The function MatrixTools::apply_boundary_values() does exactly
* the same that this class does, except for the fact that that
* function actually modifies the matrix. Due to this, it is only
* possible to solve with a matrix onto which
- * @p MatrixTools::apply_boundary_values was applied for one right
+ * MatrixTools::apply_boundary_values() was applied for one right
* hand side and one set of boundary values since the modification of
* the right hand side depends on the original matrix.
*
/**
* Default constructor. You will
* have to set the matrix to be
- * used later using the
- * @p set_referenced_matrix
- * function.
+ * used later using
+ * set_referenced_matrix().
*/
FilteredMatrix ();
* let $dst = M^T*src$ with $M$
* being this matrix. This
* function does the same as
- * @p vmult but takes the
+ * vmult() but takes the
* transposed matrix. (This
* matrix is the filtered one to
* which we store a reference.)
* matrix. In order to guarantee
* that it is not deleted while
* still in use, we subscribe to
- * it using the @p SmartPointer
+ * it using the SmartPointer
* class.
*/
SmartPointer<const MATRIX> matrix;
/**
- * Mean value filter. The @p vmult functions of this matrix filter
+ * Mean value filter. The vmult() functions of this matrix filter
* out mean values of the vector. If the vector is of type
- * @p BlockVector, then an additional parameter selects a single
+ * BlockVector, then an additional parameter selects a single
* component for this operation.
*
* @author Guido Kanschat, 2002, 2003
* FullMatrix, as long as it satisfies a number of requirements,
* stated with the member functions of this class.
*
- * The generation of patches through the @p build_patches function
+ * The generation of patches through the build_patches() function
* can be modified by giving it an object holding certain flags. See
* the documentation of the members of the Options class for a
* description of these flags.
* D d;
* @endverbatim
*
- *
+ * @ingroup IO
* @author Wolfgang Bangerth, 2001
*/
class MatrixOut : public DataOutInterface<2,2>
* requires that we can extract
* elements of the matrix, which
* is done using the
- * @p get_element function
+ * get_element() function
* declared below. By adding
* specializations, you can
* extend this class to other
/**
* Abbreviate the somewhat
- * lengthy name for the @p Patch
+ * lengthy name for the ::DataOutBase::Patch
* class.
*
* Note that we have to indicate
* the global scope using the
* @p :: in front of
- * @p DataOutBase, since
+ * DataOutBase, since
* otherwise the C++ rules
* specify that this here
- * indicates the @p DataOutBase
+ * indicates the DataOutBase
* base class of this
* class. Since that is a private
* base class, we cannot access
* its members, and so access to
- * the local @p Patch type would
+ * the local Patch type would
* be forbidden.
*/
typedef ::DataOutBase::Patch<2,2> Patch;
/**
* This is a list of patches that
* is created each time
- * @p build_patches is
+ * build_patches() is
* called. These patches are used
* in the output routines of the
* base classes.
* that by calling the @p reinit
* functions of the blocks
* themselves. Do not forget to
- * call @p collect_sizes after
+ * call collect_sizes() after
* that on this object.
*
* The reason that you have to
* functions, and is often exchangable. However, since PETSc only supports a
* single scalar type (either double, float, or a complex data type), it is
* not templated, and only works with whatever your PETSc installation has
- * defined the data type @p PetscScalar to.
+ * defined the data type PetscScalar to.
*
* Note that PETSc only guarantees that operations do what you expect if the
* functions @p MatAssemblyBegin and @p MatAssemblyEnd have been called
* that by calling the @p reinit
* functions of the blocks
* themselves. Do not forget to
- * call @p collect_sizes after
+ * call collect_sizes() after
* that on this object.
*
* The reason that you have to
* of elements per row may be
* varying, etc. It is simpler
* not to reproduce the interface
- * of the @p SparsityPattern
+ * of the SparsityPattern
* class here but rather let the
* user call whatever function
* she desires.
projects / dealii-svn.git / commitdiff