* Define the basis for accessors to the degrees of freedom.
*
* Note that it is allowed to construct an object of which the
- * @p{dof_handler} pointer is a Null pointer. Such an object would
+ * @p dof_handler pointer is a Null pointer. Such an object would
* result in a strange kind of behaviour, though every reasonable
* operating system should disallow access through that pointer.
* The reason we do not check for the null pointer in the
- * constructor which gets passed the @ref{DoFHandler} pointer is that
+ * constructor which gets passed the DoFHandler pointer is that
* if we did we could not make dof iterators member of other classes
- * (like in the @ref{FEValues} class) if we did not know about the
- * @ref{DoFHandler} object to be used upon construction of that object.
+ * (like in the FEValues class) if we did not know about the
+ * DoFHandler object to be used upon construction of that object.
* Through the way this class is implemented here, we allow the
* creation of a kind of virgin object which only gets useful if
* assigned to from another object before first usage.
* which has an invalid dof handler pointer. This is to guarantee
* that every iterator which is once assigned to is a valid
* object. However, this assertion only holds in debug mode, when
- * the @p{Assert} macro is switched on.
+ * the @p Assert macro is switched on.
*
* @author Wolfgang Bangerth, 1998
*/
/**
* This should be the default constructor.
- * We cast away the @p{const}ness of the
+ * We cast away the @p constness of the
* pointer which clearly is EVIL but
* we can't help without making all
* functions which could somehow use
/**
* Return a handle on the
- * @ref{DoFHandler} object which we
+ * DoFHandler object which we
* are using.
*/
const DoFHandler<dim> &
protected:
/**
- * Store the address of the @ref{DoFHandler} object
+ * Store the address of the DoFHandler object
* to be accessed.
*/
DoFHandler<dim> *dof_handler;
/* -------------------------------------------------------------------------- */
/**
- * This is a switch class which only declares a @p{typedef}. It is meant to
- * determine which class a @ref{DoFObjectAccessor} class is to be derived
+ * This is a switch class which only declares a @p typedef. It is meant to
+ * determine which class a DoFObjectAccessor class is to be derived
* from. By default, @p{DoFObjectAccessor<celldim,dim>} derives from
- * the @p{typedef} in the general @p{DoFObjectAccessor_Inheritance<celldim,dim>}
+ * the @p typedef in the general @p{DoFObjectAccessor_Inheritance<celldim,dim>}
* class, which is @p{TriaObjectAccessor<celldim,dim>},
* but if @p{celldim==dim}, then the specialization @p{DoFObjectAccessor_Inheritance<dim,dim>}
* is used which declares its local type to be @p{CellAccessor<dim>}. Therefore,
- * the inheritance is automatically chosen to be from @ref{CellAccessor} if the
+ * the inheritance is automatically chosen to be from CellAccessor if the
* object under consideration has full dimension, i.e. constitutes a cell.
*
* @author Wolfgang Bangerth, 1999
{
public:
/**
- * Declaration of the @p{typedef}.
+ * Declaration of the @p typedef.
* See the full documentation for
* more information.
*/
/**
- * This is a switch class which only declares a @p{typedef}. It is meant to
- * determine which class a @ref{DoFObjectAccessor} class is to be derived
+ * This is a switch class which only declares a @p typedef. It is meant to
+ * determine which class a DoFObjectAccessor class is to be derived
* from. By default, @p{DoFObjectAccessor<celldim,dim>} derives from
- * the @p{typedef} in the general @p{DoFObjectAccessor_Inheritance<celldim,dim>}
+ * the @p typedef in the general @p{DoFObjectAccessor_Inheritance<celldim,dim>}
* class, which is @p{TriaObjectAccessor<celldim,dim>},
* but if @p{celldim==dim}, then the specialization @p{DoFObjectAccessor_Inheritance<dim,dim>}
* is used which declares its local type to be @p{CellAccessor<dim>}. Therefore,
- * the inheritance is automatically chosen to be from @ref{CellAccessor} if the
+ * the inheritance is automatically chosen to be from CellAccessor if the
* object under consideration has full dimension, i.e. constitutes a cell.
*
* @author Wolfgang Bangerth, 1999
{
public:
/**
- * Declaration of the @p{typedef}.
+ * Declaration of the @p typedef.
* See the full documentation for
* more information.
*/
* parameters. In this class here, we only collect all functions which
* are in the specialized classes for simpler reference. Some
* functions, however, might be missing in the specialized classes,
- * such as @p{quad} in the accessors for lines and quads, etc.
+ * such as @p quad in the accessors for lines and quads, etc.
*
* This class follows mainly the route laid out by the accessor library
- * declared in the triangulation library (@ref{TriaAccessor}). It enables
+ * declared in the triangulation library (TriaAccessor). It enables
* the user to access the degrees of freedom on the lines (there are similar
* versions for the DoFs on quads, etc), where the dimension of the underlying
* triangulation does not really matter (i.e. this accessor works with the
*
* @sect3{Usage}
*
- * The @ref{DoFDimensionInfo} classes inherited by the @ref{DoFHandler} classes
+ * The DoFDimensionInfo classes inherited by the DoFHandler classes
* declare typedefs to iterators using the accessors declared in this class
* hierarchy tree. Usage is best to happen through these typedefs, since they
* are more secure to changes in the class naming and template interface as well
DoFObjectAccessor ();
/**
- * Constructor. The @p{local_data}
+ * Constructor. The @p local_data
* argument is assumed to be a pointer
- * to a @ref{DoFHandler} object.
+ * to a DoFHandler object.
*/
DoFObjectAccessor (const Triangulation<dim> *tria,
const int level,
const AccessorData *local_data);
/**
- * Index of the @p{i}th degree
+ * Index of the @p ith degree
* of freedom of this object.
*/
unsigned int dof_index (const unsigned int i) const;
/**
- * Set the index of the @p{i}th degree
- * of freedom of this object to @p{index}.
+ * Set the index of the @p ith degree
+ * of freedom of this object to @p index.
*/
void set_dof_index (const unsigned int i,
const int index) const;
/**
- * Index of the @p{i}th degree
- * on the @p{vertex}th vertex.
+ * Index of the @p ith degree
+ * on the @p vertexth vertex.
*/
unsigned int vertex_dof_index (const unsigned int vertex,
const unsigned int i) const;
/**
- * Set the index of the @p{i}th degree
- * on the @p{vertex}th vertex to @p{index}.
+ * Set the index of the @p ith degree
+ * on the @p vertexth vertex to @p index.
*/
void set_vertex_dof_index (const unsigned int vertex,
const unsigned int i,
*
* The input vector may be either a
* @p{Vector<float>},
- * @ref{Vector}@p{<double>}, or a
- * @ref{BlockVector}@p{<double>}, or a
+ * Vector@p{<double>}, or a
+ * BlockVector@p{<double>}, or a
* PETSc vector if deal.II is compiled to
* support PETSc. It is in the
* responsibility of the caller to assure
/**
* This function is the counterpart to
- * @p{get_dof_values}: it takes a vector
+ * @p get_dof_values: it takes a vector
* of values for the degrees of freedom
* of the cell pointed to by this iterator
* and writes these values into the global
- * data vector @p{values}. This function
+ * data vector @p values. This function
* is only callable for active cells.
*
* Note that for continuous finite
* to this function.
*
* The output vector may be either a
- * @ref{Vector}@p{<float>},
- * @ref{Vector}@p{<double>}, or a
- * @ref{BlockVector}@p{<double>}, or a
+ * Vector@p{<float>},
+ * Vector@p{<double>}, or a
+ * BlockVector@p{<double>}, or a
* PETSc vector if deal.II is compiled to
* support PETSc. It is in the
* responsibility of the caller to assure
OutputVector &values) const;
/**
- * Pointer to the @p{i}th line
+ * Pointer to the @p ith line
* bounding this Object.
*/
TriaIterator<dim,DoFObjectAccessor<1, dim> >
line (const unsigned int i) const;
/**
- * Pointer to the @p{i}th quad
+ * Pointer to the @p ith quad
* bounding this Object.
*/
TriaIterator<dim,DoFObjectAccessor<2, dim> >
quad (const unsigned int i) const;
/**
- * @p{i}th child as a @ref{DoFObjectAccessor}
+ * @p ith child as a DoFObjectAccessor
* iterator. This function is needed since
* the child function of the base
* class returns a hex accessor without
/**
* Access to the degrees of freedom located on lines.
* This class follows mainly the route laid out by the accessor library
- * declared in the triangulation library (@ref{TriaAccessor}). It enables
+ * declared in the triangulation library (TriaAccessor). It enables
* the user to access the degrees of freedom on the lines (there are similar
* versions for the DoFs on quads, etc), where the dimension of the underlying
* triangulation does not really matter (i.e. this accessor works with the
*
* @sect3{Usage}
*
- * The @ref{DoFDimensionInfo} classes inherited by the @ref{DoFHandler} classes
+ * The DoFDimensionInfo classes inherited by the DoFHandler classes
* declare typedefs to iterators using the accessors declared in this class
* hierarchy tree. Usage is best to happens through these typedefs, since they
* are more secure to changes in the class naming and template interface as well
*
* Inheritance from @p{DoFObjectAccessor_Inheritance<1,dim>::BaseClass} yields
* inheritance from @p{CellAccessor<1>} if @p{dim==1} and from
- * @p{TriaObjectAccessor<1,dim>} for all other @p{dim} values. Thus, an object
+ * @p{TriaObjectAccessor<1,dim>} for all other @p dim values. Thus, an object
* of this class shares all features of cells in one dimension, but behaves
* like an ordinary line in all other cases.
*
DoFObjectAccessor ();
/**
- * Constructor. The @p{local_data}
+ * Constructor. The @p local_data
* argument is assumed to be a pointer
- * to a @ref{DoFHandler} object.
+ * to a DoFHandler object.
*/
DoFObjectAccessor (const Triangulation<dim> *tria,
const int level,
const AccessorData *local_data);
/**
- * Return the index of the @p{i}th degree
+ * Return the index of the @p ith degree
* of freedom of this line.
*/
unsigned int dof_index (const unsigned int i) const;
/**
- * Set the index of the @p{i}th degree
- * of freedom of this line to @p{index}.
+ * Set the index of the @p ith degree
+ * of freedom of this line to @p index.
*/
void set_dof_index (const unsigned int i,
const unsigned int index) const;
/**
- * Return the index of the @p{i}th degree
- * on the @p{vertex}th vertex.
+ * Return the index of the @p ith degree
+ * on the @p vertexth vertex.
*/
unsigned int vertex_dof_index (const unsigned int vertex,
const unsigned int i) const;
/**
- * Set the index of the @p{i}th degree
- * on the @p{vertex}th vertex to @p{index}.
+ * Set the index of the @p ith degree
+ * on the @p vertexth vertex to @p index.
*/
void set_vertex_dof_index (const unsigned int vertex,
const unsigned int i,
* cells.
*
* The input vector may be either a
- * @ref{Vector}@p{<float>},
- * @ref{Vector}@p{<double>}, or a
- * @ref{BlockVector}@p{<double>}, or a
+ * Vector@p{<float>},
+ * Vector@p{<double>}, or a
+ * BlockVector@p{<double>}, or a
* PETSc vector if deal.II is compiled to
* support PETSc. It is in the
* responsibility of the caller to assure
/**
* This function is the counterpart to
- * @p{get_dof_values}: it takes a vector
+ * @p get_dof_values: it takes a vector
* of values for the degrees of freedom
* of the cell pointed to by this iterator
* and writes these values into the global
- * data vector @p{values}. This function
+ * data vector @p values. This function
* is only callable for active cells.
*
* Note that for continuous finite
* have the right size beforehand.
*
* The output vector may be either a
- * @ref{Vector}@p{<float>},
- * @ref{Vector}@p{<double>}, or a
- * @ref{BlockVector}@p{<double>}, or a
+ * Vector@p{<float>},
+ * Vector@p{<double>}, or a
+ * BlockVector@p{<double>}, or a
* PETSc vector if deal.II is compiled to
* support PETSc. It is in the
* responsibility of the caller to assure
OutputVector &values) const;
/**
- * Return the @p{i}th child as a DoF line
+ * Return the @p ith child as a DoF line
* iterator. This function is needed since
* the child function of the base
* class returns a line accessor without
DoFObjectAccessor ();
/**
- * Constructor. The @p{local_data}
+ * Constructor. The @p local_data
* argument is assumed to be a pointer
- * to a @ref{DoFHandler} object.
+ * to a DoFHandler object.
*/
DoFObjectAccessor (const Triangulation<dim> *tria,
const int level,
const AccessorData *local_data);
/**
- * Return the index of the @p{i}th degree
+ * Return the index of the @p ith degree
* of freedom of this quad.
*/
unsigned int dof_index (const unsigned int i) const;
/**
- * Set the index of the @p{i}th degree
- * of freedom of this quad to @p{index}.
+ * Set the index of the @p ith degree
+ * of freedom of this quad to @p index.
*/
void set_dof_index (const unsigned int i,
const unsigned int index) const;
/**
- * Return the index of the @p{i}th degree
- * on the @p{vertex}th vertex.
+ * Return the index of the @p ith degree
+ * on the @p vertexth vertex.
*/
unsigned int vertex_dof_index (const unsigned int vertex,
const unsigned int i) const;
/**
- * Set the index of the @p{i}th degree
- * on the @p{vertex}th vertex to @p{index}.
+ * Set the index of the @p ith degree
+ * on the @p vertexth vertex to @p index.
*/
void set_vertex_dof_index (const unsigned int vertex,
const unsigned int i,
* cells.
*
* The input vector may be either a
- * @ref{Vector}@p{<float>},
- * @ref{Vector}@p{<double>}, or a
- * @ref{BlockVector}@p{<double>}, or a
+ * Vector@p{<float>},
+ * Vector@p{<double>}, or a
+ * BlockVector@p{<double>}, or a
* PETSc vector if deal.II is compiled to
* support PETSc. It is in the
* responsibility of the caller to assure
/**
* This function is the counterpart to
- * @p{get_dof_values}: it takes a vector
+ * @p get_dof_values: it takes a vector
* of values for the degrees of freedom
* of the cell pointed to by this iterator
* and writes these values into the global
- * data vector @p{values}. This function
+ * data vector @p values. This function
* is only callable for active cells.
*
* Note that for continuous finite
* have the right size beforehand.
*
* The output vector may be either a
- * @ref{Vector}@p{<float>},
- * @ref{Vector}@p{<double>}, or a
- * @ref{BlockVector}@p{<double>}, or a
+ * Vector@p{<float>},
+ * Vector@p{<double>}, or a
+ * BlockVector@p{<double>}, or a
* PETSc vector if deal.II is compiled to
* support PETSc. It is in the
* responsibility of the caller to assure
OutputVector &values) const;
/**
- * Return a pointer to the @p{i}th line
- * bounding this @p{Quad}.
+ * Return a pointer to the @p ith line
+ * bounding this @p Quad.
*/
TriaIterator<dim,DoFObjectAccessor<1, dim> >
line (const unsigned int i) const;
/**
- * Return the @p{i}th child as a DoF quad
+ * Return the @p ith child as a DoF quad
* iterator. This function is needed since
* the child function of the base
* class returns a quad accessor without
DoFObjectAccessor ();
/**
- * Constructor. The @p{local_data}
+ * Constructor. The @p local_data
* argument is assumed to be a pointer
- * to a @ref{DoFHandler} object.
+ * to a DoFHandler object.
*/
DoFObjectAccessor (const Triangulation<dim> *tria,
const int level,
const AccessorData *local_data);
/**
- * Return the index of the @p{i}th degree
+ * Return the index of the @p ith degree
* of freedom of this hex.
*/
unsigned int dof_index (const unsigned int i) const;
/**
- * Set the index of the @p{i}th degree
- * of freedom of this hex to @p{index}.
+ * Set the index of the @p ith degree
+ * of freedom of this hex to @p index.
*/
void set_dof_index (const unsigned int i,
const unsigned int index) const;
/**
- * Return the index of the @p{i}th degree
- * on the @p{vertex}th vertex.
+ * Return the index of the @p ith degree
+ * on the @p vertexth vertex.
*/
unsigned int vertex_dof_index (const unsigned int vertex,
const unsigned int i) const;
/**
- * Set the index of the @p{i}th degree
- * on the @p{vertex}th vertex to @p{index}.
+ * Set the index of the @p ith degree
+ * on the @p vertexth vertex to @p index.
*/
void set_vertex_dof_index (const unsigned int vertex,
const unsigned int i,
* cells.
*
* The input vector may be either a
- * @ref{Vector}@p{<float>},
- * @ref{Vector}@p{<double>}, or a
- * @ref{BlockVector}@p{<double>}, or a
+ * Vector@p{<float>},
+ * Vector@p{<double>}, or a
+ * BlockVector@p{<double>}, or a
* PETSc vector if deal.II is compiled to
* support PETSc. It is in the
* responsibility of the caller to assure
/**
* This function is the counterpart to
- * @p{get_dof_values}: it takes a vector
+ * @p get_dof_values: it takes a vector
* of values for the degrees of freedom
* of the cell pointed to by this iterator
* and writes these values into the global
- * data vector @p{values}. This function
+ * data vector @p values. This function
* is only callable for active cells.
*
* Note that for continuous finite
* have the right size beforehand.
*
* The output vector may be either a
- * @ref{Vector}@p{<float>},
- * @ref{Vector}@p{<double>}, or a
- * @ref{BlockVector}@p{<double>}, or a
+ * Vector@p{<float>},
+ * Vector@p{<double>}, or a
+ * BlockVector@p{<double>}, or a
* PETSc vector if deal.II is compiled to
* support PETSc. It is in the
* responsibility of the caller to assure
OutputVector &values) const;
/**
- * Return a pointer to the @p{i}th line
- * bounding this @p{Hex}.
+ * Return a pointer to the @p ith line
+ * bounding this @p Hex.
*/
TriaIterator<dim,DoFObjectAccessor<1, dim> >
line (const unsigned int i) const;
/**
- * Return a pointer to the @p{i}th quad
- * bounding this @p{Hex}.
+ * Return a pointer to the @p ith quad
+ * bounding this @p Hex.
*/
TriaIterator<dim,DoFObjectAccessor<2, dim> >
quad (const unsigned int i) const;
/**
- * Return the @p{i}th child as a DoF hex
+ * Return the @p ith child as a DoF hex
* iterator. This function is needed since
* the child function of the base
* class returns a hex accessor without
* one and two, respectively, this class only collects the pieces
* together by deriving from the appropriate @p{DoF*Accessor} and the
* right @p{CellAccessor<dim>} and finally adding two functions which give
- * access to the neighbors and children as @ref{DoFCellAccessor} objects
- * rather than @ref{CellAccessor} objects (the latter function was inherited
+ * access to the neighbors and children as DoFCellAccessor objects
+ * rather than CellAccessor objects (the latter function was inherited
* from the @p{CellAccessor<dim>} class).
*
* Note that since for the class we derive from, i.e. @p{DoFObjectAccessor<dim,dim>},
* the two template parameters are equal, the base class is actually derived from
- * @ref{CellAccessor}, which makes the functions of this class available to the
- * @ref{DoFCellAccessor} class as well.
+ * CellAccessor, which makes the functions of this class available to the
+ * DoFCellAccessor class as well.
*
* @author Wolfgang Bangerth, 1998
*/
const AccessorData *local_data);
/**
- * Return the @p{i}th neighbor as
+ * Return the @p ith neighbor as
* a DoF cell iterator. This
* function is needed since the
* neighbor function of the base
neighbor (const unsigned int) const;
/**
- * Return the @p{i}th child as a
+ * Return the @p ith child as a
* DoF cell iterator. This
* function is needed since the
* child function of the base
child (const unsigned int) const;
/**
- * Return an iterator to the @p{i}th face
+ * Return an iterator to the @p ith face
* of this cell.
*
* This function is not implemented in 1D,
/**
* Return the result of the
- * @p{neighbor_child_on_subface}
+ * @p neighbor_child_on_subface
* function of the base class,
* but convert it so that one can
* also access the DoF data (the
* vector of nodal values on that
* cell. You could then as well
* get the desired values through
- * the @p{get_dof_values}
+ * the @p get_dof_values
* function In the other case,
* when the cell has children, we
* use the restriction matrices
* decided what the this function
* does in these cases.
*
- * Unlike the @p{get_dof_values}
+ * Unlike the @p get_dof_values
* function, this function is
* associated to cells rather
* than to lines, quads, and
/**
* This, again, is the
* counterpart to
- * @p{get_interpolated_dof_values}:
+ * @p get_interpolated_dof_values:
* you specify the dof values on
* a cell and these are
* interpolated to the children
* to by this object is terminal,
* then the dof values are set in
* the global data vector by
- * calling the @p{set_dof_values}
+ * calling the @p set_dof_values
* function; otherwise, the
* values are prolonged to each
* of the children and this
* them.
*
* Using the
- * @p{get_interpolated_dof_values}
+ * @p get_interpolated_dof_values
* and this function, you can
* compute the interpolation of a
* finite element function to a
* what the prolongation matrices
* represent in this case.
*
- * Unlike the @p{set_dof_values}
+ * Unlike the @p set_dof_values
* function, this function is
* associated to cells rather
* than to lines, quads, and
* objects.
*
* The output vector may be either a
- * @ref{Vector}@p{<float>},
- * @ref{Vector}@p{<double>}, or a
- * @ref{BlockVector}@p{<double>}, or a
+ * Vector@p{<float>},
+ * Vector@p{<double>}, or a
+ * BlockVector@p{<double>}, or a
* PETSc vector if deal.II is compiled to
* support PETSc. It is in the
* responsibility of the caller to assure
*
* The matrix is organized in lines (rows), but only those lines are stored
* where constraints are present. New constraints are added by adding new
- * lines using the @ref{add_line} function, and then populating it using the
- * @ref{add_entry} function to a given line, or @ref{add_entries} to add more
+ * lines using the add_line() function, and then populating it using the
+ * add_entry() function to a given line, or add_entries() to add more
* than one entry at a time. After all constraints have been added, you need
* to call @ref{close()}, which compresses the storage format and sorts the
* entries.
*
* Condensation of a matrix is done in four steps: first one builds the
* sparsity pattern (e.g. using
- * @ref{DoFHandler}@p{::create_sparsity_pattern}); then the sparsity pattern
+ * DoFHandler@p ::create_sparsity_pattern); then the sparsity pattern
* of the condensed matrix is made out of the original sparsity pattern and
* the constraints; third, the global matrix is assembled; and fourth, the
* matrix is finally condensed. To do these steps, you have (at least) two
* possibilities:
*
- * @begin{itemize}
- * @item Use two different sparsity patterns and two different matrices: you
+ * <ul>
+ * <li> Use two different sparsity patterns and two different matrices: you
* may eliminate the lines and rows connected with a constraint and create
* a totally new sparsity pattern and a new system matrix. This has the
* advantage that the resulting system of equations is smaller and free from
* expensive, since <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
+ * <li> Use only one sparsity pattern and one matrix: doing it this way, the
* condense functions add nonzero entries to the sparsity pattern of the large
* matrix (with constrained nodes in it) where the condensation process of the
* matrix will create additional nonzero elements. In the condensation process
* consumption for those iterative solution methods using a larger number of
* auxiliary vectors (e.g. methods using explicit orthogonalization
* procedures).
- * @end{itemize}
+ * </ul>
*
* Usually, the second way is chosen since memory consumption upon
* construction of a second matrix rules out the first
* possibility. Furthermore, all example programs use this method, and we
* recommend that you use it instead of the first way.
*
- * This class provides two sets of @p{condense} functions: those taking two
+ * This class provides two sets of @p condense functions: those taking two
* arguments refer to the first possibility above, those taking only one do
* their job in-place and refer to the second possibility.
*
* The condensation functions exist for different argument types. The in-place
* functions (i.e. those following the second way) exist for arguments of type
- * @ref{SparsityPattern}, @ref{SparseMatrix} and @ref{BlockSparseMatrix}. Note
+ * SparsityPattern, SparseMatrix and BlockSparseMatrix. Note
* that there are no versions for arguments of type
- * @ref{PETScWrappers::SparseMatrix} or any of the other PETSc matrix wrapper
+ * PETScWrappers::SparseMatrix() or any of the other PETSc matrix wrapper
* classes. This is due to the fact that it is relatively hard to get a
* representation of the sparsity structure of PETSc matrices, and to modify
* them; this holds in particular, if the matrix is actually distributed
* @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
+ * be redistributed. This is done by the two @p distribute function, one
* working with two vectors, one working in-place. The operation of
* distribution undoes the condensation process in some sense, but it should
* be noted that it is not the inverse operation. Basically, distribution sets
* this object. Both objects may
* or may not be closed (by
* having their function
- * @p{close} called before), if
+ * @p close called before), if
* this object was closed before,
* then it will be closed
* afterwards as well. Note,
* an exception is thrown.
*
* However, the following is
- * possible: if DoF @p{x} is
- * constrained to dofs @p{x_i}
- * for some set of indices @p{i},
- * then the DoFs @p{x_i} may be
+ * possible: if DoF @p x is
+ * constrained to dofs @p x_i
+ * for some set of indices @p i,
+ * then the DoFs @p x_i may be
* further constrained by the
* constraints object given as
* argument, although not to
* constrained in either of the
* two objects. Note that it is
* not possible that the DoFs
- * @p{x_i} are constrained within
+ * @p x_i are constrained within
* the present object.
*
* Because of simplicity of
/**
* Shift all entries of this
- * matrix down @p{offset} rows
- * and over @p{offset} columns.
+ * matrix down @p offset rows
+ * and over @p offset columns.
*
* This function is useful if you
* are building block matrices,
* where all blocks are built by
- * the same @p{DoFHandler}
+ * the same @p DoFHandler
* object, i.e. the matrix size
* is larger than the number of
* degrees of freedom. Since
* degrees of freedom, you'd
* generate several constraint
* objects, then shift them, and
- * finally @p{merge} them
+ * finally @p merge them
* together again.
*/
void shift (const unsigned int offset);
/**
* Return whether the degree of
- * freedom with number @p{index} is
+ * freedom with number @p index is
* a constrained one.
*
- * Note that if @p{close} was
+ * Note that if @p close was
* called before, then this
* function is significantly
* faster, since then the
* constrained degrees of freedom
* are sorted and we can do a
* binary search, while before
- * @p{close} was called, we have to
+ * @p close was called, we have to
* perform a linear search
* through all entries.
*/
* eliminated in favor of exactly
* one other degree of freedom.
*
- * The function returns @p{false}
+ * The function returns @p false
* if either the degree of
* freedom is not constrained at
* all, or if it is constrained
* in 2d a hanging node is
* constrained only to its two
* neighbors, so the returned
- * value would be @p{2}. However,
+ * value would be @p 2. However,
* for higher order elements
* and/or higher dimensions, or
* other types of constraints,
* matrix struct should be condensed and
* compressed. It is the user's
* responsibility to guarantee that all
- * entries in the @p{condensed} matrix be
+ * entries in the @p condensed matrix be
* zero!
*
* The constraint matrix object must be
/**
* Condense the given vector
- * @p{uncondensed} into @p{condensed}. It
+ * @p uncondensed into @p condensed. It
* is the user's responsibility to
* guarantee that all entries of
- * @p{condensed} be zero.
+ * @p condensed be zero.
*
- * The @p{VectorType} may be a
- * @ref{Vector}@p{<float>},
- * @ref{Vector}@p{<double>},
- * @ref{BlockVector}@p{<...>}, a PETSc
+ * The @p VectorType may be a
+ * Vector@p{<float>},
+ * Vector@p{<double>},
+ * BlockVector@p{<...>}, a PETSc
* vector wrapper class, or any other
* type having the same interface.
*/
/**
* Condense the given vector
- * in-place. The @p{VectorType} may be a
- * @ref{Vector}@p{<float>},
- * @ref{Vector}@p{<double>},
- * @ref{BlockVector}@p{<...>}, a PETSc
+ * in-place. The @p VectorType may be a
+ * Vector@p{<float>},
+ * Vector@p{<double>},
+ * BlockVector@p{<...>}, a PETSc
* vector wrapper class, or any other
* type having the same interface.
*/
/**
* Re-distribute the elements of
- * the vector @p{condensed} to
- * @p{uncondensed}. It is the
+ * the vector @p condensed to
+ * @p uncondensed. It is the
* user's responsibility to
* guarantee that all entries of
- * @p{uncondensed} be zero!
+ * @p uncondensed be zero!
*
* This function undoes the
- * action of @p{condense} somehow,
+ * action of @p condense somehow,
* but it should be noted that it
* is not the inverse of
- * @p{condense}.
+ * @p condense.
*
- * The @p{VectorType} may be a
- * @ref{Vector}@p{<float>},
- * @ref{Vector}@p{<double>},
- * @ref{BlockVector}@p{<...>}, a PETSc
+ * The @p VectorType may be a
+ * Vector@p{<float>},
+ * Vector@p{<double>},
+ * BlockVector@p{<...>}, a PETSc
* vector wrapper class, or any other
* type having the same interface.
*/
/**
* Re-distribute the elements of the
- * vector in-place. The @p{VectorType}
- * may be a @ref{Vector}@p{<float>},
- * @ref{Vector}@p{<double>},
- * @ref{BlockVector}@p{<...>}, a PETSc
+ * vector in-place. The @p VectorType
+ * may be a Vector@p{<float>},
+ * Vector@p{<double>},
+ * BlockVector@p{<...>}, a PETSc
* vector wrapper class, or any other
* type having the same interface.
*/
/**
* Delete hanging nodes in a vector.
* Sets all hanging node values to
- * zero. The @p{VectorType} may be a
- * @ref{Vector}@p{<float>},
- * @ref{Vector}@p{<double>},
- * @ref{BlockVector}@p{<...>}, a PETSc
+ * zero. The @p VectorType may be a
+ * Vector@p{<float>},
+ * Vector@p{<double>},
+ * BlockVector@p{<...>}, a PETSc
* vector wrapper class, or any other
* type having the same interface.
*/
* For the reason why we use a vector
* instead of a map and the consequences
* thereof, the same applies as what is
- * said for @ref{ConstraintMatrix}@p{::lines}.
+ * said for ConstraintMatrix@p ::lines.
*/
std::vector<std::pair<unsigned int,double> > entries;
bool sorted;
/**
- * Return @p{true} if the weight
+ * Return @p true if the weight
* of an entry (the second
* element of the pair) equals
* zero. This function is used to
{
// this line is constrained
new_line.push_back (-1);
- // note that @p{lines} is ordered
+ // note that @p lines is ordered
++shift;
++next_constraint;
if (next_constraint == lines.end())
next_constraint = lines.begin();
// note: in this loop we need not check
- // whether @p{next_constraint} is a valid
- // iterator, since @p{next_constraint} is
+ // whether @p next_constraint is a valid
+ // iterator, since @p next_constraint is
// only evaluated so often as there are
// entries in new_line[*] which tells us
// which constraints exist
if (distribute[column] != deal_II_numbers::invalid_unsigned_int)
// distribute entry at
- // regular row @p{row}
+ // regular row @p row
// and irregular column
// sparsity.get_column_numbers()[j];
// set old entry to
if (distribute[column] == deal_II_numbers::invalid_unsigned_int)
// distribute entry at
// irregular row
- // @p{row} and regular
+ // @p row and regular
// column
// column. set
// old entry to zero
}
else
// distribute entry at
- // irregular row @p{row} and
+ // irregular row @p row and
// irregular column
- // @p{column} set old entry
+ // @p column set old entry
// to one if on main
// diagonal, zero otherwise
{
if (distribute[global_col] != deal_II_numbers::invalid_unsigned_int)
// distribute entry at
- // regular row @p{row}
+ // regular row @p row
// and irregular column
// global_col; set old
// entry to zero
// distribute
// entry at
// irregular
- // row @p{row}
+ // row @p row
// and regular
// column
// global_col. set
}
else
// distribute entry at
- // irregular row @p{row}
+ // irregular row @p row
// and irregular column
- // @p{global_col} set old
+ // @p global_col set old
// entry to one if on
// main diagonal, zero
// otherwise
{
// this line is constrained
new_line.push_back (-1);
- // note that @p{lines} is ordered
+ // note that @p lines is ordered
++shift;
++next_constraint;
if (next_constraint == lines.end())
next_constraint = lines.begin();
// note: in this loop we need not check
- // whether @p{next_constraint} is a valid
- // iterator, since @p{next_constraint} is
+ // whether @p next_constraint is a valid
+ // iterator, since @p next_constraint is
// only evaluated so often as there are
// entries in new_line[*] which tells us
// which constraints exist
{
// this line is constrained
old_line.push_back (-1);
- // note that @p{lines} is ordered
+ // note that @p lines is ordered
++shift;
++next_constraint;
if (next_constraint == lines.end())
next_constraint = lines.begin();
// note: in this loop we need not check
- // whether @p{next_constraint} is a valid
- // iterator, since @p{next_constraint} is
+ // whether @p next_constraint is a valid
+ // iterator, since @p next_constraint is
// only evaluated so often as there are
// entries in new_line[*] which tells us
// which constraints exist
/**
* Define some types which differ between the dimensions. This class
- * is analogous to the @ref{TriaDimensionInfo} class hierarchy.
+ * is analogous to the TriaDimensionInfo class hierarchy.
*
* @ref DoFDimensionInfo<1>
* @ref DoFDimensionInfo<2>
* also refer to all degrees of freedom and some kind of condensation
* is needed to restrict the systems of equations to the unconstrained
* degrees of freedom only. The actual layout of storage of the indices
- * is described in the @ref{DoFLevel} class documentation.
+ * is described in the DoFLevel class documentation.
*
* Finally it offers a starting point for the assemblage of the matrices
* by offering @p{begin()} and @p{end()} functions which return iterators
* to walk on the DoF structures as well as the triangulation data.
* These iterators work much like those described in the documentation
- * of the @ref{Triangulation} class and of the iterator classes themselved,
+ * of the Triangulation class and of the iterator classes themselved,
* but offer more functionality than pure triangulation iterators. The
- * order in which dof iterators are presented by the @p{++} and @p{--} operators
+ * order in which dof iterators are presented by the @p{++} and @p -- operators
* is the same as that for the alike triangulation iterators.
*
* This class also provides functions to create the sparsity patterns of
*
* This numbering implies very large bandwiths of the resulting matrices and
* is thus vastly suboptimal for some solution algorithms. For this reason,
- * the @ref{DoFRenumbering} class offers the function @p{renumber_dofs} which reorders
+ * the DoFRenumbering class offers the function @p renumber_dofs which reorders
* the dof numbering according to some scheme. See there for a discussion of
* the implemented algorithms.
*
*
* @sect3{User defined renumbering schemes}
*
- * The @ref{DoFRenumbering} class offers a number of renumbering
+ * The DoFRenumbering class offers a number of renumbering
* schemes like the Cuthill-McKey scheme. Basically, the function sets
* up an array in which for each degree of freedom the index is stored
* which is to be assigned by the renumbering. Using this array, the
typedef typename DoFDimensionInfo<dim>::active_face_iterator active_face_iterator;
/**
- * Alias the @p{FunctionMap} type
+ * Alias the @p FunctionMap type
* declared elsewhere.
*/
typedef typename ::FunctionMap<dim>::type FunctionMap;
static const unsigned int invalid_dof_index = deal_II_numbers::invalid_unsigned_int;
/**
- * Constructor. Take @p{tria} as the
+ * Constructor. Take @p tria as the
* triangulation to work on.
*/
DoFHandler (const Triangulation<dim> &tria);
* method.
*
* The additional optional
- * parameter @p{offset} allows you
+ * parameter @p offset allows you
* to reserve space for a finite
* number of additional vector
* entries in the beginning of
* object shall be longer than
* that of this object. If you
* don't want this behaviour, you
- * may want to call the @p{clear}
+ * may want to call the @p clear
* member function which also
* releases the lock of this
* object to the finite element.
* Clear all data of this object and
* especially delete the lock this object
* has to the finite element used the last
- * time when @p{distribute_dofs} was called.
+ * time when @p distribute_dofs was called.
*/
virtual void clear ();
* a list of new dof numbers for all the
* dofs.
*
- * @p{new_numbers} is an array of integers
+ * @p new_numbers is an array of integers
* with size equal to the number of dofs
* on the present grid. It stores the new
* indices after renumbering in the
* order of the old indices.
*
* This function is called by the
- * @p{renumber_dofs} function after computing
+ * @p renumber_dofs function after computing
* the ordering of the degrees of freedom.
* However, you can call this function
* yourself, which is necessary if a user
* This is the maximum number of entries
* per line in the system matrix; this
* information can therefore be used upon
- * construction of the @ref{SparsityPattern}
+ * construction of the SparsityPattern
* object.
*
* The returned number is not really the
* the boundary can couple with.
*
* The number is the same as for
- * @p{max_coupling_between_dofs} in one
+ * @p max_coupling_between_dofs in one
* dimension less.
*/
unsigned int max_couplings_between_boundary_dofs () const;
/*@{*/
/**
* Iterator to the first cell, used
- * or not, on level @p{level}. If a level
+ * or not, on level @p level. If a level
* has no cells, a past-the-end iterator
* is returned.
*
- * This function calls @p{begin_raw_line}
- * in 1D and @p{begin_raw_quad} in 2D.
+ * This function calls @p begin_raw_line
+ * in 1D and @p begin_raw_quad in 2D.
*/
raw_cell_iterator begin_raw (const unsigned int level = 0) const;
/**
* Iterator to the first used cell
- * on level @p{level}.
+ * on level @p level.
*
- * This function calls @p{begin_line}
- * in 1D and @p{begin_quad} in 2D.
+ * This function calls @p begin_line
+ * in 1D and @p begin_quad in 2D.
*/
cell_iterator begin (const unsigned int level = 0) const;
/**
* Iterator to the first active
- * cell on level @p{level}.
+ * cell on level @p level.
*
- * This function calls @p{begin_active_line}
- * in 1D and @p{begin_active_quad} in 2D.
+ * This function calls @p begin_active_line
+ * in 1D and @p begin_active_quad in 2D.
*/
active_cell_iterator begin_active(const unsigned int level = 0) const;
* iterators with past-the-end or
* before-the-beginning states.
*
- * This function calls @p{end_line}
- * in 1D and @p{end_quad} in 2D.
+ * This function calls @p end_line
+ * in 1D and @p end_quad in 2D.
*/
raw_cell_iterator end () const;
/**
* Return an iterator which is the first
- * iterator not on level. If @p{level} is
+ * iterator not on level. If @p level is
* the last level, then this returns
* @p{end()}.
*/
/**
* Return a raw iterator which is the first
- * iterator not on level. If @p{level} is
+ * iterator not on level. If @p level is
* the last level, then this returns
* @p{end()}.
*/
/**
* Return an active iterator which is the
- * first iterator not on level. If @p{level}
+ * first iterator not on level. If @p level
* is the last level, then this returns
* @p{end()}.
*/
* Return an iterator pointing to the
* last cell, used or not.
*
- * This function calls @p{last_raw_line}
- * in 1D and @p{last_raw_quad} in 2D.
+ * This function calls @p last_raw_line
+ * in 1D and @p last_raw_quad in 2D.
*/
raw_cell_iterator last_raw () const;
/**
* Return an iterator pointing to the last
- * cell of the level @p{level}, used or not.
+ * cell of the level @p level, used or not.
*
- * This function calls @p{last_raw_line}
- * in 1D and @p{last_raw_quad} in 2D.
+ * This function calls @p last_raw_line
+ * in 1D and @p last_raw_quad in 2D.
*/
raw_cell_iterator last_raw (const unsigned int level) const;
* Return an iterator pointing to the last
* used cell.
*
- * This function calls @p{last_line}
- * in 1D and @p{last_quad} in 2D.
+ * This function calls @p last_line
+ * in 1D and @p last_quad in 2D.
*/
cell_iterator last () const;
/**
* Return an iterator pointing to the last
- * used cell on level @p{level}.
+ * used cell on level @p level.
*
- * This function calls @p{last_line}
- * in 1D and @p{last_quad} in 2D.
+ * This function calls @p last_line
+ * in 1D and @p last_quad in 2D.
*/
cell_iterator last (const unsigned int level) const;
* Return an iterator pointing to the last
* active cell.
*
- * This function calls @p{last_active_line}
- * in 1D and @p{last_active_quad} in 2D.
+ * This function calls @p last_active_line
+ * in 1D and @p last_active_quad in 2D.
*/
active_cell_iterator last_active () const;
/**
* Return an iterator pointing to the last
- * active cell on level @p{level}.
+ * active cell on level @p level.
*
- * This function calls @p{last_active_line}
- * in 1D and @p{last_active_quad} in 2D.
+ * This function calls @p last_active_line
+ * in 1D and @p last_active_quad in 2D.
*/
active_cell_iterator last_active (const unsigned int level) const;
//@}
/*@{*/
/**
* Iterator to the first face, used
- * or not, on level @p{level}. If a level
+ * or not, on level @p level. If a level
* has no faces, a past-the-end iterator
* is returned.
*
- * This function calls @p{begin_raw_line}
- * in 2D and @p{begin_raw_quad} in 3D.
+ * This function calls @p begin_raw_line
+ * in 2D and @p begin_raw_quad in 3D.
*/
raw_face_iterator begin_raw_face (const unsigned int level = 0) const;
/**
* Iterator to the first used face
- * on level @p{level}.
+ * on level @p level.
*
- * This function calls @p{begin_line}
- * in 2D and @p{begin_quad} in 3D.
+ * This function calls @p begin_line
+ * in 2D and @p begin_quad in 3D.
*/
face_iterator begin_face (const unsigned int level = 0) const;
/**
* Iterator to the first active
- * face on level @p{level}.
+ * face on level @p level.
*
- * This function calls @p{begin_active_line}
- * in 2D and @p{begin_active_quad} in 3D.
+ * This function calls @p begin_active_line
+ * in 2D and @p begin_active_quad in 3D.
*/
active_face_iterator begin_active_face(const unsigned int level = 0) const;
* iterators with past-the-end or
* before-the-beginning states.
*
- * This function calls @p{end_line}
- * in 2D and @p{end_quad} in 3D.
+ * This function calls @p end_line
+ * in 2D and @p end_quad in 3D.
*/
raw_face_iterator end_face () const;
/**
* Return an iterator which is the first
- * iterator not on level. If @p{level} is
+ * iterator not on level. If @p level is
* the last level, then this returns
* @p{end()}.
*/
/**
* Return a raw iterator which is the first
- * iterator not on level. If @p{level} is
+ * iterator not on level. If @p level is
* the last level, then this returns
* @p{end()}.
*/
/**
* Return an active iterator which is the
- * first iterator not on level. If @p{level}
+ * first iterator not on level. If @p level
* is the last level, then this returns
* @p{end()}.
*/
* Return an iterator pointing to the
* last face, used or not.
*
- * This function calls @p{last_raw_line}
- * in 2D and @p{last_raw_quad} in 3D.
+ * This function calls @p last_raw_line
+ * in 2D and @p last_raw_quad in 3D.
*/
raw_face_iterator last_raw_face () const;
/**
* Return an iterator pointing to the last
- * face of the level @p{level}, used or not.
+ * face of the level @p level, used or not.
*
- * This function calls @p{last_raw_line}
- * in 2D and @p{last_raw_quad} in 3D.
+ * This function calls @p last_raw_line
+ * in 2D and @p last_raw_quad in 3D.
*/
raw_face_iterator last_raw_face (const unsigned int level) const;
* Return an iterator pointing to the last
* used face.
*
- * This function calls @p{last_line}
- * in 2D and @p{last_quad} in 3D.
+ * This function calls @p last_line
+ * in 2D and @p last_quad in 3D.
*/
face_iterator last_face () const;
/**
* Return an iterator pointing to the last
- * used face on level @p{level}.
+ * used face on level @p level.
*
- * This function calls @p{last_line}
- * in 2D and @p{last_quad} in 3D.
+ * This function calls @p last_line
+ * in 2D and @p last_quad in 3D.
*/
face_iterator last_face (const unsigned int level) const;
* Return an iterator pointing to the last
* active face.
*
- * This function calls @p{last_active_line}
- * in 2D and @p{last_active_quad} in 3D.
+ * This function calls @p last_active_line
+ * in 2D and @p last_active_quad in 3D.
*/
active_face_iterator last_active_face () const;
/**
* Return an iterator pointing to the last
- * active face on level @p{level}.
+ * active face on level @p level.
*
- * This function calls @p{last_active_line}
- * in 2D and @p{last_active_quad} in 3D.
+ * This function calls @p last_active_line
+ * in 2D and @p last_active_quad in 3D.
*/
active_face_iterator last_active_face (const unsigned int level) const;
//@}
/*@{*/
/**
* Iterator to the first line, used
- * or not, on level @p{level}. If a level
+ * or not, on level @p level. If a level
* has no lines, a past-the-end iterator
* is returned.
*/
/**
* Iterator to the first used line
- * on level @p{level}.
+ * on level @p level.
*/
line_iterator begin_line (const unsigned int level = 0) const;
/**
* Iterator to the first active
- * line on level @p{level}.
+ * line on level @p level.
*/
active_line_iterator begin_active_line(const unsigned int level = 0) const;
/**
* Return an iterator which is the first
- * iterator not on level. If @p{level} is
+ * iterator not on level. If @p level is
* the last level, then this returns
* @p{end()}.
*/
/**
* Return a raw iterator which is the first
- * iterator not on level. If @p{level} is
+ * iterator not on level. If @p level is
* the last level, then this returns
* @p{end()}.
*/
/**
* Return an active iterator which is the
- * first iterator not on level. If @p{level}
+ * first iterator not on level. If @p level
* is the last level, then this returns
* @p{end()}.
*/
/**
* Return an iterator pointing to the last
- * line of the level @p{level}, used or not.
+ * line of the level @p level, used or not.
*/
raw_line_iterator last_raw_line (const unsigned int level) const;
/**
* Return an iterator pointing to the last
- * used line on level @p{level}.
+ * used line on level @p level.
*/
line_iterator last_line (const unsigned int level) const;
/**
* Return an iterator pointing to the last
- * active line on level @p{level}.
+ * active line on level @p level.
*/
active_line_iterator last_active_line (const unsigned int level) const;
/*@}*/
*/
/**
* Iterator to the first quad, used
- * or not, on level @p{level}. If a level
+ * or not, on level @p level. If a level
* has no quads, a past-the-end iterator
* is returned.
*/
/**
* Iterator to the first used quad
- * on level @p{level}.
+ * on level @p level.
*/
quad_iterator begin_quad (const unsigned int level = 0) const;
/**
* Iterator to the first active
- * quad on level @p{level}.
+ * quad on level @p level.
*/
active_quad_iterator begin_active_quad(const unsigned int level = 0) const;
/**
* Return an iterator which is the first
- * iterator not on level. If @p{level} is
+ * iterator not on level. If @p level is
* the last level, then this returns
* @p{end()}.
*/
/**
* Return a raw iterator which is the first
- * iterator not on level. If @p{level} is
+ * iterator not on level. If @p level is
* the last level, then this returns
* @p{end()}.
*/
/**
* Return an active iterator which is the
- * first iterator not on level. If @p{level}
+ * first iterator not on level. If @p level
* is the last level, then this returns
* @p{end()}.
*/
/**
* Return an iterator pointing to the last
- * quad of the level @p{level}, used or not.
+ * quad of the level @p level, used or not.
*/
raw_quad_iterator last_raw_quad (const unsigned int level) const;
/**
* Return an iterator pointing to the last
- * used quad on level @p{level}.
+ * used quad on level @p level.
*/
quad_iterator last_quad (const unsigned int level) const;
/**
* Return an iterator pointing to the last
- * active quad on level @p{level}.
+ * active quad on level @p level.
*/
active_quad_iterator last_active_quad (const unsigned int level) const;
/*@}*/
*/
/**
* Iterator to the first hex, used
- * or not, on level @p{level}. If a level
+ * or not, on level @p level. If a level
* has no hexs, a past-the-end iterator
* is returned.
*/
/**
* Iterator to the first used hex
- * on level @p{level}.
+ * on level @p level.
*/
hex_iterator
begin_hex (const unsigned int level = 0) const;
/**
* Iterator to the first active
- * hex on level @p{level}.
+ * hex on level @p level.
*/
active_hex_iterator
begin_active_hex(const unsigned int level = 0) const;
/**
* Return an iterator which is the first
- * iterator not on level. If @p{level} is
+ * iterator not on level. If @p level is
* the last level, then this returns
* @p{end()}.
*/
/**
* Return a raw iterator which is the first
- * iterator not on level. If @p{level} is
+ * iterator not on level. If @p level is
* the last level, then this returns
* @p{end()}.
*/
/**
* Return an active iterator which is the
- * first iterator not on level. If @p{level}
+ * first iterator not on level. If @p level
* is the last level, then this returns
* @p{end()}.
*/
/**
* Return an iterator pointing to the last
- * hex of the level @p{level}, used or not.
+ * hex of the level @p level, used or not.
*/
raw_hex_iterator
/**
* Return an iterator pointing to the last
- * used hex on level @p{level}.
+ * used hex on level @p level.
*/
hex_iterator
last_hex (const unsigned int level) const;
/**
* Return an iterator pointing to the last
- * active hex on level @p{level}.
+ * active hex on level @p level.
*/
active_hex_iterator
last_active_hex (const unsigned int level) const;
* parts of the boundary which
* have a boundary indicator
* listed in the given set. The
- * reason that a @p{map} rather
- * than a @p{set} is used is the
+ * reason that a @p map rather
+ * than a @p set is used is the
* same as descibed in the
* section on the
- * @p{make_boundary_sparsity_pattern}
+ * @p make_boundary_sparsity_pattern
* function.
*/
unsigned int
* needed for the given element. The
* given element is that one which
* was selected when calling
- * @p{distribute_dofs} the last time.
+ * @p distribute_dofs the last time.
*/
void reserve_space ();
/**
* Distribute dofs on the given cell,
* with new dofs starting with index
- * @p{next_free_dof}. Return the next
+ * @p next_free_dof. Return the next
* unused index number. The finite
* element used is the one given to
- * @p{distribute_dofs}, which is copied
- * to @p{selected_fe}.
+ * @p distribute_dofs, which is copied
+ * to @p selected_fe.
*
* This function is excluded from the
- * @p{distribute_dofs} function since
+ * @p distribute_dofs function since
* it can not be implemented dimension
* independent.
*/
/**
* Space to store the DoF numbers for the
* different levels. Analogous to the
- * @p{levels[]} tree of the @ref{Triangulation}
+ * @p{levels[]} tree of the Triangulation
* objects.
*/
std::vector<DoFLevel<dim>*> levels;
/**
* Store the indices of the degrees of freedom which are located on
- * objects of dimension @p{N}. Declare this general template
+ * objects of dimension @p N. Declare this general template
* class, but do not actually use it. Rather, only specializations of
* this class are used.
*
* Store the indices of the degrees of freedom which are located on
* the lines.
*
- * @sect3{Information for all @ref{DoFLevel} classes}
+ * @sect3{Information for all DoFLevel classes}
*
- * The @ref{DoFLevel}@p{<N>} classes
+ * The DoFLevel@p{<N>} 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
* $\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 @ref{DoFHandler}@p{::make_hanging_node_constraints ()}
+ * constraint matrix returned by DoFHandler@p{::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
- * @ref{DoFLevel}@p{<dim>} classes for the different dimensions which
- * have objects named @p{line_dofs}, @p{quad_dofs} and so on, in which
+ * DoFLevel@p{<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
- * @ref{DoFHandler}@p{::distribute_dofs()} to select a finite element)
+ * DoFHandler@p{::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{i}th
+ * @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
* line are at the positions @p{N*i...(N+1)*i-1}.
*
* The DoF indices for vertices are not stored this way, since they
* need different treatment in multigrid environments. If no multigrid
- * is used, the indices are stored in the @p{vertex_dofs} array of the
- * @ref{DoFHandler} class.
+ * is used, the indices are stored in the @p vertex_dofs array of the
+ * DoFHandler class.
*
* @author Wolfgang Bangerth, 1998
*/
/**
* Store the global indices of
* the degrees of freedom. See
- * @ref{DoFLevel} for detailed
+ * DoFLevel for detailed
* information.
*/
std::vector<unsigned int> line_dofs;
/**
* Store the global indices of
* the degrees of freedom. See
- * @ref{DoFLevel} for detailed
+ * DoFLevel for detailed
* information.
*/
std::vector<unsigned int> quad_dofs;
/**
* Store the global indices of
* the degrees of freedom. See
- * @ref{DoFLevel} for detailed
+ * DoFLevel for detailed
* information.
*/
std::vector<unsigned int> hex_dofs;
*
* The renumbering algorithms need quite a lot of memory, since they have
* to store for each dof with which other dofs it couples. This is done
- * using a @ref{SparsityPattern} object used to store the sparsity pattern of
+ * using a SparsityPattern object used to store the sparsity pattern of
* matrices. It
* is not useful for the user to do anything between distributing the dofs
- * and renumbering, i.e. the calls to @ref{DoFHandler}@p{::distribute_dofs} and
- * @ref{DoFHandler}@p{::renumber_dofs} should follow each other immediately. If
+ * and renumbering, i.e. the calls to DoFHandler@p ::distribute_dofs and
+ * DoFHandler@p ::renumber_dofs should follow each other immediately. If
* you try to create a sparsity pattern or anything else in between, these
* will be invalid afterwards.
*
* The renumbering may take care of dof-to-dof couplings only induced by
* eliminating constraints. In addition to the memory consumption mentioned
* above, this also takes quite some computational time, but it may be
- * switched off upon calling the @p{renumber_dofs} function. This will then
+ * switched off upon calling the @p renumber_dofs function. This will then
* give inferior results, since knots in the graph (representing dofs)
* are not found to be neighbors even if they would be after condensation.
*
*
* @sect2{Component-wise numbering}
*
- * For finite elements composed of several base elements using the @ref{FESystem}
+ * For finite elements composed of several base elements using the FESystem
* class, or for elements which provide several components themselves, it
* may be of interest to sort the DoF indices by component. This will then
* bring out the block matrix structure, since otherwise the degrees of freedom
* different components.
*
* This kind of numbering may be obtained by calling the
- * @p{component_wise} function of this class. Since it does not touch
+ * @p component_wise function of this class. Since it does not touch
* the order of indices within each, it may be worthwhile to first
* renumber using the Cuthill-McKee or a similar algorithm and
* afterwards renumbering component-wise. This will bring out the
*
* @sect2{Random renumbering}
*
- * The @p{random} function renumbers degrees of freedom randomly. This
+ * The @p random function renumbers degrees of freedom randomly. This
* function is probably seldom of use, except to check the dependence of
* solvers (iterative or direct ones) on the numbering of the degrees
- * of freedom. It uses the @p{random_shuffle} function from the C++
+ * of freedom. It uses the @p random_shuffle function from the C++
* standard library to do its work.
*
*
/**
* Computes the renumbering
* vector needed by the
- * @p{Cuthill_McKee}
+ * @p Cuthill_McKee
* function. Does not perform the
* renumbering on the
- * @p{DoFHandler} dofs but
+ * @p DoFHandler dofs but
* returns the renumbering
* vector.
*/
* You can specify that the
* components are ordered in a
* different way than suggested
- * by the @p{FESystem} object you
+ * by the @p FESystem object you
* use. To this end, Set up the
- * vector @p{target_component}
+ * vector @p target_component
* such that the entry at index
- * @p{i} denotes the number of
+ * @p i denotes the number of
* the target component for dofs
- * with component @p{i} in the
- * @p{FESystem}. Naming the same
+ * with component @p i in the
+ * @p FESystem. Naming the same
* component more than once is
* possible and results in a
* blocking of several components
/**
* Computes the renumbering
* vector needed by the
- * @p{component_wise}
+ * @p component_wise
* functions. Does not perform the
* renumbering on the
- * @p{DoFHandler} dofs but
+ * @p DoFHandler dofs but
* returns the renumbering
* vector.
*/
* Cell-wise renumbering for DG
* elements. This function takes
* the ordered set of cells in
- * @p{cell_order}, and makes sure
+ * @p cell_order, and makes sure
* that all degrees of freedom in
* a cell with higher index are
* behind all degrees of freedom
/**
* Computes the renumbering
* vector needed by the
- * @p{cell_wise_dg}
+ * @p cell_wise_dg
* function. Does not perform the
* renumbering on the
- * @p{DoFHandler} dofs but
+ * @p DoFHandler dofs but
* returns the renumbering
* vector.
*/
* the centers of higher numbers
* are further downstream with
* respect to the constant vector
- * @p{direction} than the centers
+ * @p direction than the centers
* of lower numbers. Even if this
* yields a downstream numbering
* with respect to the flux on
* This function produces a
* downstream ordering of the
* mesh cells and calls
- * @ref{cell_wise_dg}.
+ * cell_wise_dg().
* Therefore, it only works with
* Discontinuous Galerkin Finite
* Elements, i.e. all degrees of
/**
* Computes the renumbering
* vector needed by the
- * @p{downstream_dg}
+ * @p downstream_dg
* function. Does not perform the
* renumbering on the
- * @p{DoFHandler} dofs but
+ * @p DoFHandler dofs but
* returns the renumbering
* vector.
*/
* This function produces a
* (counter)clockwise ordering of
* the mesh cells with respect to
- * the hub @p{center} and calls
- * @ref{cell_wise_dg}.
+ * the hub @p center and calls
+ * cell_wise_dg().
* Therefore, it only works with
* Discontinuous Galerkin Finite
* Elements, i.e. all degrees of
/**
* Computes the renumbering
* vector needed by the
- * @p{clockwise_dg}
+ * @p clockwise_dg
* functions. Does not perform the
* renumbering on the
- * @p{DoFHandler} dofs but
+ * @p DoFHandler dofs but
* returns the renumbering
* vector.
*/
/**
* Sort those degrees of freedom
- * which are tagged with @p{true}
- * in the @p{selected_dofs} array
+ * which are tagged with @p true
+ * in the @p selected_dofs array
* to the back of the DoF
* numbers. The sorting is
* stable, i.e. the relative
/**
* Computes the renumbering
* vector needed by the
- * @p{sort_selected_dofs_back}
+ * @p sort_selected_dofs_back
* function. Does not perform the
* renumbering on the
- * @p{DoFHandler} dofs but
+ * @p DoFHandler dofs but
* returns the renumbering
* vector.
*/
/**
* Computes the renumbering
* vector needed by the
- * @p{random} function. Does not
+ * @p random function. Does not
* perform the renumbering on the
- * @p{DoFHandler} dofs but
+ * @p DoFHandler dofs but
* returns the renumbering
* vector.
*/
* when doing parallel computations after
* assigning subdomain ids using a
* partitioner (see the
- * @p{GridTools::partition_triangulation}
+ * @p GridTools::partition_triangulation
* function for this).
*
* Note that degrees of freedom
* which subdomain they have to be
* associated. For this, we use what we
* get from the
- * @p{DoFTools::get_subdomain_association}
+ * @p DoFTools::get_subdomain_association
* function.
*
* The algorithm is stable, i.e. if
/**
* Computes the renumbering vector needed
- * by the @p{subdomain_wise}
+ * by the @p subdomain_wise
* function. Does not perform the
- * renumbering on the @p{DoFHandler} dofs
+ * renumbering on the @p DoFHandler dofs
* but returns the renumbering vector.
*/
template <int dim>
* documentation stating some commonalities.
*
* All member functions are static, so there is no need to create an
- * object of class @ref{DoFTools}.
+ * object of class DoFTools.
*
*
* @sect3{Setting up sparsity patterns}
* of freedom on the boundary. What is needed in this case is a
* numbering of the boundary degrees of freedom, starting from zero on
* and not considering the degrees of freedom in the interior. The
- * @p{map_dof_to_boundary_indices} function does exactly this, by
+ * @p map_dof_to_boundary_indices function does exactly this, by
* providing a vector with as many entries as there are degrees of
* freedom on the whole domain, with each entry being the number in
* the numbering of the boundary or
- * @ref{DoFHandler}@p{::invalid_dof_index} if the dof is not on the
+ * DoFHandler@p ::invalid_dof_index if the dof is not on the
* boundary. You should always use this function to get the mapping
* between local (boundary) and the global numbers, for example to
* build the mass matrix on the boundary, or to get the global index
* algorithm, you are better off if you just accept the mapping `as
* is'.
*
- * Actually, there are two @p{map_dof_to_boundary_indices} functions,
+ * Actually, there are two @p map_dof_to_boundary_indices functions,
* one producing a numbering for all boundary degrees of freedom and
* one producing a numbering for only parts of the boundary, namely
* those parts for which the boundary indicator is listed in a set of
* indices of degrees of freedom on different parts may be intermixed.
*
* Degrees of freedom on the boundary but not on one of the specified
- * boundary parts are given the index @p{invalid_dof_index}, as if
+ * boundary parts are given the index @p invalid_dof_index, as if
* they were in the interior. If no boundary indicator was given or if
* no face of a cell has a boundary indicator contained in the given
* list, the vector of new indices consists solely of
- * @p{invalid_dof_index}s.
+ * @p invalid_dof_indexs.
*
* The question what a degree of freedom on the boundary is, is not so
* easy. It should really be a degree of freedom of which the
* least for Lagrange elements this definition is equal to the
* statement that the off-point of the shape function, i.e. the point
* where the function assumes its nominal value (for Lagrange elements
- * this is the point where it has the function value @p{1}), is
+ * this is the point where it has the function value @p 1), is
* located on the boundary. We do not check this directly, the
* criterion is rather defined through the information the finite
- * element class gives: the @ref{FiniteElementBase} class defines the
+ * element class gives: the FiniteElementBase class defines the
* numbers of basis functions per vertex, per line, and so on and the
* basis functions are numbered after this information; a basis
* function is to be considered to be on the face of a cell (and thus
* correspond to degrees of
* freedom of at least one common
* cell. Therefore,
- * @p{make_sparsity_pattern} just
+ * @p make_sparsity_pattern just
* loops over all cells and
* enters all couplings local to
* that cell. As the generation
* of hanging nodes. They have
* to be taken care of by a call
* to
- * @ref{ConstraintMatrix}@p{::condense()}
+ * ConstraintMatrix@p{::condense()}
* afterwards.
*
* Remember using
- * @ref{SparsityPattern}@p{::compress()}
+ * SparsityPattern@p{::compress()}
* after generating the pattern.
*
* The actual type of the
* sparsity pattern may be
- * @ref{SparsityPattern},
- * @ref{CompressedSparsityPattern},
- * @ref{BlockSparsityPattern},
- * @ref{CompressedBlockSparsityPattern},
+ * SparsityPattern,
+ * CompressedSparsityPattern,
+ * BlockSparsityPattern,
+ * CompressedBlockSparsityPattern,
* or any other class that
* satisfies similar
* requirements. It is assumed
* ector valued finite elements.
* This function does mostly the
* same as the previous
- * @p{make_sparsity_pattern}, but
+ * @p make_sparsity_pattern, but
* it is specialized for vector
* finite elements and allows to
* specify which variables couple
* in which equation. For
* example, if wanted to solve
* the Stokes equations,
- * @begin{verbatim}
+ * @verbatim
* -\Delta \vec u + \nabla p = 0,
* \div u = 0
- * @end{verbatim}
+ * @endverbatim
* in two space dimensions,
* using stable Q2/Q1 mixed
- * elements (using the @ref{FESystem}
+ * elements (using the FESystem
* class), then you don't want
* all degrees of freedom to
* couple in each equation. You
* rather may want to give the
* following pattern of
* couplings:
- * @begin{verbatim}
+ * @verbatim
* 1 0 1
* 0 1 1
* 1 1 0
- * @end{verbatim}
+ * @endverbatim
* where "1" indicates that two
* variables (i.e. components of
- * the @ref{FESystem}) couple in the
+ * the FESystem) couple in the
* respective equation, and a "0"
* means no coupling, in which
* case it is not necessary to
* allocate space in the matrix
* structure. Obviously, the mask
* refers to components of the
- * composed @ref{FESystem}, rather
+ * composed FESystem, rather
* than to the degrees of freedom
* contained in there.
*
* This function is designed to
* accept a mask, like the one
* shown above, through the
- * @p{mask} parameter, which
+ * @p mask parameter, which
* contains boolean values. It
* builds the matrix structure
* just like the previous
*
* The actual type of the
* sparsity pattern may be
- * @ref{SparsityPattern},
- * @ref{CompressedSparsityPattern},
- * @ref{BlockSparsityPattern},
- * @ref{CompressedBlockSparsityPattern},
+ * SparsityPattern,
+ * CompressedSparsityPattern,
+ * BlockSparsityPattern,
+ * CompressedBlockSparsityPattern,
* or any other class that
* satisfies similar
* requirements.
* nodes. The sparsity pattern
* is not compressed, since if
* you want to call
- * @ref{ConstraintMatrix}@p{::condense(1)}
+ * ConstraintMatrix@p{::condense(1)}
* afterwards, new entries have
* to be added. However, if you
* don't want to call
- * @ref{ConstraintMatrix}@p{::condense(1)},
+ * ConstraintMatrix@p{::condense(1)},
* you have to compress the
* matrix yourself, using
- * @ref{SparsityPattern}@p{::compress()}.
+ * SparsityPattern@p{::compress()}.
*
* The actual type of the
* sparsity pattern may be
- * @ref{SparsityPattern},
- * @ref{CompressedSparsityPattern},
- * @ref{BlockSparsityPattern},
- * @ref{CompressedBlockSparsityPattern},
+ * SparsityPattern,
+ * CompressedSparsityPattern,
+ * BlockSparsityPattern,
+ * CompressedBlockSparsityPattern,
* or any other class that
* satisfies similar
* requirements. It is assumed
* the boundary indicator is listed in the
* set of numbers passed to this function.
*
- * In fact, rather than a @p{set}
+ * In fact, rather than a @p set
* of boundary indicators, a
- * @p{map} needs to be passed,
+ * @p map needs to be passed,
* since most of the functions
* handling with boundary
* indicators take a mapping of
* couple across faces of cells.
* This is a replacement of the
* function
- * @p{make_sparsity_pattern} for
+ * @p make_sparsity_pattern for
* discontinuous methods. Since
* the fluxes include couplings
* between neighboring elements,
* immediately. The object is not cleared
* before use, so you should make sure
* it containts only constraints you still
- * want; otherwise call the @p{clear}
+ * want; otherwise call the @p clear
* function.
*
* To condense a given sparsity pattern,
- * use @ref{ConstraintMatrix}@p{::condense}.
+ * use ConstraintMatrix@p ::condense.
* Before doing so, you need to close
* the constraint object, which must be
* done after all constraints are entered.
* note that the resulting field will not
* be continuous at hanging nodes. This
* can, however, easily be arranged by
- * calling the appropraite @p{distribute}
- * function of a @ref{ConstraintMatrix}
+ * calling the appropraite @p distribute
+ * function of a ConstraintMatrix
* object created for this
- * @ref{DoFHandler} object, after the
+ * DoFHandler object, after the
* vector has been fully assembled.
*
* It is assumed that the number
- * of elements in @p{cell_data}
+ * of elements in @p cell_data
* equals the number of active
* cells. The size of
- * @p{dof_data} is adjusted to
+ * @p dof_data is adjusted to
* the right size.
*
* Note that the input vector may
* be a vector of any data type
* as long as it is convertible
- * to @p{double}. The output
+ * to @p double. The output
* vector, being a data vector on
* the grid, always consists of
- * elements of type @p{double}.
+ * elements of type @p double.
*
* In case the finite element
- * used by this @ref{DoFHandler}
+ * used by this DoFHandler
* consists of more than one
* component, you should give
* which component in the output
* contents are not changed.
*
* It is assumed that the output
- * vector @p{dof_data} already
+ * vector @p dof_data already
* has the right size,
* i.e. @p{n_dofs()} elements.
*
* to certain vector components
* of a vector-valued finite
* element. The bit vector
- * @p{select} defines, which
+ * @p select defines, which
* components of an
- * @ref{FESystem} are to be
+ * FESystem are to be
* extracted from the
- * @ref{DoFHandler} @p{dof}. The
- * entries in @p{selected_dofs}
+ * DoFHandler @p dof. The
+ * entries in @p selected_dofs
* corresponding to degrees of
* freedom belonging to these
* components are then flagged
- * @p{true}, while all others are
- * set to @p{false}.
+ * @p true, while all others are
+ * set to @p false.
*
* The size of
- * @p{component_select} shall
+ * @p component_select shall
* equal the number of components
* in the finite element used by
- * @p{dof}. The size of
- * @p{selected_dofs} shall equal
+ * @p dof. The size of
+ * @p selected_dofs shall equal
* @p{dof_handler.n_dofs()}. Previous
* contents of this array or
* overwritten.
* case, if <em>one</em> shape
* vector component of this
* element is flagged in
- * @p{component_select}, then
+ * @p component_select, then
* this is equivalent to
* selecting <em>all</em> vector
* components corresponding to
/**
* Do the same thing as
- * @p{extract_dofs} for one level
+ * @p extract_dofs for one level
* of a multi-grid DoF numbering.
*/
template <int dim>
* returns its results in the
* last non-default-valued
* parameter which contains
- * @p{true} if a degree of
+ * @p true if a degree of
* freedom is at the boundary and
* belongs to one of the selected
- * components, and @p{false}
+ * components, and @p false
* otherwise.
*
* By specifying the
- * @p{boundary_indicator}
+ * @p boundary_indicator
* variable, you can select which
* boundary indicators the faces
* have to have on which the
* boundary indicators are
* accepted.
*
- * The size of @p{component_select}
+ * The size of @p component_select
* shall equal the number of
* components in the finite
- * element used by @p{dof}. The
- * size of @p{selected_dofs} shall
+ * element used by @p dof. The
+ * size of @p selected_dofs shall
* equal
* @p{dof_handler.n_dofs()}. Previous
* contents of this array or
* constraints, i.e. all hanging
* nodes.
*
- * The size of @p{selected_dofs}
+ * The size of @p selected_dofs
* shall equal
* @p{dof_handler.n_dofs()}. Previous
* contents of this array or
* If you want to get a unique
* association of degree of freedom with
* subdomains, use the
- * @p{get_subdomain_association}
+ * @p get_subdomain_association
* function.
*/
template <int dim>
* degrees of freedom.
*
* The additional optional
- * argument @p{target_component}
+ * argument @p target_component
* allows for a re-sorting and
* grouping of components. To
* this end, it contains for each
* vectors, but want to pack
* several components into the
* same block (for example, when
- * you have @p{dim} velocities
+ * you have @p dim velocities
* and one pressure, to put all
* velocities into one block, and
* the pressure into another).
*
* The result is returned in
- * @p{dofs_per_component}.
+ * @p dofs_per_component.
*/
template <int dim>
static void
* to the variable ``q''; zero
* would be ``u'', two would be
* ``lambda''). Furthermore, an
- * object of type @ref{IntergridMap}
+ * object of type IntergridMap
* is needed; this could in
* principle be generated by the
* function itself from the two
* it. Finally, the computed
* constraints are entered into a
* variable of type
- * @ref{ConstraintMatrix}; the
+ * ConstraintMatrix; the
* constraints are added,
* i.e. previous contents which
* may have, for example, be
*
* The output of this function is
* a compressed format that can
- * be given to the @p{reinit}
+ * be given to the @p reinit
* functions of the
- * @ref{SparsityPattern} ad
- * @ref{SparseMatrix} classes.
+ * SparsityPattern ad
+ * SparseMatrix classes.
*/
template <int dim>
static void
* this operation, @p{mapping[dof]}
* gives the index of the
* degree of freedom with global
- * number @p{dof} in the list of
+ * number @p dof in the list of
* degrees of freedom on the
* boundary. If the degree of
* freedom requested is not on
* the boundary, the value of
* @p{mapping[dof]} is
- * @p{invalid_dof_index}. This
+ * @p invalid_dof_index. This
* function is mainly used when
* setting up matrices and
* vectors on the boundary from
* numbers of the trial functions
* local to the boundary.
*
- * Prior content of @p{mapping}
+ * Prior content of @p mapping
* is deleted.
*/
template <int dim>
/**
* Declare the type as discussed
* above. Since we can't name it
- * @p{FunctionMap} (as that would
+ * @p FunctionMap (as that would
* ambiguate a possible
* constructor of this class),
* name it in the fashion of the
/**
* Common interface of all finite elements. Here, the functions to
- * fill the data fields of @ref{FEValues} are declared. While
- * @ref{FiniteElementBase} provides implementation of common
+ * fill the data fields of FEValues are declared. While
+ * FiniteElementBase provides implementation of common
* functionality, this class only serves as an abstract base class.
*
* The interface of this class is very restrictive. The reason is that
* finite element values should be accessed only by use of
- * @ref{FEValues} objects. These, together with @p{FiniteElement} are
+ * FEValues objects. These, together with @p FiniteElement are
* responsible to provide an optimized implementation.
*
* This even holds for evaluating finite elements at their support
* points (provided the element is based on Lagrangian interpolation):
* first, it is necessary to construct a quadrature rule from the
* support points. This is then fed into an object of class
- * @ref{FEValues}. Even for evaluation on the unit cell, you will need
+ * FEValues. Even for evaluation on the unit cell, you will need
* a triangulation containing that single cell.
*
* Basically, this class just declares the shape function and their
* derivatives on the unit cell $[0,1]^d$, and the means to transform
* them onto a given cell in physical space if provided by the
- * @ref{FEValues} class with a @ref{Mapping} object.
+ * FEValues class with a Mapping object.
*
* @author Wolfgang Bangerth, Guido Kanschat, Ralf Hartmann, 1998, 2000, 2001
*/
* exception, since copying finite
* element objects is not really
* supported. If you want to copy such an
- * object, use the @p{clone} function.
+ * object, use the @p clone function.
*/
FiniteElement (const FiniteElement &);
* coincide with the number of
* base elements, since they may
* be reused. For example, if you
- * create a @ref{FESystem} with
+ * create a FESystem with
* three identical finite element
* classes by using the
* constructor that takes one
* objects. If the element is
* scalar, then
* @p{base_element(0)} is
- * @p{this}.
+ * @p this.
*/
virtual
const FiniteElement<dim> &
/**
* This index denotes how often
- * the base element @p{index} is
+ * the base element @p index is
* used in a composed element. If
* the element is scalar, then
* the result is always equal to
* one. See the documentation for
- * the @p{n_base_elements}
+ * the @p n_base_elements
* function for more details.
*/
virtual
* Check for non-zero values on a face.
*
* This function returns
- * @p{true}, if the shape
- * function @p{shape_index} has
+ * @p true, if the shape
+ * function @p shape_index has
* non-zero values on the face
- * @p{face_index}.
+ * @p face_index.
*/
virtual bool has_support_on_face (const unsigned int shape_index,
const unsigned int face_index) const = 0;
* Determine the values a finite
* element should compute on
* initialization of data for
- * @p{FEValues}.
+ * @p FEValues.
*
* Given a set of flags
* indicating what quantities are
- * requested from a @p{FEValues}
- * object, @p{update_once} and
- * @p{update_each} compute which
+ * requested from a @p FEValues
+ * object, @p update_once and
+ * @p update_each compute which
* values must really be
* computed. Then, the
* @p{fill_*_values} functions
* computed either on the unit
* cell or on the physical
* cell. For instance, the
- * function values of @p{FE_Q} do
+ * function values of @p FE_Q do
* only depend on the quadrature
* points on the unit
* cell. Therefore, this flags
* will be returned by
- * @p{update_once}. The gradients
+ * @p update_once. The gradients
* require computation of the
* covariant transformation
* matrix. Therefore,
- * @p{update_covariant_transformation}
- * and @p{update_gradients} will
+ * @p update_covariant_transformation
+ * and @p update_gradients will
* be returned by
- * @p{update_each}.
+ * @p update_each.
*
* For an example see the same
* function in the derived class
- * @p{FE_Q}.
+ * @p FE_Q.
*/
virtual UpdateFlags update_once (const UpdateFlags flags) const = 0;
/**
* Complementary function for
- * @p{update_once}.
+ * @p update_once.
*
- * While @p{update_once} returns
+ * While @p update_once returns
* the values to be computed on
* the unit cell for yielding the
* required data, this function
* must be recomputed on each
* cell.
*
- * Refer to @p{update_once} for
+ * Refer to @p update_once for
* more details.
*/
virtual UpdateFlags update_each (const UpdateFlags flags) const = 0;
/**
- * @p{clone} function instead of
+ * @p clone function instead of
* a copy constructor.
*
* This function is needed by the
- * constructors of @p{FESystem}.
+ * constructors of @p FESystem.
*/
virtual FiniteElement<dim> *clone() const = 0;
/**
* Fill the fields of
- * @ref{FEValues}. This function
+ * FEValues. This function
* performs all the operations
* needed to compute the data of an
- * @p{FEValues} object.
+ * @p FEValues object.
*
* The same function in
- * @p{mapping} must have been
+ * @p mapping must have been
* called for the same cell first!
*/
virtual void
/**
* Fill the fields of
- * @ref{FEFaceValues}. This function
+ * FEFaceValues. This function
* performs all the operations
* needed to compute the data of an
- * @p{FEFaceValues} object.
+ * @p FEFaceValues object.
*
* The same function in
- * @p{mapping} must have been
+ * @p mapping must have been
* called for the same cell first!
*/
virtual void
/**
* Fill the fields of
- * @ref{FESubfaceValues}. This function
+ * FESubfaceValues. This function
* performs all the operations
* needed to compute the data of an
- * @p{FESubfaceValues} object.
+ * @p FESubfaceValues object.
*
* The same function in
- * @p{mapping} must have been
+ * @p mapping must have been
* called for the same cell first!
*/
virtual void
/**
* Dimension independent data for finite elements. See the derived
- * class @ref{FiniteElementBase} class for information on its use. All
+ * class FiniteElementBase class for information on its use. All
* its data are available to the implementation in a concrete finite
* element class.
*
* components is in many cases
* equal to the number of base
* elements glued together with
- * the help of the @ref{FESystem}
+ * the help of the FESystem
* class. However, for elements
* like the Nedelec element, the
* number is greater than one
/**
* Base class for internal data.
* Adds data for second derivatives to
- * @ref{Mapping::InternalDataBase}
+ * Mapping::InternalDataBase()
*
* For information about the
* general purpose of this class,
const Quadrature<dim> &quadrature);
/**
- * Storage for @p{FEValues}
+ * Storage for @p FEValues
* objects needed to
* approximate second
* derivatives.
*
* The ordering is @p{p+hx},
* @p{p+hy}, @p{p+hz},
- * @p{p-hx}, @p{p-hy},
- * @p{p-hz}, where unused
+ * @p p-hx, @p p-hy,
+ * @p p-hz, where unused
* entries in lower dimensions
* are missing.
*/
*
* Systems of elements have their
* own naming convention, see the
- * @ref{FESystem} class.
+ * FESystem class.
*/
virtual std::string get_name () const = 0;
/**
* Return the value of the
- * @p{i}th shape function at the
- * point @p{p}. @p{p} is a point
+ * @p ith shape function at the
+ * point @p p. @p p is a point
* on the reference element. If
* the finite element is
* vector-valued, then return the
* classes implementing this
* function should throw an
* exception of type
- * @p{ExcShapeFunctionNotPrimitive}. In
+ * @p ExcShapeFunctionNotPrimitive. In
* that case, use the
- * @ref{shape_value_component}
+ * shape_value_component()
* function.
*
* An
- * @p{ExcUnitShapeValuesDoNotExist}
+ * @p ExcUnitShapeValuesDoNotExist
* is thrown if the shape values
- * of the @p{FiniteElement} under
+ * of the @p FiniteElement under
* consideration depends on the
* shape of the cell in real
* space.
const Point<dim> &p) const;
/**
- * Just like for @p{shape_value},
+ * Just like for @p shape_value,
* but this function will be
* called when the shape function
* has more than one non-zero
* vector component. In that
* case, this function should
* return the value of the
- * @p{component}-th vector
- * component of the @p{i}th shape
- * function at point @p{p}.
+ * @p component-th vector
+ * component of the @p ith shape
+ * function at point @p p.
*/
virtual double shape_value_component (const unsigned int i,
const Point<dim> &p,
/**
* Return the gradient of the
- * @p{i}th shape function at the
- * point @p{p}. @p{p} is a point
+ * @p ith shape function at the
+ * point @p p. @p p is a point
* on the reference element, and
* likewise the gradient is the
* gradient on the unit cell with
* classes implementing this
* function should throw an
* exception of type
- * @p{ExcShapeFunctionNotPrimitive}. In
+ * @p ExcShapeFunctionNotPrimitive. In
* that case, use the
- * @ref{shape_grad_component}
+ * shape_grad_component()
* function.
*
* An
- * @p{ExcUnitShapeValuesDoNotExist}
+ * @p ExcUnitShapeValuesDoNotExist
* is thrown if the shape values
- * of the @p{FiniteElement} under
+ * of the @p FiniteElement under
* consideration depends on the
* shape of the cell in real
* space.
const Point<dim> &p) const;
/**
- * Just like for @p{shape_grad},
+ * Just like for @p shape_grad,
* but this function will be
* called when the shape function
* has more than one non-zero
* vector component. In that
* case, this function should
* return the gradient of the
- * @p{component}-th vector
- * component of the @p{i}th shape
- * function at point @p{p}.
+ * @p component-th vector
+ * component of the @p ith shape
+ * function at point @p p.
*/
virtual Tensor<1,dim> shape_grad_component (const unsigned int i,
const Point<dim> &p,
/**
* Return the tensor of second
- * derivatives of the @p{i}th
- * shape function at point @p{p}
+ * derivatives of the @p ith
+ * shape function at point @p p
* on the unit cell. The
* derivatives are derivatives on
* the unit cell with respect to
* classes implementing this
* function should throw an
* exception of type
- * @p{ExcShapeFunctionNotPrimitive}. In
+ * @p ExcShapeFunctionNotPrimitive. In
* that case, use the
- * @ref{shape_grad_grad_component}
+ * shape_grad_grad_component()
* function.
*
* An
- * @p{ExcUnitShapeValuesDoNotExist}
+ * @p ExcUnitShapeValuesDoNotExist
* is thrown if the shape values
- * of the @p{FiniteElement} under
+ * of the @p FiniteElement under
* consideration depends on the
* shape of the cell in real
* space.
const Point<dim> &p) const;
/**
- * Just like for @p{shape_grad_grad},
+ * Just like for @p shape_grad_grad,
* but this function will be
* called when the shape function
* has more than one non-zero
* vector component. In that
* case, this function should
* return the gradient of the
- * @p{component}-th vector
- * component of the @p{i}th shape
- * function at point @p{p}.
+ * @p component-th vector
+ * component of the @p ith shape
+ * function at point @p p.
*/
virtual Tensor<2,dim> shape_grad_grad_component (const unsigned int i,
const Point<dim> &p,
* space onto a coarse grid
* space. If this projection
* operator is associated with a
- * matrix @p{P}, then the
+ * matrix @p P, then the
* restriction of this matrix
- * @p{P_i} to a single child cell
+ * @p P_i to a single child cell
* is returned here.
*
- * The matrix @p{P} is the
+ * The matrix @p P is the
* concatenation or the sum of
- * the cell matrices @p{P_i},
+ * the cell matrices @p P_i,
* depending on the
- * @p{restriction_is_additive_flags}
+ * @p restriction_is_additive_flags
* given to the constructor. This
* distinguishes interpolation
* (concatenation) and projection
* implemented in the derived
* finite element class, this
* function aborts with
- * @p{ExcProjectionVoid}.
+ * @p ExcProjectionVoid.
*/
const FullMatrix<double> &
get_restriction_matrix (const unsigned int child) const;
* The identity operator from a
* coarse grid space into a fine
* grid space is associated with
- * a matrix @p{P}. The
- * restriction of this matrix @p{P_i} to
+ * a matrix @p P. The
+ * restriction of this matrix @p P_i to
* a single child cell is
* returned here.
*
- * The matrix @p{P} is the
+ * The matrix @p P is the
* concatenation, not the sum of
* the cell matrices
- * @p{P_i}. That is, if the same
+ * @p P_i. That is, if the same
* non-zero entry @p{j,k} exists
* in in two different child
- * matrices @p{P_i}, the value
+ * matrices @p P_i, the value
* should be the same in both
* matrices and it is copied into
- * the matrix @p{P} only once.
+ * the matrix @p P only once.
*
* Row and column indices are
* related to fine grid and
* implemented in the derived
* finite element class, this
* function aborts with
- * @p{ExcEmbeddingVoid}. You can
+ * @p ExcEmbeddingVoid. You can
* check whether this is the case
* by calling the
* @ref{prolongation_is_implemented()}.
* Return whether this element implements
* its prolongation matrices. The return
* value also indicates whether a call to
- * the @p{get_prolongation_matrix}
+ * the @p get_prolongation_matrix
* function will generate an error or
* not.
*
* should have a way to live with
* this, then you might want to
* use the
- * @p{constraints_are_implemented}
+ * @p constraints_are_implemented
* function to check up front
* whethehr this function will
* succeed or generate the
* implements its hanging node
* constraints. The return value
* also indicates whether a call
- * to the @p{constraint} function
+ * to the @p constraint function
* will generate an error or not.
*
* This function is mostly here
* interpolating from the given
* finite element to the present
* one. The size of the matrix is
- * then @p{dofs_per_cell} times
+ * then @p dofs_per_cell times
* @p{source.dofs_per_cell}.
*
* Derived elements will have to
* implementational question
* about comparing arrays and do
* not compare the matrix arrays
- * @p{restriction} and
- * @p{prolongation}.
+ * @p restriction and
+ * @p prolongation.
*/
bool operator == (const FiniteElementBase<dim> &) const;
* cannot be associated with one
* vector component, and an
* exception of type
- * @p{ExcShapeFunctionNotPrimitive}
+ * @p ExcShapeFunctionNotPrimitive
* will be raised.
*
* Note that if the element is
* that has more than one
* vector-component). For this
* information, refer to the
- * @p{system_to_base_table} field
+ * @p system_to_base_table field
* and the
- * @p{system_to_base_index}
+ * @p system_to_base_index
* function.
*/
std::pair<unsigned int,unsigned int>
/**
* Return for shape function
- * @p{index} the base element it
+ * @p index the base element it
* belongs to, the number of the
* copy of this base element
* (which is between zero and the
* then base values and dof
* indices within this element
* are equal to the
- * @p{system_to_component_table}. It
+ * @p system_to_component_table. It
* differs only in case the
* element is composed of other
* elements and at least one of
* vector-valued
* (i.e. non-primitive) shape
* functions, in contrast to the
- * @p{system_to_component_index}
+ * @p system_to_component_index
* function.
*/
std::pair<std::pair<unsigned int, unsigned int>, unsigned int>
/**
* Same as
- * @p{system_to_base_index}, but
+ * @p system_to_base_index, but
* for degrees of freedom located
* on a face.
*/
* implementing a certain vector
* component, which can be done
* using this function and the
- * @ref{FESystem}::@p{base_element}
+ * FESystem::@p base_element
* function.
*
* If this is a scalar finite
/**
* Access the
- * @p{restriction_is_additive_flag}
+ * @p restriction_is_additive_flag
* field. See there for more
* information on its contents.
*
* element has defined support
* points. If the result is true,
* then a call to the
- * @p{get_unit_support_points}
+ * @p get_unit_support_points
* yields a non-empty array.
*
* The result may be false if an
* other shape functions.
*
* In composed elements (i.e. for
- * the @ref{FESystem} class, the
+ * the FESystem class, the
* result will be true if all all
* the base elements have defined
* support points.
/**
* Return the position of the
* support point of the
- * @p{index}th shape function. If
+ * @p indexth shape function. If
* it does not exist, raise an
* exception.
*
* simply returns the respective
* element from the array you get
* from
- * @ref{get_unit_support_points},
+ * get_unit_support_points(),
* but derived elements may
* overload this function. In
* particular, note that the
- * @ref{FESystem} class overloads
+ * FESystem class overloads
* it so that it can return the
* support points of individual
* base elements, of not all the
* points. In this way, you can
* still ask for certain support
* points, even if
- * @p{get_unit_support_points}
+ * @p get_unit_support_points
* only returns an empty array.
*/
virtual
* support points, then their
* number equals the number of
* degrees of freedom on the face
- * (@p{dofs_per_face}). The order
+ * (@p dofs_per_face). The order
* of points in the array matches
* that returned by the
* @p{cell->get_dof_indices}
* element has defined support
* points on faces. If the result
* is true, then a call to the
- * @p{get_unit_support_points}
+ * @p get_unit_support_points
* yields a non-empty array.
*
* For more information, see the
* documentation for the
- * @ref{has_support_points}
+ * has_support_points()
* function.
*/
bool has_face_support_points () const;
/**
* The function corresponding to
- * the @p{unit_support_point}
+ * the @p unit_support_point
* function, but for faces. See
* there for more information.
*/
/**
* Return in which of the vector
* components of this finite
- * element the @p{i}the shape
+ * element the @p ithe shape
* function is non-zero. The
* length of the returned array
* is equal to the number of
* spaces, the result of this
* function will be a vector with
* exactly one element being
- * @p{true}, since for most
+ * @p true, since for most
* spaces the individual vector
* components are independent. In
* that case, the component with
* components, for example to
* make a shape function
* divergence free, will there be
- * more than one @p{true} entry.
+ * more than one @p true entry.
*/
const std::vector<bool> &
get_nonzero_components (const unsigned int i) const;
/**
* Return in how many vector
- * components the @p{i}th shape
+ * components the @p ith shape
* function is non-zero. This
* value equals the number of
- * entries equal to @p{true} in
+ * entries equal to @p true in
* the result of the
- * @p{get_nonzero_components}
+ * @p get_nonzero_components
* function.
*
* For most finite element
n_nonzero_components (const unsigned int i) const;
/**
- * Return whether the @p{i}th
+ * Return whether the @p ith
* shape function is primitive in
* the sense that the shape
* function is non-zero in only
* components are coupled.
*
* The result of the function is
- * @p{true} if and only if the
+ * @p true if and only if the
* result of
* @p{n_nonzero_components(i)} is
* equal to one.
* Since this is an extremely
* common operation, the result
* is cached in the
- * @p{cached_primitivity}
+ * @p cached_primitivity
* variable which is computed in
* the constructor.
*/
*
* This function is not
* virtual. Use a
- * @ref{FiniteElement} object to
+ * FiniteElement object to
* get the actual size of a
* concrete element.
*/
protected:
/**
* Array of projection matrices. See
- * @p{get_restriction_matrix} above.
+ * @p get_restriction_matrix above.
*
* Matrices in this array are
* automatically initialized to
/**
* Store what
- * @p{system_to_component_index}
+ * @p system_to_component_index
* will return.
*/
std::vector< std::pair<unsigned int, unsigned int> > system_to_component_table;
* then base values and dof
* indices within this element
* are equal to the
- * @p{system_to_component_table}. It
+ * @p system_to_component_table. It
* differs only in case the
* element is composed of other
* elements and at least one of
* vector-valued
* (i.e. non-primitive) shape
* functions, in contrast to the
- * @p{system_to_component_table}.
+ * @p system_to_component_table.
*/
std::vector<std::pair<std::pair<unsigned int,unsigned int>,unsigned int> >
system_to_base_table;
* This table converts a
* component number to a pair
* consisting of the
- * @p{base_element} number, and
+ * @p base_element number, and
* the component within this base
* element. While component
* information contains
* functional are identified and
* enter the interpolated value
* only once. In this case, the
- * flag must be @p{false}.
+ * flag must be @p false.
*
* For projections with respect
* to scalar products, the child
* matrices must be summed up to
* build the complete matrix. The
- * flag should be @p{true}.
+ * flag should be @p true.
*
* For examples of use of these
* flags, see the places in the
* this flag in the vector-valued
* case: this used to be done
* with the
- * @p{system_to_component_index}
+ * @p system_to_component_index
* function that returns which
* vector component a shape
* function is associated
/**
* Same for the faces. See the
* description of the
- * @p{get_unit_face_support_points}
+ * @p get_unit_face_support_points
* function for a discussion of
* what contributes a face
* support point.
/**
* This array holds how many
* values in the respective entry
- * of the @p{nonzero_components}
+ * of the @p nonzero_components
* element are non-zero. The
* array is thus a short-cut to
* allow faster access to this
* possibility to see if these matrices
* are initialized without accessing
* these matrices through the
- * @p{get_restriction_matrix} and
- * @p{get_prolongation_matrix}
+ * @p get_restriction_matrix and
+ * @p get_prolongation_matrix
* functions. This is important as these
* functions include assertions that
* throw if the matrices are not already
* identifies a finite
* element. This class returns
* @p{FE_DGP<dim>(degree)}, with
- * @p{dim} and @p{degree}
+ * @p dim and @p degree
* replaced by appropriate
* values.
*/
* Check for non-zero values on a face.
*
* This function returns
- * @p{true}, if the shape
- * function @p{shape_index} has
+ * @p true, if the shape
+ * function @p shape_index has
* non-zero values on the face
- * @p{face_index}.
+ * @p face_index.
*
* Implementation of the
* interface in
- * @ref{FiniteElement}
+ * FiniteElement
*/
virtual bool has_support_on_face (const unsigned int shape_index,
const unsigned int face_index) const;
static const unsigned int n_embedding_matrices;
/**
- * As @p{embedding} but for
+ * As @p embedding but for
* projection matrices.
*/
static const double * const projection_matrices[][GeometryInfo<dim>::children_per_cell];
/**
* As
- * @p{n_embedding_matrices}
+ * @p n_embedding_matrices
* but for projection
* matrices.
*/
protected:
/**
- * @p{clone} function instead of
+ * @p clone function instead of
* a copy constructor.
*
* This function is needed by the
- * constructors of @p{FESystem}.
+ * constructors of @p FESystem.
*/
virtual FiniteElement<dim> *clone() const;
/**
* Only for internal use. Its
* full name is
- * @p{get_dofs_per_object_vector}
+ * @p get_dofs_per_object_vector
* function and it creates the
- * @p{dofs_per_object} vector that is
+ * @p dofs_per_object vector that is
* needed within the constructor to
* be passed to the constructor of
- * @p{FiniteElementData}.
+ * @p FiniteElementData.
*/
static std::vector<unsigned int> get_dpo_vector(unsigned int degree);
template <int dim1> friend class FE_DGP;
/**
- * Allows @p{MappingQ} class
+ * Allows @p MappingQ class
* access to build_renumbering
* function.
*/
* interpolating from the given
* finite element to the present
* one. The size of the matrix is
- * then @p{dofs_per_cell} times
+ * then @p dofs_per_cell times
* @p{source.dofs_per_cell}.
*
* These matrices are only
* available if the source
- * element is also a @p{FE_Q}
+ * element is also a @p FE_Q
* element. Otherwise, an
* exception of type
* @ref{FiniteElementBase<dim>::ExcInterpolationNotImplemented}
* Check for non-zero values on a face.
*
* This function returns
- * @p{true}, if the shape
- * function @p{shape_index} has
+ * @p true, if the shape
+ * function @p shape_index has
* non-zero values on the face
- * @p{face_index}.
+ * @p face_index.
*
* Implementation of the
* interface in
- * @ref{FiniteElement}
+ * FiniteElement
*/
virtual bool has_support_on_face (const unsigned int shape_index,
const unsigned int face_index) const;
protected:
/**
- * @p{clone} function instead of
+ * @p clone function instead of
* a copy constructor.
*
* This function is needed by the
- * constructors of @p{FESystem}.
+ * constructors of @p FESystem.
*/
virtual FiniteElement<dim> *clone() const;
/**
* Only for internal use. Its
* full name is
- * @p{get_dofs_per_object_vector}
+ * @p get_dofs_per_object_vector
* function and it creates the
- * @p{dofs_per_object} vector that is
+ * @p dofs_per_object vector that is
* needed within the constructor to
* be passed to the constructor of
- * @p{FiniteElementData}.
+ * @p FiniteElementData.
*/
static std::vector<unsigned int> get_dpo_vector(unsigned int degree);
void initialize_restriction ();
/**
- * Allows @p{MappingQ} class
+ * Allows @p MappingQ class
* access to build_renumbering
* function.
*/
public:
/**
* Constructor for tensor product
- * polynomials of degree @p{k}.
+ * polynomials of degree @p k.
*/
FE_DGPNonparametric (const unsigned int k);
* identifies a finite
* element. This class returns
* @p{FE_DGPNonparametric<dim>(degree)},
- * with @p{dim} and @p{degree}
+ * with @p dim and @p degree
* replaced by appropriate
* values.
*/
/**
* Return the value of the
- * @p{i}th shape function at the
- * point @p{p}. See the
- * @ref{FiniteElementBase} base
+ * @p ith shape function at the
+ * point @p p. See the
+ * FiniteElementBase base
* class for more information
* about the semantics of this
* function.
/**
* Return the value of the
- * @p{component}th vector
- * component of the @p{i}th shape
+ * @p componentth vector
+ * component of the @p ith shape
* function at the point
- * @p{p}. See the
- * @ref{FiniteElementBase} base
+ * @p p. See the
+ * FiniteElementBase base
* class for more information
* about the semantics of this
* function.
* Since this element is scalar,
* the returned value is the same
* as if the function without the
- * @p{_component} suffix were
+ * @p _component suffix were
* called, provided that the
* specified component is zero.
*/
/**
* Return the gradient of the
- * @p{i}th shape function at the
- * point @p{p}. See the
- * @ref{FiniteElementBase} base
+ * @p ith shape function at the
+ * point @p p. See the
+ * FiniteElementBase base
* class for more information
* about the semantics of this
* function.
/**
* Return the gradient of the
- * @p{component}th vector
- * component of the @p{i}th shape
+ * @p componentth vector
+ * component of the @p ith shape
* function at the point
- * @p{p}. See the
- * @ref{FiniteElementBase} base
+ * @p p. See the
+ * FiniteElementBase base
* class for more information
* about the semantics of this
* function.
* Since this element is scalar,
* the returned value is the same
* as if the function without the
- * @p{_component} suffix were
+ * @p _component suffix were
* called, provided that the
* specified component is zero.
*/
/**
* Return the tensor of second
- * derivatives of the @p{i}th
- * shape function at point @p{p}
+ * derivatives of the @p ith
+ * shape function at point @p p
* on the unit cell. See the
- * @ref{FiniteElementBase} base
+ * FiniteElementBase base
* class for more information
* about the semantics of this
* function.
/**
* Return the second derivative
- * of the @p{component}th vector
- * component of the @p{i}th shape
+ * of the @p componentth vector
+ * component of the @p ith shape
* function at the point
- * @p{p}. See the
- * @ref{FiniteElementBase} base
+ * @p p. See the
+ * FiniteElementBase base
* class for more information
* about the semantics of this
* function.
* Since this element is scalar,
* the returned value is the same
* as if the function without the
- * @p{_component} suffix were
+ * @p _component suffix were
* called, provided that the
* specified component is zero.
*/
* Access to base element
* objects. Since this element is
* scalar, @p{base_element(0)} is
- * @p{this}, and all other
+ * @p this, and all other
* indices throw an error.
*/
virtual const FiniteElement<dim> &
/**
* Multiplicity of base element
- * @p{index}. Since this is a
+ * @p index. Since this is a
* scalar element,
* @p{element_multiplicity(0)}
* returns one, and all other
* Check for non-zero values on a face.
*
* This function returns
- * @p{true}, if the shape
- * function @p{shape_index} has
+ * @p true, if the shape
+ * function @p shape_index has
* non-zero values on the face
- * @p{face_index}.
+ * @p face_index.
*
* Implementation of the
* interface in
- * @ref{FiniteElement}
+ * FiniteElement
*/
virtual bool has_support_on_face (const unsigned int shape_index,
const unsigned int face_index) const;
static const unsigned int n_embedding_matrices;
/**
- * As @p{embedding} but for
+ * As @p embedding but for
* projection matrices.
*/
static const double * const projection_matrices[][GeometryInfo<dim>::children_per_cell];
/**
* As
- * @p{n_embedding_matrices}
+ * @p n_embedding_matrices
* but for projection
* matrices.
*/
protected:
/**
- * @p{clone} function instead of
+ * @p clone function instead of
* a copy constructor.
*
* This function is needed by the
- * constructors of @p{FESystem}.
+ * constructors of @p FESystem.
*/
virtual FiniteElement<dim> *clone() const;
/**
* Implementation of the same
* function in
- * @ref{FiniteElement}.
+ * FiniteElement.
*/
virtual void
fill_fe_values (const Mapping<dim> &mapping,
/**
* Implementation of the same
* function in
- * @ref{FiniteElement}.
+ * FiniteElement.
*/
virtual void
fill_fe_face_values (const Mapping<dim> &mapping,
/**
* Implementation of the same
* function in
- * @ref{FiniteElement}.
+ * FiniteElement.
*/
virtual void
fill_fe_subface_values (const Mapping<dim> &mapping,
/**
* Only for internal use. Its
* full name is
- * @p{get_dofs_per_object_vector}
+ * @p get_dofs_per_object_vector
* function and it creates the
- * @p{dofs_per_object} vector that is
+ * @p dofs_per_object vector that is
* needed within the constructor to
* be passed to the constructor of
- * @p{FiniteElementData}.
+ * @p FiniteElementData.
*/
static std::vector<unsigned int> get_dpo_vector(unsigned int degree);
/**
* Given a set of flags indicating
* what quantities are requested
- * from a @p{FEValues} object,
+ * from a @p FEValues object,
* return which of these can be
* precomputed once and for
* all. Often, the values of
* example, in which case the
* return value of this function
* would be the logical and of
- * the input @p{flags} and
- * @p{update_values}.
+ * the input @p flags and
+ * @p update_values.
*
* For the present kind of finite
* element, this is exactly the
template <int dim1> friend class FE_DGPNonparametric;
/**
- * Allows @p{MappingQ} class to
+ * Allows @p MappingQ class to
* access to build_renumbering
* function.
*/
* interpolating from the given
* finite element to the present
* one. The size of the matrix is
- * then @p{dofs_per_cell} times
+ * then @p dofs_per_cell times
* @p{source.dofs_per_cell}.
*
* These matrices are only
* available if the source
- * element is also a @p{FE_DGQ}
+ * element is also a @p FE_DGQ
* element. Otherwise, an
* exception of type
* @ref{FiniteElementBase<dim>::ExcInterpolationNotImplemented}
* Check for non-zero values on a face.
*
* This function returns
- * @p{true}, if the shape
- * function @p{shape_index} has
+ * @p true, if the shape
+ * function @p shape_index has
* non-zero values on the face
- * @p{face_index}.
+ * @p face_index.
*
* Implementation of the
* interface in
- * @ref{FiniteElement}
+ * FiniteElement
*/
virtual bool has_support_on_face (const unsigned int shape_index,
const unsigned int face_index) const;
static const unsigned int n_embedding_matrices;
/**
- * As @p{embedding} but for
+ * As @p embedding but for
* projection matrices.
*/
static const double * const projection_matrices[];
/**
* As
- * @p{n_embedding_matrices}
+ * @p n_embedding_matrices
* but for projection
* matrices.
*/
protected:
/**
- * @p{clone} function instead of
+ * @p clone function instead of
* a copy constructor.
*
* This function is needed by the
- * constructors of @p{FESystem}.
+ * constructors of @p FESystem.
*/
virtual FiniteElement<dim> *clone() const;
/**
* Only for internal use. Its
* full name is
- * @p{get_dofs_per_object_vector}
+ * @p get_dofs_per_object_vector
* function and it creates the
- * @p{dofs_per_object} vector that is
+ * @p dofs_per_object vector that is
* needed within the constructor to
* be passed to the constructor of
- * @p{FiniteElementData}.
+ * @p FiniteElementData.
*/
static std::vector<unsigned int> get_dpo_vector(unsigned int degree);
* The direction parameter
* determines the type of
* rotation. It is one character
- * of @p{xXyYzZ}. The character
+ * of @p xXyYzZ. The character
* determines the axis of
* rotation, case determines the
* direction. Lower case is
template <int dim1> friend class FE_DGQ;
/**
- * Allows @p{MappingQ} class to
+ * Allows @p MappingQ class to
* access to build_renumbering
* function.
*/
* H_curl. Note, however, that continuity only concerns the tangential
* component of the vector field.
*
- * The constructor of this class takes the degree @p{p} of this finite
+ * The constructor of this class takes the degree @p p of this finite
* element. However, presently, only lowest order elements
* (i.e. @p{p==1}) are implemented. For a general overview of this
* element and its properties, see the report by Anna Schneebeli that
* interpolated or projected, or better: whether the matrices the
* finite element provides are to be treated with the properties of a
* projection or of an interpolation, is controlled by the
- * @p{restriction_is_additive} flag. See there for more information.)
+ * @p restriction_is_additive flag. See there for more information.)
*
* Here, things are not so simple: since the element has some
* continuity requirements across faces, we can only resort to some
* direction. We use the standard enumeration and direction of edges
* in deal.II, yielding the following shape functions in 2d:
*
- * @begin{verbatim}
+ * @verbatim
* 2
* *--->---*
* | |
* | |
* *--->---*
* 0
- * @end{verbatim}
+ * @endverbatim
*
* For the 3d case, the ordering follows the same scheme: the lines
* are numbered as described in the documentation of the
- * @ref{Triangulation} class, i.e.
- * @begin{verbatim}
+ * Triangulation class, i.e.
+ * @verbatim
* *---6---* *---6---*
* /| | / /|
* 11 | 5 11 10 5
* 3 8 9 3 | 9
* |/ / | |/
* *---0---* *---0---*
- * @end{verbatim}
+ * @endverbatim
* and their directions are as follows:
- * @begin{verbatim}
+ * @verbatim
* *--->---* *--->---*
* /| | / /|
* ^ | ^ ^ ^ ^
* ^ ^ ^ ^ | ^
* |/ / | |/
* *--->---* *--->---*
- * @end{verbatim}
+ * @endverbatim
*
* The element does not make much sense in 1d, so it is not
* implemented there.
public:
/**
* Constructor for the Nedelec
- * element of degree @p{p}.
+ * element of degree @p p.
*/
FE_Nedelec (const unsigned int p);
* identifies a finite
* element. This class returns
* @p{FE_Nedelec<dim>(degree)}, with
- * @p{dim} and @p{degree}
+ * @p dim and @p degree
* replaced by appropriate
* values.
*/
/**
* Return the value of the
- * @p{component}th vector
- * component of the @p{i}th shape
+ * @p componentth vector
+ * component of the @p ith shape
* function at the point
- * @p{p}. See the
- * @ref{FiniteElementBase} base
+ * @p p. See the
+ * FiniteElementBase base
* class for more information
* about the semantics of this
* function.
/**
* Return the gradient of the
- * @p{component}th vector
- * component of the @p{i}th shape
+ * @p componentth vector
+ * component of the @p ith shape
* function at the point
- * @p{p}. See the
- * @ref{FiniteElementBase} base
+ * @p p. See the
+ * FiniteElementBase base
* class for more information
* about the semantics of this
* function.
/**
* Return the second derivative
- * of the @p{component}th vector
- * component of the @p{i}th shape
+ * of the @p componentth vector
+ * component of the @p ith shape
* function at the point
- * @p{p}. See the
- * @ref{FiniteElementBase} base
+ * @p p. See the
+ * FiniteElementBase base
* class for more information
* about the semantics of this
* function.
* Access to base element
* objects. Since this element is
* atomic, @p{base_element(0)} is
- * @p{this}, and all other
+ * @p this, and all other
* indices throw an error.
*/
virtual const FiniteElement<dim> &
/**
* Multiplicity of base element
- * @p{index}. Since this is an
+ * @p index. Since this is an
* atomic element,
* @p{element_multiplicity(0)}
* returns one, and all other
/**
* This function returns
- * @p{true}, if the shape
- * function @p{shape_index} has
+ * @p true, if the shape
+ * function @p shape_index has
* non-zero values on the face
- * @p{face_index}. For the lowest
+ * @p face_index. For the lowest
* order Nedelec elements, this
* is actually the case for the
* one on which the shape
*
* Implementation of the
* interface in
- * @ref{FiniteElement}
+ * FiniteElement
*/
virtual bool has_support_on_face (const unsigned int shape_index,
const unsigned int face_index) const;
/**
* As the
- * @p{embedding_matrices}
+ * @p embedding_matrices
* field, but for the
* interface constraints. One
* for each element for which
/**
* Like
- * @p{n_embedding_matrices},
+ * @p n_embedding_matrices,
* but for the number of
* interface constraint
* matrices.
protected:
/**
- * @p{clone} function instead of
+ * @p clone function instead of
* a copy constructor.
*
* This function is needed by the
- * constructors of @p{FESystem}.
+ * constructors of @p FESystem.
*/
virtual FiniteElement<dim> * clone() const;
/**
* Implementation of the same
* function in
- * @ref{FiniteElement}.
+ * FiniteElement.
*/
virtual void
fill_fe_values (const Mapping<dim> &mapping,
/**
* Implementation of the same
* function in
- * @ref{FiniteElement}.
+ * FiniteElement.
*/
virtual void
fill_fe_face_values (const Mapping<dim> &mapping,
/**
* Implementation of the same
* function in
- * @ref{FiniteElement}.
+ * FiniteElement.
*/
virtual void
fill_fe_subface_values (const Mapping<dim> &mapping,
/**
* Only for internal use. Its
* full name is
- * @p{get_dofs_per_object_vector}
+ * @p get_dofs_per_object_vector
* function and it creates the
- * @p{dofs_per_object} vector that is
+ * @p dofs_per_object vector that is
* needed within the constructor to
* be passed to the constructor of
- * @p{FiniteElementData}.
+ * @p FiniteElementData.
*/
static std::vector<unsigned int> get_dpo_vector(const unsigned int degree);
/**
* Initialize the
- * @p{unit_support_points} field
- * of the @ref{FiniteElementBase}
+ * @p unit_support_points field
+ * of the FiniteElementBase
* class. Called from the
* constructor.
*/
/**
* Initialize the
- * @p{unit_face_support_points} field
- * of the @ref{FiniteElementBase}
+ * @p unit_face_support_points field
+ * of the FiniteElementBase
* class. Called from the
* constructor.
*/
/**
* Given a set of flags indicating
* what quantities are requested
- * from a @p{FEValues} object,
+ * from a @p FEValues object,
* return which of these can be
* precomputed once and for
* all. Often, the values of
* example, in which case the
* return value of this function
* would be the logical and of
- * the input @p{flags} and
- * @p{update_values}.
+ * the input @p flags and
+ * @p update_values.
*
* For the present kind of finite
* element, this is exactly the
*
* The effect in this element is
* as follows:
- * @begin{itemize}
+ * <ul>
- * @item if
+ * <li> if
* <tt>update_gradients</tt> is
* set, the result will contain
* <tt>update_gradients</tt> and
* is actually performed by the
* Mapping object used in
* conjunction with this finite
- * element. @item if
+ * element. <li> if
* <tt>update_second_derivatives</tt>
* is set, the result will
* contain
* quotients for the actual
* computation.
*
- * @end{itemize}
+ * </ul>
*/
virtual UpdateFlags update_each (const UpdateFlags flags) const;
/*@{*/
/**
- * Implementation of Lagrange finite elements @p{Qp} that yield the
+ * Implementation of Lagrange finite elements @p Qp that yield the
* finite element space of continuous, piecewise polynomials of degree
- * @p{p}. This class is realized using tensor product polynomials
+ * @p p. This class is realized using tensor product polynomials
* based on equidistant support points.
*
- * The constructor of this class takes the degree @p{p} of this finite
+ * The constructor of this class takes the degree @p p of this finite
* element.
*
* @sect3{Implementation}
*
- * The constructor creates a @ref{TensorProductPolynomials} object
- * that includes the tensor product of @p{LagrangeEquidistant}
- * polynomials of degree @p{p}. This @p{TensorProductPolynomials}
+ * The constructor creates a TensorProductPolynomials object
+ * that includes the tensor product of @p LagrangeEquidistant
+ * polynomials of degree @p p. This @p TensorProductPolynomials
* object provides all values and derivatives of the shape functions.
*
- * Furthermore the constructor filles the @p{interface_constraints},
- * the @p{prolongation} (embedding) and the @p{restriction}
+ * Furthermore the constructor filles the @p interface_constraints,
+ * the @p prolongation (embedding) and the @p restriction
* matrices. These are implemented only up to a certain degree, that
* is listed in the following:
*
- * @begin{itemize}
- * @item @p{dim==1}
- * @begin{itemize}
- * @item the @p{interface_constraints} are not needed
- * @item the @p{prolongation} matrices up to degree 4, and
- * @item the @p{restriction} matrices up to degree 4.
- * @end{itemize}
- * @item @p{dim==2}
- * @begin{itemize}
- * @item the @p{interface_constraints} up to degree 4,
- * @item the @p{prolongation} matrices up to degree 3, and
- * @item the @p{restriction} matrices up to degree 4.
- * @end{itemize}
- * @item @p{dim==3}
- * @begin{itemize}
- * @item the @p{interface_constraints} up to degree 2,
- * @item the @p{prolongation} matrices up to degree 2, and
- * @item the @p{restriction} matrices up to degree 4.
- * @end{itemize}
- * @end{itemize}
+ * <ul>
+ * <li> @p{dim==1}
+ * <ul>
+ * <li> the @p interface_constraints are not needed
+ * <li> the @p prolongation matrices up to degree 4, and
+ * <li> the @p restriction matrices up to degree 4.
+ * </ul>
+ * <li> @p{dim==2}
+ * <ul>
+ * <li> the @p interface_constraints up to degree 4,
+ * <li> the @p prolongation matrices up to degree 3, and
+ * <li> the @p restriction matrices up to degree 4.
+ * </ul>
+ * <li> @p{dim==3}
+ * <ul>
+ * <li> the @p interface_constraints up to degree 2,
+ * <li> the @p prolongation matrices up to degree 2, and
+ * <li> the @p restriction matrices up to degree 4.
+ * </ul>
+ * </ul>
*
* @sect3{Numbering of the degrees of freedom (DoFs)}
*
* The original ordering of the shape functions represented by the
- * @ref{TensorProductPolynomials} is a tensor product
+ * TensorProductPolynomials is a tensor product
* numbering. However, the shape functions on a cell are renumbered
* beginning with the shape functions whose support points are at the
* vertices, then on the line, on the quads, and finally (for 3d) on
* following:
*
* @sect4{Q1 elements}
- * @begin{itemize}
- * @item 1D case:
- * @begin{verbatim}
+ * <ul>
+ * <li> 1D case:
+ * @verbatim
* 0-------1
- * @end{verbatim}
+ * @endverbatim
*
- * @item 2D case:
- * @begin{verbatim}
+ * <li> 2D case:
+ * @verbatim
* 3-------2
* | |
* | |
* | |
* 0-------1
- * @end{verbatim}
+ * @endverbatim
*
- * @item 3D case:
- * @begin{verbatim}
+ * <li> 3D case:
+ * @verbatim
* 7-------6 7-------6
* /| | / /|
* / | | / / |
* | / / | | /
* |/ / | |/
* 0-------1 0-------1
- * @end{verbatim}
+ * @endverbatim
*
* The respective coordinate values of the support points of the degrees
* of freedom are as follows:
- * @begin{itemize}
- * @item Index 0: @p{[0, 0, 0]};
- * @item Index 1: @p{[1, 0, 0]};
- * @item Index 2: @p{[1, 0, 1]};
- * @item Index 3: @p{[0, 0, 1]};
- * @item Index 4: @p{[0, 1, 0]};
- * @item Index 5: @p{[1, 1, 0]};
- * @item Index 6: @p{[1, 1, 1]};
- * @item Index 7: @p{[0, 1, 1]};
- * @end{itemize}
- * @end{itemize}
+ * <ul>
+ * <li> Index 0: @p{[0, 0, 0]};
+ * <li> Index 1: @p{[1, 0, 0]};
+ * <li> Index 2: @p{[1, 0, 1]};
+ * <li> Index 3: @p{[0, 0, 1]};
+ * <li> Index 4: @p{[0, 1, 0]};
+ * <li> Index 5: @p{[1, 1, 0]};
+ * <li> Index 6: @p{[1, 1, 1]};
+ * <li> Index 7: @p{[0, 1, 1]};
+ * </ul>
+ * </ul>
* @sect4{Q2 elements}
- * @begin{itemize}
- * @item 1D case:
- * @begin{verbatim}
+ * <ul>
+ * <li> 1D case:
+ * @verbatim
* 0---2---1
- * @end{verbatim}
+ * @endverbatim
*
- * @item 2D case:
- * @begin{verbatim}
+ * <li> 2D case:
+ * @verbatim
* 3---6---2
* | |
* 7 8 5
* | |
* 0---4---1
- * @end{verbatim}
+ * @endverbatim
*
- * @item 3D case:
- * @begin{verbatim}
+ * <li> 3D case:
+ * @verbatim
* 7--14---6 7--14---6
* /| | / /|
* 19 | 13 19 1813
* | / 22 / | | /
* |/ / | |/
* *-------* *-------*
- * @end{verbatim}
+ * @endverbatim
* The center vertex has number 26.
*
* The respective coordinate values of the support points of the degrees
* of freedom are as follows:
- * @begin{itemize}
- * @item Index 0: @p{[0, 0, 0]};
- * @item Index 1: @p{[1, 0, 0]};
- * @item Index 2: @p{[1, 0, 1]};
- * @item Index 3: @p{[0, 0, 1]};
- * @item Index 4: @p{[0, 1, 0]};
- * @item Index 5: @p{[1, 1, 0]};
- * @item Index 6: @p{[1, 1, 1]};
- * @item Index 7: @p{[0, 1, 1]};
- * @item Index 8: @p{[1/2, 0, 0]};
- * @item Index 9: @p{[1, 0, 1/2]};
- * @item Index 10: @p{[1/2, 0, 1]};
- * @item Index 11: @p{[0, 0, 1/2]};
- * @item Index 12: @p{[1/2, 1, 0]};
- * @item Index 13: @p{[1, 1, 1/2]};
- * @item Index 14: @p{[1/2, 1, 1]};
- * @item Index 15: @p{[0, 1, 1/2]};
- * @item Index 16: @p{[0, 1/2, 0]};
- * @item Index 17: @p{[1, 1/2, 0]};
- * @item Index 18: @p{[1, 1/2, 1]};
- * @item Index 19: @p{[0, 1/2, 1]};
- * @item Index 20: @p{[1/2, 0, 1/2]};
- * @item Index 21: @p{[1/2, 1, 1/2]};
- * @item Index 22: @p{[1/2, 1/2, 0]};
- * @item Index 23: @p{[1, 1/2, 1/2]};
- * @item Index 24: @p{[1/2, 1/2, 1]};
- * @item Index 25: @p{[0, 1/2, 1/2]};
- * @item Index 26: @p{[1/2, 1/2, 1/2]};
- * @end{itemize}
- * @end{itemize}
+ * <ul>
+ * <li> Index 0: @p{[0, 0, 0]};
+ * <li> Index 1: @p{[1, 0, 0]};
+ * <li> Index 2: @p{[1, 0, 1]};
+ * <li> Index 3: @p{[0, 0, 1]};
+ * <li> Index 4: @p{[0, 1, 0]};
+ * <li> Index 5: @p{[1, 1, 0]};
+ * <li> Index 6: @p{[1, 1, 1]};
+ * <li> Index 7: @p{[0, 1, 1]};
+ * <li> Index 8: @p{[1/2, 0, 0]};
+ * <li> Index 9: @p{[1, 0, 1/2]};
+ * <li> Index 10: @p{[1/2, 0, 1]};
+ * <li> Index 11: @p{[0, 0, 1/2]};
+ * <li> Index 12: @p{[1/2, 1, 0]};
+ * <li> Index 13: @p{[1, 1, 1/2]};
+ * <li> Index 14: @p{[1/2, 1, 1]};
+ * <li> Index 15: @p{[0, 1, 1/2]};
+ * <li> Index 16: @p{[0, 1/2, 0]};
+ * <li> Index 17: @p{[1, 1/2, 0]};
+ * <li> Index 18: @p{[1, 1/2, 1]};
+ * <li> Index 19: @p{[0, 1/2, 1]};
+ * <li> Index 20: @p{[1/2, 0, 1/2]};
+ * <li> Index 21: @p{[1/2, 1, 1/2]};
+ * <li> Index 22: @p{[1/2, 1/2, 0]};
+ * <li> Index 23: @p{[1, 1/2, 1/2]};
+ * <li> Index 24: @p{[1/2, 1/2, 1]};
+ * <li> Index 25: @p{[0, 1/2, 1/2]};
+ * <li> Index 26: @p{[1/2, 1/2, 1/2]};
+ * </ul>
+ * </ul>
* @sect4{Q3 elements}
- * @begin{itemize}
- * @item 1D case:
- * @begin{verbatim}
+ * <ul>
+ * <li> 1D case:
+ * @verbatim
* 0--2--3--1
- * @end{verbatim}
+ * @endverbatim
*
- * @item 2D case:
- * @begin{verbatim}
+ * <li> 2D case:
+ * @verbatim
* 3--8--9--2
* | |
* 11 14 15 7
* 10 12 13 6
* | |
* 0--4--5--1
- * @end{verbatim}
+ * @endverbatim
* Note the reverse ordering of degrees of freedom on the left and
* upper line.
- * @end{itemize}
+ * </ul>
* @sect4{Q4 elements}
- * @begin{itemize}
- * @item 1D case:
- * @begin{verbatim}
+ * <ul>
+ * <li> 1D case:
+ * @verbatim
* 0--2--3--4--1
- * @end{verbatim}
+ * @endverbatim
*
- * @item 2D case:
- * @begin{verbatim}
+ * <li> 2D case:
+ * @verbatim
* 3--10-11-12-2
* | |
* 15 22 23 24 9
* 13 16 17 18 7
* | |
* 0--4--5--6--1
- * @end{verbatim}
- * @end{itemize}
+ * @endverbatim
+ * </ul>
* Note the reverse ordering of degrees of freedom on the left and upper
* line.
*
public:
/**
* Constructor for tensor product
- * polynomials of degree @p{p}.
+ * polynomials of degree @p p.
*/
FE_Q (const unsigned int p);
* identifies a finite
* element. This class returns
* @p{FE_Q<dim>(degree)}, with
- * @p{dim} and @p{degree}
+ * @p dim and @p degree
* replaced by appropriate
* values.
*/
* interpolating from the given
* finite element to the present
* one. The size of the matrix is
- * then @p{dofs_per_cell} times
+ * then @p dofs_per_cell times
* @p{source.dofs_per_cell}.
*
* These matrices are only
* available if the source
- * element is also a @p{FE_Q}
+ * element is also a @p FE_Q
* element. Otherwise, an
* exception of type
* @ref{FiniteElementBase<dim>::ExcInterpolationNotImplemented}
* Check for non-zero values on a face.
*
* This function returns
- * @p{true}, if the shape
- * function @p{shape_index} has
+ * @p true, if the shape
+ * function @p shape_index has
* non-zero values on the face
- * @p{face_index}.
+ * @p face_index.
*
* Implementation of the
* interface in
- * @ref{FiniteElement}
+ * FiniteElement
*/
virtual bool has_support_on_face (const unsigned int shape_index,
const unsigned int face_index) const;
{
/**
* As the
- * @p{embedding_matrices}
+ * @p embedding_matrices
* field, but for the
* interface constraints. One
* for each element for which
/**
* Like
- * @p{n_embedding_matrices},
+ * @p n_embedding_matrices,
* but for the number of
* interface constraint
* matrices.
protected:
/**
- * @p{clone} function instead of
+ * @p clone function instead of
* a copy constructor.
*
* This function is needed by the
- * constructors of @p{FESystem}.
+ * constructors of @p FESystem.
*/
virtual FiniteElement<dim> * clone() const;
/**
* Only for internal use. Its
* full name is
- * @p{get_dofs_per_object_vector}
+ * @p get_dofs_per_object_vector
* function and it creates the
- * @p{dofs_per_object} vector that is
+ * @p dofs_per_object vector that is
* needed within the constructor to
* be passed to the constructor of
- * @p{FiniteElementData}.
+ * @p FiniteElementData.
*/
static std::vector<unsigned int> get_dpo_vector(const unsigned int degree);
* shape function numbering. This
* function is actually an alike
* replica of the respective
- * function in the @ref{FETools}
+ * function in the FETools
* class, but is kept for three
* reasons:
*
* 1. It only operates on a
- * @ref{FiniteElementData}
+ * FiniteElementData
* structure. This is ok in the
* present context, since we can
* control which types of
* because this is a private
* function. However, the
* publicly visible function in
- * the @ref{FETools} class needs
+ * the FETools class needs
* to make sure that the
- * @ref{FiniteElementData} object
+ * FiniteElementData object
* it works on actually
* represents a continuous finite
* element, which we found too
* difficult if we do not pass an
- * object of type @ref{FE_Q}
+ * object of type FE_Q()
* directly.
*
* 2. If we would call the
/**
* Initialize the
- * @p{unit_support_points} field
- * of the @ref{FiniteElementBase}
+ * @p unit_support_points field
+ * of the FiniteElementBase
* class. Called from the
* constructor.
*/
/**
* Initialize the
- * @p{unit_face_support_points} field
- * of the @ref{FiniteElementBase}
+ * @p unit_face_support_points field
+ * of the FiniteElementBase
* class. Called from the
* constructor.
*/
* Allow access from other
* dimensions. We need this since
* we want to call the functions
- * @p{get_dpo_vector} and
- * @p{lexicographic_to_hierarchic_numbering}
+ * @p get_dpo_vector and
+ * @p lexicographic_to_hierarchic_numbering
* for the faces of the finite
* element of dimension dim+1.
*/
/*@{*/
/**
- * Implementation of Hierarchical finite elements @p{Qp} that yield the
+ * Implementation of Hierarchical finite elements @p Qp that yield the
* finite element space of continuous, piecewise polynomials of degree
- * @p{p}. This class is realized using tensor product polynomials
- * based on a hierarchical basis @p{Hierarchical} of the interval
- * @p{[0,1]} which is suitable for building an @p{hp} tensor product
+ * @p p. This class is realized using tensor product polynomials
+ * based on a hierarchical basis @p Hierarchical of the interval
+ * @p{[0,1]} which is suitable for building an @p hp tensor product
* finite element, if we assume that each element has a single degree.
*
- * There are not many differences between @p{FE_Q_Hierarchical} and
- * @p{FE_Q}, except that we add a function @p{embedding_dofs} that takes
- * a given integer @p{q}, between @p{1} and @p{p}, and
+ * There are not many differences between @p FE_Q_Hierarchical and
+ * @p FE_Q, except that we add a function @p embedding_dofs that takes
+ * a given integer @p q, between @p 1 and @p p, and
* returns the numbering of basis functions of the element of order
- * @p{q} in basis of order @p{p}. This function is
+ * @p q in basis of order @p p. This function is
* useful if one wants to make calculations using the hierarchical
* nature of these shape functions.
*
- * The unit support points now are reduced to @p{0}, @p{1}, and @p{0.5} in
+ * The unit support points now are reduced to @p 0, @p 1, and @p{0.5} in
* one dimension, and tensor products in higher dimensions. Thus, various
* interpolation functions will only work correctly for the linear case.
* Future work will involve writing projection--interpolation operators
* that can interpolate onto the higher order bubble functions.
*
* The various constraint, prolongation, and restriction matrices are
- * now available in all dimensions for all degrees @p{p}, currently up to
+ * now available in all dimensions for all degrees @p p, currently up to
* order 19.
*
- * The constructor of this class takes the degree @p{p} of this finite
+ * The constructor of this class takes the degree @p p of this finite
* element.
*
* @sect3{Implementation}
*
- * The constructor creates a @ref{TensorProductPolynomials} object
- * that includes the tensor product of @p{Hierarchical}
- * polynomials of degree @p{p}. This @p{TensorProductPolynomials}
+ * The constructor creates a TensorProductPolynomials object
+ * that includes the tensor product of @p Hierarchical
+ * polynomials of degree @p p. This @p TensorProductPolynomials
* object provides all values and derivatives of the shape functions.
*
* @sect3{Numbering of the degrees of freedom (DoFs)}
*
* The original ordering of the shape functions represented by the
- * @ref{TensorProductPolynomials} is a tensor product
+ * TensorProductPolynomials is a tensor product
* numbering. However, the shape functions on a cell are renumbered
* beginning with the shape functions whose support points are at the
* vertices, then on the line, on the quads, and finally (for 3d) on
* following:
*
* @sect4{Q1 elements}
- * @begin{itemize}
- * @item 1D case:
- * @begin{verbatim}
+ * <ul>
+ * <li> 1D case:
+ * @verbatim
* 0-------1
- * @end{verbatim}
+ * @endverbatim
*
- * @item 2D case:
- * @begin{verbatim}
+ * <li> 2D case:
+ * @verbatim
* 3-------2
* | |
* | |
* | |
* 0-------1
- * @end{verbatim}
+ * @endverbatim
*
- * @item 3D case:
- * @begin{verbatim}
+ * <li> 3D case:
+ * @verbatim
* 7-------6 7-------6
* /| | / /|
* / | | / / |
*
* The respective coordinate values of the support points of the degrees
* of freedom are as follows:
- * @begin{itemize}
- * @item Index 0: @p{[0, 0, 0]};
- * @item Index 1: @p{[1, 0, 0]};
- * @item Index 2: @p{[1, 0, 1]};
- * @item Index 3: @p{[0, 0, 1]};
- * @item Index 4: @p{[0, 1, 0]};
- * @item Index 5: @p{[1, 1, 0]};
- * @item Index 6: @p{[1, 1, 1]};
- * @item Index 7: @p{[0, 1, 1]};
- * @end{itemize}
- * @end{itemize}
+ * <ul>
+ * <li> Index 0: @p{[0, 0, 0]};
+ * <li> Index 1: @p{[1, 0, 0]};
+ * <li> Index 2: @p{[1, 0, 1]};
+ * <li> Index 3: @p{[0, 0, 1]};
+ * <li> Index 4: @p{[0, 1, 0]};
+ * <li> Index 5: @p{[1, 1, 0]};
+ * <li> Index 6: @p{[1, 1, 1]};
+ * <li> Index 7: @p{[0, 1, 1]};
+ * </ul>
+ * </ul>
* @sect4{Q2 elements}
- * @begin{itemize}
- * @item 1D case:
- * @begin{verbatim}
+ * <ul>
+ * <li> 1D case:
+ * @verbatim
* 0---2---1
- * @end{verbatim}
+ * @endverbatim
*
- * @item 2D case:
- * @begin{verbatim}
+ * <li> 2D case:
+ * @verbatim
* 3---6---2
* | |
* 7 8 5
* | |
* 0---4---1
- * @end{verbatim}
+ * @endverbatim
*
- * @item 3D case:
- * @begin{verbatim}
+ * <li> 3D case:
+ * @verbatim
* 7--14---6 7--14---6
* /| | / /|
* 19 | 13 19 1813
* | / 22 / | | /
* |/ / | |/
* *-------* *-------*
- * @end{verbatim}
+ * @endverbatim
* The center vertex has number 26.
*
* The respective coordinate values of the support points of the degrees
* of freedom are as follows:
- * @begin{itemize}
- * @item Index 0: @p{[0, 0, 0]};
- * @item Index 1: @p{[1, 0, 0]};
- * @item Index 2: @p{[1, 0, 1]};
- * @item Index 3: @p{[0, 0, 1]};
- * @item Index 4: @p{[0, 1, 0]};
- * @item Index 5: @p{[1, 1, 0]};
- * @item Index 6: @p{[1, 1, 1]};
- * @item Index 7: @p{[0, 1, 1]};
- * @item Index 8: @p{[1/2, 0, 0]};
- * @item Index 9: @p{[1, 0, 1/2]};
- * @item Index 10: @p{[1/2, 0, 1]};
- * @item Index 11: @p{[0, 0, 1/2]};
- * @item Index 12: @p{[1/2, 1, 0]};
- * @item Index 13: @p{[1, 1, 1/2]};
- * @item Index 14: @p{[1/2, 1, 1]};
- * @item Index 15: @p{[0, 1, 1/2]};
- * @item Index 16: @p{[0, 1/2, 0]};
- * @item Index 17: @p{[1, 1/2, 0]};
- * @item Index 18: @p{[1, 1/2, 1]};
- * @item Index 19: @p{[0, 1/2, 1]};
- * @item Index 20: @p{[1/2, 0, 1/2]};
- * @item Index 21: @p{[1/2, 1, 1/2]};
- * @item Index 22: @p{[1/2, 1/2, 0]};
- * @item Index 23: @p{[1, 1/2, 1/2]};
- * @item Index 24: @p{[1/2, 1/2, 1]};
- * @item Index 25: @p{[0, 1/2, 1/2]};
- * @item Index 26: @p{[1/2, 1/2, 1/2]};
- * @end{itemize}
- * @end{itemize}
+ * <ul>
+ * <li> Index 0: @p{[0, 0, 0]};
+ * <li> Index 1: @p{[1, 0, 0]};
+ * <li> Index 2: @p{[1, 0, 1]};
+ * <li> Index 3: @p{[0, 0, 1]};
+ * <li> Index 4: @p{[0, 1, 0]};
+ * <li> Index 5: @p{[1, 1, 0]};
+ * <li> Index 6: @p{[1, 1, 1]};
+ * <li> Index 7: @p{[0, 1, 1]};
+ * <li> Index 8: @p{[1/2, 0, 0]};
+ * <li> Index 9: @p{[1, 0, 1/2]};
+ * <li> Index 10: @p{[1/2, 0, 1]};
+ * <li> Index 11: @p{[0, 0, 1/2]};
+ * <li> Index 12: @p{[1/2, 1, 0]};
+ * <li> Index 13: @p{[1, 1, 1/2]};
+ * <li> Index 14: @p{[1/2, 1, 1]};
+ * <li> Index 15: @p{[0, 1, 1/2]};
+ * <li> Index 16: @p{[0, 1/2, 0]};
+ * <li> Index 17: @p{[1, 1/2, 0]};
+ * <li> Index 18: @p{[1, 1/2, 1]};
+ * <li> Index 19: @p{[0, 1/2, 1]};
+ * <li> Index 20: @p{[1/2, 0, 1/2]};
+ * <li> Index 21: @p{[1/2, 1, 1/2]};
+ * <li> Index 22: @p{[1/2, 1/2, 0]};
+ * <li> Index 23: @p{[1, 1/2, 1/2]};
+ * <li> Index 24: @p{[1/2, 1/2, 1]};
+ * <li> Index 25: @p{[0, 1/2, 1/2]};
+ * <li> Index 26: @p{[1/2, 1/2, 1/2]};
+ * </ul>
+ * </ul>
* @sect4{Q3 elements}
- * @begin{itemize}
- * @item 1D case:
- * @begin{verbatim}
+ * <ul>
+ * <li> 1D case:
+ * @verbatim
* 0--2--3--1
- * @end{verbatim}
+ * @endverbatim
*
- * @item 2D case:
- * @begin{verbatim}
+ * <li> 2D case:
+ * @verbatim
* 3--8--9--2
* | |
* 11 14 15 7
* 10 12 13 6
* | |
* 0--4--5--1
- * @end{verbatim}
+ * @endverbatim
* Note the reverse ordering of degrees of freedom on the left and
* upper line.
- * @end{itemize}
+ * </ul>
* @sect4{Q4 elements}
- * @begin{itemize}
- * @item 1D case:
- * @begin{verbatim}
+ * <ul>
+ * <li> 1D case:
+ * @verbatim
* 0--2--3--4--1
- * @end{verbatim}
+ * @endverbatim
*
- * @item 2D case:
- * @begin{verbatim}
+ * <li> 2D case:
+ * @verbatim
* 3--10-11-12-2
* | |
* 15 22 23 24 9
* 13 16 17 18 7
* | |
* 0--4--5--6--1
- * @end{verbatim}
- * @end{itemize}
+ * @endverbatim
+ * </ul>
* Note the reverse ordering of degrees of freedom on the left and upper
* line.
*
* identifies a finite
* element. This class returns
* @p{FE_Q_Hierarchical<dim>(degree)},
- * with @p{dim} and @p{degree}
+ * with @p dim and @p degree
* replaced by appropriate
* values.
*/
* Check for non-zero values on a face.
*
* This function returns
- * @p{true}, if the shape
- * function @p{shape_index} has
+ * @p true, if the shape
+ * function @p shape_index has
* non-zero values on the face
- * @p{face_index}.
+ * @p face_index.
*
* Implementation of the
* interface in
- * @ref{FiniteElement}
+ * FiniteElement
*/
virtual bool has_support_on_face (const unsigned int shape_index,
const unsigned int face_index) const;
/**
* For a finite element of degree
- * @p{sub_degree} < @p{degree}, we
+ * @p sub_degree < @p degree, we
* return a vector which maps the
* numbering on an FE
- * of degree @p{sub_degree} into the
+ * of degree @p sub_degree into the
* numbering on this element.
*/
std::vector<unsigned int> get_embedding_dofs (const unsigned int sub_degree) const;
protected:
/**
- * @p{clone} function instead of
+ * @p clone function instead of
* a copy constructor.
*
* This function is needed by the
- * constructors of @p{FESystem}.
+ * constructors of @p FESystem.
*/
virtual FiniteElement<dim> * clone() const;
/**
* Only for internal use. Its
* full name is
- * @p{get_dofs_per_object_vector}
+ * @p get_dofs_per_object_vector
* function and it creates the
- * @p{dofs_per_object} vector that is
+ * @p dofs_per_object vector that is
* needed within the constructor to
* be passed to the constructor of
- * @p{FiniteElementData}.
+ * @p FiniteElementData.
*/
static std::vector<unsigned int> get_dpo_vector(const unsigned int degree);
* shape function numbering. This
* function is actually an alike
* replica of the respective
- * function in the @ref{FETools}
+ * function in the FETools
* class, but is kept for three
* reasons:
*
* 1. It only operates on a
- * @ref{FiniteElementData}
+ * FiniteElementData
* structure. This is ok in the
* present context, since we can
* control which types of
* because this is a private
* function. However, the
* publicly visible function in
- * the @ref{FETools} class needs
+ * the FETools class needs
* to make sure that the
- * @ref{FiniteElementData} object
+ * FiniteElementData object
* it works on actually
* represents a continuous finite
* element, which we found too
* difficult if we do not pass an
- * object of type @ref{FE_Q}
+ * object of type FE_Q()
* directly.
*
* 2. If we would call the
/**
* Initialize the
- * @p{unit_support_points} field
- * of the @ref{FiniteElementBase}
+ * @p unit_support_points field
+ * of the FiniteElementBase
* class. Called from the
* constructor.
*/
/**
* Initialize the
- * @p{unit_face_support_points} field
- * of the @ref{FiniteElementBase}
+ * @p unit_face_support_points field
+ * of the FiniteElementBase
* class. Called from the
* constructor.
*/
* Allow access from other
* dimensions. We need this since
* we want to call the functions
- * @p{get_dpo_vector} and
- * @p{lexicographic_to_hierarchic_numbering}
+ * @p get_dpo_vector and
+ * @p lexicographic_to_hierarchic_numbering
* for the faces of the finite
* element of dimension dim+1.
*/
* H_div. Note, however, that continuity only concerns the normal
* component of the vector field.
*
- * The constructor of this class takes the degree @p{p} of this finite
+ * The constructor of this class takes the degree @p p of this finite
* element. The numbering of the degree of this element in the
* literature is somewhat funny: the degree is defined not as the
* polynomial degree of the finite element space, but as that of the
* interpolated or projected, or better: whether the matrices the
* finite element provides are to be treated with the properties of a
* projection or of an interpolation, is controlled by the
- * @p{restriction_is_additive} flag. See there for more information.)
+ * @p restriction_is_additive flag. See there for more information.)
*
* Here, things are not so simple: since the element has some
* continuity requirements across faces, we can only resort to some
* direction. We use the standard enumeration and direction of edges
* in deal.II, yielding the following shape functions in 2d:
*
- * @begin{verbatim}
+ * @verbatim
* 2
* *---^---*
* | |
* | |
* *---^---*
* 0
- * @end{verbatim}
+ * @endverbatim
*
* For the 3d case, the ordering follows the same scheme: the lines
* are numbered as described in the documentation of the
- * @ref{Triangulation} class, i.e.
- * @begin{verbatim}
+ * Triangulation class, i.e.
+ * @verbatim
* *---6---* *---6---*
* /| | / /|
* 11 | 5 11 10 5
* 3 8 9 3 | 9
* |/ / | |/
* *---0---* *---0---*
- * @end{verbatim}
+ * @endverbatim
* and their directions are as follows:
- * @begin{verbatim}
+ * @verbatim
* *--->---* *--->---*
* /| | / /|
* ^ | ^ ^ ^ ^
* ^ ^ ^ ^ | ^
* |/ / | |/
* *--->---* *--->---*
- * @end{verbatim}
+ * @endverbatim
*
* The element does not make much sense in 1d, so it is not
* implemented there.
public:
/**
* Constructor for the Nedelec
- * element of degree @p{p}.
+ * element of degree @p p.
*/
FE_RaviartThomas (const unsigned int p);
* identifies a finite
* element. This class returns
* @p{FE_RaviartThomas<dim>(degree)}, with
- * @p{dim} and @p{degree}
+ * @p dim and @p degree
* replaced by appropriate
* values.
*/
/**
* Return the value of the
- * @p{component}th vector
- * component of the @p{i}th shape
+ * @p componentth vector
+ * component of the @p ith shape
* function at the point
- * @p{p}. See the
- * @ref{FiniteElementBase} base
+ * @p p. See the
+ * FiniteElementBase base
* class for more information
* about the semantics of this
* function.
/**
* Return the gradient of the
- * @p{component}th vector
- * component of the @p{i}th shape
+ * @p componentth vector
+ * component of the @p ith shape
* function at the point
- * @p{p}. See the
- * @ref{FiniteElementBase} base
+ * @p p. See the
+ * FiniteElementBase base
* class for more information
* about the semantics of this
* function.
/**
* Return the second derivative
- * of the @p{component}th vector
- * component of the @p{i}th shape
+ * of the @p componentth vector
+ * component of the @p ith shape
* function at the point
- * @p{p}. See the
- * @ref{FiniteElementBase} base
+ * @p p. See the
+ * FiniteElementBase base
* class for more information
* about the semantics of this
* function.
* interpolating from the given
* finite element to the present
* one. The size of the matrix is
- * then @p{dofs_per_cell} times
+ * then @p dofs_per_cell times
* @p{source.dofs_per_cell}.
*
* These matrices are only
* Access to base element
* objects. Since this element is
* atomic, @p{base_element(0)} is
- * @p{this}, and all other
+ * @p this, and all other
* indices throw an error.
*/
virtual const FiniteElement<dim> &
/**
* Multiplicity of base element
- * @p{index}. Since this is an
+ * @p index. Since this is an
* atomic element,
* @p{element_multiplicity(0)}
* returns one, and all other
* Right now, this is only
* implemented for RT0 in
* 1D. Otherwise, returns always
- * @p{true}.
+ * @p true.
*
* Implementation of the
* interface in
- * @ref{FiniteElement}
+ * FiniteElement
*/
virtual bool has_support_on_face (const unsigned int shape_index,
const unsigned int face_index) const;
protected:
/**
- * @p{clone} function instead of
+ * @p clone function instead of
* a copy constructor.
*
* This function is needed by the
- * constructors of @p{FESystem}.
+ * constructors of @p FESystem.
*/
virtual FiniteElement<dim> * clone() const;
/**
* Implementation of the same
* function in
- * @ref{FiniteElement}.
+ * FiniteElement.
*/
virtual void
fill_fe_values (const Mapping<dim> &mapping,
/**
* Implementation of the same
* function in
- * @ref{FiniteElement}.
+ * FiniteElement.
*/
virtual void
fill_fe_face_values (const Mapping<dim> &mapping,
/**
* Implementation of the same
* function in
- * @ref{FiniteElement}.
+ * FiniteElement.
*/
virtual void
fill_fe_subface_values (const Mapping<dim> &mapping,
* Spaces describing the
* anisotropic polynomial spaces
* for each vector component,
- * i.e. there are @p{dim}
+ * i.e. there are @p dim
* elements of this field. The
* values for this member are
* created in
- * @ref{create_polynomials}.
+ * create_polynomials().
*/
const std::vector<AnisotropicPolynomials<dim> > polynomials;
* component.
*
* These values are computed by
- * the @ref{compute_renumber}
+ * the compute_renumber()
* function.
*/
const std::vector<std::pair<unsigned int, unsigned int> > renumber;
/**
* Generate the polynomial spaces
- * for the @ref{polynomials}
+ * for the polynomials()
* member.
*/
static std::vector<AnisotropicPolynomials<dim> >
/**
* Only for internal use. Its
* full name is
- * @p{get_dofs_per_object_vector}
+ * @p get_dofs_per_object_vector
* function and it creates the
- * @p{dofs_per_object} vector that is
+ * @p dofs_per_object vector that is
* needed within the constructor to
* be passed to the constructor of
- * @p{FiniteElementData}.
+ * @p FiniteElementData.
*/
static std::vector<unsigned int>
get_dpo_vector (const unsigned int degree);
/**
* Compute the vector used for
* the
- * @p{restriction_is_additive}
+ * @p restriction_is_additive
* field passed to the base
* class's constructor.
*/
/**
* Compute the values of the
- * @p{renumber} field.
+ * @p renumber field.
*/
static std::vector<std::pair<unsigned int, unsigned int> >
compute_renumber (const unsigned int);
/**
* Initialize the
- * @p{unit_support_points} field
- * of the @ref{FiniteElementBase}
+ * @p unit_support_points field
+ * of the FiniteElementBase
* class. Called from the
* constructor.
*/
/**
* Initialize the
- * @p{unit_face_support_points} field
- * of the @ref{FiniteElementBase}
+ * @p unit_face_support_points field
+ * of the FiniteElementBase
* class. Called from the
* constructor.
*/
/**
* Given a set of flags indicating
* what quantities are requested
- * from a @p{FEValues} object,
+ * from a @p FEValues object,
* return which of these can be
* precomputed once and for
* all. Often, the values of
* example, in which case the
* return value of this function
* would be the logical and of
- * the input @p{flags} and
- * @p{update_values}.
+ * the input @p flags and
+ * @p update_values.
*
* For the present kind of finite
* element, this is exactly the
* elements and the third being a quadratic lagrange element, the
* ordering for the system @p{s=(u,v,p)} is:
*
- * @begin{itemize}
- * @item First vertex: @p{u0, v0, p0 = s0, s1, s2}
- * @item Second vertex: @p{u1, v1, p1 = s3, s4, s5}
- * @item First component on the line:
+ * <ul>
+ * <li> First vertex: @p{u0, v0, p0 = s0, s1, s2}
+ * <li> Second vertex: @p{u1, v1, p1 = s3, s4, s5}
+ * <li> First component on the line:
* @p{u2, u3 = s4, s5}
- * @item Second component on the line:
+ * <li> Second component on the line:
* @p{v2, v3 = s6, s7}.
- * @item Third component on the line:
+ * <li> Third component on the line:
* @p{p2 = s8}.
- * @end{itemize}
+ * </ul>
* Do not rely on this numbering in your application as these
* internals might change in future. Rather use the functions
- * @p{system_to_component_index} and @p{component_to_system_index},
+ * @p system_to_component_index and @p component_to_system_index,
* instead.
*
* In the most cases, the composed element behaves as if it were a usual element
* couple the degrees of freedom of the subobject. E.g. the continuity requirement
* is imposed for the shape functions of the subobjects separately; no requirement
* exist between shape functions of different subobjects, i.e. in the above
- * example: on a hanging node, the respective value of the @p{u} velocity is only
- * coupled to @p{u} at the vertices and the line on the larger cell next to this
- * vertex, there is no interaction with @p{v} and @p{w} of this or the other cell.
+ * example: on a hanging node, the respective value of the @p u velocity is only
+ * coupled to @p u at the vertices and the line on the larger cell next to this
+ * vertex, there is no interaction with @p v and @p w of this or the other cell.
*
* @author Wolfgang Bangerth, Guido Kanschat, 1999, 2002, 2003, partial reimplementation Ralf Hartmann 2001.
*/
* and the number of elements you want to
* group together using this class.
*
- * In fact, the object @p{fe} is not used,
+ * In fact, the object @p fe is not used,
* apart from getting the number of dofs
* per vertex, line, etc for that finite
* element class. The objects creates its
* own copy of the finite element object
* at construction time (but after
* the initialization of the base class
- * @p{FiniteElement}, which is why we need
+ * @p FiniteElement, which is why we need
* a valid finite element object passed
* to the constructor).
*
* element. This element returns
* a string that is composed of
* the strings
- * @p{name1}...@p{nameN} returned
+ * @p name1...@p nameN returned
* by the basis elements. From
* these, we create a sequence
* @p{FESystem<dim>[name1^m1-name2^m2-...-nameN^mN]},
- * where @p{mi} are the
+ * where @p mi are the
* multiplicities of the basis
* elements. If a multiplicity is
* equal to one, then the
/**
* Return the value of the
- * @p{i}th shape function at the
- * point @p{p}. @p{p} is a point
+ * @p ith shape function at the
+ * point @p p. @p p is a point
* on the reference element. Since
* this finite element is always
* vector-valued, we return the
* we refer to with the term
* non-primitive), then throw an
* exception of type
- * @p{ExcShapeFunctionNotPrimitive}.
+ * @p ExcShapeFunctionNotPrimitive.
*
* An
- * @p{ExcUnitShapeValuesDoNotExist}
+ * @p ExcUnitShapeValuesDoNotExist
* is thrown if the shape values
- * of the @p{FiniteElement}
- * (corresponding to the @p{i}th
+ * of the @p FiniteElement
+ * (corresponding to the @p ith
* shape function) depend on the
* shape of the cell in real
* space.
/**
* Return the value of the
- * @p{component}th vector
- * component of the @p{i}th shape
+ * @p componentth vector
+ * component of the @p ith shape
* function at the point
- * @p{p}. See the
- * @ref{FiniteElementBase} base
+ * @p p. See the
+ * FiniteElementBase base
* class for more information
* about the semantics of this
* function.
/**
* Return the gradient of the
- * @p{i}th shape function at the
- * point @p{p}. @p{p} is a point
+ * @p ith shape function at the
+ * point @p p. @p p is a point
* on the reference element, and
* likewise the gradient is the
* gradient on the unit cell with
* we refer to with the term
* non-primitive), then throw an
* exception of type
- * @p{ExcShapeFunctionNotPrimitive}.
+ * @p ExcShapeFunctionNotPrimitive.
*
* An
- * @p{ExcUnitShapeValuesDoNotExist}
+ * @p ExcUnitShapeValuesDoNotExist
* is thrown if the shape values
- * of the @p{FiniteElement}
- * (corresponding to the @p{i}th
+ * of the @p FiniteElement
+ * (corresponding to the @p ith
* shape function) depend on the
* shape of the cell in real
* space.
/**
* Return the gradient of the
- * @p{component}th vector
- * component of the @p{i}th shape
+ * @p componentth vector
+ * component of the @p ith shape
* function at the point
- * @p{p}. See the
- * @ref{FiniteElementBase} base
+ * @p p. See the
+ * FiniteElementBase base
* class for more information
* about the semantics of this
* function.
/**
* Return the tensor of second
- * derivatives of the @p{i}th
- * shape function at point @p{p}
+ * derivatives of the @p ith
+ * shape function at point @p p
* on the unit cell. The
* derivatives are derivatives on
* the unit cell with respect to
* we refer to with the term
* non-primitive), then throw an
* exception of type
- * @p{ExcShapeFunctionNotPrimitive}.
+ * @p ExcShapeFunctionNotPrimitive.
*
* An
- * @p{ExcUnitShapeValuesDoNotExist}
+ * @p ExcUnitShapeValuesDoNotExist
* is thrown if the shape values
- * of the @p{FiniteElement}
- * (corresponding to the @p{i}th
+ * of the @p FiniteElement
+ * (corresponding to the @p ith
* shape function) depend on the
* shape of the cell in real
* space.
/**
* Return the second derivatives
- * of the @p{component}th vector
- * component of the @p{i}th shape
+ * of the @p componentth vector
+ * component of the @p ith shape
* function at the point
- * @p{p}. See the
- * @ref{FiniteElementBase} base
+ * @p p. See the
+ * FiniteElementBase base
* class for more information
* about the semantics of this
* function.
* interpolating from the given
* finite element to the present
* one. The size of the matrix is
- * then @p{dofs_per_cell} times
+ * then @p dofs_per_cell times
* @p{source.dofs_per_cell}.
*
* These matrices are available
* if source and destination
- * element are both @p{FESystem}
+ * element are both @p FESystem
* elements, have the same number
* of base elements with same
* element multiplicity, and if
* these base elements also
* implement their
- * @p{get_interpolation_matrix}
+ * @p get_interpolation_matrix
* functions. Otherwise, an
* exception of type
* @ref{FiniteElementBase<dim>::ExcInterpolationNotImplemented}
* face.
*
* This function returns
- * @p{true}, if the shape
- * function @p{shape_index} has
+ * @p true, if the shape
+ * function @p shape_index has
* non-zero values on the face
- * @p{face_index}.
+ * @p face_index.
*
* Implementation of the
* interface in
- * @ref{FiniteElement}
+ * FiniteElement
*/
virtual bool has_support_on_face (const unsigned int shape_index,
const unsigned int face_index) const;
virtual UpdateFlags update_each (const UpdateFlags flags) const;
/**
- * @p{clone} function instead of
+ * @p clone function instead of
* a copy constructor.
*
* This function is needed by the
- * constructors of @p{FESystem}.
+ * constructors of @p FESystem.
*/
virtual FiniteElement<dim> * clone() const;
/**
* Implementation of the same
* function in
- * @ref{FiniteElement}.
+ * FiniteElement.
*
* Passes on control to
- * @p{compute_fill} that does the
+ * @p compute_fill that does the
* work for all three
* @p{fill_fe*_values}
* functions.
/**
* Implementation of the same
* function in
- * @ref{FiniteElement}.
+ * FiniteElement.
*
* Passes on control to
- * @p{compute_fill} that does the
+ * @p compute_fill that does the
* work for all three
* @p{fill_fe*_values} functions.
*/
/**
* Implementation of the same
* function in
- * @ref{FiniteElement}.
+ * FiniteElement.
*
* Passes on control to
- * @p{compute_fill} that does the
+ * @p compute_fill that does the
* work for all three
* @p{fill_fe*_values} functions.
*/
* Calls (among other things)
* @p{fill_fe_([sub]face)_values}
* of the base elements. Calls
- * @p{fill_fe_values} if
+ * @p fill_fe_values if
* @p{face_no==invalid_face_no}
* and
* @p{sub_no==invalid_face_no};
- * calls @p{fill_fe_face_values}
+ * calls @p fill_fe_face_values
* if
* @p{face_no==invalid_face_no}
* and
* @p{sub_no!=invalid_face_no};
* and calls
- * @p{fill_fe_subface_values} if
+ * @p fill_fe_subface_values if
* @p{face_no!=invalid_face_no}
* and
* @p{sub_no!=invalid_face_no}.
/**
* Initialize the
- * @p{unit_support_points} field
- * of the @ref{FiniteElementBase}
+ * @p unit_support_points field
+ * of the FiniteElementBase
* class. Called from the
* constructor.
*/
/**
* Initialize the
- * @p{unit_face_support_points} field
- * of the @ref{FiniteElementBase}
+ * @p unit_face_support_points field
+ * of the FiniteElementBase
* class. Called from the
* constructor.
*/
/**
* Helper function used in the constructor:
- * take a @p{FiniteElementData} object
+ * take a @p FiniteElementData object
* and return an object of the same type
* with the number of degrees of
* freedom per vertex, line, etc.
- * multiplied by @p{n}. Don't touch the
+ * multiplied by @p n. Don't touch the
* number of functions for the
* transformation from unit to real
* cell.
/**
* Helper function used in the
* constructor: takes a
- * @p{FiniteElement} object and
+ * @p FiniteElement object and
* returns an boolean vector
* including the
- * @p{restriction_is_additive_flags}
+ * @p restriction_is_additive_flags
* of the mixed element
- * consisting of @p{N} elements
- * of the sub-element @p{fe}.
+ * consisting of @p N elements
+ * of the sub-element @p fe.
*/
static std::vector<bool>
compute_restriction_is_additive_flags (const FiniteElement<dim> &fe,
* constructors since there are
* several of them. It sets up
* the index table for the system
- * as well as @p{restriction} and
- * @p{prolongation}
+ * as well as @p restriction and
+ * @p prolongation
* matrices.
*/
void initialize();
/**
- * Used by @p{initialize}.
+ * Used by @p initialize.
*/
void build_cell_tables();
/**
- * Used by @p{initialize}.
+ * Used by @p initialize.
*/
void build_face_tables();
/**
- * Used by @p{initialize}.
+ * Used by @p initialize.
*/
void build_interface_constraints ();
* However, here, this class does
* not itself store the data but
* only pointers to
- * @p{InternalData} objects for
+ * @p InternalData objects for
* each of the base elements.
*/
class InternalData : public FiniteElementBase<dim>::InternalDataBase
public:
/**
* Constructor. Is called by
- * the @p{get_data}
+ * the @p get_data
* function. Sets the size of
- * the @p{base_fe_datas}
+ * the @p base_fe_datas
* vector to
- * @p{n_base_elements}.
+ * @p n_base_elements.
*/
InternalData (const unsigned int n_base_elements);
/**
* Destructor. Deletes all
- * @p{InternalDatas} whose
+ * @p InternalDatas whose
* pointers are stored by the
- * @p{base_fe_datas}
+ * @p base_fe_datas
* vector.
*/
~InternalData();
/**
* Gives write-access to the
* pointer to a
- * @p{InternalData} of the
- * @p{base_no}th base
+ * @p InternalData of the
+ * @p base_noth base
* element.
*/
void set_fe_data(const unsigned int base_no,
/**
* Gives read-access to the
* pointer to a
- * @p{InternalData} of the
- * @p{base_no}th base element.
+ * @p InternalData of the
+ * @p base_noth base element.
*/
typename FiniteElementBase<dim>::InternalDataBase &
get_fe_data (const unsigned int base_no) const;
/**
* Gives write-access to the
* pointer to a
- * @p{FEValuesData} for the
- * @p{base_no}th base
+ * @p FEValuesData for the
+ * @p base_noth base
* element.
*/
void set_fe_values_data (const unsigned int base_no,
/**
* Gives read-access to the
* pointer to a
- * @p{FEValuesData} for the
- * @p{base_no}th base element.
+ * @p FEValuesData for the
+ * @p base_noth base element.
*/
FEValuesData<dim> & get_fe_values_data (const unsigned int base_no) const;
/**
* Deletes the
- * @p{FEValuesData} the
+ * @p FEValuesData the
* @p{fe_datas[base_no]}
* pointer is pointing
* to. Sets
* zero.
*
* This function is used to
- * delete @p{FEValuesData}
+ * delete @p FEValuesData
* that are needed only on
* the first cell but not any
* more afterwards. This is
* the case for
* e.g. Lagrangian elements
- * (see e.g. @p{FE_Q}
+ * (see e.g. @p FE_Q
* classes).
*/
void delete_fe_values_data (const unsigned int base_no);
/**
- * Set the @p{first_cell}
- * flag to @p{false}. Used by
- * the @p{FEValues} class to
+ * Set the @p first_cell
+ * flag to @p false. Used by
+ * the @p FEValues class to
* indicate that we have
* already done the work on
* the first cell.
/**
* Pointers to
- * @p{InternalData} objects
+ * @p InternalData objects
* for each of the base
* elements. They are
* accessed to by the
- * @p{set_} and
- * @p{get_fe_data} functions.
+ * @p set_ and
+ * @p get_fe_data functions.
*
* The size of this vector is
- * set to @p{n_base_elements}
+ * set to @p n_base_elements
* by the InternalData
* constructor. It is filled
- * by the @p{get_data}
+ * by the @p get_data
* function. Note that since
* the data for each instance
* of a base class is
/**
* Pointers to the
- * @p{FEValuesData} objects
+ * @p FEValuesData objects
* that are given to the
- * @p{fill_fe_values}
+ * @p fill_fe_values
* function of the base
* elements. They are
* accessed to by the
- * @p{set_} and
- * @p{get_fe_values_data}
+ * @p set_ and
+ * @p get_fe_values_data
* functions.
*
* The size of this vector is
- * set to @p{n_base_elements}
+ * set to @p n_base_elements
* by the InternalData
* constructor.
*/
/**
* This class performs interpolations and extrapolations of discrete
- * functions of one @p{FiniteElement} @p{fe1} to another @p{FiniteElement}
- * @p{fe2}.
+ * functions of one @p FiniteElement @p fe1 to another @p FiniteElement
+ * @p fe2.
*
* It also provides the local interpolation matrices that interpolate
* on each cell. Furthermore it provides the difference matrix
public:
/**
* Gives the interpolation matrix
- * that interpolates a @p{fe1}-
- * function to a @p{fe2}-function on
+ * that interpolates a @p fe1-
+ * function to a @p fe2-function on
* each cell. The interpolation_matrix
* needs to be of size
* @p{(fe2.dofs_per_cell, fe1.dofs_per_cell)}.
*
* Note, that if the finite element
- * space @p{fe1} is a subset of
+ * space @p fe1 is a subset of
* the finite element space
- * @p{fe2} then the @p{interpolation_matrix}
+ * @p fe2 then the @p interpolation_matrix
* is an embedding matrix.
*/
template <int dim, typename number>
/**
* Gives the interpolation matrix
- * that interpolates a @p{fe1}-
- * function to a @p{fe2}-function, and
+ * that interpolates a @p fe1-
+ * function to a @p fe2-function, and
* interpolates this to a second
- * @p{fe1}-function on
+ * @p fe1-function on
* each cell. The interpolation_matrix
* needs to be of size
* @p{(fe1.dofs_per_cell, fe1.dofs_per_cell)}.
*
* Note, that this function only
* makes sense if the finite element
- * space due to @p{fe1} is not a subset of
+ * space due to @p fe1 is not a subset of
* the finite element space due to
- * @p{fe2}, as if it were a subset then
- * the @p{interpolation_matrix} would be
+ * @p fe2, as if it were a subset then
+ * the @p interpolation_matrix would be
* only the unit matrix.
*/
template <int dim, typename number>
/**
* Gives the unit matrix minus the
* back interpolation matrix.
- * The @p{difference_matrix}
+ * The @p difference_matrix
* needs to be of size
* @p{(fe1.dofs_per_cell, fe1.dofs_per_cell)}.
*
* This function gives
* the matrix that transforms a
- * @p{fe1} function $z$ to $z-I_hz$
+ * @p fe1 function $z$ to $z-I_hz$
* where $I_h$ denotes the interpolation
- * operator from the @p{fe1} space to
- * the @p{fe2} space. This matrix hence
+ * operator from the @p fe1 space to
+ * the @p fe2 space. This matrix hence
* is useful to evaluate
* error-representations where $z$
* denotes the dual solution.
/**
* Gives the interpolation of a the
- * @p{dof1}-function @p{u1} to a
- * @p{dof2}-function @p{u2}. @p{dof1} and
- * @p{dof2} need to be @ref{DoFHandler}s
+ * @p dof1-function @p u1 to a
+ * @p dof2-function @p u2. @p dof1 and
+ * @p dof2 need to be DoFHandlers
* based on the same triangulation.
*
- * If the elements @p{fe1} and @p{fe2}
+ * If the elements @p fe1 and @p fe2
* are either both continuous or
* both discontinuous then this
* interpolation is the usual point
* interpolation. The same is true
- * if @p{fe1} is a continuous and
- * @p{fe2} is a discontinuous finite
- * element. For the case that @p{fe1}
- * is a discontinuous and @p{fe2} is
+ * if @p fe1 is a continuous and
+ * @p fe2 is a discontinuous finite
+ * element. For the case that @p fe1
+ * is a discontinuous and @p fe2 is
* a continuous finite element
* there is no point interpolation
* defined at the discontinuities.
* For this case (continuous
* elements on grids with hanging
* nodes), please use the
- * @p{interpolate} function with
+ * @p interpolate function with
* an additional
- * @p{ConstraintMatrix} argument,
+ * @p ConstraintMatrix argument,
* see below, or make the field
* conforming yourself by calling
- * the @p{distribute} function of
+ * the @p distribute function of
* your hanging node constraints
* object.
*/
/**
* Gives the interpolation of a
- * the @p{dof1}-function @p{u1}
- * to a @p{dof2}-function
- * @p{u2}. @p{dof1} and @p{dof2}
- * need to be @ref{DoFHandler}s
+ * the @p dof1-function @p u1
+ * to a @p dof2-function
+ * @p u2. @p dof1 and @p dof2
+ * need to be DoFHandlers
* based on the same
* triangulation.
- * @p{constraints} is a hanging
+ * @p constraints is a hanging
* node constraints object
* corresponding to
- * @p{dof2}. This object is
+ * @p dof2. This object is
* particular important when
* interpolating onto continuous
* elements on grids with hanging
* nodes (locally refined grids).
*
- * If the elements @p{fe1} and @p{fe2}
+ * If the elements @p fe1 and @p fe2
* are either both continuous or
* both discontinuous then this
* interpolation is the usual point
* interpolation. The same is true
- * if @p{fe1} is a continuous and
- * @p{fe2} is a discontinuous finite
- * element. For the case that @p{fe1}
- * is a discontinuous and @p{fe2} is
+ * if @p fe1 is a continuous and
+ * @p fe2 is a discontinuous finite
+ * element. For the case that @p fe1
+ * is a discontinuous and @p fe2 is
* a continuous finite element
* there is no point interpolation
* defined at the discontinuities.
/**
* Gives the interpolation of the
- * @p{fe1}-function @p{u1} to a
- * @p{fe2}-function, and
+ * @p fe1-function @p u1 to a
+ * @p fe2-function, and
* interpolates this to a second
- * @p{fe1}-function named
- * @p{u1_interpolated}.
+ * @p fe1-function named
+ * @p u1_interpolated.
*
* Note, that this function does
* not work on continuous
* elements at hanging nodes. For
* that case use the
- * @p{back_interpolate} function,
+ * @p back_interpolate function,
* below, that takes an
* additional
- * @p{ConstraintMatrix} object.
+ * @p ConstraintMatrix object.
*
* Furthermore note, that for the
* specific case when the finite
* element space corresponding to
- * @p{fe1} is a subset of the
+ * @p fe1 is a subset of the
* finite element space
- * corresponding to @p{fe2}, this
+ * corresponding to @p fe2, this
* function is simply an identity
* mapping.
*/
/**
* Gives the interpolation of the
- * @p{dof1}-function @p{u1} to a
- * @p{dof2}-function, and
+ * @p dof1-function @p u1 to a
+ * @p dof2-function, and
* interpolates this to a second
- * @p{dof1}-function named
- * @p{u1_interpolated}.
- * @p{constraints1} and
- * @p{constraints2} are the
+ * @p dof1-function named
+ * @p u1_interpolated.
+ * @p constraints1 and
+ * @p constraints2 are the
* hanging node constraints
- * corresponding to @p{dof1} and
- * @p{dof2}, respectively. These
+ * corresponding to @p dof1 and
+ * @p dof2, respectively. These
* objects are particular
* important when continuous
* elements on grids with hanging
* Furthermore note, that for the
* specific case when the finite
* element space corresponding to
- * @p{dof1} is a subset of the
+ * @p dof1 is a subset of the
* finite element space
- * corresponding to @p{dof2}, this
+ * corresponding to @p dof2, this
* function is simply an identity
* mapping.
*/
/**
* Gives $(Id-I_h)z1$ for a given
- * @p{dof1}-function @p{z1}, where $I_h$
- * is the interpolation from @p{fe1}
- * to @p{fe2}. $(Id-I_h)z1$ is
- * denoted by @p{z1_difference}.
+ * @p dof1-function @p z1, where $I_h$
+ * is the interpolation from @p fe1
+ * to @p fe2. $(Id-I_h)z1$ is
+ * denoted by @p z1_difference.
*
* Note, that this function does
* not work on continuous
* elements at hanging nodes. For
* that case use the
- * @p{interpolation_difference}
+ * @p interpolation_difference
* function, below, that takes an
* additional
- * @p{ConstraintMatrix} object.
+ * @p ConstraintMatrix object.
*/
template <int dim, class InVector, class OutVector>
static void interpolation_difference(const DoFHandler<dim> &dof1,
/**
* Gives $(Id-I_h)z1$ for a given
- * @p{dof1}-function @p{z1}, where $I_h$
- * is the interpolation from @p{fe1}
- * to @p{fe2}. $(Id-I_h)z1$ is
- * denoted by @p{z1_difference}.
- * @p{constraints1} and
- * @p{constraints2} are the
+ * @p dof1-function @p z1, where $I_h$
+ * is the interpolation from @p fe1
+ * to @p fe2. $(Id-I_h)z1$ is
+ * denoted by @p z1_difference.
+ * @p constraints1 and
+ * @p constraints2 are the
* hanging node constraints
- * corresponding to @p{dof1} and
- * @p{dof2}, respectively. These
+ * corresponding to @p dof1 and
+ * @p dof2, respectively. These
* objects are particular
* important when continuous
* elements on grids with hanging
/**
* Gives the patchwise
- * extrapolation of a @p{dof1}
- * function @p{z1} to a @p{dof2}
- * function @p{z2}. @p{dof1} and
- * @p{dof2} need to be @ref{DoFHandler}
+ * extrapolation of a @p dof1
+ * function @p z1 to a @p dof2
+ * function @p z2. @p dof1 and
+ * @p dof2 need to be DoFHandler
* based on the same triangulation.
*
* This function is interesting
* When you use continuous
* elements on grids with hanging
* nodes, please use the
- * @p{extrapolate} function with
+ * @p extrapolate function with
* an additional
- * @p{ConstraintMatrix} argument,
+ * @p ConstraintMatrix argument,
* see below.
*
* Since this function operates
/**
* Gives the patchwise
- * extrapolation of a @p{dof1}
- * function @p{z1} to a @p{dof2}
- * function @p{z2}. @p{dof1} and
- * @p{dof2} need to be @ref{DoFHandler}
+ * extrapolation of a @p dof1
+ * function @p z1 to a @p dof2
+ * function @p z2. @p dof1 and
+ * @p dof2 need to be DoFHandler
* based on the same triangulation.
- * @p{constraints} is a hanging
+ * @p constraints is a hanging
* node constraints object
* corresponding to
- * @p{dof2}. This object is
+ * @p dof2. This object is
* particular important when
* interpolating onto continuous
* elements on grids with hanging
* nodes (locally refined grids).
*
* Otherwise, the same holds as
- * for the other @p{extrapolate}
+ * for the other @p extrapolate
* function.
*/
template <int dim, class InVector, class OutVector>
* running in x-direction, then
* in y-direction and finally in
* z-direction. Discontinuous
- * elements of class @ref{FE_DGQ}
+ * elements of class FE_DGQ()
* are numbered in this way, for
* example.
*
* uses specifics of the
* continuous finite elements, it
* can only operate on objects of
- * type @ref{FE_Q}.
+ * type FE_Q().
*
* It is assumed that the size of
* the output argument already
/**
* Given a name in the form which
* is returned by the
- * @p{FiniteElement::get_name}
+ * @p FiniteElement::get_name
* function, regenerate such a
* finite element.
*
* finite element can be
* reconstructed from this
* string, an exception of type
- * @p{FETools::ExcInvalidFEName}
+ * @p FETools::ExcInvalidFEName
* is thrown.
*
* There is one exception,
* calling site can continue
* parsing finite element lists
* (for example for
- * @ref{FESystem} objects) at the
+ * FESystem objects) at the
* position after which the
* present element's name ends.
*
* beginning of the given string,
* then an exception is thrown,
* just as for the
- * @ref{get_fe_from_name}
+ * get_fe_from_name()
* function.
*/
template <int dim>
* @sect2{Description of Flags}
*
* The following flags are declared:
- * @begin{itemize}
- * @item <tt>update_default</tt>: Default: update nothing.
- * @item <tt>update_values</tt>: Compute the values of the shape
+ * <ul>
+ * <li> <tt>update_default</tt>: Default: update nothing.
+ * <li> <tt>update_values</tt>: Compute the values of the shape
* functions at the quadrature points on the real space cell. For
* the usual Lagrange elements, these values are equal to the
* values of the shape functions at the quadrature points on the
* unit cell, but they are different for more complicated
* elements, such as BDM or Raviart-Thomas elements.
- * @item <tt>update_gradients</tt>: Transform gradients on unit cell
+ * <li> <tt>update_gradients</tt>: Transform gradients on unit cell
* to gradients on real cell.
- * @item <tt>update_second_derivatives</tt>: Update the second
+ * <li> <tt>update_second_derivatives</tt>: Update the second
* derivatives of the shape functions on the real cell.
- * @item <tt>update_boundary_forms</tt>: Update boundary forms on the
+ * <li> <tt>update_boundary_forms</tt>: Update boundary forms on the
* face. This flag is only evaluated by the FEFaceValues class.
* Giving this flag to the FEValues class will result in an error,
* since boundary forms only exist on the boundary.
- * @item <tt>update_q_points</tt>: Compute quadrature points in real
+ * <li> <tt>update_q_points</tt>: Compute quadrature points in real
* space (not on unit cell).
- * @item <tt>update_JxW_values</tt>: Compute the JxW values (Jacobian
+ * <li> <tt>update_JxW_values</tt>: Compute the JxW values (Jacobian
* determinant at the quadrature point times the weight of this
* point).
- * @item <tt>update_normal_vectors</tt>: Update the outward normal
+ * <li> <tt>update_normal_vectors</tt>: Update the outward normal
* vectors to the face relative to this cell. This flag is only
* evaluated by the FEFaceValues class. Giving this flag to the
* FEValues class will result in an error, since normal vectors
* are not useful in that case.
- * @item <tt>update_jacobians</tt>: Compute jacobian matrices of the
+ * <li> <tt>update_jacobians</tt>: Compute jacobian matrices of the
* transform between unit and real cell in the evaluation points.
- * @item <tt>update_jacobian_grads</tt>: Update gradients of the
+ * <li> <tt>update_jacobian_grads</tt>: Update gradients of the
* jacobian. These are used to compute second derivatives.
- * @item <tt>update_covariant_transformation</tt>: Update co-variant
+ * <li> <tt>update_covariant_transformation</tt>: Update co-variant
* transformation. This flag is used internally to tell Mapping
* objects to compute the transformation matrices for co-variant
* vectors.
- * @item <tt>update_contravariant_transformation</tt>: Update
+ * <li> <tt>update_contravariant_transformation</tt>: Update
* contra-variant transformation. This flag is used internally to
* tell Mapping objects to compute the transformation matrices for
* contra-variant vectors.
- * @item <tt>update_transformation_values</tt>: Update the shape
+ * <li> <tt>update_transformation_values</tt>: Update the shape
* function values of the transformation.
- * @item <tt>update_transformation_gradients</tt>: Update the
+ * <li> <tt>update_transformation_gradients</tt>: Update the
* gradients of the shape functions of the transformation.
- * @end{itemize}
+ * </ul>
*
* @author Wolfgang Bangerth, Guido Kanschat, 1998, 1999, 2000, 2001, Ralf Hartmann 2004
*/
/*@{*/
/**
- * Contains all data vectors for @p{FEValues}.
- * This class has been extracted from @p{FEValuesBase} to be handed
- * over to the fill functions of @p{Mapping} and
- * @p{FiniteElement}.
+ * Contains all data vectors for @p FEValues.
+ * This class has been extracted from @p FEValuesBase to be handed
+ * over to the fill functions of @p Mapping and
+ * @p FiniteElement.
*
* @note All data fields are public, but this is not
- * critical, because access to this object is private in @p{FEValues}.
+ * critical, because access to this object is private in @p FEValues.
*
* @author Guido Kanschat, 2000
*/
* shape function number equals
* the row number. Otherwise, use
* the
- * @p{shape_function_to_row_table}
+ * @p shape_function_to_row_table
* array to get at the first row
* that belongs to this
* particular shape function, and
* navigate among all the rows
* for this shape function using
* the
- * @p{FiniteElement::get_nonzero_components}
+ * @p FiniteElement::get_nonzero_components
* function which tells us which
* components are non-zero and
* thus have a row in the array
* Storage type for
* gradients. The layout of data
* is the same as for the
- * @ref{ShapeVector} data type.
+ * ShapeVector data type.
*/
typedef Table<2,Tensor<1,dim> > GradientVector;
* times the Jacobi determinant
* at the quadrature points. This
* function is reset each time
- * @p{reinit} is called. The
+ * @p reinit is called. The
* Jacobi determinant is actually
* the reciprocal value of the
* Jacobi matrices stored in this
/**
* Array of quadrature points. This array
- * is set up upon calling @p{reinit} and
+ * is set up upon calling @p reinit and
* contains the quadrature points on the
* real element, rather than on the
* reference element.
/**
* Indicate the first row which a
* given shape function occupies
- * in the @p{ShapeVector},
- * @p{ShapeGradient}, etc
+ * in the @p ShapeVector,
+ * @p ShapeGradient, etc
* arrays. If all shape functions
* are primitive, then this is
* the identity mapping. If, on
/**
* Original update flags handed
* to the constructor of
- * @p{FEValues}.
+ * @p FEValues.
*/
UpdateFlags update_flags;
};
* @sect3{Member functions}
*
* The functions of this class fall into different cathegories:
- * @begin{itemize}
- * @item @p{shape_value}, @p{shape_grad}, etc: return one of the values
+ * <ul>
+ * <li> @p shape_value, @p shape_grad, etc: return one of the values
* of this object at a time. These functions are inlined, so this
* is the suggested access to all finite element values. There
* should be no loss in performance with an optimizing compiler. If
* throw an exception since they cannot generate a useful
* result. Rather, use the next set of functions.
*
- * @item @p{shape_value_component}, @p{shape_grad_component}, etc:
+ * <li> @p shape_value_component, @p shape_grad_component, etc:
* This is the same set of functions as above, except that for vector
* valued finite elements they return only one vector component. This
* is useful for elements of which shape functions have more than one
* and you have to walk over all (or only the non-zero) components of
* the shape function using this set of functions.
*
- * @item @p{get_function_values}, @p{get_function_grads}, @p{...}:
+ * <li> @p get_function_values, @p get_function_grads, @p{...}:
* Compute a finite element function or its derivative
* in quadrature points.
*
- * @item @p{reinit}: initialize the @p{FEValues} object for a certain cell.
+ * <li> @p reinit: initialize the @p FEValues object for a certain cell.
* This function is not in the present class but only in the derived
* classes and has a variable call syntax.
* See the docs for the derived classes for more information.
- * @end{itemize}
+ * </ul>
*
*
* @sect3{UpdateFlags}
*
- * The @ref{UpdateFlags} object handed to the constructor is used to
+ * The UpdateFlags object handed to the constructor is used to
* determine, which of the data fields to compute. This way, it is
* possible to avoid expensive computations of useless derivatives.
* In the beginning, these flags are processed through the functions
- * @p{update_once} and @p{update_each} of @ref{Mapping} and
- * @p{FiniteElement}. All the results are bit-wise or'd and determine
- * the fields actually computed. This enables @ref{Mapping} and
- * @p{FiniteElement} to schedule auxiliary data fields for
+ * @p update_once and @p update_each of Mapping and
+ * @p FiniteElement. All the results are bit-wise or'd and determine
+ * the fields actually computed. This enables Mapping and
+ * @p FiniteElement to schedule auxiliary data fields for
* updating. Still, it is recommended to give ALL needed update flags
- * to @p{FEValues}.
+ * to @p FEValues.
*
* @author Wolfgang Bangerth, 1998, Guido Kanschat, 2001
*/
* finite element is scalar, then
* only component zero is allowed
* and the return value equals
- * that of the @p{shape_value}
+ * that of the @p shape_value
* function. If the finite
* element is vector valued but
* all shape functions are
* primitive (i.e. they are
* non-zero in only one
* component), then the value
- * returned by @p{shape_value}
+ * returned by @p shape_value
* equals that of this function
* for exactly one
* component. This function is
* finite element in use is a scalar one,
* i.e. has only one vector component. If
* it is a vector-valued one, then use
- * the other @p{get_function_values}
+ * the other @p get_function_values
* function.
*
* The function assumes that the
*
* This function does the same as
* the other
- * @p{get_function_values}, but
+ * @p get_function_values, but
* applied to multi-component
* elements.
*
/**
* Compute the gradient of the
- * @p{i}th shape function at the
- * @p{j} quadrature point with
+ * @p ith shape function at the
+ * @p j quadrature point with
* respect to real cell
* coordinates. If you want to
* get the derivative in one of
/**
* Compute the gradients of the finite
* element function characterized
- * by @p{fe_function} restricted to
- * @p{cell} at the quadrature points.
+ * by @p fe_function restricted to
+ * @p cell at the quadrature points.
*
* If the present cell is not an active
* one the interpolated function values
* finite element in use is a scalar one,
* i.e. has only one vector component. If
* it is a vector-valued one, then use
- * the other @p{get_function_grads}
+ * the other @p get_function_grads
* function.
*
* The function assumes that the
- * @p{gradients} object already has the
+ * @p gradients object already has the
* right size.
*
* The actual data type of the input
/**
* Compute the gradients of the finite
* element function characterized
- * by @p{fe_function} restricted to
- * @p{cell} at the quadrature points.
+ * by @p fe_function restricted to
+ * @p cell at the quadrature points.
*
* If the present cell is not an active
* one the interpolated function values
* are returned.
*
* The function assumes that the
- * @p{gradients} object already has the
+ * @p gradients object already has the
* right size.
*
* This function does the same as
- * the other @p{get_function_values},
+ * the other @p get_function_values,
* but applied to multi-component
* elements.
*
* PETSc vector wrapper classes. It
* represents a global vector of
* DoF values associated with the
- * @ref{DofHandler} object with
- * which this @ref{FEValues}
+ * DofHandler object with
+ * which this FEValues
* object was last initialized.
*
* The output are the gradients
/**
* Second derivatives of
- * the @p{function_no}th shape function at
- * the @p{point_no}th quadrature point
+ * the @p function_noth shape function at
+ * the @p point_noth quadrature point
* with respect to real cell
* coordinates. If you want to
* get the derivatives in one of
* the coordinate directions, use
* the appropriate function of
- * the @p{Tensor} class to
+ * the @p Tensor class to
* extract one component. Since
* only a reference to the
* derivative values is returned,
* non-zero component (i.e. it is
* not primitive), then throw an
* exception of type
- * @p{ExcShapeFunctionNotPrimitive}. In
+ * @p ExcShapeFunctionNotPrimitive. In
* that case, use the
- * @ref{shape_grad_grad_component}
+ * shape_grad_grad_component()
* function.
*/
const Tensor<2,dim> &
* is scalar, then only component
* zero is allowed and the return
* value equals that of the
- * @p{shape_2nd_derivative}
+ * @p shape_2nd_derivative
* function. If the finite
* element is vector valued but
* all shape functions are
* non-zero in only one
* component), then the value
* returned by
- * @p{shape_2nd_derivative}
+ * @p shape_2nd_derivative
* equals that of this function
* for exactly one
* component. This function is
* Compute the tensor of second
* derivatives of the finite
* element function characterized
- * by @p{fe_function} restricted
- * to @p{cell} at the quadrature
+ * by @p fe_function restricted
+ * to @p cell at the quadrature
* points.
*
* The function assumes that the
- * @p{second_derivatives} object
+ * @p second_derivatives object
* already has the correct size.
*
* This function may only be used if the
* i.e. has only one vector component. If
* it is a vector-valued one, then use
* the other
- * @p{get_function_2nd_derivatives}
+ * @p get_function_2nd_derivatives
* function.
*
* The actual data type of the input
* PETSc vector wrapper classes..It
* represents a global vector of
* DoF values associated with the
- * @ref{DofHandler} object with
- * which this @ref{FEValues}
+ * DofHandler object with
+ * which this FEValues
* object was last initialized.
*
* The output are the second derivatives
* Compute the tensor of second
* derivatives of the finite
* element function characterized
- * by @p{fe_function} restricted to
- * @p{cell} at the quadrature points.
+ * by @p fe_function restricted to
+ * @p cell at the quadrature points.
*
* The function assumes that the
- * @p{second_derivatives} object already has
+ * @p second_derivatives object already has
* the right size.
*
* This function does the same as
* PETSc vector wrapper classes. It
* represents a global vector of
* DoF values associated with the
- * @ref{DofHandler} object with
- * which this @ref{FEValues}
+ * DofHandler object with
+ * which this FEValues
* object was last initialized.
*
* The output are the second derivatives
std::vector<std::vector<Tensor<2,dim> > > &second_derivatives) const;
/**
- * Position of the @p{i}th
+ * Position of the @p ith
* quadrature point in real space.
*/
const Point<dim> & quadrature_point (const unsigned int i) const;
* Mapped quadrature weight. This
* is the Jacobi determinant
* times the weight of the
- * @p{i}th unit quadrature point.
+ * @p ith unit quadrature point.
*
* On faces, this is the mapped
* surface element.
protected:
/**
* Store the cell selected last time
- * the @p{reinit} function was called
+ * the @p reinit function was called
* to make access
* to the @p{get_function_*} functions
* safer.
/**
* Initialize some update
* flags. Called from the
- * @p{initialize} functions of
+ * @p initialize functions of
* derived classes, which are in
* turn called from their
* constructors.
/**
* Returns reference to default
- * @p{MappingQ1} object. Needed
+ * @p MappingQ1 object. Needed
* by constructors of derived
* classes that uses
- * @p{MappingQ1} implicitly.
+ * @p MappingQ1 implicitly.
*/
static const Mapping<dim> &get_default_mapping();
};
* Finite element evaluated in quadrature points of a cell.
*
* This function implements the initialization routines for
- * @ref{FEValuesBase}, if values in quadrature points of a cell are
+ * FEValuesBase, if values in quadrature points of a cell are
* needed. For further documentation see this class.
*
* @author Wolfgang Bangerth, 1998, Guido Kanschat, 2001
/**
- * Extend the interface of @ref{FEValuesBase} by surface values.
+ * Extend the interface of FEValuesBase by surface values.
*
* On surfaces of mesh cells, normal vectors and boundary forms are
* additional values that can be computed. This class provides the
* interface to access those. Implementations are in derived classes
- * @p{FEFaceValues} and @p{FESubfaceValues}.
+ * @p FEFaceValues and @p FESubfaceValues.
*
- * @ref{FEValuesBase}
+ * FEValuesBase
*
* @author Wolfgang Bangerth, 1998, Guido Kanschat, 2000, 2001
*/
* duty of the derived class's
* constructors.
*
- * @p{n_faces_or_subfaces} is the number
+ * @p n_faces_or_subfaces is the number
* of faces or subfaces that this object
* is to store. The actual number depends
* on the derived class, for
- * @p{FEFaceValues} it is @p{2*dim}, while for
- * the @p{FESubfaceValues} class it is
+ * @p FEFaceValues it is @p{2*dim}, while for
+ * the @p FESubfaceValues class it is
* @p{2*dim*(1<<(dim-1))}, i.e. the number
* of faces times the number of subfaces
* per face.
/**
* Return the outward normal vector to
- * the cell at the @p{i}th quadrature
+ * the cell at the @p ith quadrature
* point. The length of the vector
* is normalized to one.
*/
/**
* Boundary form of the
* transformation of the cell at
- * the @p{i}th quadrature point.
+ * the @p ith quadrature point.
*
* The boundary form is the cross
* product of the images of the
/**
* Finite element evaluated in quadrature points on a face.
*
- * This class adds the functionality of @ref{FEFaceValuesBase} to
- * @ref{FEValues}; see there for more documentation.
+ * This class adds the functionality of FEFaceValuesBase to
+ * FEValues; see there for more documentation.
*
* Since finite element functions and their derivatives may be
* discontinuous at cell boundaries, there is no restriction of this
/**
* Reinitialize the gradients, Jacobi
* determinants, etc for the face with
- * number @p{face_no} of @p{cell}
+ * number @p face_no of @p cell
* and the given finite element.
*/
void reinit (const typename DoFHandler<dim>::cell_iterator& cell,
/**
* Finite element evaluated in quadrature points on a face.
*
- * This class adds the functionality of @ref{FEFaceValuesBase} to
- * @ref{FEValues}; see there for more documentation.
+ * This class adds the functionality of FEFaceValuesBase to
+ * FEValues; see there for more documentation.
*
* This class is used for faces lying on a refinement edge. In this
* case, the neighboring cell is refined. To be able to compute
/**
* Reinitialize the gradients, Jacobi
* determinants, etc for the face with
- * number @p{face_no} of @p{cell}
+ * number @p face_no of @p cell
* and the given finite element.
*/
void reinit (const typename DoFHandler<dim>::cell_iterator& cell,
/**
* Abstract base class for mapping classes.
*
- * The interface for filling the tables of @ref{FEValues} is provided.
+ * The interface for filling the tables of FEValues is provided.
* Everything else has to happen in derived classes.
*
* The following paragraph applies to the implementation of
- * @ref{FEValues}. Usage of the class is as follows: first, call the
- * functions @p{update_once} and @p{update_each} with the update
+ * FEValues. Usage of the class is as follows: first, call the
+ * functions @p update_once and @p update_each with the update
* flags you need. This includes the flags needed by the
- * @ref{FiniteElement}. Then call @p{get_*_data} and with the or'd
+ * FiniteElement. Then call @p{get_*_data} and with the or'd
* results. This will initialize and return some internal data
* structures. On the first cell, call @p{fill_fe_*_values} with the
- * result of @p{update_once}. Finally, on each cell, use
- * @p{fill_fe_*_values} with the result of @p{update_each} to compute
+ * result of @p update_once. Finally, on each cell, use
+ * @p{fill_fe_*_values} with the result of @p update_each to compute
* values for a special cell.
*
* A hint to implementators: no function except the two functions
- * @p{update_once} and @p{update_each} may add any flags.
+ * @p update_once and @p update_each may add any flags.
*
* @author Guido Kanschat, Ralf Hartmann 2000, 2001
*/
virtual ~Mapping ();
/**
- * Transforms the point @p{p} on
+ * Transforms the point @p p on
* the unit cell to the point
- * @p{p_real} on the real cell
- * @p{cell} and returns @p{p_real}.
+ * @p p_real on the real cell
+ * @p cell and returns @p p_real.
*/
virtual Point<dim>
transform_unit_to_real_cell (
const Point<dim> &p) const = 0;
/**
- * Transforms the point @p{p} on
+ * Transforms the point @p p on
* the real cell to the point
- * @p{p_unit} on the unit cell
- * @p{cell} and returns @p{p_unit}.
+ * @p p_unit on the unit cell
+ * @p cell and returns @p p_unit.
*/
virtual Point<dim>
transform_real_to_unit_cell (
* of finite element and mapping
* objects. The internal
* mechanism is that upon
- * construction of a @p{FEValues}
+ * construction of a @p FEValues
* objects, it asks the mapping
* and finite element classes
* that are to be used to
* they do not change from cell
* to cell and only need to be
* computed once. Since different
- * @p{FEValues} objects using
+ * @p FEValues objects using
* different quadrature rules
* might access the same finite
* element object at the same
* time, it is necessary to
* create one such object per
- * @p{FEValues} object. Ownership
+ * @p FEValues object. Ownership
* of this object is then
* transferred to the
- * @p{FEValues} object, but a
+ * @p FEValues object, but a
* pointer to this object is
* passed to the finite element
* object every time it shall
public:
/**
* Constructor. Sets
- * @p{UpdateFlags} to
- * @p{update_default} and
- * @p{first_cell} to @p{true}.
+ * @p UpdateFlags to
+ * @p update_default and
+ * @p first_cell to @p true.
*/
InternalDataBase ();
/**
* If @p{first_cell==true}
* this function returns
- * @p{update_flags},
+ * @p update_flags,
* i.e. @p{update_once|update_each}.
* If @p{first_cell==false}
* it returns
- * @p{update_each}.
+ * @p update_each.
*/
UpdateFlags current_update_flags() const;
* cell. The value of the
* field this function is
* returning is set to
- * @p{true} in the
+ * @p true in the
* constructor, and cleared
- * by the @p{FEValues} class
+ * by the @p FEValues class
* after the first cell has
* been initialized.
*
* This function is used to
* determine whether we need
- * to use the @p{update_once}
+ * to use the @p update_once
* flags for computing data,
* or whether we can use the
- * @p{update_each} flags.
+ * @p update_each flags.
*/
bool is_first_cell () const;
/**
- * Set the @p{first_cell}
- * flag to @p{false}. Used by
- * the @p{FEValues} class to
+ * Set the @p first_cell
+ * flag to @p false. Used by
+ * the @p FEValues class to
* indicate that we have
* already done the work on
* the first cell.
private:
/**
* The value returned by
- * @p{is_first_cell}.
+ * @p is_first_cell.
*/
bool first_cell;
};
* matrix.
*
* The range of vectors spanned
- * by @p{begin} and @p{end} must
+ * by @p begin and @p end must
* have as many elements as there
* are quadrature points (not
* tested inside the function).
* Also note the different
* convention for parameters
* compared to the standard C++
- * @p{transform} function: here,
+ * @p transform function: here,
* first destination, then source
* are specified, and the number
* of elements is determined by a
* due to the way the function is
* usually called.
*
- * The vector @p{src} must
+ * The vector @p src must
* contain at least as many
* elements as there are
* quadrature points.
* unit to real space cell.
*
* The range of vectors spanned
- * by @p{begin} and @p{end} must
+ * by @p begin and @p end must
* have as many elements as there
* are quadrature points (not
* tested inside the function).
* Also note the different
* convention for parameters
* compared to the standard C++
- * @p{transform} function: here,
+ * @p transform function: here,
* first destination, then source
* are specified, and the number
* of elements is determined by a
* due to the way the function is
* usually called.
*
- * The vector @p{src} must
+ * The vector @p src must
* contain at least as many
* elements as there are
* quadrature points.
/**
* Indicate fields to be updated
* in the constructor of
- * @ref{FEValues}. Especially,
+ * FEValues. Especially,
* fields not asked for by
- * @ref{FEValues}, but computed
+ * FEValues, but computed
* for efficiency reasons will be
* notified here.
*
* Refer to the same function in
- * @ref{FiniteElement} for
+ * FiniteElement for
* further information.
*
* Example: refer to the same
virtual UpdateFlags update_once (const UpdateFlags) const = 0;
/**
- * The same as @p{update_once},
+ * The same as @p update_once,
* but for the flags to be updated for
* each grid cell.
*/
/**
* Fill the transformation fields
- * of @p{FEValues}. Given a grid
+ * of @p FEValues. Given a grid
* cell and the quadrature points
* on the unit cell, it computes
* all values specified by
- * @p{flags}. The arrays to be
+ * @p flags. The arrays to be
* filled have to have the
* correct size.
*
* Values are split into three
* groups: first,
- * @p{quadrature_points} and
- * @p{JxW_values} are
+ * @p quadrature_points and
+ * @p JxW_values are
* filled with the quadrature
* rule transformed to the
* cell in physical space.
* matrices needed to transform
* vector-valued functions,
* namely
- * @p{covariant_transformation},
- * @p{contravariant_transformation} and the
+ * @p covariant_transformation,
+ * @p contravariant_transformation and the
* derivatives
- * @p{covariant_grads}.
+ * @p covariant_grads.
*
*/
virtual void
std::vector<double> &JxW_values) const = 0;
/**
- * Performs the same as @p{fill_fe_values}
+ * Performs the same as @p fill_fe_values
* on a face.
- * Additionally, @p{boundary_form} and
- * @p{normal_vectors} can be
+ * Additionally, @p boundary_form and
+ * @p normal_vectors can be
* computed on surfaces. The
* boundary form is the vector
* product of the image of
std::vector<Point<dim> > &normal_vectors) const = 0;
/**
- * Give class @p{FEValues} access
+ * Give class @p FEValues access
* to the private @p{get_...data}
* and @p{fill_fe_...values}
* functions.
/**
* Mapping class that uses C1 (continuously differentiable) cubic
* mappings of the boundary. This class is built atop of
- * @ref{MappingQ} by simply determining the interpolation points for a
- * cubic mapping of the boundary differently: @ref{MappingQ} chooses
+ * MappingQ by simply determining the interpolation points for a
+ * cubic mapping of the boundary differently: MappingQ chooses
* them such that they interpolate the boundary, while this class
* chooses them such that the discretized boundary is globally
* continuously differentiable.
*
* To use this class, make sure that the
- * @ref{Boundary}::@p{get_normals_at_vertices} function is implemented
+ * Boundary::@p get_normals_at_vertices function is implemented
* for the users boundary object.
*
* @author Wolfgang Bangerth, 2001
public:
/**
* Constructor. Pass the fixed
- * degree @p{3} down to the base
+ * degree @p 3 down to the base
* class, as a cubic mapping
* suffices to generate a
* continuous mapping of the
* support points of all shape
* functions located on bounding
* lines to the vector
- * @p{a}. Points located on the
+ * @p a. Points located on the
* line but on vertices are not
* included.
*
* support points of all shape
* functions located on bounding
* faces (quads in 3d) to the
- * vector @p{a}. Points located
+ * vector @p a. Points located
* on the line but on vertices
* are not included.
*
* Needed by the
- * @p{compute_support_points_laplace}
+ * @p compute_support_points_laplace
* function. For @p{dim=1} and 2
* this function is empty.
*
const Point<dim> &p) const;
/**
- * Transforms the point @p{p} on
+ * Transforms the point @p p on
* the real cell to the point
- * @p{p_unit} on the unit cell
- * @p{cell} and returns @p{p_unit}.
+ * @p p_unit on the unit cell
+ * @p cell and returns @p p_unit.
*
* Uses Newton iteration and the
- * @p{transform_unit_to_real_cell}
+ * @p transform_unit_to_real_cell
* function.
*/
virtual Point<dim>
{
public:
/**
- * Constructor. @p{p} gives the
+ * Constructor. @p p gives the
* degree of mapping polynomials
* on boundary cells.
*/
virtual ~MappingQ ();
/**
- * Transforms the point @p{p} on
+ * Transforms the point @p p on
* the unit cell to the point
- * @p{p_real} on the real cell
- * @p{cell} and returns @p{p_real}.
+ * @p p_real on the real cell
+ * @p cell and returns @p p_real.
*/
virtual Point<dim>
transform_unit_to_real_cell (
const Point<dim> &p) const;
/**
- * Transforms the point @p{p} on
+ * Transforms the point @p p on
* the real cell to the point
- * @p{p_unit} on the unit cell
- * @p{cell} and returns @p{p_unit}.
+ * @p p_unit on the unit cell
+ * @p cell and returns @p p_unit.
*
* Uses Newton iteration and the
- * @p{transform_unit_to_real_cell}
+ * @p transform_unit_to_real_cell
* function.
*/
virtual Point<dim>
/**
* Implementation of the
- * interface in @ref{Mapping}.
+ * interface in Mapping.
*/
virtual void
transform_covariant (Tensor<1,dim> *begin,
/**
* Implementation of the
- * interface in @ref{Mapping}.
+ * interface in Mapping.
*/
virtual void
transform_covariant (Tensor<2,dim> *begin,
/**
* Implementation of the
- * interface in @ref{Mapping}.
+ * interface in Mapping.
*/
virtual void
transform_contravariant (Tensor<1,dim> *begin,
/**
* Implementation of the
- * interface in @ref{Mapping}.
+ * interface in Mapping.
*/
virtual void
transform_contravariant (Tensor<2,dim> *begin,
* for the alternative
* computation of the normal
* vectors. See doc of the
- * @p{alternative_normals_computation}
+ * @p alternative_normals_computation
* flag.
*
* Filled (hardcoded) once in
- * @p{get_face_data}.
+ * @p get_face_data.
*/
std::vector<std::vector<Point<dim> > > unit_normals;
* @p{fill_fe_[[sub]face]_values}
* function.
*
- * If this flag is @p{true}
+ * If this flag is @p true
* we are on an interior cell
* and the
- * @p{mapping_q1_data} is
+ * @p mapping_q1_data is
* used.
*/
bool use_mapping_q1_on_current_cell;
/**
* On interior cells
- * @p{MappingQ1} is used.
+ * @p MappingQ1 is used.
*/
typename MappingQ1<dim>::InternalData mapping_q1_data;
};
protected:
/**
* Implementation of the interface in
- * @ref{Mapping}.
+ * Mapping.
*/
virtual void
fill_fe_values (const typename DoFHandler<dim>::cell_iterator &cell,
/**
* Implementation of the interface in
- * @ref{Mapping}.
+ * Mapping.
*/
virtual void
fill_fe_face_values (const typename DoFHandler<dim>::cell_iterator &cell,
/**
* Implementation of the interface in
- * @ref{Mapping}.
+ * Mapping.
*/
virtual void
fill_fe_subface_values (const typename DoFHandler<dim>::cell_iterator &cell,
* support points of all shape
* functions located on bounding
* lines to the vector
- * @p{a}. Points located on the
+ * @p a. Points located on the
* line but not on vertices are not
* included.
*
* Needed by the
- * @p{compute_support_points_laplace}
+ * @p compute_support_points_laplace
* function . For @p{dim=1} this
* function is empty.
*
* support points of all shape
* functions located on bounding
* faces (quads in 3d) to the
- * vector @p{a}. Points located
+ * vector @p a. Points located
* on the quad but not on vertices
* are not included.
*
* Needed by the
- * @p{compute_support_points_laplace}
+ * @p compute_support_points_laplace
* function. For @p{dim=1} and
* @p{dim=2} this function is
* empty.
/**
* Implementation of the interface in
- * @ref{Mapping}.
+ * Mapping.
*/
virtual
typename Mapping<dim>::InternalDataBase *
/**
* Implementation of the interface in
- * @ref{Mapping}.
+ * Mapping.
*/
virtual
typename Mapping<dim>::InternalDataBase *
/**
* Implementation of the interface in
- * @ref{Mapping}.
+ * Mapping.
*/
virtual
typename Mapping<dim>::InternalDataBase *
*
* For @p{degree<4} this function
* sets the
- * @p{laplace_on_quad_vector} to
+ * @p laplace_on_quad_vector to
* the hardcoded data. For
* @p{degree>=4} and MappingQ<2>
* this vector is computed.
*
* For the definition of the
- * @p{laplace_on_quad_vector}
+ * @p laplace_on_quad_vector
* please refer to equation (8)
* of the `mapping' report.
*/
*
* For @p{degree==2} this function
* sets the
- * @p{laplace_on_hex_vector} to
+ * @p laplace_on_hex_vector to
* the hardcoded data. For
* @p{degree>2} this vector is
* computed.
*
* For the definition of the
- * @p{laplace_on_hex_vector}
+ * @p laplace_on_hex_vector
* please refer to equation (8)
* of the `mapping' report.
*/
* Takes a
* @p{laplace_on_hex(quad)_vector}
* and applies it to the vector
- * @p{a} to compute the inner
+ * @p a to compute the inner
* support points as a linear
* combination of the exterior
* points.
*
- * The vector @p{a} initially
+ * The vector @p a initially
* contains the locations of the
- * @p{n_outer} points, the
- * @p{n_inner} computed inner
+ * @p n_outer points, the
+ * @p n_inner computed inner
* points are appended.
*
* See equation (7) of the
/**
* Needed by the
- * @p{laplace_on_quad} function
+ * @p laplace_on_quad function
* (for @p{dim==2}). Filled by the
* constructor.
*
/**
* Needed by the
- * @p{laplace_on_hex} function
+ * @p laplace_on_hex function
* (for @p{dim==3}). Filled by the
* constructor.
*
<< "laplace_vector not set for degree=" << arg1 << ".");
/**
- * Degree @p{p} of the
+ * Degree @p p of the
* polynomials used as shape
* functions for the Qp mapping
* of cells at the boundary.
/**
* Pointer to the
- * @p{dim}-dimensional tensor
+ * @p dim-dimensional tensor
* product polynomials used as
* shape functions for the Qp
* mapping of cells at the
* Mapping from lexicographic to
* to the Qp shape function
* numbering. Its size is
- * @p{dofs_per_cell}.
+ * @p dofs_per_cell.
*/
std::vector<unsigned int> renumber;
/**
- * If this flag is set @p{true}
- * then @p{MappingQ} is used on
+ * If this flag is set @p true
+ * then @p MappingQ is used on
* all cells, not only on
* boundary cells.
*
* functions.
*
* This function maps the unit cell to a general grid cell with
- * straight lines in @p{d} dimensions (remark that in 3D the surfaces
+ * straight lines in @p d dimensions (remark that in 3D the surfaces
* may be curved, even if the edges are not). This is the well-known
* mapping for polyhedral domains.
*
* Shape function for this mapping are the same as for the finite
- * element @p{FE_Q} of order 1. Therefore, coupling these two yields
+ * element @p FE_Q of order 1. Therefore, coupling these two yields
* an isoparametric element.
*
* @author Guido Kanschat, Ralf Hartmann, 2000, 2001
MappingQ1 ();
/**
- * Transforms the point @p{p} on
+ * Transforms the point @p p on
* the unit cell to the point
- * @p{p_real} on the real cell
- * @p{cell} and returns @p{p_real}.
+ * @p p_real on the real cell
+ * @p cell and returns @p p_real.
*/
virtual Point<dim>
transform_unit_to_real_cell (
const Point<dim> &p) const;
/**
- * Transforms the point @p{p} on
+ * Transforms the point @p p on
* the real cell to the point
- * @p{p_unit} on the unit cell
- * @p{cell} and returns @p{p_unit}.
+ * @p p_unit on the unit cell
+ * @p cell and returns @p p_unit.
*
* Uses Newton iteration and the
- * @p{transform_unit_to_real_cell}
+ * @p transform_unit_to_real_cell
* function.
*/
virtual Point<dim>
/**
* Implementation of the interface in
- * @ref{Mapping}.
+ * Mapping.
*/
virtual void
transform_covariant (Tensor<1,dim> *begin,
/**
* Implementation of the interface in
- * @ref{Mapping}.
+ * Mapping.
*/
virtual void
transform_covariant (Tensor<2,dim> *begin,
/**
* Implementation of the interface in
- * @ref{Mapping}.
+ * Mapping.
*/
virtual void
transform_contravariant (Tensor<1,dim> *begin,
/**
* Implementation of the interface in
- * @ref{Mapping}.
+ * Mapping.
*/
virtual void
transform_contravariant (Tensor<2,dim> *begin,
/**
* Implementation of the interface in
- * @ref{Mapping}.
+ * Mapping.
*
* Description of effects:
- * @begin{itemize}
- * @item if @p{update_q_points}
+ * <ul>
+ * <li> if @p update_q_points
* is required, the output will
* contain
- * @p{update_transformation_values}. This
+ * @p update_transformation_values. This
* computes the values of the
* transformation basis
* polynomials at the unit cell
* quadrature points.
- * @item if any of
- * @p{update_covariant_transformation},
- * @p{update_contravariant_transformation},
- * @p{update_JxW_values},
- * @p{update_boundary_forms},
- * @p{update_normal_vectors} is
+ * <li> if any of
+ * @p update_covariant_transformation,
+ * @p update_contravariant_transformation,
+ * @p update_JxW_values,
+ * @p update_boundary_forms,
+ * @p update_normal_vectors is
* required, the output will
* contain
- * @p{update_transformation_gradients}
+ * @p update_transformation_gradients
* to compute derivatives of the
* transformation basis
* polynomials.
- * @end{itemize}
+ * </ul>
*/
virtual UpdateFlags update_once (const UpdateFlags flags) const;
/**
* Implementation of the interface in
- * @ref{Mapping}.
+ * Mapping.
*
* Description of effects if
- * @p{flags} contains:
- * @begin{itemize}
- * @item p{update_q_points} is
+ * @p flags contains:
+ * <ul>
+ * <li> p{update_q_points} is
* copied to the output to
* compute the quadrature points
* on the real cell.
- * @item p{update_JxW_values} is
+ * <li> p{update_JxW_values} is
* copied and requires
- * @p{update_boundary_forms} on
+ * @p update_boundary_forms on
* faces. The latter, because the
* surface element is just the
* norm of the boundary form.
- * @item p{update_normal_vectors}
+ * <li> p{update_normal_vectors}
* is copied and requires
- * @p{update_boundary_forms}. The
+ * @p update_boundary_forms. The
* latter, because the normal
* vector is the normalized
* boundary form.
- * @item
+ * <li>
* p{update_covariant_transformation}
* is copied and requires
- * @p{update_contravariant_transformation},
+ * @p update_contravariant_transformation,
* since it is computed as the
* inverse of the latter.
- * @item p{update_JxW_values} is
+ * <li> p{update_JxW_values} is
* copied and requires
- * @p{update_contravariant_transformation},
+ * @p update_contravariant_transformation,
* since it is computed as one
* over determinant of the
* latter.
- * @item p{update_boundary_forms}
+ * <li> p{update_boundary_forms}
* is copied and requires
- * @p{update_contravariant_transformation},
+ * @p update_contravariant_transformation,
* since the boundary form is
* computed as the contravariant
* image of the normal vector to
* the unit cell.
- * @end{itemize}
+ * </ul>
*/
virtual UpdateFlags update_each (const UpdateFlags flags) const;
/**
* Values of shape
* functions. Access by
- * function @p{shape}.
+ * function @p shape.
*
* Computed once.
*/
/**
* Values of shape function
* derivatives. Access by
- * function @p{derivative}.
+ * function @p derivative.
*
* Computed once.
*/
* inverse of the Jacobian
* matrix, which itself is
* stored in the
- * @p{contravariant} field of
+ * @p contravariant field of
* this structure.
*
* Computed on each cell.
/**
* Stores the support points of
* the mapping shape functions on
- * the @p{cell_of_current_support_points}.
+ * the @p cell_of_current_support_points.
*/
std::vector<Point<dim> > mapping_support_points;
/**
* Stores the cell of which the
- * @p{mapping_support_points} are
+ * @p mapping_support_points are
* stored.
*/
typename DoFHandler<dim>::cell_iterator cell_of_current_support_points;
/**
* Default value of this flag
- * is @p{true}. If @p{*this}
+ * is @p true. If @p{*this}
* is an object of a derived
* class, this flag is set to
- * @p{false}.
+ * @p false.
*/
bool is_mapping_q1_data;
* cell. However, since also
* derived classes use this
* class (e.g. the
- * @ref{Mapping_Q} class),
+ * Mapping_Q() class),
* the number of shape
* functions may also be
* different.
/**
* Implementation of the interface in
- * @ref{Mapping}.
+ * Mapping.
*/
virtual void
fill_fe_values (const typename DoFHandler<dim>::cell_iterator &cell,
/**
* Implementation of the interface in
- * @ref{Mapping}.
+ * Mapping.
*/
virtual void
fill_fe_face_values (const typename DoFHandler<dim>::cell_iterator &cell,
/**
* Implementation of the interface in
- * @ref{Mapping}.
+ * Mapping.
*/
virtual void
fill_fe_subface_values (const typename DoFHandler<dim>::cell_iterator &cell,
* derivatives.
*
* Calls either the
- * @p{compute_shapes_virtual} of
+ * @p compute_shapes_virtual of
* this class or that of the
* derived class, depending on
* whether
* @p{data.is_mapping_q1_data}
- * equals @p{true} or @p{false}.
+ * equals @p true or @p false.
*/
void compute_shapes (const std::vector<Point<dim> > &unit_points,
InternalData &data) const;
/**
* Do the computations for the
- * @p{get_data} functions. Here,
+ * @p get_data functions. Here,
* the data vectors of
- * @p{InternalData} are
+ * @p InternalData are
* reinitialized to proper size
* and shape values are computed.
*/
/**
* Do the computations for the
- * @p{get_face_data}
+ * @p get_face_data
* functions. Here, the data
- * vectors of @p{InternalData}
+ * vectors of @p InternalData
* are reinitialized to proper
* size and shape values and
* derivatives are
* computed. Furthermore
- * @p{unit_tangential} vectors of
+ * @p unit_tangential vectors of
* the face are computed.
*/
void compute_face_data (const UpdateFlags flags,
InternalData &data) const;
/**
- * Transforms a point @p{p} on
+ * Transforms a point @p p on
* the unit cell to the point
- * @p{p_real} on the real cell
- * @p{cell} and returns @p{p_real}.
+ * @p p_real on the real cell
+ * @p cell and returns @p p_real.
*
* This function is called by
- * @p{transform_unit_to_real_cell}
+ * @p transform_unit_to_real_cell
* and multiply (through the
* Newton iteration) by
- * @p{transform_real_to_unit_cell_internal}.
+ * @p transform_real_to_unit_cell_internal.
*
* Takes a reference to an
- * @p{InternalData} that must
+ * @p InternalData that must
* already include the shape
- * values at point @p{p} and the
+ * values at point @p p and the
* mapping support points of the
* cell.
*
- * This @p{InternalData} argument
+ * This @p InternalData argument
* avoids multiple computations
* of the shape values at point
- * @p{p} and especially multiple
+ * @p p and especially multiple
* computations of the mapping
* support points.
*/
Point<dim> transform_unit_to_real_cell_internal (const InternalData &mdata) const;
/**
- * Transforms the point @p{p} on
+ * Transforms the point @p p on
* the real cell to the point
- * @p{p_unit} on the unit cell
- * @p{cell} by a Newton
+ * @p p_unit on the unit cell
+ * @p cell by a Newton
* iteration.
*
* Takes a reference to an
- * @p{InternalData} that is
+ * @p InternalData that is
* assumed to be previously
- * created by the @p{get_data}
- * function with @p{UpdateFlags}
+ * created by the @p get_data
+ * function with @p UpdateFlags
* including
- * @p{update_transformation_values}
+ * @p update_transformation_values
* and
- * @p{update_transformation_gradients}
+ * @p update_transformation_gradients
* and a one point Quadrature
* including the given point
- * @p{p_unit}. Hence this
+ * @p p_unit. Hence this
* function assumes that
- * @p{mdata} already includes the
+ * @p mdata already includes the
* transformation shape values
* and gradients computed at
- * @p{p_unit}.
+ * @p p_unit.
*
* These assumptions should be
* fulfilled by the calling
* function. That is up to now
* only the function
- * @p{transform_real_to_unit_cell}
+ * @p transform_real_to_unit_cell
* and its overloaded versions.
- * @p{mdata} will be changed by
+ * @p mdata will be changed by
* this function.
*/
void transform_real_to_unit_cell_internal (const typename Triangulation<dim>::cell_iterator &cell,
private:
/**
* Implementation of the interface in
- * @ref{Mapping}.
+ * Mapping.
*/
virtual
typename Mapping<dim>::InternalDataBase *
/**
* Implementation of the interface in
- * @ref{Mapping}.
+ * Mapping.
*/
virtual
typename Mapping<dim>::InternalDataBase *
/**
* Implementation of the interface in
- * @ref{Mapping}.
+ * Mapping.
*/
virtual
typename Mapping<dim>::InternalDataBase *
/**
* Computes the support points of
- * the mapping. For @p{MappingQ1}
+ * the mapping. For @p MappingQ1
* these are the
* vertices.
*/
* The constructor of this class takes two arguments: a reference to
* the vector that defines the mapping from the reference
* configuration to the current configuration and a reference to the
- * @ref{DoFHandler}. The vector should then represent a (flattened out
+ * DoFHandler. The vector should then represent a (flattened out
* version of a) vector valued field defined at nodes defined by the
- * the @ref{DoFHandler}, where the number of components of the vector
+ * the DoFHandler, where the number of components of the vector
* field equals the number of space dimensions. Thus, the
- * @ref{DoFHandler} shall operate on a finite element that has as many
+ * DoFHandler shall operate on a finite element that has as many
* components as space dimensions. As an additional requirement, we
* impose that it have as many degree of freedom per vertex as there
* are space dimensions; since this object only evaluates the finite
* element field at the vertices, the values
* of all other degrees of freedom (not associated to vertices) are
* ignored. These requirements are met if the finite element which the
- * given @ref{DoFHandler} operates on is constructed as a system
- * element (@ref{FESystem}) from @p{dim} continuous @ref{FE_Q}
+ * given DoFHandler operates on is constructed as a system
+ * element (FESystem) from @p dim continuous FE_Q()
* objects.
*
* In many cases, the shift vector will also be the solution vector of
* space dimension, e.g. for scalar problems in @p{dim>1} where the
* Eulerian coordinates only give a background field) or for coupled
* problems where more variables are computed than just the flow
- * field), then a different @ref{DoFHandler} has to be set up on the
+ * field), then a different DoFHandler has to be set up on the
* given triangulation, and the shift vector has then to be associated
* to it.
*
* An example is shown below:
- * @begin{verbatim}
+ * @verbatim
* FESystem<dim> fe(FE_Q<dim>(1), dim);
* DoFHandler<dim> flowfield_dof_handler(triangulation);
* flowfield_dof_handler.distribute_dofs(fe);
* Vector<double> map_points(flowfield_dof_handler.n_dofs());
* MappingQ1Eulerian<dim> mymapping(map_points, flowfield_dof_handler);
- * @end{verbatim}
+ * @endverbatim
*
* Note that since the vector of shift values and the dof handler are
* only associated to this object at construction time, you have to
* problem from the reference to
* the current configuration.
* The organization of the
- * elements in the @p{Vector}
+ * elements in the @p Vector
* must follow the concept how
* deal.II stores solutions that
* are associated to a
* triangulation. This is
* automatically the case if the
- * @p{Vector} represents the
+ * @p Vector represents the
* solution of the previous step
* of a nonlinear problem.
- * Alternatively, the @p{Vector}
+ * Alternatively, the @p Vector
* can be initialized by
* @p{DoFObjectAccessor::set_dof_values()}.
*/
/**
* Computes the support points of
* the mapping. For
- * @p{MappingQ1Eulerian} these
+ * @p MappingQ1Eulerian these
* are the vertices.
*/
virtual void compute_mapping_support_points(
/**
* In this namespace a number of classes is declared that may be used
- * as filters in the @ref{FilteredIterator} class. The filters either
- * check for binary information (for example, the @p{Active} filter
+ * as filters in the FilteredIterator class. The filters either
+ * check for binary information (for example, the @p Active filter
* class checks whether the object pointed to is active), or for
* valued information by comparison with prescribed values (for
- * example, the @ref{LevelEqualTo} filter class checks whether the
+ * example, the LevelEqualTo filter class checks whether the
* level of the object pointed to by the iterator under consideration
* is equal to a value that was given to the filter upon construction.
*
* For examples of use of these classes as well as requirements on
- * filters see the general description of the @ref{FilteredIterator}
+ * filters see the general description of the FilteredIterator
* class.
*
* @author Wolfgang Bangerth, 2002
* pointers as well as classes that implement an @p{operator ()}.
*
* An example of a simple valid predicate is the following: given the function
- * @begin{verbatim}
+ * @verbatim
* template <typename Iterator>
* bool level_equal_to_3 (const Iterator c)
* {
* return (static_cast<unsigned int>(c->level()) == 3);
* };
- * @end{verbatim}
+ * @endverbatim
* then
- * @begin{verbatim}
+ * @verbatim
* &level_equal_to_3<typename Triangulation<dim>::active_cell_iterator>
- * @end{verbatim}
+ * @endverbatim
* is a valid predicate.
*
* Likewise, given the following binary function
- * @begin{verbatim}
+ * @verbatim
* template <typename Iterator>
* bool level_equal_to (const Iterator c,
* const unsigned int level)
* {
* return (static_cast<unsigned int>(c->level()) == level);
* };
- * @end{verbatim}
+ * @endverbatim
* then
- * @begin{verbatim}
+ * @verbatim
* std::bind2nd (std::ptr_fun(&level_equal_to<active_cell_iterator>), 3)
- * @end{verbatim}
+ * @endverbatim
* is another valid predicate (here: a function that returns true if
* either the iterator is past the end or the level is equal to the
* second argument; this second argument is bound to a fixed value
- * using the @p{std::bind2nd} function).
+ * using the @p std::bind2nd function).
*
* Finally, classes can be predicates. The following class is one:
- * @begin{verbatim}
+ * @verbatim
* class Active
* {
* public:
* return (i->active());
* }
* };
- * @end{verbatim}
+ * @endverbatim
* and objects of this type can be used as predicates. Likewise, this
* more complicated one can also be used:
- * @begin{verbatim}
+ * @verbatim
* class SubdomainEqualTo
* {
* public:
* private:
* const unsigned int subdomain_id;
* };
- * @end{verbatim}
+ * @endverbatim
* Objects like @p{SubdomainEqualTo(3)} can then be used as predicates.
*
* Since whenever a predicate is evaluated it is checked that the
* checks for this case have to be performed inside predicates.
*
* A number of filter classes are already implemented in the
- * @ref{IteratorFilters} namespace, but writing different ones is
+ * IteratorFilters namespace, but writing different ones is
* simple following the examples above.
*
*
* iterator to the first one that satisfies a predicate (for example,
* the first one for which the user flag is set, or the first one with
* a given subdomain id), there are assignement functions
- * @p{set_to_next_positive} and @p{set_to_previous_positive} that
+ * @p set_to_next_positive and @p set_to_previous_positive that
* assign the next or last previous iterator that satisfies the
* predicate, i.e. they follow the list of iterators in either
* direction until they find a matching one (or the past-the-end
*
* The following call counts the number of active cells that
* have a set user flag:
- * @begin{verbatim}
+ * @verbatim
* FilteredIterator<typename Triangulation<dim>::active_cell_iterator>
* begin (IteratorFilters::UserFlagSet()),
* end (IteratorFilters::UserFlagSet());
* begin.set_to_next_positive(tria.begin_active());
* end = tria.end();
* n_flagged_cells = std::distance (begin, end);
- * @begin{verbatim}
- * Note that by the @p{set_to_next_positive} call the first cell with
- * a set user flag was assigned to the @p{begin} iterator. For the
+ * @verbatim
+ * Note that by the @p set_to_next_positive call the first cell with
+ * a set user flag was assigned to the @p begin iterator. For the
* @{end} iterator, no such call was necessary, since the past-the-end
* iterator always satisfies all predicates.
*
* The same can be achieved by the following snippet, though harder to read:
- * @begin{verbatim}
+ * @verbatim
* typedef FilteredIterator<typename Triangulation<dim>::active_cell_iterator> FI;
* n_flagged_cells =
* std::distance (FI(IteratorFilters::UserFlagSet())
* .set_to_next_positive(tria.begin_active()),
* FI(IteratorFilters::UserFlagSet(), tria.end()));
- * @begin{verbatim}
+ * @verbatim
* It relies on the fact that if we create an unnamed filtered
* iterator with a given predicate but no iterator value and assign it
* the next positive value with respect to this predicate, it returns
* itself which is then used as the first parameter to the
- * @p{std::distance} function. This procedure is not necessary for the
+ * @p std::distance function. This procedure is not necessary for the
* end element to this function here, since the past-the-end iterator
* always satisfies the predicate so that we can assign this value to
* the filtered iterator directly in the constructor.
*
* Finally, the following loop only assembles the matrix on cells with
* subdomain id equal to three:
- * @begin{verbatim}
+ * @verbatim
* FilteredIterator<typename Triangulation<dim>::active_cell_iterator>
* cell (FilteredIterator::SubdomainEqualTo(3)),
* endc (FilteredIterator::SubdomainEqualTo(3), tria.end());
* cell.set_to_next_positive (tria.begin_active());
* for (; cell!=endc; ++cell)
* assemble_local_matrix (cell);
- * @end{verbatim}
+ * @endverbatim
*
* Since comparison between filtered and unfiltered iterators is
- * defined, we could as well have let the @p{endc} variable in the
+ * defined, we could as well have let the @p endc variable in the
* last example be of type
* @p{Triangulation<dim>::active_cell_iterator} since it is unchanged
* and its value does not depend on the filter.
/**
* Search for the next iterator
- * from @p{bi} onwards that
+ * from @p bi onwards that
* satisfies the predicate of
* this object and assign it to
* this object.
/**
* As above, but search for the
- * previous iterator from @p{bi}
+ * previous iterator from @p bi
* backwards that satisfies the
* predicate of this object and
* assign it to this object.
*
* For example, in 2D the layout of
* a cell is as follows:
- * @begin{verbatim}
+ * @verbatim
* . 2
* . 3-->--2
* . | |
* . | |
* . 0-->--1
* . 0
- * @end{verbatim}
+ * @endverbatim
* Vertices and faces are indicated
* with their numbers, faces also with
* their directions.
*
* Now, when refined, the layout is
* like this:
- * @begin{verbatim}
+ * @verbatim
* *--*--*
* | 3|2 |
* *--*--*
* | 0|1 |
* *--*--*
- * @end{verbatim}
+ * @endverbatim
*
* Thus, the child cells on face zero
* are (ordered in the direction of the
* the exact order of the
* children is laid down in the
* documentation of the
- * @ref{Triangulation} class.
+ * Triangulation class.
* However, it must be noted that
* this class and function only
* deals with faces in standard
/**
* Return the position of the
- * @p{i}th vertex on the unit
+ * @p ith vertex on the unit
* cell. The order of vertices is
* the canonical one in deal.II,
* as described in the
* documentation of the
- * @ref{Triangulation} class.
+ * Triangulation class.
*/
static Point<dimension> unit_cell_vertex (const unsigned int vertex);
* Report, for @p{vertex=0,1} the
* indices of the two vertices
* adjacent to the line with
- * index @p{line} among the lines
+ * index @p line among the lines
* forming this cell. In 1d, the
* only line is the cell itself,
* while in 2d and 3d there are 4
* The positions of these
* vertices in the unit cell can
* be obtained using the
- * @p{unit_cell_vertex} function.
+ * @p unit_cell_vertex function.
*
* The order of the lines, as
* well as their direction (which
* vertex on a line) is the
* canonical one in deal.II, as
* described in the documentation
- * of the @ref{Triangulation}
+ * of the Triangulation
* class.
*/
static unsigned int vertices_adjacent_to_line (const unsigned int line,
const unsigned int vertex);
/**
- * Given a point @p{p} in unit
+ * Given a point @p p in unit
* coordinates, return the number
* of the child cell in which it
* would lie in. If the point
*
* The order of child cells is
* described the documentation of
- * the @ref{Triangulation} class.
+ * the Triangulation class.
*/
static unsigned int child_cell_from_point (const Point<dimension> &p);
/**
- * Given coordinates @p{p} on the
+ * Given coordinates @p p on the
* unit cell, return the values
* of the coordinates of this
* point in the coordinate system
* faces.
*
* This class contains as static members information on vertices and
- * faces of a @p{dim}-dimensional grid cell. The interface is the same
+ * 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. @p subfaces_per_cell in
* 1d.
*
* This information should always replace hard-coded numbers of
* number (in the hope that a compiler
* may warn when it sees constructs like
* @p{for (i=0; i<vertices_per_face; ++i)},
- * at least if @p{i} is an @p{unsigned int}.
+ * at least if @p i is an @p{unsigned int}.
*/
static const unsigned int vertices_per_face = 0;
* Topological description of one dimensional cells.
*
* This class contains as static members information on vertices and
- * faces of a @p{dim}-dimensional grid cell. The interface is the same
+ * 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. @p subfaces_per_cell in
* 1d.
*
* This information should always replace hard-coded numbers of
* number (in the hope that a compiler
* may warn when it sees constructs like
* @p{for (i=0; i<vertices_per_face; ++i)},
- * at least if @p{i} is an @p{unsigned int}.
+ * at least if @p i is an @p{unsigned int}.
*/
static const unsigned int vertices_per_face = 1;
*
* For example, in 2D the layout of
* a cell is as follows:
- * @begin{verbatim}
+ * @verbatim
* . 2
* . 3-->--2
* . | |
* . | |
* . 0-->--1
* . 0
- * @end{verbatim}
+ * @endverbatim
* Vertices and faces are indicated
* with their numbers, faces also with
* their directions.
*
* Now, when refined, the layout is
* like this:
- * @begin{verbatim}
+ * @verbatim
* *--*--*
* | 3|2 |
* *--*--*
* | 0|1 |
* *--*--*
- * @end{verbatim}
+ * @endverbatim
*
* Thus, the child cells on face zero
* are (ordered in the direction of the
* the exact order of the
* children is laid down in the
* documentation of the
- * @ref{Triangulation}
+ * Triangulation
* class. However, it must be
* noted that this class and
* function only deals with faces
/**
* Return the position of the
- * @p{i}th vertex on the unit
+ * @p ith vertex on the unit
* cell. The order of vertices is
* the canonical one in deal.II,
* as described in the
* documentation of the
- * @ref{Triangulation} class.
+ * Triangulation class.
*/
static Point<1> unit_cell_vertex (const unsigned int vertex);
* Report, for @p{vertex=0,1} the
* indices of the two vertices
* adjacent to the line with
- * index @p{line} among the lines
+ * index @p line among the lines
* forming this cell. In 1d, the
* only line is the cell itself,
* while in 2d and 3d there are 4
* The positions of these
* vertices in the unit cell can
* be obtained using the
- * @p{unit_cell_vertex} function.
+ * @p unit_cell_vertex function.
*
* The order of the lines, as
* well as their direction (which
* vertex on a line) is the
* canonical one in deal.II, as
* described in the documentation
- * of the @ref{Triangulation}
+ * of the Triangulation
* class.
*/
static unsigned int vertices_adjacent_to_line (const unsigned int line,
const unsigned int vertex);
/**
- * Given a point @p{p} in unit
+ * Given a point @p p in unit
* coordinates, return the number
* of the child cell in which it
* would lie in. If the point
*
* The order of child cells is
* described the documentation of
- * the @ref{Triangulation} class.
+ * the Triangulation class.
*/
static unsigned int child_cell_from_point (const Point<1> &p);
/**
- * Given coordinates @p{p} on the
+ * Given coordinates @p p on the
* unit cell, return the values
* of the coordinates of this
* point in the coordinate system
* Topological description of two dimensional cells.
*
* This class contains as static members information on vertices and
- * faces of a @p{dim}-dimensional grid cell. The interface is the same
+ * 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. @p subfaces_per_cell in
* 1d.
*
* This information should always replace hard-coded numbers of
* number (in the hope that a compiler
* may warn when it sees constructs like
* @p{for (i=0; i<vertices_per_face; ++i)},
- * at least if @p{i} is an @p{unsigned int}.
+ * at least if @p i is an @p{unsigned int}.
*/
static const unsigned int vertices_per_face = 2;
*
* For example, in 2D the layout of
* a cell is as follows:
- * @begin{verbatim}
+ * @verbatim
* . 2
* . 3-->--2
* . | |
* . | |
* . 0-->--1
* . 0
- * @end{verbatim}
+ * @endverbatim
* Vertices and faces are indicated
* with their numbers, faces also with
* their directions.
*
* Now, when refined, the layout is
* like this:
- * @begin{verbatim}
+ * @verbatim
* *--*--*
* | 3|2 |
* *--*--*
* | 0|1 |
* *--*--*
- * @end{verbatim}
+ * @endverbatim
*
* Thus, the child cells on face zero
* are (ordered in the direction of the
* the exact order of the
* children is laid down in the
* documentation of the
- * @ref{Triangulation}
+ * Triangulation
* class. However, it must be
* noted that this class and
* function only deals with faces
/**
* Return the position of the
- * @p{i}th vertex on the unit
+ * @p ith vertex on the unit
* cell. The order of vertices is
* the canonical one in deal.II,
* as described in the
* documentation of the
- * @ref{Triangulation} class.
+ * Triangulation class.
*/
static Point<2> unit_cell_vertex (const unsigned int i);
* Report, for @p{vertex=0,1} the
* indices of the two vertices
* adjacent to the line with
- * index @p{line} among the lines
+ * index @p line among the lines
* forming this cell. In 1d, the
* only line is the cell itself,
* while in 2d and 3d there are 4
* The positions of these
* vertices in the unit cell can
* be obtained using the
- * @p{unit_cell_vertex} function.
+ * @p unit_cell_vertex function.
*
* The order of the lines, as
* well as their direction (which
* vertex on a line) is the
* canonical one in deal.II, as
* described in the documentation
- * of the @ref{Triangulation}
+ * of the Triangulation
* class.
*/
static unsigned int vertices_adjacent_to_line (const unsigned int line,
const unsigned int vertex);
/**
- * Given a point @p{p} in unit
+ * Given a point @p p in unit
* coordinates, return the number
* of the child cell in which it
* would lie in. If the point
*
* The order of child cells is
* described the documentation of
- * the @ref{Triangulation} class.
+ * the Triangulation class.
*/
static unsigned int child_cell_from_point (const Point<2> &p);
/**
- * Given coordinates @p{p} on the
+ * Given coordinates @p p on the
* unit cell, return the values
* of the coordinates of this
* point in the coordinate system
* Topological description of three dimensional cells.
*
* This class contains as static members information on vertices and
- * faces of a @p{dim}-dimensional grid cell. The interface is the same
+ * 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. @p subfaces_per_cell in
* 1d.
*
* This information should always replace hard-coded numbers of
* number (in the hope that a compiler
* may warn when it sees constructs like
* @p{for (i=0; i<vertices_per_face; ++i)},
- * at least if @p{i} is an @p{unsigned int}.
+ * at least if @p i is an @p{unsigned int}.
*/
static const unsigned int vertices_per_face = 4;
*
* For example, in 2D the layout of
* a cell is as follows:
- * @begin{verbatim}
+ * @verbatim
* . 2
* . 3-->--2
* . | |
* . | |
* . 0-->--1
* . 0
- * @end{verbatim}
+ * @endverbatim
* Vertices and faces are indicated
* with their numbers, faces also with
* their directions.
*
* Now, when refined, the layout is
* like this:
- * @begin{verbatim}
+ * @verbatim
* *--*--*
* | 3|2 |
* *--*--*
* | 0|1 |
* *--*--*
- * @end{verbatim}
+ * @endverbatim
*
* Thus, the child cells on face zero
* are (ordered in the direction of the
* the exact order of the
* children is laid down in the
* documentation of the
- * @ref{Triangulation}
+ * Triangulation
* class. However, it must be
* noted that this class and
* function only deals with faces
const unsigned int subface);
/**
* Return the position of the
- * @p{i}th vertex on the unit
+ * @p ith vertex on the unit
* cell. The order of vertices is
* the canonical one in deal.II,
* as described in the
* documentation of the
- * @ref{Triangulation} class.
+ * Triangulation class.
*/
static Point<3> unit_cell_vertex (const unsigned int i);
* Report, for @p{vertex=0,1} the
* indices of the two vertices
* adjacent to the line with
- * index @p{line} among the lines
+ * index @p line among the lines
* forming this cell. In 1d, the
* only line is the cell itself,
* while in 2d and 3d there are 4
* The positions of these
* vertices in the unit cell can
* be obtained using the
- * @p{unit_cell_vertex} function.
+ * @p unit_cell_vertex function.
*
* The order of the lines, as
* well as their direction (which
* vertex on a line) is the
* canonical one in deal.II, as
* described in the documentation
- * of the @ref{Triangulation}
+ * of the Triangulation
* class.
*/
static unsigned int vertices_adjacent_to_line (const unsigned int line,
const unsigned int vertex);
/**
- * Given a point @p{p} in unit
+ * Given a point @p p in unit
* coordinates, return the number
* of the child cell in which it
* would lie in. If the point
*
* The order of child cells is
* described the documentation of
- * the @ref{Triangulation} class.
+ * the Triangulation class.
*/
static unsigned int child_cell_from_point (const Point<3> &p);
/**
- * Given coordinates @p{p} on the
+ * Given coordinates @p p on the
* unit cell, return the values
* of the coordinates of this
* point in the coordinate system
* equation timestep after timestep in a (d+1)-dimensional space).
*
* This class contains as static members information on vertices and
- * faces of a @p{dim}-dimensional grid cell. The interface is the same
+ * 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. @p subfaces_per_cell in
* 1d.
*
* This information should always replace hard-coded numbers of
* number (in the hope that a compiler
* may warn when it sees constructs like
* @p{for (i=0; i<vertices_per_face; ++i)},
- * at least if @p{i} is an @p{unsigned int}.
+ * at least if @p i is an @p{unsigned int}.
*/
static const unsigned int vertices_per_face = 8;
* This class offers triangulations of some standard domains such as hypercubes,
* hyperball and the like. Following is a list of domains that can be generated
* by the functions of this class:
- * @begin{itemize}
- * @item Hypercube triangulations: a hypercube triangulation is a
+ * <ul>
+ * <li> Hypercube triangulations: a hypercube triangulation is a
* 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
* If you want the hypercube subdivided a certain number of
* times (and if this is not achievable by hierarchic
* refinement, for example 3 times), then the
- * @p{subdivided_hyper_cube} function may be what you are
+ * @p subdivided_hyper_cube function may be what you are
* looking for.
*
- * @item Rectangular coordinate-parallel domains as a generalization
+ * <li> Rectangular coordinate-parallel domains as a generalization
* of hypercubes are generated by
* GridGenerator::hyper_rectangle (tria, p1, p2), with two
- * opposite corner points @p{p1} and @p{p2}.
+ * opposite corner points @p p1 and @p p2.
*
- * @item Rectangular coordinate-parallel domains with different numbers of
+ * <li> Rectangular coordinate-parallel domains with different numbers of
* cells in each coordinate direction are generated by
* GridGenerator::subdivided_hyper_rectangle
* (tria, int[dim] repetitions, p1, p2, colorize), with two
- * opposite corner points @p{p1} and @p{p2}.
+ * opposite corner points @p p1 and @p p2.
*
- * @item Generalized L-shape domain:
+ * <li> Generalized L-shape domain:
* 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$
* $[-1,1]^2 - [0,1]^2$. To create a hyper-L in one dimension results in
* an error. The function is also implemented for three space dimensions.
*
- * @item Hyper ball:
+ * <li> Hyper ball:
* You get the circle or ball (or generalized: hyperball) around
- * origin @p{p} and with radius @p{r} by calling
+ * 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
* to the triangulation object you passed to this function if you later want
* the triangulation to be refined at the outer boundaries.
*
- * @item Half Hyper ball:
+ * <li> Half Hyper ball:
* You get half of the circle generated by Hyper ball.
- * with center @p{p} and with radius @p{r} by calling
+ * with center @p p and with radius @p r by calling
* 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.
* the triangulation to be refined at the outer boundaries. The class
* HalfHyperBallBoundary will provide a boundary object.
*
- * @item Hyper shell: A hyper shell is the region between two hyper
+ * <li> 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
* GridGenerator::hyper_shell (tria, origin, inner_radius, outer_radius, N),
* the inner and outer radius of the two spheres are given as
* shown.
*
- * The parameter @p{N} denotes how many cells are to be used for
+ * The parameter @p N denotes how many cells are to be used for
* this coarse triangulation. It defaults to zero, which tells
* the function to chose the number itself; this, then, is done
* such that the aspect ration of the resulting cells is as small
* used in the radial direction.
*
* You need to attach a boundary object to the triangulation. A
- * suitable boundary class is provided as @ref{HyperSphereBoundary}
+ * suitable boundary class is provided as HyperSphereBoundary
* in the library.
*
- * @item Half shells: This is a variant of the preceeding domain,
+ * <li> Half shells: This is a variant of the preceeding domain,
* where only one half of the shell is taken, defined by the first
* coordinate having non-negative values. This class is useful in
* computations with rotational symmetry, as then a 3d shell can be
* modeled by a 2d half shell.
*
- * @item Slit domain: The slit domain is a variant of the hyper cube
+ * <li> Slit domain: The slit domain is a variant of the hyper cube
* domain. In two spatial dimensions, it is a square into which a slit
* is sawed; if the initial square is though to be composed of four
* smaller squares, then two of them are not connected even though
* they are neighboring each other. Analogously, into the cube in
* three spatial dimensions, a half-plane is sawed, disconnecting four
* of the eight child-cubes from one of their neighbors.
- * @end{itemize}
+ * </ul>
*
- * Some of these functions receive a flag @p{colorize}. If this is
+ * Some of these functions receive a flag @p colorize. If this is
* set, parts of the boundary receive different boundary numbers,
* allowing them to be distinguished by application programs. See the
* documentation of the functions for details.
*
* Additionally this class provides a function
- * (@p{laplace_transformation}) that smoothly transforms a grid
+ * (@p laplace_transformation) that smoothly transforms a grid
* according to given new boundary points. This can be used to
* transform (simple-shaped) grids to a more complicated ones, like a
* shell onto a grid of an airfoil, for example.
const double right= 1.);
/**
- * Same as @ref{hyper_cube}, but
+ * Same as hyper_cube(), but
* with the difference that not
* only one cell is created but
* each coordinate direction is
* subdivided into
- * @p{repetitions} cells. Thus,
+ * @p repetitions cells. Thus,
* the number of cells filling
* the given volume is
* @p{repetitions^d}.
* Create a coordinate-parallel
* parallelepiped from the two
* diagonally opposite corner
- * points @p{p1} and @p{p2}.
+ * points @p p1 and @p p2.
*
- * If the @p{colorize} flag is
+ * If the @p colorize flag is
* set, the
- * @p{boundary_indicator}s of the
+ * @p boundary_indicators of the
* surfaces are assigned, such
* that the lower one in
- * @p{x}-direction is 0, the
+ * @p x-direction is 0, the
* upper one is 1. The indicators
* for the surfaces in
- * @p{y}-direction are 2 and 3,
- * the ones for @p{z} are 4 and
+ * @p y-direction are 2 and 3,
+ * the ones for @p z are 4 and
* 5.
*
* The triangulation needs to be
* Create a coordinate-parallel
* parallelepiped from the two
* diagonally opposite corner
- * points @p{p1} and @p{p2}. In
- * dimension @p{i},
+ * points @p p1 and @p p2. In
+ * dimension @p i,
* @p{repetitions[i]} cells are
* generated.
*
* directions. The minimum number
* of subdivisions in each
* direction is
- * 1. @p{repetitions} is a list
+ * 1. @p repetitions is a list
* of integers denoting the
* number of subdivisions in each
* coordinate direction.
*
- * If the @p{colorize} flag is
+ * If the @p colorize flag is
* set, the
- * @p{boundary_indicator}s of the
+ * @p boundary_indicators of the
* surfaces are assigned, such
* that the lower one in
- * @p{x}-direction is 0, the
+ * @p x-direction is 0, the
* upper one is 1. The indicators
* for the surfaces in
- * @p{y}-direction are 2 and 3,
- * the ones for @p{z} are 4 and
+ * @p y-direction are 2 and 3,
+ * the ones for @p z are 4 and
* 5.
*/
template <int dim>
* lower and upper bound of the
* inner hypercube in all
* coordinate directions.
- * @p{thickness} marks the size of
+ * @p thickness marks the size of
* the layer cells.
*
* If the flag colorize is set,
* from @p{x=-half_length} to
* @p{x=+half_length} and its
* projection into the
- * @p{yz}-plane is a circle of
- * radius @p{radius}.
+ * @p yz-plane is a circle of
+ * radius @p radius.
*
* The boundaries are colored
* according to the following
/**
* Projection of the
* three-dimensional cylinder
- * into the @p{xy}-plane.
+ * into the @p xy-plane.
* Therefore, this is simply a square.
*
* Coloring is like in 3D.
* Currently, only a two-dimensional
* version is implemented. The appropriate
* boundary class is
- * @ref{HalfHyperBallBoundary}.
+ * HalfHyperBallBoundary.
*/
static void half_hyper_ball (Triangulation<2> &tria,
const Point<2> ¢er = Point<2>(),
/**
* This function transformes the
- * @p{Triangulation} @p{tria}
+ * @p Triangulation @p tria
* smoothly to a domain that is
* described by the boundary
* points in the map
- * @p{new_points}. This map maps
+ * @p new_points. This map maps
* the point indices to the
* boundary points in the
* transformed domain.
*
* Note, that the
- * @p{Triangulation} is changed
+ * @p Triangulation is changed
* in-place, therefore you don't
* need to keep two
* triangulations, but the given
private:
/**
* Perform the action specified
- * by the @p{colorize} flag of
- * the @ref{hyper_rectangle}
+ * by the @p colorize flag of
+ * the hyper_rectangle()
* function of this class.
*/
template <int dim>
/**
* Perform the action specified
- * by the @p{colorize} flag of
+ * by the @p colorize flag of
* the
- * @ref{subdivided_hyper_rectangle}
+ * subdivided_hyper_rectangle()
* function of this class. This
* function is singled out
* because it is dimension
/**
* Solve the Laplace equation for
- * @p{laplace_transformation}
+ * @p laplace_transformation
* function for one of the
- * @p{dim} space
+ * @p dim space
* dimensions. Externalized into
* a function of its own in order
* to allow parallel execution.
* format for grid data. Any numerical data after the block of
* topological information is ignored.
*
- * Since the coarse mesh fed into a @p{Triangulation} object cannot
+ * Since the coarse mesh fed into a @p Triangulation object cannot
* have hanging nodes, strange things will happen if the input file
* has them. This is due to the fact that most mesh description
* formats do not store neighborship information between cells, so the
*
* Note: if you experience unexpected problems with the use of this
* class, be sure to read the documentation right until the end, and
- * also read the documentation of the @ref{GridReordering} class.
+ * also read the documentation of the GridReordering class.
*
* To read grid data, the triangulation to be fed with has to be empty.
* When giving a file which does not contain the assumed information or
*
* Material indicators are accepted to denote the material ID of cells and
* to denote boundary part indication for lines in 2D. Read the according
- * sections in the documentation of the @ref{Triangulation} class for
+ * sections in the documentation of the Triangulation class for
* further details.
*
*
* @sect3{Supported input formats}
*
* At present, the following input formats are supported:
- * @begin{itemize}
- * @item @p{UCD} (unstructured cell data) format: this format is used
+ * <ul>
+ * <li> @p UCD (unstructured cell data) format: this format is used
* for grid input as well as data output. If there are data vectors in
* the input file, they are ignored, as we are only interested in the
* grid in this class. The exact description of the format can be
* found in the AVS Explorer manual (see @url{http://www.avs.com}).
- * The @p{UCD} format can be read by the @p{read_ucd} function.
+ * The @p UCD format can be read by the @p read_ucd function.
*
- * @item @p{DB mesh} format: this format is used by the @p{BAMG} mesh
+ * <li> @p{DB mesh} format: this format is used by the @p BAMG mesh
* generator (see
* @url{http://www-rocq.inria.fr/gamma/cdrom/www/bamg/eng.htm}. The
- * documentation of the format in the @p{BAMG} manual is very
+ * documentation of the format in the @p BAMG manual is very
* incomplete, so we don't actually parse many of the fields of the
* output since we don't know their meaning, but the data that is read
* is enough to build up the mesh as intended by the mesh generator.
- * This format can be read by the @p{read_dbmesh} function.
+ * This format can be read by the @p read_dbmesh function.
*
- * @item @p{XDA} format: this is a rather simple format used by the MGF
+ * <li> @p XDA format: this is a rather simple format used by the MGF
* code. We don't have an exact specification of the format, but the reader
* can read in several example files. If the reader does not grok your files,
* it should be fairly simple to extend it.
- * @end{itemize}
+ * </ul>
*
*
* @sect3{Structure of input grid data. The GridReordering class}
* list, i.e. for lines in 1d, you have to first give the vertex with
* the lower coordinate value, then that with the higher coordinate
* value. For quadrilaterals in two dimensions, the vertex indices in
- * the @p{quad} list have to be such that the vertices are numbered in
+ * the @p quad list have to be such that the vertices are numbered in
* counter-clockwise sense.
*
* In two dimensions, another difficulty occurs, which has to do with the sense
* of a quadrilateral. A quad consists of four lines which have a direction,
* which is per definitionem as follows:
- * @begin{verbatim}
+ * @verbatim
* 3-->--2
* | |
* ^ ^
* | |
* 0-->--1
- * @end{verbatim}
+ * @endverbatim
* Now, two adjacent cells must have a vertex numbering such that the direction
* of the common side is the same. For example, the following two quads
- * @begin{verbatim}
+ * @verbatim
* 3---4---5
* | | |
* 0---1---2
- * @end{verbatim}
+ * @endverbatim
* may be characterised by the vertex numbers @p{(0 1 4 3)} and
* @p{(1 2 5 4)}, since the middle line would get the direction @p{1->4}
* when viewed from both cells. The numbering @p{(0 1 4 3)} and
* @p{(5 4 1 2)} would not be allowed, since the left quad would give the
* common line the direction @p{1->4}, while the right one would want
- * to use @p{4->1}, leading to an ambiguity. The @ref{Triangulation}
+ * to use @p{4->1}, leading to an ambiguity. The Triangulation
* object is capable of detecting this special case, which can be
* eliminated by rotating the indices of the right quad by
* two. However, it would not know what to do if you gave the vertex
* taken care of.
*
* For this reason, the @p{read_*} functions of this class that read
- * in grids in various input formats call the @ref{GridReordering}
+ * in grids in various input formats call the GridReordering
* class to bring the order of vertices that define the cells into an
* ordering that satisfies the requiremenets of the
- * @ref{Triangulation} class. Be sure to read the documentation of
+ * Triangulation class. Be sure to read the documentation of
* that class if you experience unexpected problems when reading grids
* through this class.
*
* what actually was created, if
* it is known that the data is
* not correct in some way, but
- * the @ref{Triangulation} class
+ * the Triangulation class
* refuses to generate a
* triangulation because of these
* errors. In particular, the
* respect to neighboring cells
* (see the documentations to
* this class and the
- * @ref{GridReordering} class).
+ * GridReordering class).
*
* The output of this function
* consists of vectors for each
* Within this namespace, we define several structures that are used
* to describe flags that can be given to grid output routines to
* modify the default outfit of the grids written into a file. See the
- * different subclasses and the documentation of the @ref{GridOut}
+ * different subclasses and the documentation of the GridOut
* class for more details.
*/
namespace GridOutFlags
* by this, so you can switch it off
* this way.
*
- * Default: @p{true}.
+ * Default: @p true.
*/
bool write_preamble;
* to write the triangulation to
* view or print it.
*
- * Default: @p{false}.
+ * Default: @p false.
*/
bool write_faces;
* the size of the output
* significantly, however.
*
- * Default: @p{false}.
+ * Default: @p false.
*/
bool write_cell_numbers;
/**
* Enum denoting the possibilities
* whether the scaling should be done
- * such that the given @p{size} equals
+ * such that the given @p size equals
* the width or the height of
* the resulting picture.
*/
};
/**
- * See above. Default is @p{width}.
+ * See above. Default is @p width.
*/
SizeType size_type;
* strange unit 1/72 inch. Whether
* this is height or width is
* specified by the flag
- * @p{size_type}.
+ * @p size_type.
*
* Default is 300.
*/
/**
* Should lines with a set
- * @p{user_flag} be drawn in a
+ * @p user_flag be drawn in a
* different color (red)?
*/
bool color_lines_on_user_flag;
*
* This is used if the
* mapping used is not the
- * standard @p{MappingQ1}
+ * standard @p MappingQ1
* mapping.
*/
unsigned int n_boundary_face_points;
* The format of the cell
* number written is
* @p{level.index}, or simply
- * @p{index}, depending on the
+ * @p index, depending on the
* value of the following flag.
*/
bool write_cell_numbers;
* flag determines whether the
* format shall be
* @p{level.index}, or simply
- * @p{index}. If @p{true}, the
+ * @p index. If @p true, the
* first format is
- * taken. Default is @p{true}.
+ * taken. Default is @p true.
*
* The flag has obviously no
* effect if
- * @p{write_cell_numbers} is
- * @p{false}.
+ * @p write_cell_numbers is
+ * @p false.
*/
bool write_cell_number_level;
* written onto the
* vertices. This is controled
* by the following
- * flag. Default is @p{false}.
+ * flag. Default is @p false.
*/
bool write_vertex_numbers;
* the different output functions based on a parameter given, e.g., through
* a parameter file, thus making user programs invariant of the number and
* names of the file formats implemented in this class. The main advantage of
- * this class over the @ref{DataOut} class is that it does not have to mess around
- * with actual data vectors and that no @ref{DoFHandler} object is needed to
+ * this class over the DataOut class is that it does not have to mess around
+ * with actual data vectors and that no DoFHandler object is needed to
* write the pure geometrical information involved here.
*
* Available output formats can be found in the functions with names @p{write_...}
*
* @sect3{Usage}
* Usage is simple: either you use the direct form
- * @begin{verbatim}
+ * @verbatim
* ofstream output_file("some_filename");
* GridOut().write_gnuplot (tria, output_file);
- * @end{verbatim}
+ * @endverbatim
* if you know which format you want to have, or if you want the format to be
* a runtime parameter, you can write
- * @begin{verbatim}
+ * @verbatim
* GridOut::OutputFormat grid_format =
* GridOut::parse_output_format(get_format_name_from_somewhere());
* ofstream output_file("some_filename" + GridOut::default_suffix(output_format));
* GridOut().write (tria, output_file, output_format);
- * @end{verbatim}
+ * @endverbatim
* The function @p{get_output_format_names()} provides a list of possible names of
- * output formats in a string that is understandable by the @ref{ParameterHandler} class.
+ * output formats in a string that is understandable by the ParameterHandler class.
*
- * Note that here, we have created an unnamed object of type @ref{GridOut} and called
+ * Note that here, we have created an unnamed object of type GridOut and called
* one of its @p{write_*} functions. This looks like as if the respective function
- * could really be made @p{static}. This was not done in order to allow for
+ * could really be made @p static. This was not done in order to allow for
* parameters to be passed to the different output functions in a way compatible
* with the scheme of allowing the right output format to be selected at run-time
- * through the generic @p{write} function.
+ * through the generic @p write function.
*
* In order to explain this, consider each function had one or more additional
* parameters giving the details of output, for example position of the spectator
* for 3d meshed, line thicknesses, etc. While this would allow each output
* function any flexibility it needs, it would not allow us to use the generic
- * function @p{write} which is given a parameter determining the output format,
+ * function @p write which is given a parameter determining the output format,
* since it is impractical to give it a list of parameters for each and every
* output format supported which it may then pass on to the respective output
* function.
*
* Rather, we have chosen to let each object of this class
- * @ref{GridOut} have a set of parameters for each supported output
- * format. These are collected in structures @ref{GridOutFlags::Eps},
- * @ref{GridOutFlags::Gnuplot}, etc declared in the @ref{GridOutFlags}
+ * GridOut have a set of parameters for each supported output
+ * format. These are collected in structures GridOutFlags::Eps(),
+ * GridOutFlags::Gnuplot(), etc declared in the GridOutFlags
* namespace, and you can set your preferred flags like this:
- * @begin{verbatim}
+ * @verbatim
* GridOut grid_out;
* GridOutFlags::Ucd ucd_flags;
* ... // set some fields in ucd_flags
* grid_out.set_flags (ucd_flags);
* ...
* ... // write some file with data_out
- * @end{verbatim}
+ * @endverbatim
* The respective output function then use the so-set flags. By default, they
* are set to reasonable values as described above and in the documentation
* of the different flags structures. Resetting the flags can
*
* The advantage of this approach is that it is possible to change the flags
* of one or more output formats according to your needs and later use the
- * generic @p{write} function; the actual output function then called will
+ * generic @p write function; the actual output function then called will
* use the flags as set before.
*
* Note that some of the structures describing the flags of the different
* output formats are empty since the respective format does not support
- * any flags. The structure and the @p{set_flags} function are provided
+ * any flags. The structure and the @p set_flags function are provided
* anyway. Note also that some of the structures may differ between the
* dimensions supported by this class; they then have a template parameter,
* as usual.
* this feature is the following:
* if you use the GNUPLOT
* command (for a 2d grid here)
- * @begin{verbatim}
+ * @verbatim
* splot [:][:][2.5:3.5] "grid_file.gnuplot" *
- * @end{verbatim}
+ * @endverbatim
* then the
* whole x- and y-range will be
* plotted, i.e. the whole grid,
* plots of the different levels
* of grid.
*
- * @p{mapping} is a pointer to a
+ * @p mapping is a pointer to a
* mapping used for the
* transformation of cells at the
* boundary. If zero, then use
* flags controlling the output
* can be found in the
* documentation of the
- * @ref{GridOutFlags::Gnuplot} class.
+ * GridOutFlags::Gnuplot() class.
*/
template <int dim>
void write_gnuplot (const Triangulation<dim> &tria,
* only, you can decide through
* additional flags (see below,
* and the documentation of the
- * @ref{GridOutFlags::Ucd} class)
+ * GridOutFlags::Ucd() class)
* whether boundary faces with
* non-zero boundary indicator
* shall be written to the file
* flags controlling the output
* can be found in the
* documentation of the
- * @ref{GridOut::Ucd} class.
+ * GridOut::Ucd() class.
*/
template <int dim>
void write_ucd (const Triangulation<dim> &tria,
* shall fit into is determined
* by the output flags (see
* below, and the documentation
- * of the @ref{GridOutFlags::Eps}
+ * of the GridOutFlags::Eps()
* class).
*
* The bounding box is close to
* of which the default is 300.
*
* The flag
- * @p{color_lines_on_user_flag}
+ * @p color_lines_on_user_flag
* allows to draw lines with the
- * @p{user_flag} set to be drawn in
+ * @p user_flag set to be drawn in
* red. The colors black and red
- * are defined as @p{b} and @p{r} in
+ * are defined as @p b and @p r in
* the preamble of the output
* file and can be changed there
* according to need.
*
- * @p{mapping} is a pointer to a
+ * @p mapping is a pointer to a
* mapping used for the
* transformation of cells at the
* boundary. If zero, then use
* flags controlling the output
* can be found in the
* documentation of the
- * @ref{GridOutFlags::Eps}
+ * GridOutFlags::Eps()
* class. Especially the
* viewpoint for three
* dimensional grids is of
std::ostream &out,
const Mapping<dim> *mapping=0);
/**
- * Write data and grid to @p{out} according
+ * Write data and grid to @p out according
* to the given data format. This function
* simply calls the appropriate
* @p{write_*} function.
* suffix with a given output format
* usually has. At present the following
* formats are defined:
- * @begin{itemize}
- * @item @p{OpenDX}: @p{.dx}
- * @item @p{gnuplot}: @p{.gnuplot}
- * @item @p{ucd}: @p{.inp}
- * @item @p{eps}: @p{.eps}.
- * @end{itemize}
+ * <ul>
+ * <li> @p OpenDX: @p{.dx}
+ * <li> @p gnuplot: @p{.gnuplot}
+ * <li> @p ucd: @p{.inp}
+ * <li> @p eps: @p{.eps}.
+ * </ul>
*
* Since this function does not need data
* from this object, it is static and can
static std::string default_suffix (const OutputFormat output_format);
/**
- * Return the @p{OutputFormat} value
+ * Return the @p OutputFormat value
* corresponding to the given string. If
* the string does not match any known
* format, an exception is thrown.
*
* To get a list of presently available
* format names, e.g. to give it to the
- * @ref{ParameterHandler} class, use the
+ * ParameterHandler class, use the
* function @p{get_output_format_names ()}.
*/
static OutputFormat parse_output_format (const std::string &format_name);
* Return a list of implemented output
* formats. The different names are
* separated by vertical bar signs (@p{`|'})
- * as used by the @ref{ParameterHandler}
+ * as used by the ParameterHandler
* classes.
*/
static std::string get_output_format_names ();
/**
* Flags for UCD output. Can be
* changed by using the
- * @p{set_flags} function.
+ * @p set_flags function.
*/
GridOutFlags::Ucd ucd_flags;
/**
* Flags to be used upon output of GNUPLOT
* data. Can be changed by using the
- * @p{set_flags} function.
+ * @p set_flags function.
*/
GridOutFlags::Gnuplot gnuplot_flags;
/**
* Flags to be used upon output of EPS
* data in one space dimension. Can be
- * changed by using the @p{set_flags}
+ * changed by using the @p set_flags
* function.
*/
GridOutFlags::Eps<1> eps_flags_1;
/**
* Flags to be used upon output of EPS
* data in two space dimensions. Can be
- * changed by using the @p{set_flags}
+ * changed by using the @p set_flags
* function.
*/
GridOutFlags::Eps<2> eps_flags_2;
/**
* Flags to be used upon output of EPS
* data in three space dimensions. Can be
- * changed by using the @p{set_flags}
+ * changed by using the @p set_flags
* function.
*/
GridOutFlags::Eps<3> eps_flags_3;
/**
* Write the grid information about
- * faces to @p{out}. Only those faces
+ * faces to @p out. Only those faces
* are printed which are on the boundary
* and which have a boundary indicator
* not equal to zero, since the latter
* is the default for boundary faces.
*
* Since cells and faces are continuously
- * numbered, the @p{starting_index} for
+ * numbered, the @p starting_index for
* the numbering of the faces is passed
* also.
*
* This function unfortunately can not
- * be included in the regular @p{write_ucd}
+ * be included in the regular @p write_ucd
* function, since it needs special
* treatment for the case @p{dim==1}, in
* which case the face iterators are
* list in one dimension.
*
* The reason for this function is the
- * same as for @p{write_ucd_faces}. See
+ * same as for @p write_ucd_faces. See
* there for more information.
*/
template <int dim>
* flags those cells for
* coarsening for which the criterion is less than the threshold.
*
- * There are two variations of these functions, which rely on @p{refine} and
- * @p{coarsen} by computing the thresholds from other information:
- * @begin{itemize}
- * @item @p{refine_and_coarsen_fixed_number}: this function takes a vector as
+ * There are two variations of these functions, which rely on @p refine and
+ * @p coarsen by computing the thresholds from other information:
+ * <ul>
+ * <li> @p refine_and_coarsen_fixed_number: this function takes a vector as
* above and two values between zero and one denoting the fractions of cells to
* be refined and coarsened. For this purpose, it sorts the criteria per cell
* and takes the threshold to be the one belonging to the cell with the
* the fraction is $0.3$, the threshold is computed to a value such that
* 30 per cent of cells have a criterion higher than the threshold and are
* thus flagged for refinement. The flagging for refinement is done through
- * the central @p{refine} function. For coarsening, the same holds.
+ * the central @p refine function. For coarsening, the same holds.
*
* The sorting of criteria is not done actually, since we only need one
* value, in the example above the criterion of the cell which is at
* 30 per cent in the sorted list of cells. The order of cells with higher
* and of those with lower criteria is irrelevant. Getting this value is
- * accomplished by the @p{nth_element} function of the @p{C++} standard
+ * accomplished by the @p nth_element function of the @p{C++} standard
* library, which takes only linear time in the number of elements, rather
* than @p{N log N} for sorting all values.
*
* want to chose a smaller value to avoid overrefinement in regions which
* do not contribute much to the error.
*
- * @item @p{refine_and_coarsen_fixed_fraction}: this function computes the
+ * <li> @p refine_and_coarsen_fixed_fraction: this function computes the
* threshold such that the number of cells getting flagged for refinement
* makes up for a certain fraction of the total error. If this fraction is 50
* per cent, for example, the threshold is computed such that the cells with
* From the point of view of implementation, this time we really need to
* sort the array of criteria.
* Just like the other strategy described above, this function only
- * computes the threshold values and then passes over to @p{refine} and
- * @p{coarsen}.
+ * computes the threshold values and then passes over to @p refine and
+ * @p coarsen.
*
* A typical value for the fraction of the total error is 0.5.
- * @end{itemize}
+ * </ul>
*
* There are other functions relying on different methods to flag
* cells for refinement or coarsening. See their documentation for
* Refine the triangulation
* according to the given
* criteria. The criterion is a
- * @p{double} value for each cell
+ * @p double value for each cell
* which determines which cells
* are to be refined by
* comparison with the threshold:
* guarantee that the threshold
* value is in a resonable
* range. Please note that the
- * @p{criteria} array may contain
+ * @p criteria array may contain
* negative values (sometimes,
* error estimators are evaluated
* in a way which produces
* positive and negative values),
* but the comparison with
- * @p{threshold} is done only on
+ * @p threshold is done only on
* the absolute values of the
* criteria.
*
* refinement, they are not
* actually refined. To do so,
* you have to call the
- * @p{execute_coarsening_and_refinement}
+ * @p execute_coarsening_and_refinement
* function.
*
* There are more sophisticated
const double threshold);
/**
- * Analogue to the @p{refine}
+ * Analogue to the @p refine
* function: flag all cells for
* coarsening for which the
* absolute value of the
/**
* Refine the triangulation by
* refining a certain fraction
- * @p{top_fraction_of_cells} with
+ * @p top_fraction_of_cells with
* the highest error. Likewise
* coarsen the fraction
- * @p{bottom_fraction_of_cells}
+ * @p bottom_fraction_of_cells
* with the least error. To
* actually perform the
* refinement, call
- * @p{execute_coarsening_and_refinement}.
+ * @p execute_coarsening_and_refinement.
*
- * @p{fraction_of_cells} shall be
+ * @p fraction_of_cells shall be
* a value between zero and one.
*
* Refer to the general doc of
* Refine the triangulation by
* flagging those cells which
* make up a certain
- * @p{top_fraction} of the total
+ * @p top_fraction of the total
* error. Likewise, coarsen all
* cells which make up only
- * @p{bottom_fraction}. To
+ * @p bottom_fraction. To
* actually perform the
* refinement, call
- * @p{execute_coarsening_and_refinement}.
+ * @p execute_coarsening_and_refinement.
*
* @p{*_fraction} shall be a
* values between zero and one.
private:
/**
- * Sorts the vector @p{ind} as an
- * index vector of @p{a} in
+ * Sorts the vector @p ind as an
+ * index vector of @p a in
* increasing order. This
* implementation of quicksort
* seems to be faster than the
* STL version and is needed in
- * @p{refine_and_coarsen_optimize}
+ * @p refine_and_coarsen_optimize
*/
template <class Vector>
static void qsort_index (const Vector &a,
/**
* This class reorders the vertices of cells such that they meet the
- * requirements of the @ref{Triangulation} class when creating
+ * requirements of the Triangulation class when creating
* grids. This class is mainly used when reading in grids from files
* and converting them to deal.II triangulations.
*
*
* For example, in two dimensions, a quad consists of four lines which
* have a direction, which is by definition as follows:
- * @begin{verbatim}
+ * @verbatim
* 3-->--2
* | |
* ^ ^
* | |
* 0-->--1
- * @end{verbatim}
+ * @endverbatim
* Now, two adjacent cells must have a vertex numbering such that the direction
* of the common side is the same. For example, the following two quads
- * @begin{verbatim}
+ * @verbatim
* 3---4---5
* | | |
* 0---1---2
- * @end{verbatim}
+ * @endverbatim
* may be characterised by the vertex numbers @p{(0 1 4 3)} and
* @p{(1 2 5 4)}, since the middle line would get the direction @p{1->4}
* when viewed from both cells. The numbering @p{(0 1 4 3)} and
* it is not possible to orient them such that they represent a
* (counter-)clockwise sense, since then we couldn't already find a
* valid orientation of the following patch of three cells:
- * @begin{verbatim}
+ * @verbatim
* o
* / \
* o o
* | o |
* | | |
* o---o---o
- * @end{verbatim}
+ * @endverbatim
* (The reader is asked to try to find a conforming choice of line
* directions; it will soon be obvious that there can't exists such a
* thing, even if we allow that there might be cells with clockwise
* the requirements stated above. To this end, we will first show some
* examples why this is a difficult problem, and then develop
* algorithms that finds such a reordering. Note that the algorithm
- * operates on a set of @ref{CellData} objects that are used to
+ * operates on a set of CellData objects that are used to
* describe a mesh to the triangulation class. These objects are, for
- * example, generated by the @ref{GridIn} class, when reading in grids
+ * example, generated by the GridIn class, when reading in grids
* from input files.
*
* As a last question for this first section: is it guaranteed that
* following picture we only show one such column of three cells at
* the left, but we will indicate what happens if we prolong this
* list):
- * @begin{verbatim}
+ * @verbatim
* 9---10-----11
* | | / |
* 6---7---8 |
* 3---4---5 |
* | | \ |
* 0---1------2
- * @end{verbatim}
+ * @endverbatim
* Assume that you had numbered the vertices in the cells at the left boundary
* in a way, that the following line directions are induced:
- * @begin{verbatim}
+ * @verbatim
* 9->-10-----11
* ^ ^ / |
* 6->-7---8 |
* 3->-4---5 |
* ^ ^ \ |
* 0->-1------2
- * @end{verbatim}
+ * @endverbatim
* (This could for example be done by using the indices @p{(0 1 4 3)}, @p{(3 4 7 6)},
* @p{(6 7 10 9)} for the three cells). Now, you will not find a way of giving
* indices for the right cells, without introducing either ambiguity for
* The solution in this case is to renumber one of the three left cells, e.g.
* by reverting the sense of the line between vertices 7 and 10 by numbering
* the top left cell by @p{(9 6 7 10)}:
- * @begin{verbatim}
+ * @verbatim
* 9->-10-----11
* v v / |
* 6->-7---8 |
* 3->-4---5 |
* ^ ^ \ |
* 0->-1------2
- * @end{verbatim}
+ * @endverbatim
*
* The point here is the following: assume we wanted to prolong the grid to
* the left like this:
- * @begin{verbatim}
+ * @verbatim
* o---o---o---o---o------o
* | | | | | / |
* o---o---o---o---o---o |
* o---o---o---o---o---o |
* | | | | | \ |
* o---o---o---o---o------o
- * @end{verbatim}
+ * @endverbatim
* Then we run into the same problem as above if we order the cells at
* the left uniformly, thus forcing us to revert the ordering of one
* cell (the one which we could order as @p{(9 6 7 10)}
*
* As a second example, consider the following simple grid, where the
* order in which the cells are numbered is important:
- * @begin{verbatim}
+ * @verbatim
* 3-----2-----o-----o ... o-----7-----6
* | | | | | | |
* | 0 | N | N-1 | ... | 2 | 1 |
* | | | | | | |
* 0-----1-----o-----o ... o-----4-----5
- * @end{verbatim}
+ * @endverbatim
* We have here only indicated the numbers of the vertices that are
* relevant. Assume that the user had given the cells 0 and 1 by the
* vertex indices @p{0 1 2 3} and @p{6 7 4 5}. Then, if we follow this
* orientation, the grid after creating the lines for these two cells
* would look like this:
- * @begin{verbatim}
+ * @verbatim
* 3-->--2-----o-----o ... o-----7--<--6
* | | | | | | |
* ^ 0 ^ N | N-1 | ... | 2 v 1 v
* | | | | | | |
* 0-->--1-----o-----o ... o-----4--<--5
- * @end{verbatim}
+ * @endverbatim
* Now, since opposite lines must point in the same direction, we can
* only add the cells 2 through N-1 to cells 1 such that all vertical
* lines point down. Then, however, we cannot add cell N in any
*
* In more detail, the algorithm is best illustrated using an
* example. We consider the mesh below:
- * @begin{verbatim}
+ * @verbatim
* 9------10-------11
* | | /|
* | | / |
* | | \ |
* | | \|
* 0------1---------2
- * @end{verbatim}
+ * @endverbatim
* First a cell is chosen ( (0,1,4,3) in this case). A single side of the cell
* is oriented arbitrarily (3->4). This choice of orientation is then propogated
* through the mesh, across sides and elements. (0->1), (6->7) and (9->10).
* The involves edge-hopping and face hopping, giving a path through the mesh
* shown in dots.
- * @begin{verbatim}
+ * @verbatim
* 9-->--10-------11
* | . | /|
* | . | / |
* | X | \ |
* | . | \|
* 0-->--1---------2
- * @end{verbatim}
+ * @endverbatim
* This is then repeated for the other sides of the chosen element, orienting
* more sides of the mesh.
- * @begin{verbatim}
+ * @verbatim
* 9-->--10-------11
* | | /|
* v.....v.......V |
* ^..X..^.......^ |
* | | \|
* 0-->--1---------2
- * @end{verbatim}
+ * @endverbatim
* Once an element has been completely oriented it need not be considered
* further. These elements are filled with o's in the diagrams. We then move
* to the next element.
- * @begin{verbatim}
+ * @verbatim
* 9-->--10->-----11
* | ooo | . /|
* v ooo v . V |
* ^ ooo ^ X ^ |
* | ooo | . \|
* 0-->--1-->------2
- * @end{verbatim}
+ * @endverbatim
* Repeating this gives
- * @begin{verbatim}
+ * @verbatim
* 9-->--10->-----11
* | ooo | oooooo /|
* v ooo v ooooo V |
* ^ ooo ^ ooooo ^ |
* | ooo | oooooo \|
* 0-->--1-->------2
- * @end{verbatim}
+ * @endverbatim
* and the final oriented mesh is
- * @begin{verbatim}
+ * @verbatim
* 9-->--10->-----11
* | | /|
* v v V |
* ^ ^ ^ |
* | | \|
* 0-->--1-->-------2
- * @end{verbatim}
+ * @endverbatim
* It is obvious that this algorithm has linear run-time, since it
* only ever touches each face exactly once.
*
* in the initial algorithm; note also that the example is in 2d where
* we now have the much better algorithm described above, but the same
* observations also apply to 3d):
- * @begin{verbatim}
+ * @verbatim
* 13----------14----15
* | \ | |
* | \ 4 | 5 |
* | 2 | 1 | 0 |
* | | | |
* 0-----1-----2-----3
- * @end{verbatim}
+ * @endverbatim
* Note that there is a hole in the middle. Assume now that the user
* described the first cell 0 by the vertex numbers @p{2 3 7 6}, and
* cell 5 by @p{15 14 10 11}, and assume that cells 1, 2, 3, and 4 are
* cells, the algorithm will start with cell zero and add one cell
* after the other, up until the sixth one. Then the situation will be
* the following:
- * @begin{verbatim}
+ * @verbatim
* 13----->---14--<--15
* | \ | |
* | > 4 v 5 v
* ^ 2 ^ 1 ^ 0 ^
* | | | |
* 0-->--1-->--2-->--3
- * @end{verbatim}
+ * @endverbatim
* Coming now to cell 7, we see that the two opposite lines at its top
* and bottom have different directions; we will therefore find no
* orientation of cell 7 in which it can be added without violation of
* 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
- * @ref{Triangulation}@p{<dim>::create_triangulation} function.
+ * Triangulation@p{<dim>::create_triangulation} function.
*
* @author Wolfgang Bangerth, 2000, Michael Anderson 2003
*/
* already exists in a list of
* edges, and if it already
* exists in reverse order, then
- * return @p{false}. If it is not
+ * return @p false. If it is not
* already in the list, or in the
* correct direction, then go on
* with the next faces or cell.
* edges come into each node and what the default deal.II directions
* are for the quad.
*
- * @begin{verbatim}
+ * @verbatim
* s2
*
* +-->--+
* +-->--+
*
* s0
- * @end{verbatim}
+ * @endverbatim
*
* @author Michael Anderson, 2003
*/
unsigned int side[4];
/**
- * Copy of the @p{CellData} object
+ * Copy of the @p CellData object
* from which we construct the
* data of this object.
*/
/**
* Implement the 2d algorithm for grid reordering described in the
- * documentation of the @ref{GridReordering} class.
+ * documentation of the GridReordering class.
*
* @author Michael Anderson, 2003
*/
* Export the data of this
* object to the deal.II
* format that the
- * @ref{Triangulation} class
+ * Triangulation class
* wants as input.
*/
void
* private, the only entry
* point of this class is the
* static function
- * @ref{orient_mesh}.
+ * orient_mesh().
*/
Orienter (const std::vector<CellData<3> > &incubes);
/**
* Return whether the cell
* with cell number
- * @p{cell_num} is fully
+ * @p cell_num is fully
* oriented.
*/
bool is_oriented (const unsigned int cell_num) const;
* Shift each vertex of the
* triangulation by the given
* shift vector. This function
- * uses the @ref{transform}
+ * uses the transform()
* function above, so the
* requirements on the
* triangulation stated there
* system by the given angle
* (given in radians, rather than
* degrees). This function uses
- * the @ref{transform} function
+ * the transform() function
* above, so the requirements on
* the triangulation stated there
* hold for this function as
* must be positive.
*
* This function uses the
- * @ref{transform} function
+ * transform() function
* above, so the requirements on
* the triangulation stated there
* hold for this function as
/**
* Find and return an iterator to
* the active cell that surrounds
- * a given point @p{ref}. The
+ * a given point @p ref. The
* type of the first parameter
* may be either
- * @ref{Triangulation},
- * @ref{DoFHandler}, or
- * @ref{MGDoFHandler}, i.e. we
+ * Triangulation,
+ * DoFHandler, or
+ * MGDoFHandler, i.e. we
* can find the cell around a
* point for iterators into each
* of these classes.
* then recursively checking its
* sibling cells. The complexity
* is thus @p{O(M+log N)} where
- * @p{M} is the number of coarse
- * grid cells, and @p{N} the
+ * @p M is the number of coarse
+ * grid cells, and @p N the
* total number of cells.
*
* There are cases where this
* calling this function, the subdomain
* ids of all active cells will have
* values between zero and
- * @p{n_partitions-1}. You can access the
+ * @p n_partitions-1. You can access the
* subdomain id of a cell by using
* @p{cell->subdomain_id()}.
*
* This function will generate an error
* if METIS is not installed unless
- * @p{n_partitions} is one. I.e., you can
+ * @p n_partitions is one. I.e., you can
* write a program so that it runs in the
* single-processor single-partition case
* without METIS installed, and only
*
* Usually, the two grids will be refined differently. Then, the value
* returned for an iterator on the source grid will be either:
- * @begin{itemize}
- * @item The same cell on the destination grid, if it exists there;
- * @item The most refined cell of the destination grid from which the
+ * <ul>
+ * <li> The same cell on the destination grid, if it exists there;
+ * <li> The most refined cell of the destination grid from which the
* pendant of the source cell could be obtained by refinement. This
* cell is always active and has a refinement level less than that
* of the source cell.
- * @end{itemize}
+ * </ul>
* Keys for this map are all cells on the source grid, whether active or
* not.
*
* For example, consider these two one-dimensional grids:
- * @begin{verbatim}
+ * @verbatim
* Grid 1:
* x--x--x-----x-----------x
* 1 2 3 4
* Grid 2:
* x-----x-----x-----x-----x
* 1 2 3 4
- * @end{verbatim}
+ * @endverbatim
* (Cell numbers are only given as an example and will not correspond
* to real cell iterator's indices.) The mapping from grid 1 to grid 2
* will then be as follows:
- * @begin{verbatim}
+ * @verbatim
* Cell on grid 1 Cell on grid 2
* 1 ------------------> 1
* 2 ------------------> 1
* 3 ------------------> 2
* 4 ------------------> mother cell of cells 3 and 4
* (a non-active cell, not shown here)
- * @end{verbatim}
+ * @endverbatim
* Besides the mappings shown here, the non-active cells on grid 1 are also
* valid keys. For example, the mapping for the mother cell of cells 1 and 2
* on the first grid will point to cell 1 on the second grid.
*
* The implementation of this class is such that not only cell iterators
* into triangulations can be mapped, but also iterators into objects of
- * type @ref{DoFHandler} and @ref{MGDoFHandler}. The extension to other classes
+ * type DoFHandler and MGDoFHandler. The extension to other classes
* offering iterator functions and some minor additional requirements is
* simple.
*
* @sect2{Usage}
*
* In practice, use of this class is as follows:
- * @begin{verbatim}
+ * @verbatim
* // have two grids, which are derived from the
* // same coarse grid
* Triangulation<dim> tria1, tria2;
* endc = dof_handler_1.end();
* for (; cell!=endc; ++cell)
* // now do something with the cell of dof_handler_2
- * // corresponding to @p{cell} (which is one of
+ * // corresponding to @p cell (which is one of
* // dof_handler_1
* f( grid_1_to_2_map[cell]);
- * @end{verbatim}
+ * @endverbatim
*
* Note that the template parameters to this class have to be given as
* @p{InterGridMap<DoFHandler,2>}, i.e. the dimension is given explicitly and
* no dimension is attributed to the first parameter, which here is
- * @ref{DoFHandler} (and could equally well be @ref{Triangulation} or @ref{MGDoFHandler}).
+ * DoFHandler (and could equally well be Triangulation or MGDoFHandler).
*
* @author Wolfgang Bangerth, 1999
*/
const cell_iterator &dst_cell);
/**
- * Set the value of the key @p{src_cell}
- * to @p{dst_cell}. Do so as well for
+ * Set the value of the key @p src_cell
+ * to @p dst_cell. Do so as well for
* all the children and their children
- * of @p{src_cell}. This function is
+ * of @p src_cell. This function is
* used for cells which are more
- * refined on @p{src_grid} than on
- * @p{dst_grid}; then all values of
+ * refined on @p src_grid than on
+ * @p dst_grid; then all values of
* the hierarchy of cells and their
* children point to one cell on the
- * @p{dst_grid}.
+ * @p dst_grid.
*/
void set_entries_to_cell (const cell_iterator &src_cell,
const cell_iterator &dst_cell);
* of cell numbers to the geometrical cells.
*
* Basically, this is a drop-in replacement for the triangulation. Since it
- * is derived from the @ref{Triangulation} class, it shares all the
+ * is derived from the Triangulation class, it shares all the
* functionality, but it overrides some virtual functions and adds some
* functions, too. The main change to the base class is that it overrides
- * the @p{execute_coarsening_and_refinement} function, where the new version
+ * the @p execute_coarsening_and_refinement function, where the new version
* first stores all refinement and coarsening flags and only then calls the
* respective function of the base class. The stored flags may later be
* used to restore the grid just as it was before. Some other functions
*
* We note that since the triangulation is created in exactly the same state
* as it was before, other objects working on it should result in the same
- * state as well. This holds in particular for the @ref{DoFHandler} object, which
+ * state as well. This holds in particular for the DoFHandler object, which
* will assign the same degrees of freedom to the original cells and the ones
* after reconstruction of the triangulation. You can therefore safely use data
* vectors computed on the original grid on the reconstructed grid as well.
*
* @sect3{Usage}
* You can use objects of this class almost in the same way as objects of the
- * @ref{Triangulation} class. One of the few differences is that you can only
+ * Triangulation class. One of the few differences is that you can only
* construct such an object by giving a coarse grid to the constructor. The
* coarse grid will be used to base the triangulation on, and therefore the
* lifetime of the coarse grid has to be longer than the lifetime of the
* object of this class.
*
* Basically, usage looks like this:
- * @begin{verbatim}
+ * @verbatim
* Triangulation<dim> coarse_grid;
* ... // initialize coarse grid
*
* // is not needed anymore, e.g.
* // working with another grid
* };
- * @end{verbatim}
+ * @endverbatim
*
- * Note that initially, the @ref{PersistentTriangulation} object does not
- * 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.
- * @ref{Triangulation}@p{<dim>::clear ()} resets the underlying triangulation to a
+ * Note that initially, the PersistentTriangulation object does not
+ * 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@p{<dim>::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 @p{restore()}.
* flags, etc from that grid as well.
* Note that the initial state of the
* triangulation is empty, until
- * @p{restore_grid} is called for the
+ * @p restore_grid is called for the
* first time.
*
* The coarse grid must persist until
/**
* Differential restore. Performs
- * the @p{step_no}th local
+ * the @p step_noth local
* refinement and coarsening step.
* Step 0 stands for the copying
* of the coarse grid.
* Returns the number of
* refinement and coarsening
* steps. This is given by the
- * size of the @p{refine_flags}
+ * size of the @p refine_flags
* vector.
*/
unsigned int n_refinement_steps () const;
/**
* Overload this function to use
- * @p{tria} as a new coarse grid. The
+ * @p tria as a new coarse grid. The
* present triangulation and all
* refinement and coarsening flags
* storing its history are deleted,
* and the state of the underlying
* triangulation is reset to be
- * empty, until @p{restore_grid} is
+ * empty, until @p restore_grid is
* called the next time.
*
* The coarse grid must persist until
/**
* Writes all refine and coarsen
- * flags to the ostream @p{out}.
+ * flags to the ostream @p out.
*/
virtual void write_flags(std::ostream &out) const;
/**
* Structure which is passed to the
- * @ref{Triangulation}@p{<dim>::create_triangulation} function. It
+ * Triangulation@p{<dim>::create_triangulation} function. It
* contains all data needed to construct a cell, namely the indices
* of the vertices and the material indicator.
*/
/**
- * Structure to be passed to the @ref{Triangulation}@p{<dim>::create_triangulation}
+ * Structure to be passed to the Triangulation@p{<dim>::create_triangulation}
* function to describe boundary information.
*
* This structure is the same for all dimensions, since we use an input
* dimension are really empty. I.e.,
* whether the @p{boundary_*} arrays are
* empty when in one space dimension
- * and whether the @p{boundary_quads}
+ * and whether the @p boundary_quads
* array is empty when in two dimensions.
*
* Since this structure is the same for all
* This class implements some types which differ between the dimensions.
* These are the declararions for the 1D case only.
*
- * A @p{line_iterator} is typdef'd to an iterator operating on the
- * @p{lines} member variable of a @p{Triangulation<1>} object. An
- * @p{active_line_iterator} only operates on the active lines.
- * @p{raw_line_iterator} objects operate on all lines, used or not.
+ * A @p line_iterator is typdef'd to an iterator operating on the
+ * @p lines member variable of a @p{Triangulation<1>} object. An
+ * @p active_line_iterator only operates on the active lines.
+ * @p raw_line_iterator objects operate on all lines, used or not.
*
* Since we are in one dimension, the following identities are declared:
- * @begin{verbatim}
+ * @verbatim
* typedef raw_line_iterator raw_cell_iterator;
* typedef line_iterator cell_iterator;
* typedef active_line_iterator active_cell_iterator;
- * @end{verbatim}
+ * @endverbatim
*
- * To enable the declaration of @p{begin_quad} and the like in
- * @p{Triangulation<1>}, the @p{quad_iterator}s are declared as
+ * To enable the declaration of @p begin_quad and the like in
+ * @p{Triangulation<1>}, the @p quad_iterators are declared as
* @p{void *}. Thus these types exist, but are useless and will
* certainly make any involuntary use visible. The same holds
* for hexahedron iterators.
*
- * The same applies for the @p{face_iterator} types, since lines
+ * The same applies for the @p face_iterator types, since lines
* have no substructures apart from vertices, which are handled in
* a different way, however.
*
* This class implements some types which differ between the dimensions.
* These are the declararions for the 2D case only.
*
- * A @p{line_iterator} is typdef'd to an iterator operating on the
- * @p{lines} member variable of a @p{Triangulation<2>} object. An
- * @p{active_line_iterator} only operates on the active lines.
- * @p{raw_line_iterator} objects operate on all lines, used or not.
- * Using @p{active_line_iterator}s may not be particularly in 2D useful since it
+ * A @p line_iterator is typdef'd to an iterator operating on the
+ * @p lines member variable of a @p{Triangulation<2>} object. An
+ * @p active_line_iterator only operates on the active lines.
+ * @p raw_line_iterator objects operate on all lines, used or not.
+ * Using @p active_line_iterators may not be particularly in 2D useful since it
* only operates on unrefined lines. However, also refined lines may bound
* unrefined cells if the neighboring cell is refined once more than the
* present one.
*
- * Similarly to line iterators, @p{quad_iterator}, @p{raw_quad_iterator} and
- * @p{active_quad_iterator} are declared.
+ * Similarly to line iterators, @p quad_iterator, @p raw_quad_iterator and
+ * @p active_quad_iterator are declared.
*
- * To enable the declaration of @p{begin_hex} and the like in
- * @p{Triangulation<[12]>}, the @p{hex_iterator}s are declared as
+ * To enable the declaration of @p begin_hex and the like in
+ * @p{Triangulation<[12]>}, the @p hex_iterators are declared as
* @p{void *}. Thus these types exist, but are useless and will
* certainly make any involuntary use visible.
*
* Since we are in two dimension, the following identities are declared:
- * @begin{verbatim}
+ * @verbatim
* typedef raw_quad_iterator raw_cell_iterator;
* typedef quad_iterator cell_iterator;
* typedef active_quad_iterator active_cell_iterator;
* typedef raw_line_iterator raw_face_iterator;
* typedef line_iterator face_iterator;
* typedef active_line_iterator active_face_iterator;
- * @end{verbatim}
+ * @endverbatim
*
* @author Wolfgang Bangerth, 1998
*/
* For the declarations of the data types, more or less the same holds
* as for lower dimensions (see @p{TriaDimensionInfo<[12]>}). The
* dimension specific data types are here, since we are in three dimensions:
- * @begin{verbatim}
+ * @verbatim
* typedef raw_hex_iterator raw_cell_iterator;
* typedef hex_iterator cell_iterator;
* typedef active_hex_iterator active_cell_iterator;
* typedef raw_quad_iterator raw_face_iterator;
* typedef quad_iterator face_iterator;
* typedef active_quad_iterator active_face_iterator;
- * @end{verbatim}
+ * @endverbatim
*
* @author Wolfgang Bangerth, 1998
*/
/**
- * @ref{Triangulation}s denote a hierarchy of levels of elements which together
- * form a region in @p{dim} spatial dimensions.
+ * Triangulations denote a hierarchy of levels of elements which together
+ * form a region in @p dim spatial dimensions.
*
* This class is written to be as independent of the dimension as possible
- * (thus the complex construction of the @ref{TriangulationLevel} classes) to
+ * (thus the complex construction of the TriangulationLevel classes) to
* allow code-sharing, to allow reducing the need to mirror changes in the code
* for one dimension to the code for other dimensions. Nonetheless, some of
* the functions are dependent of the dimension and there only exist
*
* @sect3{Structure and iterators}
*
- * The actual data structure of a @ref{Triangulation} object is rather complex
+ * The actual data structure of a Triangulation object is rather complex
* and quite inconvenient if one attempted to operate on it directly, since
* data is spread over quite a lot of arrays and other places. However,
* there are ways powerful enough to work on these data structures
* without knowing their exact relations. This is done through the
- * concept of iterators (see the STL documentation and @ref{TriaRawIterator}).
+ * concept of iterators (see the STL documentation and TriaRawIterator).
* In order to make things as easy and dimension independent as possible,
* use of class local typedefs is made, see below.
*
- * In the base class @ref{TriaDimensionInfo}, a @p{Cell} is typedef'd to be whatever
- * is reasonable for a cell in the respective dimension, i.e. a @p{Line} in
- * one dimension, a @p{Quad} in two dimensions, and so on.
+ * In the base class TriaDimensionInfo, a @p Cell is typedef'd to be whatever
+ * is reasonable for a cell in the respective dimension, i.e. a @p Line in
+ * one dimension, a @p Quad in two dimensions, and so on.
*
- * The @ref{Triangulation} class provides iterator which enable looping over all
+ * The Triangulation class provides iterator which enable looping over all
* lines, cells,
* etc without knowing the exact representation used to describe them. Their
- * names are typedefs in the @ref{TriaDimensionInfo} base class (thus making them
+ * names are typedefs in the TriaDimensionInfo base class (thus making them
* local types to this class) and are as follows:
*
- * @begin{itemize}
- * @item @p{raw_line_iterator}: loop over all lines, used or not (declared for
+ * <ul>
+ * <li> @p raw_line_iterator: loop over all lines, used or not (declared for
* all dimensions).
*
- * @item @p{line_iterator}: loop over all used lines (declared for all dimensions).
+ * <li> @p line_iterator: loop over all used lines (declared for all dimensions).
*
- * @item @p{active_line_iterator}: loop over all active lines (declared for all
+ * <li> @p active_line_iterator: loop over all active lines (declared for all
* dimensions).
*
- * @item @p{raw_quad_iterator}: loop over all quads, used or not (declared only
+ * <li> @p raw_quad_iterator: loop over all quads, used or not (declared only
* for @p{dim>=2}).
*
- * @item @p{quad_iterator}: loop over all quads (declared only for @p{dim}>=2).
+ * <li> @p quad_iterator: loop over all quads (declared only for @p dim>=2).
*
- * @item @p{active_quad_iterator}: loop over all active quads (declared only for
- * @p{dim}>=2).
- * @end{itemize}
+ * <li> @p active_quad_iterator: loop over all active quads (declared only for
+ * @p dim>=2).
+ * </ul>
*
- * Additionaly, for @p{dim}==1, the following identities hold:
- * @begin{verbatim}
+ * Additionaly, for @p dim==1, the following identities hold:
+ * @verbatim
* typedef raw_line_iterator raw_cell_iterator;
* typedef line_iterator cell_iterator;
* typedef active_line_iterator active_cell_iterator;
- * @end{verbatim}
- * while for @p{dim}==2
- * @begin{verbatim}
+ * @endverbatim
+ * while for @p dim==2
+ * @verbatim
* typedef quad_line_iterator raw_cell_iterator;
* typedef quad_iterator cell_iterator;
* typedef active_quad_iterator active_cell_iterator;
* typedef raw_line_iterator raw_face_iterator;
* typedef line_iterator face_iterator;
* typedef active_line_iterator active_face_iterator;
- * @end{verbatim}
+ * @endverbatim
*
* By using the cell iterators, you can write code nearly independent of
* the spatial dimension. The same applies for substructure iterators,
* cell is be a vertex in 1D and a line in 2D; however, vertices are
* handled in a different way and therefore lines have no faces.
*
- * The @ref{Triangulation} class offers functions like @p{begin_active} which gives
+ * The Triangulation class offers functions like @p begin_active which gives
* you an iterator to the first active cell. There are quite a lot of functions
* returning iterators. Take a look at the class doc to get an overview.
*
* 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</em>
- * @begin{verbatim}
+ * examples taken from the Triangulation source code follow.
+ * <ul>
+ * <li> <em>Counting the number of cells on a specific level</em>
+ * @verbatim
* template <int dim>
* int Triangulation<dim>::n_cells (const int level) const {
* cell_iterator cell = begin (level),
* ++n;
* return n;
* };
- * @end{verbatim}
- * Another way which uses the STL @p{distance} function would be to write
- * @begin{verbatim}
+ * @endverbatim
+ * Another way which uses the STL @p distance function would be to write
+ * @verbatim
* template <int dim>
* int Triangulation<dim>::n_cells (const int level) const {
* int n=0;
* n);
* return n;
* };
- * @end{verbatim}
+ * @endverbatim
*
- * @item <em>Refining all cells of a triangulation</em>
- * @begin{verbatim}
+ * <li> <em>Refining all cells of a triangulation</em>
+ * @verbatim
* template <int dim>
* void Triangulation<dim>::refine_global () {
* active_cell_iterator cell = begin_active(),
* cell->set_refine_flag ();
* execute_coarsening_and_refinement ();
* };
- * @end{verbatim}
- * @end{itemize}
+ * @endverbatim
+ * </ul>
*
*
* @sect3{Usage}
*
- * Usage of a @ref{Triangulation} is mainly done through the use of iterators.
+ * Usage of a Triangulation is mainly done through the use of iterators.
* An example probably shows best how to use it:
- * @begin{verbatim}
+ * @verbatim
* void main () {
* Triangulation<2> tria;
*
* ofstream out("grid.1");
* GridOut::write_gnuplot (tria, out);
* };
- * @end{verbatim}
+ * @endverbatim
*
*
* @sect3{Creating a triangulation}
*
* There are several possibilities to create a triangulation:
- * @begin{itemize}
- * @item The most common domains, such as hypercubes (i.e. lines, squares,
+ * <ul>
+ * <li> The most common domains, such as hypercubes (i.e. lines, squares,
* cubes, etc), hyper-balls (circles, balls, ...) and some other, more
* weird domains such as the L-shape region and higher dimensional
- * generalizations and others, are provided by the @ref{GridGenerator}
+ * generalizations and others, are provided by the GridGenerator
* class which takes a triangulation and fills it by a division
* of the required domain.
*
- * @item Reading in a triangulation: By using an object of the @ref{GridIn}
+ * <li> Reading in a triangulation: By using an object of the GridIn
* class, you can read in fairly general triangulations. See there for
* more information. The mentioned class uses the interface described
* directly below to transfer the data into the triangulation.
*
- * @item Explicitely creating a triangulation: you can create a triangulation
+ * <li> Explicitely creating a triangulation: you can create a triangulation
* 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
- * @ref{GridIn}@p{<dim>::read_*} functions. The appropriate function to be
+ * GridIn@p{<dim>::read_*} functions. The appropriate function to be
* called is @p{Triangulation<dim>::create_triangulation ()}.
*
* Creating the hierarchical information needed for this
* the data read from an UCD or any other input file, but also
* for the data passed to the
* @p{Triangulation<dim>::create_triangulation ()}
- * function. See the documentation for the @ref{GridIn} class
+ * function. See the documentation for the GridIn class
* for more details on this, and above all to the
- * @ref{GridReordering} class that explains many of the
+ * GridReordering class that explains many of the
* problems and an algorithm to reorder cells such that they
* satisfy the conditions outlined above.
*
- * @item Copying a triangulation: when computing on time dependent meshes
+ * <li> Copying a triangulation: when computing on time dependent meshes
* of when using adaptive refinement, you will often want to create a
* new triangulation to be the same as another one. This is facilitated
- * by the @p{copy_triangulation} function.
+ * by the @p copy_triangulation function.
*
* It is guaranteed that vertex, line or cell numbers in the two
* triangulations are the same and that two iterators walking on the
* operation but guaranteeing some parallelity in the two triangulations
* seems more important since usually data will have to be transferred
* between the grids.
- * @end{itemize}
+ * </ul>
*
* The material id for each cell must be specified upon construction of
* a triangulation. (There is a special section on material identifier and
* @sect3{Refinement and coarsening of a triangulation}
*
* Refinement of a triangulation may be done through several ways. The most
- * low-level way is directly through iterators: let @p{i} be an iterator to
+ * low-level way is directly through iterators: let @p i be an iterator to
* an active cell (i.e. the cell pointed to has no children), then the
* function call @p{i->set_refine_flag()} marks the respective cell for
* refinement. Marking non-active cells results in an error.
*
* After all the cells you wanted to mark for refinement, call the
- * @p{execute_coarsening_and_refinement} function to actually perform
+ * @p execute_coarsening_and_refinement function to actually perform
* the refinement. This function itself first calls the
- * @p{prepare_coarsening_and_refinement} function to regularize the resulting
+ * @p prepare_coarsening_and_refinement function to regularize the resulting
* triangulation: since a face between two adjacent cells may only
* be subdivided once (i.e. the levels of two adjacent cells may
* differ by one at most; it is not possible to have a cell refined
* step than one needed by the finite element method.
*
* To coarsen a grid, the same way as above is possible by using
- * @p{i->set_coarsen_flag} and calling @p{execute_coarsening_and_refinement}.
+ * @p{i->set_coarsen_flag} and calling @p execute_coarsening_and_refinement.
*
* The reason for first coarsening, then refining is that the
* refinement usually adds some additional cells to keep the triangulation
* they do exactly these things). There are more advanced functions,
* however, which are more suitable for automatic generation of hierarchical
* grids in the context of a-posteriori error estimation and adaptive finite
- * elements. These functions can be found in the @ref{GridRefinement} class.
+ * elements. These functions can be found in the GridRefinement class.
*
*
* @sect3{Smoothing of a triangulation}
*
* Some degradation of approximation properties has been observed
* for grids which are too unstructured. Therefore, the
- * @p{prepare_coarsening_and_refinement} function which is automatically called
- * by the @p{execute_coarsening_and_refinement} function can do some
+ * @p prepare_coarsening_and_refinement function which is automatically called
+ * by the @p execute_coarsening_and_refinement function can do some
* smoothing of the triangulation. Note that mesh smoothing is only
* done for two or more space dimensions, no smoothing is available
* at present for one spatial dimension. In the sequel, let
- * @p{execute_*} stand for @p{execute_coarsening_and_refinement}.
+ * @p{execute_*} stand for @p execute_coarsening_and_refinement.
*
* For the purpose of smoothing, the
- * @ref{Triangulation} constructor takes an argument specifying whether a
+ * Triangulation constructor takes an argument specifying whether a
* smoothing step shall be performed on the grid each time @p{execute_*}
* is called. The default is that such a step not be done, since this results
* in additional cells being produced, which may not be necessary in all
* The parameter taken by the constructor is an integer which may be composed
* bitwise by the constants defined in the @p{enum MeshSmoothing}. The meaning
* of these constants is explained in the following:
- * @begin{itemize}
- * @item @p{limit_level_difference_at_vertices}:
+ * <ul>
+ * <li> @p limit_level_difference_at_vertices:
* It can be shown, that degradation of approximation occurs if the
* triangulation contains vertices which are member of cells with levels
* differing by more than one. One such example is the following:
- * @begin{verbatim}
+ * @verbatim
* | | | |
* x-----x-----x--x--x--
* | | | | |
* | | |
* | | |
* x-----------x-----x--
- * @end{verbatim}
+ * @endverbatim
* It seems that in two space dimensions, the maximum jump in levels between
* cells sharing a common vertex is two (as in the example above). This is
* not true if more than four cells meet at a vertex. It is not uncommon
* of this cell (but with a less degree of deviation from the true value).
*
* If the smoothing indicator given to the constructor contains the bit for
- * @p{limit_level_difference_at_vertices}, situations as the above one are
+ * @p limit_level_difference_at_vertices, situations as the above one are
* eliminated by also marking the lower left cell for refinement.
*
- * @item @p{eliminate_unrefined_islands}:
+ * <li> @p eliminate_unrefined_islands:
* Single cells which are not refined and are surrounded by cells which are
* refined usually also lead to a sharp decline in approximation properties
* locally. The reason is that the nodes on the faces between unrefined and
* refined cells are not real degrees of freedom but carry constraints. The
* patch without additional degrees of freedom is thus significantly larger
* then the unrefined cell itself. If in the parameter passed to the
- * constructor the bit for @p{eliminate_unrefined_islands} is set, all cells
+ * constructor the bit for @p eliminate_unrefined_islands is set, all cells
* which are not flagged for refinement but which are surrounded by more
* refined cells than unrefined cells are flagged for refinement. Cells
* which are not yet refined but flagged for that are accounted for the
* name of the flag may indicate. However, no better name came to mind to
* the author by now.
*
- * @item @p{eliminate_refined_*_islands}:
+ * <li> @p{eliminate_refined_*_islands}:
* This algorithm seeks for isolated cells which are refined or flagged
* for refinement. This definition is unlike that for
- * @p{eliminate_unrefined_islands}, which would mean that an island is
+ * @p eliminate_unrefined_islands, which would mean that an island is
* defined as a cell which
* is refined but more of its neighbors are not refined than are refined.
* For example, in 2D, a cell's refinement would be reverted if at most
* refinement flag.
*
* Actually there are two versions of this flag,
- * @p{eliminate_refined_inner_islands} and @p{eliminate_refined_boundary_islands}.
+ * @p eliminate_refined_inner_islands and @p eliminate_refined_boundary_islands.
* There first eliminates islands defined by the definition above which are
* in the interior of the domain, while the second eliminates only those
* islands if the cell is at the boundary. The reason for this split of
* refines the mesh according to a criterion associated with a boundary
* integral or if one has rough boundary data.
*
- * @item @p{do_not_produce_unrefined_islands}:
+ * <li> @p do_not_produce_unrefined_islands:
* This flag prevents the occurrence of unrefined islands. In more detail:
* It prohibits the coarsening of a cell if 'most of the neighbors' will
* be refined after the step.
*
- * @item @p{patch_level_1}:
+ * <li> @p patch_level_1:
* Ensures patch level 1. As result the triangulation consists of
* patches, i.e. of cells that are refined once. It follows that
* if at least one of the children of a cell is or will be refined
- * than all children need to be refined. If the @p{patch_level_1} flag
- * is set, than the flags @p{eliminate_unrefined_islands},
- * @p{eliminate_refined_inner_islands} and
- * @p{eliminate_refined_boundary_islands} will be ignored as they will
+ * than all children need to be refined. If the @p patch_level_1 flag
+ * is set, than the flags @p eliminate_unrefined_islands,
+ * @p eliminate_refined_inner_islands and
+ * @p eliminate_refined_boundary_islands will be ignored as they will
* be fulfilled automatically.
*
- * @item @p{smoothing_on_refinement}:
+ * <li> @p smoothing_on_refinement:
* This flag sums up all smoothing algorithms which may be performed upon
* refinement by flagging some more cells for refinement.
*
- * @item @p{smoothing_on_coarsening}:
+ * <li> @p smoothing_on_coarsening:
* This flag sums up all smoothing algorithms which may be performed upon
* coarsening by flagging some more cells for coarsening.
*
- * @item @p{maximum_smoothing}:
+ * <li> @p maximum_smoothing:
* This flag includes all the above ones and therefore combines all
* smoothing algorithms implemented.
*
- * @item @p{none}:
+ * <li> @p none:
* Select no smoothing at all.
- * @end{itemize}
+ * </ul>
*
*
* @sect3{Material and boundary information}
* @sect3{History of a triangulation}
*
* It is possible to reconstruct a grid from its refinement history, which
- * can be stored and loaded through the @p{save_refine_flags} and
- * @p{load_refine_flags} functions. Normally, the code will look like this:
- * @begin{verbatim}
+ * can be stored and loaded through the @p save_refine_flags and
+ * @p load_refine_flags functions. Normally, the code will look like this:
+ * @verbatim
* // open output file
* ofstream history("mesh.history");
* // do 10 refinement steps
* tria.save_refine_flags (history);
* tria.execute_coarsening_and_refinement ();
* };
- * @end{verbatim}
+ * @endverbatim
*
* If you want to re-create the grid from the stored information, you write:
- * @begin{verbatim}
+ * @verbatim
* // open input file
* ifstream history("mesh.history");
* // do 10 refinement steps
* tria.load_refine_flags (history);
* tria.execute_coarsening_and_refinement ();
* };
- * @end{verbatim}
+ * @endverbatim
*
* The same scheme is employed for coarsening and the coarsening flags.
*
* used if an algorithm walks over all cells and needs information whether
* another cell, e.g. a neighbor, has already been processed. It can also
* be used to flag the lines subject to constraints in 2D, as for example the
- * functions in the @ref{DoFHandler} classes do.
+ * functions in the DoFHandler classes do.
*
- * There are two functions, @p{save_user_flags} and @p{load_user_flags} which
+ * There are two functions, @p save_user_flags and @p load_user_flags which
* write and read these flags to and from a stream. Unlike
- * @p{save_refine_flags} and @p{load_refine_flags}, these two functions store
+ * @p save_refine_flags and @p load_refine_flags, these two functions store
* 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</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
+ * @p save_user_flags_line and @p load_user_flags_line and the generalizations
* for quads, etc.
*
* As for the refinement and coarsening flags, there exist two versions of these
* line, quad, etc. You can access these user pointers through the
* functions @p{user_pointer()}, @p{clear_user_pointer()} and
* @p{set_user_pointer(p)} in the accessor classes. These pointers are
- * neither used nor changed by the library and are @p{NULL} by
+ * neither used nor changed by the library and are @p NULL by
* default. Thus, their handling is the sole responsibility of the
* application program. Especially, the pointers are not inherited
* to children upon refinement. Still, after a remeshing they are
* available on all cells, where they were set on the previous mesh.
*
- * The usual warning about the missing type safety of @p{void} pointers are
+ * The usual warning about the missing type safety of @p void pointers are
* obviously in place here; responsibility for correctness of types etc
* lies entirely with the user of the pointer.
*
* component. If a new vertex is created on a side or face at the
* boundary, this function is used to compute where it will be
* placed. The boundary indicator of the face will be used to
- * determine the proper component. See @ref{Boundary} for the
- * details. Usage with the @ref{Triangulation} object is then like this
- * (let @p{Ball} be a class derived from @ref{Boundary}@p{<2>}):
+ * determine the proper component. See Boundary for the
+ * details. Usage with the Triangulation object is then like this
+ * (let @p Ball be a class derived from Boundary@p{<2>}):
*
- * @begin{verbatim}
+ * @verbatim
* void main () {
* Triangulation<2> tria;
* // set the boundary function
* tria.execute_coarsening_and_refinement();
* };
* };
- * @end{verbatim}
+ * @endverbatim
*
* You should take note of one caveat: if you have concave
* boundaries, you must make sure that a new boundary vertex does
* further the assumptions also hold.
*
* The regularization and smoothing is done in the
- * @p{prepare_coarsening_and_refinement} function, which is called by
- * @p{execute_coarsening_and_refinement} at the very beginning. It
+ * @p prepare_coarsening_and_refinement function, which is called by
+ * @p execute_coarsening_and_refinement at the very beginning. It
* decides which additional cells to flag for refinement by looking
* at the old grid and the refinement flags for each cell.
*
- * @begin{itemize}
- * @item <em>Regularization:</em> The algorithm walks over all cells checking
+ * <ul>
+ * <li> <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
* 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:</em>
- * @begin{itemize}
- * @item @p{limit_level_difference_at_vertices}:
+ * <li> <em>Smoothing:</em>
+ * <ul>
+ * <li> @p limit_level_difference_at_vertices:
* First a list is set up which stores for each vertex
* the highest level one of the adjacent cells belongs to. Now, since we did
* smoothing in the previous refinement steps also, each cell may only have
* refinement, but these are on lower levels, as above, which is why we
* may do all kinds of additional flagging in one loop only.
*
- * @item @p{eliminate_unrefined_islands}:
+ * <li> @p eliminate_unrefined_islands:
* For each cell we count the number of neighbors which are refined or
* flagged for refinement. If this exceeds the total number of neighbors
* (which is the number of faces minus the number of faces of this cell
* will need refinement, we will need additional loops of regularization
* and smoothing over all cells until nothing changes any more.
*
- * @item @p{eliminate_refined_*_islands}:
+ * <li> @p{eliminate_refined_*_islands}:
* This one does much the same as the above one, but for coarsening. If
* a cell is flagged for refinement or if all of its children are active
* and if the number of neighbors which are either active and not flagged
* of this classes description.
*
* The same applies as above: several loops may be necessary.
- * @end{itemize}
- * @end{itemize}
+ * </ul>
+ * </ul>
*
* Regularization and smoothing are a bit complementary in that we check
* whether we need to set additional refinement flags when being on a cell
* 2D. The direction of a line is the direction of point 0 towards point 1. We
* define, that allowed cells contain of lines of which the direction is
* as follows:
- * @begin{verbatim}
+ * @verbatim
* 2
* 3--->---2
* | |
* | |
* 0--->---1
* 0
- * @end{verbatim}
+ * @endverbatim
* The number of the vertices and lines is also indicated. This orientation of
* lines has to be checked/generated upon construction of a grid and is
* preserved upon refinement.
*
* Note that information about several of these conventions can be
* extracted at run- or compile-time from the member functions and
- * variables of the @ref{GeometryInfo} classes.
+ * variables of the GeometryInfo classes.
*
*
* @sect4{Coordinate systems}
* When explicit coordinates are required for points in a cell (e.g for
* quadrature formulae or the point of definition of trial functions), we
* define the following coordinate system for the unit cell:
- * @begin{verbatim}
+ * @verbatim
* y^ 3-------2
* | | |
* | | |
* | | |
* | 0-------1
* *-------------->x
- * @end{verbatim}
+ * @endverbatim
* with vertex 0 being the origin of the coordinate system, vertex 1 having
* coordinates @p{(1,0)}, vertex 2 at @p{(1,1)} and vertex 3 at @p{(0,1)}.
*
* dimensions. Before giving these conventions we declare the
* following sketch to be the standard way of drawing 3d pictures of
* hexahedra:
- * @begin{verbatim}
+ * @verbatim
* *-------* *-------*
* /| | / /|
* / | | / / |
* | / / | | /
* |/ / | |/
* *-------* *-------*
- * @end{verbatim}
+ * @endverbatim
* The left part of the picture shows the left, bottom and back face of the
* cube, while the right one shall be the top, right and front face. You may
* recover the whole cube by moving the two parts together into one.
*
* Note again that information about several of the following
* conventions can be extracted at run- or compile-time from the
- * member functions and variables of the @ref{GeometryInfo} classes.
+ * member functions and variables of the GeometryInfo classes.
*
*
* @sect4{Vertices}
* the vertices on a quadrilateral. The vertices on the back face are numbered
* similarly by moving the front face to the back (no turning, no twisting,
* just a shift):
- * @begin{verbatim}
+ * @verbatim
* 7-------6 7-------6
* /| | / /|
* / | | / / |
* | / / | | /
* |/ / | |/
* 0-------1 0-------1
- * @end{verbatim}
+ * @endverbatim
*
* @sect4{Lines}
*
* Here, the same holds as for the vertices: the lines of the front face are
* numbered as for the quadrilateral, for the back face they are just shifted.
* Finally, the four lines connecting front and back face are numbered:
- * @begin{verbatim}
+ * @verbatim
* *---6---* *---6---*
* /| | / /|
* 11 | 5 11 10 5
* 3 8 9 3 | 9
* |/ / | |/
* *---0---* *---0---*
- * @end{verbatim}
+ * @endverbatim
* The directions of the front and back lines is as for the respective faces, while
* the connecting lines always point to the back:
- * @begin{verbatim}
+ * @verbatim
* *--->---* *--->---*
* /| | / /|
* ^ | ^ ^ ^ ^
* ^ ^ ^ ^ | ^
* |/ / | |/
* *--->---* *--->---*
- * @end{verbatim}
+ * @endverbatim
*
* The fact that edges (just as vertices and faces) are entities
* that are stored in their own right rather than constructed from
* class for creation of a triangulation, you therefore have to make
* sure that cells are oriented in a compatible fashion, so that
* edge directions are globally according to above
- * convention. However, the @ref{GridReordering} class can do this
+ * convention. However, the GridReordering class can do this
* for you, by reorienting cells and edges of an arbitrary list of
* input cells that need not be already sorted.
*
*
* The faces are numbered in the same order as the lines were numbered: front
* face, back face, then the four side faces:
- * @begin{verbatim}
+ * @verbatim
* *-------* *-------*
* /| | / /|
* / | 1 | / 4 / |
* | / 2 / | 0 | /
* |/ / | |/
* *-------* *-------*
- * @end{verbatim}
+ * @endverbatim
*
* 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:
- * @begin{verbatim}
+ * <ul>
+ * <li> Faces 0 and 1:
+ * @verbatim
* *---2---* *-------*
* /| | / /|
* / | 1 / / |
* | / / 3 | /
* |/ / | |/
* *-------* *---0---*
- * @end{verbatim}
+ * @endverbatim
*
- * @item Faces 2 and 4:
- * @begin{verbatim}
+ * <li> Faces 2 and 4:
+ * @verbatim
* *-------* *---2---*
* /| | / /|
* / | | 3 1 |
* | 3 1 | | /
* |/ / | |/
* *---0---* *-------*
- * @end{verbatim}
+ * @endverbatim
*
- * @item Faces 3 and 5:
- * @begin{verbatim}
+ * <li> Faces 3 and 5:
+ * @verbatim
* *-------* *-------*
* /| | / /|
* 2 1 | / 2 1
* | 0 / | | 0
* |/ / | |/
* *-------* *-------*
- * @end{verbatim}
- * @end{itemize}
+ * @endverbatim
+ * </ul>
*
* Due to this numbering, the following lines are identical in the
* standard orientation:
- * @begin{itemize}
- * @item Line 0 of face 0, and line 0 of face 2;
- * @item Line 1 of face 0, and line 3 of face 3;
- * @item Line 2 of face 0, and line 0 of face 4;
- * @item Line 3 of face 0, and line 3 of face 5;
- * @item Line 0 of face 1, and line 2 of face 2;
- * @item Line 1 of face 1, and line 1 of face 3;
- * @item Line 2 of face 1, and line 2 of face 4;
- * @item Line 3 of face 1, and line 1 of face 5;
- * @item Line 3 of face 2, and line 0 of face 5;
- * @item Line 1 of face 2, and line 0 of face 3;
- * @item Line 1 of face 4, and line 2 of face 3;
- * @item Line 3 of face 4, and line 2 of face 5.
- * @end{itemize}
+ * <ul>
+ * <li> Line 0 of face 0, and line 0 of face 2;
+ * <li> Line 1 of face 0, and line 3 of face 3;
+ * <li> Line 2 of face 0, and line 0 of face 4;
+ * <li> Line 3 of face 0, and line 3 of face 5;
+ * <li> Line 0 of face 1, and line 2 of face 2;
+ * <li> Line 1 of face 1, and line 1 of face 3;
+ * <li> Line 2 of face 1, and line 2 of face 4;
+ * <li> Line 3 of face 1, and line 1 of face 5;
+ * <li> Line 3 of face 2, and line 0 of face 5;
+ * <li> Line 1 of face 2, and line 0 of face 3;
+ * <li> Line 1 of face 4, and line 2 of face 3;
+ * <li> Line 3 of face 4, and line 2 of face 5.
+ * </ul>
*
* This standard orientation of faces in 3d can also be depicted by
* assigning a normal vector to each face. The direction of this
* 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,
+ * 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
* @sect4{Children}
*
* The eight children of a cell are numbered as follows:
- * @begin{verbatim}
+ * @verbatim
* *-------* *-------*
* /| 7 6 | / 7 6 /|
* /7| | / /6|
* |0/ / | |1/
* |/0 1 / | 0 1 |/
* *-------* *-------*
- * @end{verbatim}
+ * @endverbatim
*
* Taking into account the orientation of the faces, the following
* children are adjacent to the respective faces:
- * @begin{itemize}
- * @item Face 0: children 0, 1, 2, 3;
- * @item Face 1: children 4, 5, 6, 7;
- * @item Face 2: children 0, 1, 5, 4;
- * @item Face 3: children 1, 5, 6, 2;
- * @item Face 4: children 3, 2, 6, 7;
- * @item Face 5: children 0, 4, 7, 3.
- * @end{itemize}
- * You can get these numbers using the @ref{GeometryInfo<3>}@p{::child_cell_on_face}
+ * <ul>
+ * <li> Face 0: children 0, 1, 2, 3;
+ * <li> Face 1: children 4, 5, 6, 7;
+ * <li> Face 2: children 0, 1, 5, 4;
+ * <li> Face 3: children 1, 5, 6, 2;
+ * <li> Face 4: children 3, 2, 6, 7;
+ * <li> Face 5: children 0, 4, 7, 3.
+ * </ul>
+ * You can get these numbers using the @ref{GeometryInfo<3>}@p ::child_cell_on_face
* function. Each child is adjacent to the vertex with the same number.
*
* Note that, again, the above list only holds for faces in their
* The information which child cell is at which position of which
* face is most often used when computing jump terms across faces
* with hanging nodes, using objects of type
- * @ref{FESubfaceValues}. Sitting on one cell, you would look at
+ * FESubfaceValues. Sitting on one cell, you would look at
* face and figure out which child of the neighbor is sitting on a
* given subface between the present and the neighboring cell. To
* avoid having to query the standard orientation of the faces of
*
* We define the following coordinate system for the explicit coordinates of
* the vertices of the unit cell:
- * @begin{verbatim}
+ * @verbatim
* 7-------6 7-------6
* /| | / /|
* / | | / / |
* | / | / / | | /
* |/ |/ / | |/
* *------>x 0-------1 0-------1
- * @end{verbatim}
+ * @endverbatim
* This convention in conjunction with the numbering of the vertices is a bit
* unfortunate, since the vertices 0 through 3 have the coordinates @p{(x,0,z)}
- * with @p{x} and @p{z} being the same as the @p{x} and @p{y} coordinates of a quad
+ * with @p x and @p z being the same as the @p x and @p y coordinates of a quad
* in the plane; more intuitive would have been if they had the coordinates
* @p{(x,y,0)}. However, the vertex numbering was historically chosen as shown.
*
* By the convention laid down as above, the vertices have the following
* coordinates:
- * @begin{itemize}
- * @item Vertex 0: @p{(0,0,0)};
- * @item Vertex 1: @p{(1,0,0)};
- * @item Vertex 2: @p{(1,0,1)};
- * @item Vertex 3: @p{(0,0,1)};
- * @item Vertex 4: @p{(0,1,0)};
- * @item Vertex 5: @p{(1,1,0)};
- * @item Vertex 6: @p{(1,1,1)};
- * @item Vertex 7: @p{(0,1,1)}.
- * @end{itemize}
+ * <ul>
+ * <li> Vertex 0: @p{(0,0,0)};
+ * <li> Vertex 1: @p{(1,0,0)};
+ * <li> Vertex 2: @p{(1,0,1)};
+ * <li> Vertex 3: @p{(0,0,1)};
+ * <li> Vertex 4: @p{(0,1,0)};
+ * <li> Vertex 5: @p{(1,1,0)};
+ * <li> Vertex 6: @p{(1,1,1)};
+ * <li> Vertex 7: @p{(0,1,1)}.
+ * </ul>
*
*
* @sect3{Warning}
*
- * It seems impossible to preserve @p{const}ness of a triangulation through
- * iterator usage. Thus, if you declare pointers to a @p{const} triangulation
+ * It seems impossible to preserve @p constness of a triangulation through
+ * iterator usage. Thus, if you declare pointers to a @p const triangulation
* object, you should be well aware that you might involuntarily alter the
* data stored in the triangulation.
*
* Default boundary object. This
* declaration is used for the
* default argument in
- * @p{set_boundary}.
+ * @p set_boundary.
*
* The proper way would have been
* to use a static object here,
* object. However, we have to
* work around a bug in gcc2.95,
* where the compiler tries to
- * instantiate @p{Triangulation}
+ * instantiate @p Triangulation
* while instantiating
- * @p{Boundary} (which it needs
+ * @p Boundary (which it needs
* to do, since local typedefs
* are involved), but then tries
* to in turn instantiate
- * @p{StraightBoundary} because
+ * @p StraightBoundary because
* of this member variable. This
* is not needed since the member
* variable is a static one, but
* the compiler tries anyway and
* finds that it can't since the
- * base class @p{Boundary} is not
+ * base class @p Boundary is not
* yet complete...
*/
static const StraightBoundary<dim> *straight_boundary;
* for mesh smoothing
* algorithms. The meaning of
* these flags is documented in
- * the @ref{Triangulation} class.
+ * the Triangulation class.
*/
enum MeshSmoothing
{
/**
* Copy constructor. You should really
- * use the @p{copy_triangulation} function,
+ * use the @p copy_triangulation function,
* so we declare this function but let
* it throw an internal error. The
* reason for this is that we may use
*
* Note that this operation is only allowed
* if no subscriptions to this object exist
- * any more, such as @ref{DoFHandler} objects
+ * any more, such as DoFHandler objects
* using it.
*/
void clear ();
/**
* Assign a boundary object to
* the triangulation. If a face
- * with boundary number @p{number}
+ * with boundary number @p number
* is refined, this object is
* used to find the location of
* new vertices on the
* and are accessed with accessor
* functions of that name.
*
- * The @p{boundary_object} is not
+ * The @p boundary_object is not
* copied and MUST persist until
* the triangulation is
* destroyed. Otherwise, the
- * @ref{Subscriptor} class will issue
- * @p{ExcObjectInUse}. This is
+ * Subscriptor class will issue
+ * @p ExcObjectInUse. This is
* also true for triangulations
* generated from this one by
- * @p{copy_triangulation}.
+ * @p copy_triangulation.
*
* It is possible to remove or
* replace the boundary object
* a boundary object used for
* this triangulation. Number is
* the same as in
- * @p{set_boundary}
+ * @p set_boundary
*/
const Boundary<dim> & get_boundary (const unsigned int number) const;
* function also copies the
* pointer to the boundary
* descriptor previously set by
- * the @p{set_boundary}
+ * the @p set_boundary
* function. You must therefore
* also guarantee that the
* boundary objects has a
* empty beforehand.
*
* The function is made
- * @p{virtual} since some
+ * @p virtual since some
* derived classes might want to
* disable or extend the
* functionality of this
* (connected domain, etc.).
*
* Material data for the cells is
- * given within the @p{cells}
+ * given within the @p cells
* array, while boundary
* information is given in the
- * @p{subcelldata} field.
+ * @p subcelldata field.
*
* The numbering of vertices
- * within the @p{cells} array is
+ * within the @p cells array is
* subject to some constraints;
* see the general class
* documentation for this.
*
* This function is made
- * @p{virtual} to allow derived
+ * @p virtual to allow derived
* classes to set up some data
* structures as well.
*
* function can generate a valid
* triangulation, see the
* documentation of this class,
- * and the @ref{GridIn} and
- * @ref{GridReordering} class.
+ * and the GridIn and
+ * GridReordering class.
*/
virtual void create_triangulation (const std::vector<Point<dim> > &vertices,
const std::vector<CellData<dim> > &cells,
* of the grid. The direction of
* moving is random, while the
* length of the shift vector has
- * a value of @p{factor} times
+ * a value of @p factor times
* the minimal length of the
* active lines adjacent to this
- * vertex. Note that @p{factor}
+ * vertex. Note that @p factor
* should obviously be well below
* @p{0.5}.
*
- * If @p{keep_boundary} is set to
- * @p{true} (which is the
+ * If @p keep_boundary is set to
+ * @p true (which is the
* default), then boundary
* vertices are not moved.
*/
void set_all_refine_flags ();
/**
- * Refine all cells @p{times}
+ * Refine all cells @p times
* times, by alternatingly
* calling
* @p{set_all_refine_flags()}
* you have no way to store the
* refinement flags unless you
* overload the
- * @p{execute_coarsening_and_refinement}
+ * @p execute_coarsening_and_refinement
* function.
*/
void refine_global (const unsigned int times);
* information.
*
* Note that this function is
- * @p{virtual} to allow derived
+ * @p virtual to allow derived
* classes to insert hooks, such
* as saving refinement flags and
* the like.
* independent. However, for some
* dimension dependent things, it
* calls
- * @p{prepare_refinement_dim_dependent}.
+ * @p prepare_refinement_dim_dependent.
*
* Regarding the coarsening part,
* flagging and deflagging cells
/**
* Save the addresses of the
* cells which are flagged for
- * refinement to @p{out}. For
+ * refinement to @p out. For
* usage, read the general
* documentation for this class.
*/
/**
* Read the information stored by
- * @p{save_refine_flags}.
+ * @p save_refine_flags.
*/
void load_refine_flags (std::istream &in);
/**
* Read the information stored by
- * @p{save_refine_flags}.
+ * @p save_refine_flags.
*/
void load_refine_flags (const std::vector<bool> &v);
/**
- * Analogue to @p{save_refine_flags}.
+ * Analogue to @p save_refine_flags.
*/
void save_coarsen_flags (std::ostream &out) const;
void save_coarsen_flags (std::vector<bool> &v) const;
/**
- * Analogue to @p{load_refine_flags}.
+ * Analogue to @p load_refine_flags.
*/
void load_coarsen_flags (std::istream &out);
/**
- * Analogue to @p{load_refine_flags}.
+ * Analogue to @p load_refine_flags.
*/
void load_coarsen_flags (const std::vector<bool> &v);
* Save all user flags. See the general
* documentation for this class
* and the documentation for the
- * @p{save_refine_flags} for more
+ * @p save_refine_flags for more
* details.
*/
void save_user_flags (std::ostream &out) const;
/**
* Read the information stored by
- * @p{save_user_flags}.
+ * @p save_user_flags.
*/
void load_user_flags (std::istream &in);
/**
* Read the information stored by
- * @p{save_user_flags}.
+ * @p save_user_flags.
*/
void load_user_flags (const std::vector<bool> &v);
/**
* Read the information stored by
- * @p{save_user_pointers}.
+ * @p save_user_pointers.
*/
void load_user_pointers (const std::vector<void *> &v);
/*@{*/
/**
* Iterator to the first cell, used
- * or not, on level @p{level}. If a level
+ * or not, on level @p level. If a level
* has no cells, a past-the-end iterator
* is returned.
*
- * This function calls @p{begin_raw_line}
- * in 1D and @p{begin_raw_quad} in 2D.
+ * This function calls @p begin_raw_line
+ * in 1D and @p begin_raw_quad in 2D.
*/
raw_cell_iterator begin_raw (const unsigned int level = 0) const;
/**
* Iterator to the first used cell
- * on level @p{level}.
+ * on level @p level.
*
- * This function calls @p{begin_line}
- * in 1D and @p{begin_quad} in 2D.
+ * This function calls @p begin_line
+ * in 1D and @p begin_quad in 2D.
*/
cell_iterator begin (const unsigned int level = 0) const;
/**
* Iterator to the first active
- * cell on level @p{level}.
+ * cell on level @p level.
*
- * This function calls @p{begin_active_line}
- * in 1D and @p{begin_active_quad} in 2D.
+ * This function calls @p begin_active_line
+ * in 1D and @p begin_active_quad in 2D.
*/
active_cell_iterator begin_active(const unsigned int level = 0) const;
* iterators with past-the-end or
* before-the-beginning states.
*
- * This function calls @p{end_line}
- * in 1D and @p{end_quad} in 2D.
+ * This function calls @p end_line
+ * in 1D and @p end_quad in 2D.
*/
raw_cell_iterator end () const;
/**
* Return an iterator which is the first
- * iterator not on level. If @p{level} is
+ * iterator not on level. If @p level is
* the last level, then this returns
* @p{end()}.
*/
/**
* Return a raw iterator which is the first
- * iterator not on level. If @p{level} is
+ * iterator not on level. If @p level is
* the last level, then this returns
* @p{end()}.
*/
/**
* Return an active iterator which is the
- * first iterator not on level. If @p{level}
+ * first iterator not on level. If @p level
* is the last level, then this returns
* @p{end()}.
*/
* Return an iterator pointing to the
* last cell, used or not.
*
- * This function calls @p{last_raw_line}
- * in 1D and @p{last_raw_quad} in 2D.
+ * This function calls @p last_raw_line
+ * in 1D and @p last_raw_quad in 2D.
*/
raw_cell_iterator last_raw () const;
/**
* Return an iterator pointing to the last
- * cell of the level @p{level}, used or not.
+ * cell of the level @p level, used or not.
*
- * This function calls @p{last_raw_line}
- * in 1D and @p{last_raw_quad} in 2D.
+ * This function calls @p last_raw_line
+ * in 1D and @p last_raw_quad in 2D.
*/
raw_cell_iterator last_raw (const unsigned int level) const;
* Return an iterator pointing to the last
* used cell.
*
- * This function calls @p{last_line}
- * in 1D and @p{last_quad} in 2D.
+ * This function calls @p last_line
+ * in 1D and @p last_quad in 2D.
*/
cell_iterator last () const;
/**
* Return an iterator pointing to the last
- * used cell on level @p{level}.
+ * used cell on level @p level.
*
- * This function calls @p{last_line}
- * in 1D and @p{last_quad} in 2D.
+ * This function calls @p last_line
+ * in 1D and @p last_quad in 2D.
*/
cell_iterator last (const unsigned int level) const;
* Return an iterator pointing to the last
* active cell.
*
- * This function calls @p{last_active_line}
- * in 1D and @p{last_active_quad} in 2D.
+ * This function calls @p last_active_line
+ * in 1D and @p last_active_quad in 2D.
*/
active_cell_iterator last_active () const;
/**
* Return an iterator pointing to the last
- * active cell on level @p{level}.
+ * active cell on level @p level.
*
- * This function calls @p{last_active_line}
- * in 1D and @p{last_active_quad} in 2D.
+ * This function calls @p last_active_line
+ * in 1D and @p last_active_quad in 2D.
*/
active_cell_iterator last_active (const unsigned int level) const;
/*@}*/
/*@{*/
/**
* Iterator to the first face, used
- * or not, on level @p{level}. If a level
+ * or not, on level @p level. If a level
* has no faces, a past-the-end iterator
* is returned.
*
- * This function calls @p{begin_raw_line}
- * in 2D and @p{begin_raw_quad} in 3D.
+ * This function calls @p begin_raw_line
+ * in 2D and @p begin_raw_quad in 3D.
*/
raw_face_iterator begin_raw_face (const unsigned int level = 0) const;
/**
* Iterator to the first used face
- * on level @p{level}.
+ * on level @p level.
*
- * This function calls @p{begin_line}
- * in 2D and @p{begin_quad} in 3D.
+ * This function calls @p begin_line
+ * in 2D and @p begin_quad in 3D.
*/
face_iterator begin_face (const unsigned int level = 0) const;
/**
* Iterator to the first active
- * face on level @p{level}.
+ * face on level @p level.
*
- * This function calls @p{begin_active_line}
- * in 2D and @p{begin_active_quad} in 3D.
+ * This function calls @p begin_active_line
+ * in 2D and @p begin_active_quad in 3D.
*/
active_face_iterator begin_active_face(const unsigned int level = 0) const;
* iterators with past-the-end or
* before-the-beginning states.
*
- * This function calls @p{end_line}
- * in 2D and @p{end_quad} in 3D.
+ * This function calls @p end_line
+ * in 2D and @p end_quad in 3D.
*/
raw_face_iterator end_face () const;
/**
* Return an iterator which is the first
- * iterator not on level. If @p{level} is
+ * iterator not on level. If @p level is
* the last level, then this returns
* @p{end()}.
*/
/**
* Return a raw iterator which is the first
- * iterator not on level. If @p{level} is
+ * iterator not on level. If @p level is
* the last level, then this returns
* @p{end()}.
*/
/**
* Return an active iterator which is the
- * first iterator not on level. If @p{level}
+ * first iterator not on level. If @p level
* is the last level, then this returns
* @p{end()}.
*/
* Return an iterator pointing to the
* last face, used or not.
*
- * This function calls @p{last_raw_line}
- * in 2D and @p{last_raw_quad} in 3D.
+ * This function calls @p last_raw_line
+ * in 2D and @p last_raw_quad in 3D.
*/
raw_face_iterator last_raw_face () const;
/**
* Return an iterator pointing to the last
- * face of the level @p{level}, used or not.
+ * face of the level @p level, used or not.
*
- * This function calls @p{last_raw_line}
- * in 2D and @p{last_raw_quad} in 3D.
+ * This function calls @p last_raw_line
+ * in 2D and @p last_raw_quad in 3D.
*/
raw_face_iterator last_raw_face (const unsigned int level) const;
* Return an iterator pointing to the last
* used face.
*
- * This function calls @p{last_line}
- * in 2D and @p{last_quad} in 3D.
+ * This function calls @p last_line
+ * in 2D and @p last_quad in 3D.
*/
face_iterator last_face () const;
/**
* Return an iterator pointing to the last
- * used face on level @p{level}.
+ * used face on level @p level.
*
- * This function calls @p{last_line}
- * in 2D and @p{last_quad} in 3D.
+ * This function calls @p last_line
+ * in 2D and @p last_quad in 3D.
*/
face_iterator last_face (const unsigned int level) const;
* Return an iterator pointing to the last
* active face.
*
- * This function calls @p{last_active_line}
- * in 2D and @p{last_active_quad} in 3D.
+ * This function calls @p last_active_line
+ * in 2D and @p last_active_quad in 3D.
*/
active_face_iterator last_active_face () const;
/**
* Return an iterator pointing to the last
- * active face on level @p{level}.
+ * active face on level @p level.
*
- * This function calls @p{last_active_line}
- * in 2D and @p{last_active_quad} in 3D.
+ * This function calls @p last_active_line
+ * in 2D and @p last_active_quad in 3D.
*/
active_face_iterator last_active_face (const unsigned int level) const;
/*@}*/
/*@{*/
/**
* Iterator to the first line, used
- * or not, on level @p{level}. If a level
+ * or not, on level @p level. If a level
* has no lines, a past-the-end iterator
* is returned.
*/
/**
* Iterator to the first used line
- * on level @p{level}.
+ * on level @p level.
*/
line_iterator
begin_line (const unsigned int level = 0) const;
/**
* Iterator to the first active
- * line on level @p{level}.
+ * line on level @p level.
*/
active_line_iterator
begin_active_line(const unsigned int level = 0) const;
/**
* Return an iterator which is the first
- * iterator not on level. If @p{level} is
+ * iterator not on level. If @p level is
* the last level, then this returns
* @p{end()}.
*/
/**
* Return a raw iterator which is the first
- * iterator not on level. If @p{level} is
+ * iterator not on level. If @p level is
* the last level, then this returns
* @p{end()}.
*/
/**
* Return an active iterator which is the
- * first iterator not on level. If @p{level}
+ * first iterator not on level. If @p level
* is the last level, then this returns
* @p{end()}.
*/
/**
* Return an iterator pointing to the last
- * line of the level @p{level}, used or not.
+ * line of the level @p level, used or not.
*/
raw_line_iterator
/**
* Return an iterator pointing to the last
- * used line on level @p{level}.
+ * used line on level @p level.
*/
line_iterator
last_line (const unsigned int level) const;
/**
* Return an iterator pointing to the last
- * active line on level @p{level}.
+ * active line on level @p level.
*/
active_line_iterator
last_active_line (const unsigned int level) const;
*/
/**
* Iterator to the first quad, used
- * or not, on level @p{level}. If a level
+ * or not, on level @p level. If a level
* has no quads, a past-the-end iterator
* is returned.
*/
/**
* Iterator to the first used quad
- * on level @p{level}.
+ * on level @p level.
*/
quad_iterator
begin_quad (const unsigned int level = 0) const;
/**
* Iterator to the first active
- * quad on level @p{level}.
+ * quad on level @p level.
*/
active_quad_iterator
begin_active_quad(const unsigned int level = 0) const;
/**
* Return an iterator which is the first
- * iterator not on level. If @p{level} is
+ * iterator not on level. If @p level is
* the last level, then this returns
* @p{end()}.
*/
/**
* Return a raw iterator which is the first
- * iterator not on level. If @p{level} is
+ * iterator not on level. If @p level is
* the last level, then this returns
* @p{end()}.
*/
/**
* Return an active iterator which is the
- * first iterator not on level. If @p{level}
+ * first iterator not on level. If @p level
* is the last level, then this returns
* @p{end()}.
*/
/**
* Return an iterator pointing to the last
- * quad of the level @p{level}, used or not.
+ * quad of the level @p level, used or not.
*/
raw_quad_iterator
/**
* Return an iterator pointing to the last
- * used quad on level @p{level}.
+ * used quad on level @p level.
*/
quad_iterator
last_quad (const unsigned int level) const;
/**
* Return an iterator pointing to the last
- * active quad on level @p{level}.
+ * active quad on level @p level.
*/
active_quad_iterator
last_active_quad (const unsigned int level) const;
*/
/**
* Iterator to the first hex, used
- * or not, on level @p{level}. If a level
+ * or not, on level @p level. If a level
* has no hexs, a past-the-end iterator
* is returned.
*/
/**
* Iterator to the first used hex
- * on level @p{level}.
+ * on level @p level.
*/
hex_iterator
begin_hex (const unsigned int level = 0) const;
/**
* Iterator to the first active
- * hex on level @p{level}.
+ * hex on level @p level.
*/
active_hex_iterator
begin_active_hex(const unsigned int level = 0) const;
/**
* Return an iterator which is the first
- * iterator not on level. If @p{level} is
+ * iterator not on level. If @p level is
* the last level, then this returns
* @p{end()}.
*/
/**
* Return a raw iterator which is the first
- * iterator not on level. If @p{level} is
+ * iterator not on level. If @p level is
* the last level, then this returns
* @p{end()}.
*/
/**
* Return an active iterator which is the
- * first iterator not on level. If @p{level}
+ * first iterator not on level. If @p level
* is the last level, then this returns
* @p{end()}.
*/
/**
* Return an iterator pointing to the last
- * hex of the level @p{level}, used or not.
+ * hex of the level @p level, used or not.
*/
raw_hex_iterator
/**
* Return an iterator pointing to the last
- * used hex on level @p{level}.
+ * used hex on level @p level.
*/
hex_iterator
last_hex (const unsigned int level) const;
/**
* Return an iterator pointing to the last
- * active hex on level @p{level}.
+ * active hex on level @p level.
*/
active_hex_iterator
last_active_hex (const unsigned int level) const;
/**
* Return total number of used lines,
- * active or not on level @p{level}.
+ * active or not on level @p level.
*/
unsigned int n_lines (const unsigned int level) const;
/**
* Return total number of active lines,
- * on level @p{level}.
+ * on level @p level.
*/
unsigned int n_active_lines (const unsigned int level) const;
/**
* Return total number of used quads,
- * active or not on level @p{level}.
+ * active or not on level @p level.
*/
unsigned int n_quads (const unsigned int level) const;
/**
* Return total number of active quads,
- * active or not on level @p{level}.
+ * active or not on level @p level.
*/
unsigned int n_active_quads (const unsigned int level) const;
/**
* Return total number of used hexahedra,
- * active or not on level @p{level}.
+ * active or not on level @p level.
*/
unsigned int n_hexs(const unsigned int level) const;
/**
* Return total number of active hexahedra,
- * active or not on level @p{level}.
+ * active or not on level @p level.
*/
unsigned int n_active_hexs(const unsigned int level) const;
/**
* Return total number of used cells,
- * active or not, on level @p{level}.
+ * active or not, on level @p level.
* Maps to @p{n_lines(level)} in one space
* dimension and so on.
*/
/**
* Return total number of active cells
- * on level @p{level}.
+ * on level @p level.
* Maps to @p{n_active_lines(level)} in one
* space dimension and so on.
*/
* holes in the numbers of used
* vertices. You can get the
* number of used vertices using
- * @p{n_used_vertices} function.
+ * @p n_used_vertices function.
*/
unsigned int n_vertices () const;
* once. You can find out about
* which vertices are actually
* used by the function
- * @ref{get_used_vertices}.
+ * get_used_vertices().
*/
const std::vector<Point<dim> > &
get_vertices () const;
/**
* Return a constant reference to
- * the array of @p{bool}s
+ * the array of @p bools
* indicating whether an entry in
* the vertex array is used or
* not.
* as ASCII text.
*
* The flags are stored in a binary
- * format: for each @p{true}, a @p{1}
- * bit is stored, a @p{0} bit otherwise.
+ * format: for each @p true, a @p 1
+ * bit is stored, a @p 0 bit otherwise.
* The bits are stored as @p{unsigned char},
* thus avoiding endianess. They are
- * written to @p{out} in plain text, thus
+ * written to @p out in plain text, thus
* amounting to 3.6 bits per active cell
* on the overage. Other information
* (magic numbers ans number of elements)
/**
* Re-read a vector of bools previously
- * written by @p{write_bool_vector} and
+ * written by @p write_bool_vector and
* compare with the magic numbers.
*/
static void read_bool_vector (const unsigned int magic_number1,
* it children, which is the
* main step for the coarsening process.
* This is the dimension dependent part
- * of @p{execute_coarsening}.
+ * of @p execute_coarsening.
*/
void delete_children (cell_iterator &cell);
* otherwise to steps of interpolation
* would be necessary. This would make
* the processes implemented in the
- * @p{ConstraintMatrix} class much more
+ * @p ConstraintMatrix class much more
* complex, since these two steps of
* interpolation do not commute.
*/
* Re-compute the number of
* lines, quads, etc. This
* function is called by
- * @p{execute_coarsening_and_refinement}
+ * @p execute_coarsening_and_refinement
* and by
- * @p{create_triangulation} after
+ * @p create_triangulation after
* the grid was changed.
*
* This function simply delegates
* classes. Since the pure
* triangulation iterators need
* no additional data, this data
- * type is @p{void}.
+ * type is @p void.
*/
typedef void AccessorData;
* 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
+ * 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
* iterator. For the different
* states an accessor can be in,
* refer to the
- * @ref{TriaRawIterator}
+ * TriaRawIterator
* documentation.
*/
IteratorState::IteratorStates state () const;
/**
* Common template for line, quad, hex accessors. According to
- * @p{celldim} objects of this class represent lines, quadrilaterals,
- * or hexahedra in @p{dim} space dimensions. Concrete implementations
- * are done for specialized @p{celldim} template parameter. For easier
+ * @p celldim objects of this class represent lines, quadrilaterals,
+ * or hexahedra in @p dim space dimensions. Concrete implementations
+ * are done for specialized @p celldim template parameter. For easier
* access, we nevertheless document all functions of the specialized
* classes here as well. However, they are not implemented.
*
* convention regarding the
* numbering of vertices is laid
* down in the documentation of
- * the @ref{Triangulation}
+ * the Triangulation
* class.
*
* Note that the returned value is only
* vertex. It has nothing to do with
* possible degrees of freedom
* associated with it. For this, see the
- * @p{DoFAccessor::vertex_dof_index}
+ * @p DoFAccessor::vertex_dof_index
* functions.
*/
int vertex_index (const unsigned int i) const;
/**
* Return a reference to the
- * @p{i}th vertex.
+ * @p ith vertex.
*/
Point<dim> & vertex (const unsigned int i) const;
/**
- * Pointer to the @p{i}th line
+ * Pointer to the @p ith line
* bounding this object.
*
* Implemented only for @p{celldim>1}.
line (const unsigned int i) const;
/**
- * Line index of the @p{i}th
+ * Line index of the @p ith
* line. The level is naturally
* the same as that of the
* object.
unsigned int line_index (const unsigned int i) const;
/**
- * Pointer to the @p{i}th quad
+ * Pointer to the @p ith quad
* bounding this object.
*
* Implemented only for @p{celldim>2}.
quad (const unsigned int i) const;
/**
- * Quad index of the @p{i}th
+ * Quad index of the @p ith
* quad. The level is naturally
* the same as that of the object.
*
/**
* Test for the element being
* used or not. The return
- * value is @p{true} for all
+ * value is @p true for all
* iterators that are either
* normal iterators or active
* iterators, only raw iterators
- * can return @p{false}. Since
+ * can return @p false. Since
* raw iterators are only used
* in the interiors of the
* library, you will not usually
bool used () const;
/**
- * Set the @p{used} flag. You
+ * Set the @p used flag. You
* should know quite exactly
* what you are doing of you
* touch this function. It is
void set_used_flag () const;
/**
- * Clear the @p{used} flag. You
+ * Clear the @p used flag. You
* should know quite exactly
* what you are doing of you
* touch this function. It is
/**
* Set the user pointer
- * to @p{p}.
+ * to @p p.
*/
void set_user_pointer (void *p) const;
/**
* Reset the user pointer
- * to a @p{NULL} pointer.
+ * to a @p NULL pointer.
*/
void clear_user_pointer () const;
* object and all of its
* descendants. The same holds as
* said for the
- * @ref{recursively_set_user_pointer}
+ * recursively_set_user_pointer()
* function.
*/
void recursively_clear_user_pointer () const;
/**
- * Pointer to the @p{i}th
+ * Pointer to the @p ith
* child.
*/
TriaIterator<dim,TriaObjectAccessor<celldim,dim> >
child (const unsigned int i) const;
/**
- * Index of the @p{i}th child.
+ * Index of the @p ith child.
* The level of the child is one
* higher than that of the
* present cell. If the child
* object is refined. Note that
* not all its children are
* refined that often (which is
- * why we prepend @p{max_}), the
+ * why we prepend @p max_), the
* returned number is rather the
* maximum number of refinement
* in any branch of children of
* for @p{dim>celldim}; however,
* for @p{dim==celldim}, an
* object is a cell and the
- * @ref{CellAccessor} class
+ * CellAccessor class
* offers another possibility to
* determine whether a cell is at
* the boundary or not.
/**
* Return whether the face with
- * index @p{face} has its normal
+ * index @p face has its normal
* pointing in the standard
- * direction (@p{true}) or
+ * direction (@p true) or
* whether it is the opposite
- * (@p{false}). Which is the
+ * (@p false). Which is the
* standard direction is
* documented with the
- * @ref{Triangulation} class. In
+ * Triangulation class. In
* 1d and 2d, this is always
- * @p{true}, but in 3d it may be
+ * @p true, but in 3d it may be
* different, see the respective
* discussion in the
* documentation of the
- * @ref{Triangulation} class.
+ * Triangulation class.
*
* This function is really only
* for internal use in the
* 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
+ * 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
/**
* Accessor to dereference the data of lines. This accessor is used
- * to point to lines in @p{dim} space dimensions. There is a derived
+ * to point to lines in @p dim space dimensions. There is a derived
* class for lines in one space dimension, in which case a line is
* also a cell and thus has much more functionality than in other
* dimensions.
* vertex. It has nothing to do with
* possible degrees of freedom
* associated with it. For this, see the
- * @p{DoFAccessor::vertex_dof_index}
+ * @p DoFAccessor::vertex_dof_index
* functions.
*/
int vertex_index (const unsigned int i) const;
/**
* Return a reference to the
- * @p{i}th vertex.
+ * @p ith vertex.
*/
Point<dim> & vertex (const unsigned int i) const;
/**
* Test for the element being
* used or not. The return
- * value is @p{true} for all
+ * value is @p true for all
* iterators that are either
* normal iterators or active
* iterators, only raw iterators
- * can return @p{false}. Since
+ * can return @p false. Since
* raw iterators are only used
* in the interiors of the
* library, you will not usually
bool used () const;
/**
- * Set the @p{used} flag. Only
+ * Set the @p used flag. Only
* for internal use in the
* library.
*/
void set_used_flag () const;
/**
- * Clear the @p{used} flag. Only
+ * Clear the @p used flag. Only
* for internal use in the
* library.
*/
/**
* Set the user pointer of this
- * line to @p{p}.
+ * line to @p p.
*/
void set_user_pointer (void *p) const;
* object and all of its
* descendants. The same holds as
* said for the
- * @ref{recursively_set_user_pointer}
+ * recursively_set_user_pointer()
* function.
*/
void recursively_clear_user_pointer () const;
/**
* Reset the user pointer of this
- * line to a @p{NULL} pointer.
+ * line to a @p NULL pointer.
*/
void clear_user_pointer () const;
/**
* Return a pointer to the
- * @p{i}th child.
+ * @p ith child.
*/
TriaIterator<dim,TriaObjectAccessor<1, dim> >
child (const unsigned int i) const;
/**
* Return the index of the
- * @p{i}th child. The level of
+ * @p ith child. The level of
* the child is one higher than
* that of the present cell. If
* the child does not exist, -1
* refined. Note that not all its
* children are refined that
* often (which is why we prepend
- * @p{max_}), the returned number
+ * @p max_), the returned number
* is rather the maximum number
* of refinement in any branch of
* children of this object.
* only possible for @p{dim>1};
* however, for @p{dim==1}, a
* line is a cell and the
- * @ref{CellAccessor} class
+ * CellAccessor class
* offers another possibility to
* determine whether a cell is at
* the boundary or not.
* Return the barycenter of the
* line, which is the
* midpoint. The same applies as
- * for the @p{center} function
+ * for the @p center function
* with regard to lines at the
* boundary.
*/
/**
* Return the length of the line.
* The same applies as for the
- * @p{center} function with
+ * @p center function with
* regard to lines at the
* boundary.
*/
/**
* Return whether the face with
- * index @p{face} has its normal
+ * index @p face has its normal
* pointing in the standard
- * direction (@p{true}) or
+ * direction (@p true) or
* whether it is the opposite
- * (@p{false}). Which is the
+ * (@p false). Which is the
* standard direction is
* documented with the
- * @ref{Triangulation} class. In
+ * Triangulation class. In
* 1d and 2d, this is always
- * @p{true}, but in 3d it may be
+ * @p true, but in 3d it may be
* different, see the respective
* discussion in the
* documentation of the
- * @ref{Triangulation} class.
+ * Triangulation class.
*
* This function is really only
* for internal use in the
* 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
+ * 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
/**
* Accessor to dereference the data of quads. This accessor is used
- * to point to quads in @p{dim} space dimensions (only @p{dim>=2}
+ * to point to quads in @p dim space dimensions (only @p{dim>=2}
* seems reasonable to me). There is a derived class for quads in
* two space dimension, in which case a quad is also a cell and thus
* has much more functionality than in other dimensions.
/**
* Return a reference to the
- * @p{i}th vertex.
+ * @p ith vertex.
*/
Point<dim> & vertex (const unsigned int i) const;
/**
* Return a pointer to the
- * @p{i}th line bounding this
- * @ref{Quad}.
+ * @p ith line bounding this
+ * Quad.
*/
TriaIterator<dim,TriaObjectAccessor<1, dim> >
line (const unsigned int i) const;
/**
* Return the line index of the
- * @p{i}th side (a line). The
+ * @p ith side (a line). The
* level is naturally the same as
* that of the quad.
*/
/**
* Test for the element being
* used or not. The return
- * value is @p{true} for all
+ * value is @p true for all
* iterators that are either
* normal iterators or active
* iterators, only raw iterators
- * can return @p{false}. Since
+ * can return @p false. Since
* raw iterators are only used
* in the interiors of the
* library, you will not usually
bool used () const;
/**
- * Set the @p{used} flag. You
+ * Set the @p used flag. You
* should know quite exactly
* what you are doing of you
* touch this function. It is
void set_used_flag () const;
/**
- * Clear the @p{used} flag. You
+ * Clear the @p used flag. You
* should know quite exactly
* what you are doing of you
* touch this function. It is
/**
* Set the user pointer of this
- * quad to @p{p}.
+ * quad to @p p.
*/
void set_user_pointer (void *p) const;
/**
* Reset the user pointer of this
- * quad to a @p{NULL} pointer.
+ * quad to a @p NULL pointer.
*/
void clear_user_pointer () const;
* object and all of its
* descendants. The same holds as
* said for the
- * @ref{recursively_set_user_pointer}
+ * recursively_set_user_pointer()
* function.
*/
void recursively_clear_user_pointer () const;
/**
- * Return a pointer to the @p{i}th
+ * Return a pointer to the @p ith
* child.
*/
TriaIterator<dim,TriaObjectAccessor<2, dim> > child (const unsigned int i) const;
/**
* Return the index of the
- * @p{i}th child. The level of
+ * @p ith child. The level of
* the child is one higher than
* that of the present cell. If
* the child does not exist, -1
* refined. Note that not all its
* children are refined that
* often (which is why we prepend
- * @p{max_}), the returned number
+ * @p max_), the returned number
* is rather the maximum number
* of refinement in any branch of
* children of this object.
* function is only useful for
* @p{dim>2}; however, for
* @p{dim==2}, a quad is a cell
- * and the @ref{CellAccessor}
+ * and the CellAccessor
* class offers another
* possibility to determine
* whether a cell is at the
/**
* Return the barycenter of the
* qaud. The same applies as for
- * the @p{center} function with
+ * the @p center function with
* regard to quads at the
* boundary.
*/
/**
* Return whether the face with
- * index @p{face} has its normal
+ * index @p face has its normal
* pointing in the standard
- * direction (@p{true}) or
+ * direction (@p true) or
* whether it is the opposite
- * (@p{false}). Which is the
+ * (@p false). Which is the
* standard direction is
* documented with the
- * @ref{Triangulation} class. In
+ * Triangulation class. In
* 1d and 2d, this is always
- * @p{true}, but in 3d it may be
+ * @p true, but in 3d it may be
* different, see the respective
* discussion in the
* documentation of the
- * @ref{Triangulation} class.
+ * Triangulation class.
*
* This function is really only
* for internal use in the
* 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
+ * 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
/**
* Accessor to dereference the data of hexahedra. This accessor is
- * used to point to hexs in @p{dim} space dimensions (only
+ * used to point to hexs in @p dim space dimensions (only
* @p{dim>=3} seems reasonable to me). There is a derived class for
* hexs in three space dimension, in which case a hex is also a cell
* and thus has much more functionality than in other dimensions.
* vertex. It has nothing to do with
* possible degrees of freedom
* associated with it. For this, see the
- * @p{DoFAccessor::vertex_dof_index}
+ * @p DoFAccessor::vertex_dof_index
* functions.
*/
int vertex_index (const unsigned int i) const;
/**
* Return a reference to the
- * @p{i}th vertex.
+ * @p ith vertex.
*/
Point<dim> & vertex (const unsigned int i) const;
/**
* Return a pointer to the
- * @p{i}th line bounding this
- * @p{Hex}.
+ * @p ith line bounding this
+ * @p Hex.
*/
TriaIterator<dim,TriaObjectAccessor<1, dim> >
line (const unsigned int i) const;
/**
* Return the line index of the
- * @p{i}th line. The level is
+ * @p ith line. The level is
* naturally the same as that of
* the hex.
*/
/**
* Return a pointer to the
- * @p{i}th quad bounding this
- * @p{Hex}.
+ * @p ith quad bounding this
+ * @p Hex.
*/
TriaIterator<dim,TriaObjectAccessor<2, dim> >
quad (const unsigned int i) const;
/**
* Return the quad index of the
- * @p{i}th side (a quad). The
+ * @p ith side (a quad). The
* level is naturally the same as
* that of the hex.
*/
/**
* Test for the element being
* used or not. The return
- * value is @p{true} for all
+ * value is @p true for all
* iterators that are either
* normal iterators or active
* iterators, only raw iterators
- * can return @p{false}. Since
+ * can return @p false. Since
* raw iterators are only used
* in the interiors of the
* library, you will not usually
bool used () const;
/**
- * Set the @p{used} flag. You
+ * Set the @p used flag. You
* should know quite exactly
* what you are doing of you
* touch this function. It is
void set_used_flag () const;
/**
- * Clear the @p{used} flag. You
+ * Clear the @p used flag. You
* should know quite exactly
* what you are doing of you
* touch this function. It is
/**
* Set the user pointer of this
- * hex to @p{p}.
+ * hex to @p p.
*/
void set_user_pointer (void *p) const;
/**
* Reset the user pointer of this
- * hex to a @p{NULL} pointer.
+ * hex to a @p NULL pointer.
*/
void clear_user_pointer () const;
* object and all of its
* descendants. The same holds as
* said for the
- * @ref{recursively_set_user_pointer}
+ * recursively_set_user_pointer()
* function.
*/
void recursively_clear_user_pointer () const;
/**
* Return a pointer to the
- * @p{i}th child.
+ * @p ith child.
*/
TriaIterator<dim,TriaObjectAccessor<3, dim> >
child (const unsigned int i) const;
/**
* Return the index of the
- * @p{i}th child. The level of
+ * @p ith child. The level of
* the child is one higher than
* that of the present cell. If
* the child does not exist, -1
* refined. Note that not all its
* children are refined that
* often (which is why we prepend
- * @p{max_}), the returned number
+ * @p max_), the returned number
* is rather the maximum number
* of refinement in any branch of
* children of this object.
* possible for @p{dim>3};
* however, for @p{dim==3}, a hex
* is a cell and the
- * @ref{CellAccessor} class
+ * CellAccessor class
* offers another possibility to
* determine whether a cell is at
* the boundary or not.
/**
* Return whether the face with
- * index @p{face} has its normal
+ * index @p face has its normal
* pointing in the standard
- * direction (@p{true}) or
+ * direction (@p true) or
* whether it is the opposite
- * (@p{false}). Which is the
+ * (@p false). Which is the
* standard direction is
* documented with the
- * @ref{Triangulation} class. In
+ * Triangulation class. In
* 1d and 2d, this is always
- * @p{true}, but in 3d it may be
+ * @p true, but in 3d it may be
* different, see the respective
* discussion in the
* documentation of the
- * @ref{Triangulation} class.
+ * Triangulation class.
*
* This function is really only
* for internal use in the
/**
* Set whether the quad with
- * index @p{face} has its normal
+ * index @p face has its normal
* pointing in the standard
- * direction (@p{true}) or
+ * direction (@p true) or
* whether it is the opposite
- * (@p{false}). Which is the
+ * (@p false). Which is the
* standard direction is
* documented with the
- * @ref{Triangulation} class.
+ * Triangulation class.
*
* This function is only for
* internal use in the
* 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
+ * object pointed to by @p b to
* the object pointed to by
- * @p{a} and since accessors are
+ * @p a and since accessors are
* not real but virtual objects,
* this operation is not useful
* for iterators on
/**
* Return a pointer to the
- * @p{i}th neighbor. If the
+ * @p ith neighbor. If the
* neighbor does not exist, an
* invalid iterator is returned.
*/
/**
* Return the index of the
- * @p{i}th neighbor. If the
+ * @p ith neighbor. If the
* neighbor does not exist, its
* index is -1.
*/
/**
* Return the level of the
- * @p{i}th neighbor. If the
+ * @p ith neighbor. If the
* neighbor does not exist, its
* level is -1.
*/
int neighbor_level (const unsigned int i) const;
/**
- * Set the neighbor @p{i} of
+ * Set the neighbor @p i of
* this cell to the cell pointed
- * to by @p{pointer}. This line
+ * to by @p pointer. This line
* must be used.
*/
void set_neighbor (const unsigned int i,
* Return the how-many'th
* neighbor this cell is of
* @p{cell->neighbor(neighbor)},
- * i.e. return the number @p{n}
+ * i.e. return the number @p n
* such that
* @p{cell->neighbor(neighbor)->neighbor(n)==cell}. This
* function is the right one if
* (i.e. @p{cell->neighbor(neighbor)->level()}
* needs to be equal to
* @p{cell->level()}. Use the
- * @p{neighbor_of_coarser_neighbor}
+ * @p neighbor_of_coarser_neighbor
* function in that case.
*/
unsigned int neighbor_of_neighbor (const unsigned int neighbor) const;
/**
* This function is a
* generalization of the
- * @p{neighbor_of_neighbor}
+ * @p neighbor_of_neighbor
* function for the case of a
* coarser neighbor. It returns a
* pair of numbers, face_no and
neighbor_of_coarser_neighbor (const unsigned int neighbor) const;
/**
- * Return whether the @p{i}th
+ * Return whether the @p ith
* vertex or face (depending on
* the dimension) is part of the
* boundary. This is true, if
- * the @p{i}th neighbor does not
+ * the @p ith neighbor does not
* exist.
*/
bool at_boundary (const unsigned int i) const;
* interiors of all faces are in
* the interior of the
* domain. For the latter case,
- * the @p{has_boundary_lines}
+ * the @p has_boundary_lines
* function is the right one to
* ask.
*/
/**
* This is a slight variation to
- * the @p{at_boundary} function:
+ * the @p at_boundary function:
* for 1 and 2 space dimensions,
* it is equivalent, for three
* space dimensions it returns
/**
* Return a pointer to the
- * @p{i}th child. Overloaded
+ * @p ith child. Overloaded
* version which returns a more
* reasonable iterator class.
*/
/**
* Return an iterator to the
- * @p{i}th face of this cell.
+ * @p ith face of this cell.
*
* This function is not
* implemented in 1D, and maps to
* of the neighbor cell the
* present cell is bordering on
* (this is what the
- * @p{neighbor_of_neighbor}
+ * @p neighbor_of_neighbor
* function does), and then
* asking
- * @p{GeometryInfo::child_cell_on_subface}
+ * @p GeometryInfo::child_cell_on_subface
* for the index of the
* child. However, the function
* is more complicated in 3d,
* since there faces may have
* more than one orientation, and
* we have to use
- * @p{face_orientation} for both
+ * @p face_orientation for both
* this and the neighbor cell to
* figure out which cell we want
* to have.
bool active () const;
/**
- * Test whether the point @p{p}
+ * Test whether the point @p p
* is inside this cell. Points on
* the boundary are counted as
* being inside the cell.
* 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
+ * 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
{
Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
// cells flagged for refinement must be active
- // (the @p{set_refine_flag} function checks this,
+ // (the @p set_refine_flag function checks this,
// but activity may change when refinement is
// executed and for some reason the refine
// flag is not cleared).
{
Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
// cells flagged for coarsening must be active
- // (the @p{set_refine_flag} function checks this,
+ // (the @p set_refine_flag function checks this,
// but activity may change when refinement is
// executed and for some reason the refine
// flag is not cleared).
* When a triangulation creates a new vertex on the boundary of the
* domain, it determines the new vertex' coordinates through the
* following code (here in two dimensions):
- * @begin{verbatim}
+ * @verbatim
* ...
* Point<2> new_vertex = boundary.get_new_point_on_line (line);
* ...
- * @end{verbatim}
- * @p{line} denotes the line at the boundary that shall be refined
+ * @endverbatim
+ * @p line denotes the line at the boundary that shall be refined
* and for which we seek the common point of the two child lines.
*
* In 3D, a new vertex may be placed on the middle of a line or on
* the middle of a side. Respectively, the library calls
- * @begin{verbatim}
+ * @verbatim
* ...
* Point<3> new_line_vertices[4]
* = { boundary.get_new_point_on_line (face->line(0)),
* boundary.get_new_point_on_line (face->line(2)),
* boundary.get_new_point_on_line (face->line(3)) };
* ...
- * @end{verbatim}
+ * @endverbatim
* to get the four midpoints of the lines bounding the quad at the
* boundary, and after that
- * @begin{verbatim}
+ * @verbatim
* ...
* Point<3> new_quad_vertex = boundary.get_new_point_on_quad (face);
* ...
- * @end{verbatim}
+ * @endverbatim
* to get the midpoint of the face. It is guaranteed that this order
* (first lines, then faces) holds, so you can use information from
* the children of the four lines of a face, since these already exist
* about boundary indicators and the like, as well as all other information
* provided by these objects.
*
- * There are specialisations, @ref{StraightBoundary}, which places
+ * There are specialisations, StraightBoundary, which places
* the new point right into the middle of the given points, and
- * @ref{HyperBallBoundary} creating a hyperball with given radius
+ * HyperBallBoundary creating a hyperball with given radius
* around a given center point.
*
* @author Wolfgang Bangerth, 1999, 2001, Ralf Hartmann, 2001
*
* This function is called after
* the four lines bounding the
- * given @p{quad} are refined, so
+ * given @p quad are refined, so
* you may want to use the
* information provided by
* @p{quad->line(i)->child(j)},
*
* The number of points requested
* is given by the size of the
- * vector @p{points}. It is the
+ * vector @p points. It is the
* task of the derived classes to
* arrange the points in
* approximately equal distances.
*
* This function is called by the
- * @p{MappingQ} class. This
+ * @p MappingQ class. This
* happens on each face line of a
* cells that has got at least
* one boundary line.
*
* As this function is not needed
- * for @p{MappingQ1}, it is not
+ * for @p MappingQ1, it is not
* made pure virtual, to avoid
* the need to overload it. The
* default implementation throws
*
* The number of points requested
* is given by the size of the
- * vector @p{points}. It is
+ * vector @p points. It is
* required that this number is a
* square of another integer,
* i.e. @p{n=points.size()=m*m}. It
* least one boundary face quad.
*
* As this function is not needed
- * for @p{MappingQ1}, it is not
+ * for @p MappingQ1, it is not
* made pure virtual, to avoid
* the need to overload it. The
* default implementation throws
/**
- * Specialisation of @ref{Boundary}<dim>, which places the new point
+ * Specialisation of Boundary<dim>, which places the new point
* right into the middle of the given points. The middle is defined
* as the arithmetic mean of the points.
*
/**
* Boundary object for the hull of a cylinder. In three dimensions,
- * points are projected on a circular tube along the @p{x}-axis. The
- * radius of the tube can be set. Similar to @ref{HyperBallBoundary},
+ * points are projected on a circular tube along the @p x-axis. The
+ * radius of the tube can be set. Similar to HyperBallBoundary,
* new points are projected by dividing the straight line between the
- * old two points and adjusting the radius in the @p{yz}-plane.
+ * old two points and adjusting the radius in the @p yz-plane.
*
* This class was developed to be used in conjunction with the
- * @p{cylinder} function of @ref{GridGenerator}. It should be used for
+ * @p cylinder function of GridGenerator. It should be used for
* the hull of the cylinder only (boundary indicator 0).
*
- * This class is derived from @ref{StraightBoundary} rather than from
- * @ref{Boundary}, which would seem natural, since this way we can use the
- * @ref{StraightBoundary}@p{<dim>::in_between(neighbors)} function.
+ * This class is derived from StraightBoundary rather than from
+ * Boundary, which would seem natural, since this way we can use the
+ * StraightBoundary@p{<dim>::in_between(neighbors)} function.
*
* @author Guido Kanschat, 2001
*/
* base class.
*
* Calls
- * @p{get_intermediate_points_between_points}.
+ * @p get_intermediate_points_between_points.
*/
virtual void
get_intermediate_points_on_line (const typename Triangulation<dim>::line_iterator &line,
/**
* Exception. Thrown by the
- * @p{get_radius} if the
- * @p{compute_radius_automatically},
+ * @p get_radius if the
+ * @p compute_radius_automatically,
* see below, flag is set true.
*/
DeclException0 (ExcRadiusNotSet);
/**
* Called by
- * @p{get_intermediate_points_on_line}
+ * @p get_intermediate_points_on_line
* and by
- * @p{get_intermediate_points_on_quad}.
+ * @p get_intermediate_points_on_quad.
*
* Refer to the general
* documentation of
- * @p{get_intermediate_points_on_line}
+ * @p get_intermediate_points_on_line
* in the documentation of the
* base class.
*/
/**
- * Specialisation of @ref{Boundary}<dim>, which places the new point on
+ * Specialisation of Boundary<dim>, which places the new point on
* the boundary of a ball in arbitrary dimension. It works by projecting
* the point in the middle of the old points onto the ball. The middle is
* defined as the arithmetic mean of the points.
* The center of the ball and its radius may be given upon construction of
* an object of this type. They default to the origin and a radius of 1.0.
*
- * This class is derived from @ref{StraightBoundary} rather than from
- * @ref{Boundary}, which would seem natural, since this way we can use the
- * @ref{StraightBoundary}@p{<dim>::in_between(neighbors)} function.
+ * This class is derived from StraightBoundary rather than from
+ * Boundary, which would seem natural, since this way we can use the
+ * StraightBoundary@p{<dim>::in_between(neighbors)} function.
*
* @author Wolfgang Bangerth, 1998, Ralf Hartmann, 2001
*/
* base class.
*
* Calls
- * @p{get_intermediate_points_between_points}.
+ * @p get_intermediate_points_between_points.
*/
virtual void
get_intermediate_points_on_line (const typename Triangulation<dim>::line_iterator &line,
/**
* Exception. Thrown by the
- * @p{get_radius} if the
- * @p{compute_radius_automatically},
+ * @p get_radius if the
+ * @p compute_radius_automatically,
* see below, flag is set true.
*/
DeclException0 (ExcRadiusNotSet);
const double radius;
/**
- * This flag is @p{false} for
+ * This flag is @p false for
* this class and for all derived
* classes that set the radius by
* the constructor. For example
- * this flag is @p{false} for the
- * @ref{HalfHyperBallBoundary}
- * class but it is @p{true} for
- * the @ref{HyperShellBoundary}
+ * this flag is @p false for the
+ * HalfHyperBallBoundary
+ * class but it is @p true for
+ * the HyperShellBoundary
* class, for example. The
* latter class doesn't get its
* radii by the constructor but
/**
* Called by
- * @p{get_intermediate_points_on_line}
+ * @p get_intermediate_points_on_line
* and by
- * @p{get_intermediate_points_on_quad}.
+ * @p get_intermediate_points_on_quad.
*
* Refer to the general
* documentation of
- * @p{get_intermediate_points_on_line}
+ * @p get_intermediate_points_on_line
* in the documentation of the
* base class.
*/
/**
- * Variant of @ref{HyperBallBoundary} which denotes a half hyper ball
+ * Variant of HyperBallBoundary which denotes a half hyper ball
* where the first coordinate is restricted to the range $x>=0$ (or
* $x>=center(0)$). In two dimensions, this equals the right half
* circle, in three space dimensions it is a half ball. This class
* base class.
*
* Calls
- * @p{get_intermediate_points_between_points}.
+ * @p get_intermediate_points_between_points.
*/
virtual void
get_intermediate_points_on_line (const typename Triangulation<dim>::line_iterator &line,
* origin.
*
* Calls the constructor of its
- * base @p{HyperBallBoundary}
+ * base @p HyperBallBoundary
* class with a dummy radius as
* argument. This radius will be
* ignored
/**
- * Variant of @ref{HyperShellBoundary} which denotes a half hyper shell
+ * Variant of HyperShellBoundary which denotes a half hyper shell
* where the first coordinate is restricted to the range $x>=0$ (or
* $x>=center(0)$). In two dimensions, this equals the right half arc,
* in three space dimensions it is a half shell. This class might be
* base class.
*
* Calls
- * @p{get_intermediate_points_between_points}.
+ * @p get_intermediate_points_between_points.
*/
virtual void
get_intermediate_points_on_line (const typename Triangulation<dim>::line_iterator &line,
#include <base/exceptions.h>
/**
- * @p{Hexahedron}s denote the fundamental entities of triangulations
+ * @p Hexahedrons denote the fundamental entities of triangulations
* in three dimensions. They are characterized by the (global)
* indices of the six bounding quadrilaterals.
*
*
* For conventions on the numbering of faces, lines and vertices
* within a hexahedron, refer to the documentation of the
- * @ref{Triangulation} class.
+ * Triangulation class.
*
* @author Wolfgang Bangerth, 1998
*/
/**
* Construct a Hex with quad
- * indices @p{i0} through
- * @p{i5}. By default, indices
+ * indices @p i0 through
+ * @p i5. By default, indices
* are set to -1, i.e. an
* invalid value.
*
/**
* Return the index of quad
- * @p{i}=0 through 5.
+ * @p i=0 through 5.
*/
int quad (const int i) const;
/**
- * Set the index of the @p{i}th
- * quad to @p{index}. @p{i}=0
+ * Set the index of the @p ith
+ * quad to @p index. @p i=0
* through 5.
*/
void set_quad (const int i, const int index);
* Through this constructor, it is also
* possible to construct objects for
* derived iterators:
- * @begin{verbatim}
+ * @verbatim
* DoFCellAccessor dof_accessor;
* Triangulation::active_cell_iterator cell
* = accessor;
- * @end{verbatim}
+ * @endverbatim
*/
TriaRawIterator (const Accessor &a);
* iterator type and copies the data;
* this conversion works, if there is
* a conversion path from the
- * @p{OtherAccessor} class to the @p{Accessor}
+ * @p OtherAccessor class to the @p Accessor
* class of this object. One such path
* would be derived class to base class,
* which for example may be used to get
- * a @ref{Triangulation}@p{::raw_cell_iterator} from
- * a @ref{DoFHandler}@p{::raw_cell_iterator}, since
- * the @ref{DoFAccessor} class is derived from
- * the @ref{TriaAccessor} class.
+ * a Triangulation@p ::raw_cell_iterator from
+ * a DoFHandler@p ::raw_cell_iterator, since
+ * the DoFAccessor class is derived from
+ * the TriaAccessor class.
*
- * Since @ref{TriaIterator} and
- * @ref{TriaActiveIterator} are derived classes
+ * Since TriaIterator and
+ * TriaActiveIterator are derived classes
* of this class, this constructor also
* serves to convert these iterators with
* other accessor classes.
*
* This function has to be specialized
* explicitly for the different
- * @p{Pointee}s, to allow an
+ * @p Pointees, to allow an
* @p{iterator<1,TriangulationLevel<1>::LinesData>}
* to point to @p{tria->lines.lines[index]} while
* for one dimension higher it has
const Accessor & operator * () const;
/**
- * Dereferencing operator, non-@p{const}
+ * Dereferencing operator, non-@p const
* version.
*/
Accessor & operator * ();
* reference of the cell pointed to.
* Usage is thus like @p{i->index ();}
*
- * There is a @p{const} and a non-@p{const}
+ * There is a @p const and a non-@p const
* version.
*/
const Accessor * operator -> () const;
/**
- * Dereferencing operator, non-@p{const}
+ * Dereferencing operator, non-@p const
* version.
*/
Accessor * operator -> ();
/**
* Offer a weak ordering of iterators,
- * which is needed to make @p{map}s with
+ * which is needed to make @p maps with
* iterators being keys. An iterator
- * pointing to an element @p{a} is
+ * pointing to an element @p a is
* less than another iterator pointing
- * to an element @p{b} if
+ * to an element @p b if
* level(a)<level(b) or
* (level(a)==level(b) and index(a)<index(b)).
*
* priviously pointed to. Since this
* involves a temporary and a copy
* operation and since an
- * @p{iterator} is quite a large
+ * @p iterator is quite a large
* object for a pointer, use the
* prefix operator @p{++i} whenever
* possible, especially in the head
TriaRawIterator operator ++ (int);
/**
- * Prefix @p{--} operator: @p{--i}. This
+ * Prefix @p -- operator: @p --i. This
* operator advances the iterator to
* the previous element and returns
* a reference to @p{*this}.
TriaRawIterator & operator -- ();
/**
- * Postfix @p{--} operator: @p{i--}. This
+ * Postfix @p -- operator: @p i--. This
* operator advances the iterator to
* the previous element, but
* returns an iterator to the element
* priviously pointed to. Since this
* involves a temporary and a copy
* operation and since an
- * @p{iterator} is quite a large
+ * @p iterator is quite a large
* object for a pointer, use the
- * prefix operator @p{--i} whenever
+ * prefix operator @p --i whenever
* possible, especially in the head
* of for loops
* (@p{for (; i!=end; --i)}) since there
IteratorState::IteratorStates state () const;
/**
- * Print the iterator to @p{out}. The
+ * Print the iterator to @p out. The
* format is like @p{level.index}.
*/
void print (std::ostream &out) const;
* iterator type and copies the data;
* this conversion works, if there is
* a conversion path from the
- * @p{OtherAccessor} class to the @p{Accessor}
+ * @p OtherAccessor class to the @p Accessor
* class of this object. One such path
* would be derived class to base class,
* which for example may be used to get
- * a @ref{Triangulation}@p{::cell_iterator} from
- * a @ref{DoFHandler}@p{::cell_iterator}, since
- * the @ref{DoFAccessor} class is derived from
- * the @ref{TriaAccessor} class.
+ * a Triangulation@p ::cell_iterator from
+ * a DoFHandler@p ::cell_iterator, since
+ * the DoFAccessor class is derived from
+ * the TriaAccessor class.
*
- * Since @ref{TriaActiveIterator} is a derived
+ * Since TriaActiveIterator is a derived
* class of this class, this constructor
* also serves to convert these iterators
* with other accessor classes.
* previously pointed to. Since this
* involves a temporary and a copy
* operation and since an
- * @p{active_iterator} is quite a large
+ * @p active_iterator is quite a large
* object for a pointer, use the
* prefix operator @p{++i} whenever
* possible, especially in the head
TriaIterator<dim,Accessor> operator ++ (int);
/**
- * Prefix @p{--} operator: @p{--i}. This
+ * Prefix @p -- operator: @p --i. This
* operator advances the iterator to
* the previous used element and returns
* a reference to @p{*this}.
TriaIterator<dim,Accessor> & operator -- ();
/**
- * Postfix @p{--} operator: @p{i--}.
+ * Postfix @p -- operator: @p i--.
*/
TriaIterator<dim,Accessor> operator -- (int);
/*@}*/
* iterator type and copies the data;
* this conversion works, if there is
* a conversion path from the
- * @p{OtherAccessor} class to the @p{Accessor}
+ * @p OtherAccessor class to the @p Accessor
* class of this object. One such path
* would be derived class to base class,
* which for example may be used to get
- * a @ref{Triangulation}@p{::active_cell_iterator} from
- * a @ref{DoFHandler}@p{::active_cell_iterator}, since
- * the @ref{DoFAccessor} class is derived from
- * the @ref{TriaAccessor} class.
+ * a Triangulation@p ::active_cell_iterator from
+ * a DoFHandler@p ::active_cell_iterator, since
+ * the DoFAccessor class is derived from
+ * the TriaAccessor class.
*/
template <typename OtherAccessor>
TriaActiveIterator (const TriaActiveIterator<dim,OtherAccessor> &i);
* previously pointed to. Since this
* involves a temporary and a copy
* operation and since an
- * @p{active_iterator} is quite a large
+ * @p active_iterator is quite a large
* object for a pointer, use the
* prefix operator @p{++i} whenever
* possible, especially in the head
TriaActiveIterator<dim,Accessor> operator ++ (int);
/**
- * Prefix @p{--} operator: @p{--i}. This
+ * Prefix @p -- operator: @p --i. This
* operator advances the iterator to
* the previous active element and
* returns a reference to @p{*this}.
TriaActiveIterator<dim,Accessor> & operator -- ();
/**
- * Postfix @p{--} operator: @p{i--}.
+ * Postfix @p -- operator: @p i--.
*/
TriaActiveIterator<dim,Accessor> operator -- (int);
/*@}*/
/**
- * Print the address to which this iterator points to @p{out}. The
- * address is given by the pair @p{(level,index)}, where @p{index} is
+ * Print the address to which this iterator points to @p out. The
+ * address is given by the pair @p{(level,index)}, where @p index is
* an index relative to the level in which the object is that is
* pointed to.
*
/**
- * Print the address to which this iterator points to @p{out}. The
- * address is given by the pair @p{(level,index)}, where @p{index} is
+ * Print the address to which this iterator points to @p out. The
+ * address is given by the pair @p{(level,index)}, where @p index is
* an index relative to the level in which the object is that is
* pointed to.
*
/**
- * Print the address to which this iterator points to @p{out}. The
- * address is given by the pair @p{(level,index)}, where @p{index} is
+ * Print the address to which this iterator points to @p out. The
+ * address is given by the pair @p{(level,index)}, where @p index is
* an index relative to the level in which the object is that is
* pointed to.
*
* vector depends on the dimension: in
* one dimension, the length of this
* vector equals the length of the
- * @p{lines} vector, in two dimensions
- * that of the @p{quads} vector, etc.
+ * @p lines vector, in two dimensions
+ * that of the @p quads vector, etc.
*/
std::vector<bool> refine_flags;
/**
* Levels and indices of the neighbors
* of the cells. Convention is, that the
- * neighbors of the cell with index @p{i}
+ * neighbors of the cell with index @p i
* are stored in the fields following
* $i*(2*real_space_dimension)$, e.g. in
* one spatial dimension, the neighbors
* is set.
*
* <em>Conventions:</em> The
- * @p{i}th neighbor of a cell is
+ * @p ith 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.
+ * @p ith 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
/**
* Reserve enough space to accomodate
- * @p{total_cells} cells on this level.
- * Since there are no @p{used} flags on this
+ * @p total_cells cells on this level.
+ * Since there are no @p used flags on this
* level, you have to give to total number
* of cells, not only the number of newly
* to accomodate ones, like in the
/**
* Check the memory consistency of the
* different containers. Should only be
- * called with the prepro flag @p{DEBUG}
+ * called with the prepro flag @p DEBUG
* set. The function should be called from
* the functions of the higher
- * @ref{TriangulationLevel} classes.
+ * TriangulationLevel classes.
*/
void monitor_memory (const unsigned int true_dimension) const;
*
* In one dimension, this is a list of the lines associated with this level,
* as well as a list with the indices of the children of these lines.
- * The @ref{TriangulationsLevel} objects of higher dimensions are derived from
+ * The TriangulationsLevel objects of higher dimensions are derived from
* this one.
*
* @author Wolfgang Bangerth, 1998
* stored in this list. A line is
* called active if it has no
* children. The function
- * @ref{TriaIterator}@p{::active()}
+ * TriaIterator@p{::active()}
* tests for this.
*/
std::vector<int> children;
/**
* Vector storing whether a line is
- * used in the @p{lines} vector.
+ * used in the @p lines vector.
*
* Since it is difficult to delete
- * elements in a @p{vector}, when an
+ * elements in a @p vector, when an
* element is not needed any more
* (e.g. after derefinement), it is
* not deleted from the list, but
- * rather the according @p{used} flag
- * is set to @p{false}.
+ * rather the according @p used flag
+ * is set to @p false.
*/
std::vector<bool> used;
* already been processed.
*
* You can clear all used flags using
- * @ref{Triangulation}@p{::clear_user_flags()}.
+ * Triangulation@p{::clear_user_flags()}.
*/
std::vector<bool> user_flags;
/**
* Assert that enough space is allocated
- * to accomodate @p{new_lines} new lines.
+ * to accomodate @p new_lines new lines.
* This function does not only call
* @p{vector::reserve()}, but does really
* append the needed elements.
* between the number of new quads and
* the number of new lines, etc.). Also
* don't forget to call the
- * @ref{TriangulationLevel<0>}@p{::reserve_space}
+ * @ref{TriangulationLevel<0>}@p ::reserve_space
* function.
*/
void reserve_space (const unsigned int new_lines);
/**
* Check the memory consistency of the
* different containers. Should only be
- * called with the prepro flag @p{DEBUG}
+ * called with the prepro flag @p DEBUG
* set. The function should be called from
* the functions of the higher
- * @ref{TriangulationLevel} classes.
+ * TriangulationLevel classes.
*/
void monitor_memory (const unsigned int true_dimension) const;
*
* It is fully analogous to the
* @ref{TriangulationLevel<1>::LinesData} structure inherited from
- * @ref{Triangulation}@p{<1>}.
+ * Triangulation@p{<1>}.
*/
struct QuadsData
{
/**
- * Same as for the @p{lines} array.
+ * Same as for the @p lines array.
*/
std::vector<Quad> quads;
/**
* Same as for the
- * @ref{TriangulationLevel<1>::LinesData}@p{::chilren}
+ * @ref{TriangulationLevel<1>::LinesData}@p ::chilren
* array, but since there
* are four children, the
* index points to the first
/**
* Same as for
- * @ref{TriangulationLevel<1>::LinesData}@p{::used}.
+ * @ref{TriangulationLevel<1>::LinesData}@p ::used.
*/
std::vector<bool> used;
/**
* Same as for
- * @ref{TriangulationLevel<1>::LinesData}@p{::used}.
+ * @ref{TriangulationLevel<1>::LinesData}@p ::used.
*/
std::vector<bool> user_flags;
/**
* Assert that enough space is allocated
- * to accomodate @p{new_quads} new quads.
+ * to accomodate @p new_quads new quads.
*/
void reserve_space (const unsigned int new_quads);
/**
* Check the memory consistency of the
* different containers. Should only be
- * called with the prepro flag @p{DEBUG}
+ * called with the prepro flag @p DEBUG
* set. The function should be called from
* the functions of the higher
- * @ref{TriangulationLevel} classes.
+ * TriangulationLevel classes.
*/
void monitor_memory (const unsigned int true_dimension) const;
struct HexesData
{
/**
- * Same as for the @p{lines} array.
+ * Same as for the @p lines array.
*/
std::vector<Hexahedron> hexes;
/**
* Same as for the
- * @ref{TriangulationLevel<1>::LinesData}@p{::chilren}
+ * @ref{TriangulationLevel<1>::LinesData}@p ::chilren
* array, but since there
* are four children, the
* index points to the first
/**
* Same as for
- * @ref{TriangulationLevel<1>::LinesData}@p{::used}.
+ * @ref{TriangulationLevel<1>::LinesData}@p ::used.
*/
std::vector<bool> used;
/**
* Same as for
- * @ref{TriangulationLevel<1>::LinesData}@p{::used}.
+ * @ref{TriangulationLevel<1>::LinesData}@p ::used.
*/
std::vector<bool> user_flags;
* follows this convention or
* not. If this is so, then
* this variable stores a
- * @p{true} value, otherwise
- * a @p{false} value.
+ * @p true value, otherwise
+ * a @p false value.
*
* In effect, this field has
* @p{6*n_cells} elements,
/**
* Assert that enough space is allocated
- * to accomodate @p{new_quads} new quads.
+ * to accomodate @p new_quads new quads.
*/
void reserve_space (const unsigned int new_quads);
* of the different
* containers. Should only be
* called with the prepro flag
- * @p{DEBUG} set. The function
+ * @p DEBUG set. The function
* should be called from the
* functions of the higher
- * @ref{TriangulationLevel}
+ * TriangulationLevel
* classes.
*/
void monitor_memory (const unsigned int true_dimension) const;
public:
/**
* Construct a line with end point
- * indices @p{i0} and @p{i1}. By default,
+ * indices @p i0 and @p i1. By default,
* indices are set to -1, i.e. an
* invalid value.
*/
const int i1 = -1);
/**
- * Return the index of end point @p{i}=0
+ * Return the index of end point @p i=0
* or 1.
*/
int vertex (const int i) const;
/**
- * Set the index of the @p{i}th vertex to
- * @p{index}. @p{i}=0 or 1.
+ * Set the index of the @p ith vertex to
+ * @p index. @p i=0 or 1.
*/
void set_vertex (const int i, const int index);
/**
- * @p{Quad}s denote the fundamental entities of triangulations in two dimensions
+ * @p Quads denote the fundamental entities of triangulations in two dimensions
* and the boundaries of hexaeders in three dimensions. They are
* characterized by the (global) indices of the dour bounding lines.
*
/**
* Construct a Quad with line
- * indices @p{i0} through @p{i3}. By default,
+ * indices @p i0 through @p i3. By default,
* indices are set to -1, i.e. an
* invalid value.
*
const int i3 = -1);
/**
- * Return the index of line @p{i}=0
+ * Return the index of line @p i=0
* through 3.
*/
int line (const int i) const;
/**
- * Set the index of the @p{i}th line to
- * @p{index}. @p{i}=0 through 3.
+ * Set the index of the @p ith line to
+ * @p index. @p i=0 through 3.
*/
void set_line (const int i, const int index);
* This is a little wrapper, transforming a triplet of iterative
* solver, matrix and preconditioner into a coarse grid solver.
*
- * The type of the matrix (i.e. the template parameter @p{MATRIX})
- * should be derived from @p{Subscriptor} to allow for the use of a
+ * The type of the matrix (i.e. the template parameter @p MATRIX)
+ * should be derived from @p Subscriptor to allow for the use of a
* smart pointer to it.
*
* @author Guido Kanschat, 1999, Ralf Hartmann, 2002.
* Coarse grid solver by QR factorization
*
* This is a direct solver for possibly indefinite coarse grid
- * problems, using the @p{least_squares} function of the class
+ * problems, using the @p least_squares function of the class
* FullMatrix.
*
* Since the currently implemented Householder algorithm transforms
* a multigrid DoF handler object.
*
* Note that it is allowed to construct an object of which the
- * @p{mg_dof_handler} pointer is a Null pointer. Such an object would
+ * @p mg_dof_handler pointer is a Null pointer. Such an object would
* result in a strange kind of behaviour, though every reasonable
* operating system should disallow access through that pointer.
* The reason we do not check for the null pointer in the
- * constructor which gets passed the @ref{DoFHandler} pointer is that
+ * constructor which gets passed the DoFHandler pointer is that
* if we did we could not make dof iterators member of other classes
- * (like in the @p{FEValues} class) if we did not know about the
- * @ref{DoFHandler} object to be used upon construction of that object.
+ * (like in the @p FEValues class) if we did not know about the
+ * DoFHandler object to be used upon construction of that object.
* Through the way this class is implemented here, we allow the
* creation of a kind of virgin object which only gets useful if
* assigned to from another object before first usage.
* which has an invalid dof handler pointer. This is to guarantee
* that every iterator which is once assigned to is a valid
* object. However, this assertion only holds in debug mode, when
- * the @p{Assert} macro is switched on.
+ * the @p Assert macro is switched on.
*
* @author Wolfgang Bangerth, 1998
*/
/**
* This should be the default constructor.
- * We cast away the @p{const}ness of the
+ * We cast away the @p constness of the
* pointer which clearly is EVIL but
* we can't help without making all
* functions which could somehow use
protected:
/**
- * Store the address of the @p{MGDoFHandler} object
+ * Store the address of the @p MGDoFHandler object
* to be accessed.
*/
MGDoFHandler<dim> *mg_dof_handler;
/* -------------------------------------------------------------------------- */
/**
- * This is a switch class which only declares a @p{typdef}. It is meant to
- * determine which class a @p{MGDoFObjectAccessor} class is to be derived
+ * This is a switch class which only declares a @p typdef. It is meant to
+ * determine which class a @p MGDoFObjectAccessor class is to be derived
* from. By default, @p{MGDoFObjectAccessor<celldim,dim>} derives from
- * the @p{typedef} in the general @p{MGDoFObjectAccessor_Inheritance<celldim,dim>}
+ * the @p typedef in the general @p{MGDoFObjectAccessor_Inheritance<celldim,dim>}
* class, which is @p{DoFObjectAccessor<celldim,dim>},
* but if @p{celldim==dim}, then the specialization @p{MGDoFObjectAccessor_Inheritance<dim,dim>}
* is used which declares its local type to be @p{DoFCellAccessor<dim>}. Therefore,
- * the inheritance is automatically chosen to be from @p{DoFCellAccessor} if the
+ * the inheritance is automatically chosen to be from @p DoFCellAccessor if the
* object under consideration has full dimension, i.e. constitutes a cell.
*
* @author Wolfgang Bangerth, 1999
{
public:
/**
- * Declaration of the @p{typedef}.
+ * Declaration of the @p typedef.
* See the full documentation for
* more information.
*/
/**
- * This is a switch class which only declares a @p{typdef}. It is meant to
- * determine which class a @p{DoFObjectAccessor} class is to be derived
+ * This is a switch class which only declares a @p typdef. It is meant to
+ * determine which class a @p DoFObjectAccessor class is to be derived
* from. By default, @p{DoFObjectAccessor<celldim,dim>} derives from
- * the @p{typedef} in the general @p{DoFObjectAccessor_Inheritance<celldim,dim>}
+ * the @p typedef in the general @p{DoFObjectAccessor_Inheritance<celldim,dim>}
* class, which is @p{TriaObjectAccessor<celldim,dim>},
* but if @p{celldim==dim}, then the specialization @p{TriaObjectAccessor<dim,dim>}
* is used which declares its local type to be @p{CellAccessor<dim>}. Therefore,
- * the inheritance is automatically chosen to be from @p{CellAccessor} if the
+ * the inheritance is automatically chosen to be from @p CellAccessor if the
* object under consideration has full dimension, i.e. constitutes a cell.
*
* @author Wolfgang Bangerth, 1999
{
public:
/**
- * Declaration of the @p{typedef}.
+ * Declaration of the @p typedef.
* See the full documentation for
* more information.
*/
/**
* Grant access to the degrees of freedom located on lines.
* This class follows mainly the route laid out by the accessor library
- * declared in the triangulation library (@ref{TriaAccessor}). It enables
+ * declared in the triangulation library (TriaAccessor). It enables
* the user to access the degrees of freedom on the lines (there are similar
* versions for the DoFs on quads, etc), where the dimension of the underlying
* triangulation does not really matter (i.e. this accessor works with the
*
* @sect3{Usage}
*
- * The @ref{DoFDimensionInfo} classes inherited by the @ref{DoFHandler} classes
+ * The DoFDimensionInfo classes inherited by the DoFHandler classes
* declare typedefs to iterators using the accessors declared in this class
* hierarchy tree. Usage is best to happens through these typedefs, since they
* are more secure to changes in the class naming and template interface as well
*
* Inheritance from @p{MGDoFObjectAccessor_Inheritance<1,dim>::BaseClass} yields
* inheritance from @p{DoFCellAccessor<1>} if @p{dim==1} and from
- * @p{TriaObjectAccessor<1,dim>} for all other @p{dim} values. Thus, an object
+ * @p{TriaObjectAccessor<1,dim>} for all other @p dim values. Thus, an object
* of this class shares all features of cells in one dimension, but behaves
* like an ordinary line in all other cases.
*
MGDoFObjectAccessor ();
/**
- * Constructor. The @p{local_data}
+ * Constructor. The @p local_data
* argument is assumed to be a pointer
* to a @p{MGDoFHandler<dim>} object.
*/
const AccessorData *local_data);
/**
- * Return the index of the @p{i}th degree
+ * Return the index of the @p ith degree
* of freedom of this line on the level
* this line lives on.
*/
unsigned int mg_dof_index (const unsigned int i) const;
/**
- * Set the index of the @p{i}th degree
+ * Set the index of the @p ith degree
* of freedom of this line on the
- * level this line lives on to @p{index}.
+ * level this line lives on to @p index.
*/
void set_mg_dof_index (const unsigned int i,
const unsigned int index) const;
/**
- * Return the index of the @p{i}th degree
- * on the @p{vertex}th vertex for the
+ * Return the index of the @p ith degree
+ * on the @p vertexth vertex for the
* level this line lives on.
*/
unsigned int mg_vertex_dof_index (const unsigned int vertex,
const unsigned int i) const;
/**
- * Set the index of the @p{i}th degree
- * on the @p{vertex}th vertex to @p{index}
+ * Set the index of the @p ith degree
+ * on the @p vertexth vertex to @p index
* for the level this line lives on.
*/
void set_mg_vertex_dof_index (const unsigned int vertex,
Vector<number> &dof_values) const;
/**
- * Return the @p{i}th child as a MGDoF line
+ * Return the @p ith child as a MGDoF line
* iterator. This function is needed since
* the child function of the base
* class returns a line accessor without
MGDoFObjectAccessor ();
/**
- * Constructor. The @p{local_data}
+ * Constructor. The @p local_data
* argument is assumed to be a pointer
- * to a @ref{DoFHandler} object.
+ * to a DoFHandler object.
*/
MGDoFObjectAccessor (const Triangulation<dim> *tria,
const int level,
const AccessorData *local_data);
/**
- * Return the index of the @p{i}th degree
+ * Return the index of the @p ith degree
* of freedom of this quad on the level
* this quad lives on.
*/
unsigned int mg_dof_index (const unsigned int i) const;
/**
- * Set the index of the @p{i}th degree
+ * Set the index of the @p ith degree
* of freedom of this quad on the
- * level this quad lives on to @p{index}.
+ * level this quad lives on to @p index.
*/
void set_mg_dof_index (const unsigned int i,
const unsigned int index) const;
/**
- * Return the index of the @p{i}th degree
- * on the @p{vertex}th vertex for the level
+ * Return the index of the @p ith degree
+ * on the @p vertexth vertex for the level
* this quad lives on.
*/
unsigned int mg_vertex_dof_index (const unsigned int vertex,
const unsigned int i) const;
/**
- * Set the index of the @p{i}th degree
- * on the @p{vertex}th vertex for the
- * level this quad lives on to @p{index}.
+ * Set the index of the @p ith degree
+ * on the @p vertexth vertex for the
+ * level this quad lives on to @p index.
*/
void set_mg_vertex_dof_index (const unsigned int vertex,
const unsigned int i,
Vector<number> &dof_values) const;
/**
- * Return a pointer to the @p{i}th line
- * bounding this @p{Quad}.
+ * Return a pointer to the @p ith line
+ * bounding this @p Quad.
*/
TriaIterator<dim,MGDoFObjectAccessor<1, dim> >
line (const unsigned int i) const;
/**
- * Return the @p{i}th child as a DoF quad
+ * Return the @p ith child as a DoF quad
* iterator. This function is needed since
* the child function of the base
* class returns a quad accessor without
MGDoFObjectAccessor ();
/**
- * Constructor. The @p{local_data}
+ * Constructor. The @p local_data
* argument is assumed to be a pointer
- * to a @ref{DoFHandler} object.
+ * to a DoFHandler object.
*/
MGDoFObjectAccessor (const Triangulation<dim> *tria,
const int level,
const AccessorData *local_data);
/**
- * Return the index of the @p{i}th degree
+ * Return the index of the @p ith degree
* of freedom of this hex on the level
* this quad lives on.
*/
unsigned int mg_dof_index (const unsigned int i) const;
/**
- * Set the index of the @p{i}th degree
+ * Set the index of the @p ith degree
* of freedom of this hex on the
- * level this hex lives on to @p{index}.
+ * level this hex lives on to @p index.
*/
void set_mg_dof_index (const unsigned int i,
const unsigned int index) const;
/**
- * Return the index of the @p{i}th degree
- * on the @p{vertex}th vertex for the level
+ * Return the index of the @p ith degree
+ * on the @p vertexth vertex for the level
* this hex lives on.
*/
unsigned int mg_vertex_dof_index (const unsigned int vertex,
const unsigned int i) const;
/**
- * Set the index of the @p{i}th degree
- * on the @p{vertex}th vertex for the
- * level this hex lives on to @p{index}.
+ * Set the index of the @p ith degree
+ * on the @p vertexth vertex for the
+ * level this hex lives on to @p index.
*/
void set_mg_vertex_dof_index (const unsigned int vertex,
const unsigned int i,
Vector<number> &dof_values) const;
/**
- * Return a pointer to the @p{i}th line
- * bounding this @p{Hex}.
+ * Return a pointer to the @p ith line
+ * bounding this @p Hex.
*/
TriaIterator<dim,MGDoFObjectAccessor<1, dim> >
line (const unsigned int i) const;
/**
- * Return a pointer to the @p{i}th quad
- * bounding this @p{Hex}.
+ * Return a pointer to the @p ith quad
+ * bounding this @p Hex.
*/
TriaIterator<dim,MGDoFObjectAccessor<2, dim> >
quad (const unsigned int i) const;
/**
- * Return the @p{i}th child as a DoF quad
+ * Return the @p ith child as a DoF quad
* iterator. This function is needed since
* the child function of the base
* class returns a hex accessor without
* one and two, respectively, this class only collects the pieces
* together by deriving from the appropriate @p{DoF*Accessor} and the
* right @p{CellAccessor<dim>} and finally adding two functions which give
- * access to the neighbors and children as @p{DoFCellAccessor} objects
- * rather than @p{CellAccessor} objects (the latter function was inherited
+ * access to the neighbors and children as @p DoFCellAccessor objects
+ * rather than @p CellAccessor objects (the latter function was inherited
* from the @p{CellAccessor<dim>} class).
*
* @author Wolfgang Bangerth, 1998
MGDoFObjectAccessor<dim, dim> (tria,level,index,local_data) {};
/**
- * Return the @p{i}th neighbor as a MGDoF cell
+ * Return the @p ith neighbor as a MGDoF cell
* iterator. This function is needed since
* the neighbor function of the base
* class returns a cell accessor without
TriaIterator<dim,MGDoFCellAccessor<dim> > neighbor (const unsigned int) const;
/**
- * Return the @p{i}th child as a MGDoF cell
+ * Return the @p ith child as a MGDoF cell
* iterator. This function is needed since
* the child function of the base
* class returns a cell accessor without
TriaIterator<dim,MGDoFCellAccessor<dim> > child (const unsigned int) const;
/**
- * Return an iterator to the @p{i}th face
+ * Return an iterator to the @p ith face
* of this cell.
*
* This function is not implemented in 1D,
/**
* Return the result of the
- * @p{neighbor_child_on_subface}
+ * @p neighbor_child_on_subface
* function of the base class,
* but convert it so that one can
* also access the MGDoF data (the
/**
* This class manages degrees of freedom for a multilevel hierarchy of
- * grids. It does mostly the same as does the @p{DoDHandler} class,
+ * grids. It does mostly the same as does the @p DoDHandler class,
* but it uses a separate enumeration of the degrees of freedom on
* each level. For example, a vertex has several DoF numbers, one for
* each level of the triangulation on which it exists.
typedef typename MGDoFDimensionInfo<dim>::active_face_iterator active_face_iterator;
/**
- * Constructor. Take @p{tria} as
+ * Constructor. Take @p tria as
* the triangulation to work on.
*/
MGDoFHandler (const Triangulation<dim> &tria);
* finite element according to
* the given distribution
* method. We first call the
- * @ref{DoFHandler}'s function
+ * DoFHandler's function
* and then distribute the
* levelwise numbers.
*
* based on a list of new dof
* numbers for all the dofs.
*
- * @p{new_numbers} is an array of
+ * @p new_numbers is an array of
* integers with size equal to
* the number of dofs on the
* present level. It stores the
/**
* Redeclare this function of the
- * @ref{DoFHandler} basis class
+ * DoFHandler basis class
* as otherwise it is hidden from
* the function with the same
* name, see above.
/**
* Iterator to the first cell,
* used or not, on level
- * @p{level}. If a level has no
+ * @p level. If a level has no
* cells, a past-the-end iterator
* is returned.
*
* This function calls
- * @p{begin_raw_line} in 1D and
- * @p{begin_raw_quad} in 2D.
+ * @p begin_raw_line in 1D and
+ * @p begin_raw_quad in 2D.
*/
raw_cell_iterator begin_raw (const unsigned int level = 0) const;
/**
* Iterator to the first used
- * cell on level @p{level}.
+ * cell on level @p level.
*
* This function calls
- * @p{begin_line} in 1D and
- * @p{begin_quad} in 2D.
+ * @p begin_line in 1D and
+ * @p begin_quad in 2D.
*/
cell_iterator begin (const unsigned int level = 0) const;
/**
* Iterator to the first active
- * cell on level @p{level}.
+ * cell on level @p level.
*
* This function calls
- * @p{begin_active_line} in 1D
- * and @p{begin_active_quad} in
+ * @p begin_active_line in 1D
+ * and @p begin_active_quad in
* 2D.
*/
active_cell_iterator begin_active(const unsigned int level = 0) const;
* before-the-beginning states.
*
* This function calls
- * @p{end_line} in 1D and
- * @p{end_quad} in 2D.
+ * @p end_line in 1D and
+ * @p end_quad in 2D.
*/
raw_cell_iterator end () const;
/**
* Return an iterator which is
* the first iterator not on
- * level. If @p{level} is the
+ * level. If @p level is the
* last level, then this returns
* @p{end()}.
*/
/**
* Return a raw iterator which is
* the first iterator not on
- * level. If @p{level} is the
+ * level. If @p level is the
* last level, then this returns
* @p{end()}.
*/
/**
* Return an active iterator
* which is the first iterator
- * not on level. If @p{level} is
+ * not on level. If @p level is
* the last level, then this
* returns @p{end()}.
*/
* the last cell, used or not.
*
* This function calls
- * @p{last_raw_line} in 1D and
- * @p{last_raw_quad} in 2D.
+ * @p last_raw_line in 1D and
+ * @p last_raw_quad in 2D.
*/
raw_cell_iterator last_raw () const;
/**
* Return an iterator pointing to
* the last cell of the level
- * @p{level}, used or not.
+ * @p level, used or not.
*
* This function calls
- * @p{last_raw_line} in 1D and
- * @p{last_raw_quad} in 2D.
+ * @p last_raw_line in 1D and
+ * @p last_raw_quad in 2D.
*/
raw_cell_iterator last_raw (const unsigned int level) const;
* the last used cell.
*
* This function calls
- * @p{last_line} in 1D and
- * @p{last_quad} in 2D.
+ * @p last_line in 1D and
+ * @p last_quad in 2D.
*/
cell_iterator last () const;
/**
* Return an iterator pointing to
* the last used cell on level
- * @p{level}.
+ * @p level.
*
* This function calls
- * @p{last_line} in 1D and
- * @p{last_quad} in 2D.
+ * @p last_line in 1D and
+ * @p last_quad in 2D.
*/
cell_iterator last (const unsigned int level) const;
* the last active cell.
*
* This function calls
- * @p{last_active_line} in 1D and
- * @p{last_active_quad} in 2D.
+ * @p last_active_line in 1D and
+ * @p last_active_quad in 2D.
*/
active_cell_iterator last_active () const;
/**
* Return an iterator pointing to
* the last active cell on level
- * @p{level}.
+ * @p level.
*
* This function calls
- * @p{last_active_line} in 1D and
- * @p{last_active_quad} in 2D.
+ * @p last_active_line in 1D and
+ * @p last_active_quad in 2D.
*/
active_cell_iterator last_active (const unsigned int level) const;
//@}
/**
* Iterator to the first face,
* used or not, on level
- * @p{level}. If a level has no
+ * @p level. If a level has no
* faces, a past-the-end iterator
* is returned.
*
* This function calls
- * @p{begin_raw_line} in 2D and
- * @p{begin_raw_quad} in 3D.
+ * @p begin_raw_line in 2D and
+ * @p begin_raw_quad in 3D.
*/
raw_face_iterator begin_raw_face (const unsigned int level = 0) const;
/**
* Iterator to the first used
- * face on level @p{level}.
+ * face on level @p level.
*
* This function calls
- * @p{begin_line} in 2D and
- * @p{begin_quad} in 3D.
+ * @p begin_line in 2D and
+ * @p begin_quad in 3D.
*/
face_iterator begin_face (const unsigned int level = 0) const;
/**
* Iterator to the first active
- * face on level @p{level}.
+ * face on level @p level.
*
* This function calls
- * @p{begin_active_line} in 2D
- * and @p{begin_active_quad} in
+ * @p begin_active_line in 2D
+ * and @p begin_active_quad in
* 3D.
*/
active_face_iterator begin_active_face(const unsigned int level = 0) const;
* before-the-beginning states.
*
* This function calls
- * @p{end_line} in 2D and
- * @p{end_quad} in 3D.
+ * @p end_line in 2D and
+ * @p end_quad in 3D.
*/
raw_face_iterator end_face () const;
/**
* Return an iterator which is
* the first iterator not on
- * level. If @p{level} is the
+ * level. If @p level is the
* last level, then this returns
* @p{end()}.
*/
/**
* Return a raw iterator which is
* the first iterator not on
- * level. If @p{level} is the
+ * level. If @p level is the
* last level, then this returns
* @p{end()}.
*/
/**
* Return an active iterator
* which is the first iterator
- * not on level. If @p{level} is
+ * not on level. If @p level is
* the last level, then this
* returns @p{end()}.
*/
* the last face, used or not.
*
* This function calls
- * @p{last_raw_line} in 2D and
- * @p{last_raw_quad} in 3D.
+ * @p last_raw_line in 2D and
+ * @p last_raw_quad in 3D.
*/
raw_face_iterator last_raw_face () const;
/**
* Return an iterator pointing to
* the last face of the level
- * @p{level}, used or not.
+ * @p level, used or not.
*
* This function calls
- * @p{last_raw_line} in 2D and
- * @p{last_raw_quad} in 3D.
+ * @p last_raw_line in 2D and
+ * @p last_raw_quad in 3D.
*/
raw_face_iterator last_raw_face (const unsigned int level) const;
* the last used face.
*
* This function calls
- * @p{last_line} in 2D and
- * @p{last_quad} in 3D.
+ * @p last_line in 2D and
+ * @p last_quad in 3D.
*/
face_iterator last_face () const;
/**
* Return an iterator pointing to
* the last used face on level
- * @p{level}.
+ * @p level.
*
* This function calls
- * @p{last_line} in 2D and
- * @p{last_quad} in 3D.
+ * @p last_line in 2D and
+ * @p last_quad in 3D.
*/
face_iterator last_face (const unsigned int level) const;
* the last active face.
*
* This function calls
- * @p{last_active_line} in 2D and
- * @p{last_active_quad} in 3D.
+ * @p last_active_line in 2D and
+ * @p last_active_quad in 3D.
*/
active_face_iterator last_active_face () const;
/**
* Return an iterator pointing to
* the last active face on level
- * @p{level}.
+ * @p level.
*
* This function calls
- * @p{last_active_line} in 2D and
- * @p{last_active_quad} in 3D.
+ * @p last_active_line in 2D and
+ * @p last_active_quad in 3D.
*/
active_face_iterator last_active_face (const unsigned int level) const;
//@}
/**
* Iterator to the first line,
* used or not, on level
- * @p{level}. If a level has no
+ * @p level. If a level has no
* lines, a past-the-end iterator
* is returned.
*/
/**
* Iterator to the first used
- * line on level @p{level}.
+ * line on level @p level.
*/
line_iterator begin_line (const unsigned int level = 0) const;
/**
* Iterator to the first active
- * line on level @p{level}.
+ * line on level @p level.
*/
active_line_iterator begin_active_line(const unsigned int level = 0) const;
/**
* Return an iterator which is
* the first iterator not on
- * level. If @p{level} is the
+ * level. If @p level is the
* last level, then this returns
* @p{end()}.
*/
/**
* Return a raw iterator which is
* the first iterator not on
- * level. If @p{level} is the
+ * level. If @p level is the
* last level, then this returns
* @p{end()}.
*/
/**
* Return an active iterator
* which is the first iterator
- * not on level. If @p{level} is
+ * not on level. If @p level is
* the last level, then this
* returns @p{end()}.
*/
/**
* Return an iterator pointing to
* the last line of the level
- * @p{level}, used or not.
+ * @p level, used or not.
*/
raw_line_iterator last_raw_line (const unsigned int level) const;
/**
* Return an iterator pointing to
* the last used line on level
- * @p{level}.
+ * @p level.
*/
line_iterator last_line (const unsigned int level) const;
/**
* Return an iterator pointing to
* the last active line on level
- * @p{level}.
+ * @p level.
*/
active_line_iterator last_active_line (const unsigned int level) const;
/*@}*/
/**
* Iterator to the first quad,
* used or not, on level
- * @p{level}. If a level has no
+ * @p level. If a level has no
* quads, a past-the-end iterator
* is returned.
*/
/**
* Iterator to the first used
- * quad on level @p{level}.
+ * quad on level @p level.
*/
quad_iterator begin_quad (const unsigned int level = 0) const;
/**
* Iterator to the first active
- * quad on level @p{level}.
+ * quad on level @p level.
*/
active_quad_iterator begin_active_quad(const unsigned int level = 0) const;
/**
* Return an iterator which is
* the first iterator not on
- * level. If @p{level} is the
+ * level. If @p level is the
* last level, then this returns
* @p{end()}.
*/
/**
* Return a raw iterator which is
* the first iterator not on
- * level. If @p{level} is the
+ * level. If @p level is the
* last level, then this returns
* @p{end()}.
*/
/**
* Return an active iterator
* which is the first iterator
- * not on level. If @p{level} is
+ * not on level. If @p level is
* the last level, then this
* returns @p{end()}.
*/
/**
* Return an iterator pointing to
* the last quad of the level
- * @p{level}, used or not.
+ * @p level, used or not.
*/
raw_quad_iterator last_raw_quad (const unsigned int level) const;
/**
* Return an iterator pointing to
* the last used quad on level
- * @p{level}.
+ * @p level.
*/
quad_iterator last_quad (const unsigned int level) const;
/**
* Return an iterator pointing to
* the last active quad on level
- * @p{level}.
+ * @p level.
*/
active_quad_iterator last_active_quad (const unsigned int level) const;
/*@}*/
/**
* Iterator to the first hex,
* used or not, on level
- * @p{level}. If a level has no
+ * @p level. If a level has no
* hexs, a past-the-end iterator
* is returned.
*/
/**
* Iterator to the first used hex
- * on level @p{level}.
+ * on level @p level.
*/
hex_iterator begin_hex (const unsigned int level = 0) const;
/**
* Iterator to the first active
- * hex on level @p{level}.
+ * hex on level @p level.
*/
active_hex_iterator begin_active_hex(const unsigned int level = 0) const;
/**
* Return an iterator which is
* the first iterator not on
- * level. If @p{level} is the
+ * level. If @p level is the
* last level, then this returns
* @p{end()}.
*/
/**
* Return a raw iterator which is
* the first iterator not on
- * level. If @p{level} is the
+ * level. If @p level is the
* last level, then this returns
* @p{end()}.
*/
/**
* Return an active iterator
* which is the first iterator
- * not on level. If @p{level} is
+ * not on level. If @p level is
* the last level, then this
* returns @p{end()}.
*/
/**
* Return an iterator pointing to
* the last hex of the level
- * @p{level}, used or not.
+ * @p level, used or not.
*/
raw_hex_iterator last_raw_hex (const unsigned int level) const;
/**
* Return an iterator pointing to
* the last used hex on level
- * @p{level}.
+ * @p level.
*/
hex_iterator last_hex (const unsigned int level) const;
/**
* Return an iterator pointing to
* the last active hex on level
- * @p{level}.
+ * @p level.
*/
active_hex_iterator last_active_hex (const unsigned int level) const;
/*@}*/
/**
* Redeclare this function of the
- * @ref{DoFHandler} basis class
+ * DoFHandler basis class
* as otherwise it is hidden from
* the function with the same
* name, see above.
* vector<>'s and still
* construct the object using
* the constructor. Use the
- * @p{init} function to
+ * @p init function to
* really allocate memory.
*/
MGVertexDoFs ();
/**
* Allocate memory and set
- * all indices to @p{-1}.
+ * all indices to @p -1.
*/
void init (const unsigned int coarsest_level,
const unsigned int finest_level,
/**
* Set the index with number
- * @p{dof_number} of this
- * vertex on @p{level} to the
+ * @p dof_number of this
+ * vertex on @p level to the
* given index. To compute
* the position in the array,
* one has to specify how
/**
* Return the index with
- * number @p{dof_number} of
+ * number @p dof_number of
* this vertex on
- * @p{level}. To compute the
+ * @p level. To compute the
* position in the array, one
* has to specify how many
* dofs per vertex there
* used for error checking
* but can also be accessed
* by the function
- * @p{get_finest_level}.
+ * @p get_finest_level.
*/
unsigned int finest_level;
* Distribute dofs on the given
* cell, with new dofs starting
* with index
- * @p{next_free_dof}. Return the
+ * @p next_free_dof. Return the
* next unused index number. The
* finite element used is the one
- * given to @p{distribute_dofs},
+ * given to @p distribute_dofs,
* which is copied to
- * @p{selected_fe}.
+ * @p selected_fe.
*
* This function is excluded from
- * the @p{distribute_dofs}
+ * the @p distribute_dofs
* function since it can not be
* implemented dimension
* independent.
/**
* Space to store the DoF numbers
* for the different
- * levels. Unlike the @p{levels}
+ * levels. Unlike the @p levels
* object in the
- * @ref{DoFHandler}, these are
+ * DoFHandler, these are
* not global numbers but rather
* are numbers which start from
* zero on each level.
/**
* This is a collection of functions operating on, and manipulating
* the numbers of degrees of freedom in a multilevel triangulation. It
- * is similar in purpose and function to the @p{DoFTools} class, but
- * operates on @p{MGDoFHandler} objects instead of @ref{DoFHandler}
+ * is similar in purpose and function to the @p DoFTools class, but
+ * operates on @p MGDoFHandler objects instead of DoFHandler
* objects. See there and the documentation of the member functions
* for more information.
*
* All member functions are static, so there is no need to create an
- * object of class @p{MGTools}.
+ * object of class @p MGTools.
*
* @author Wolfgang Bangerth, Guido Kanschat, 1999-2003
*/
/**
* Write the sparsity structure
* of the matrix belonging to the
- * specified @p{level}. The sparsity pattern
+ * specified @p level. The sparsity pattern
* is not compressed, so before
* creating the actual matrix
* you have to compress the
* the fluxes at refinement
* edges. The matrix maps a
* function of the fine level
- * space @p{level} to the coarser
+ * space @p level to the coarser
* space.
*
- * @ref{make_flux_sparsity_pattern}
+ * make_flux_sparsity_pattern()
*/
template <int dim, class SparsityPattern>
static void
* correct size. Here, we just
* count the numbers of degrees
* of freedom on each level and
- * @p{reinit} each level vector
+ * @p reinit each level vector
* to this length.
*/
template <int dim, typename number>
* the numbers of degrees of
* freedom on each level
* component-wise. Then, assign
- * each block of @p{vector} the
+ * each block of @p vector the
* corresponding size.
*
- * The boolean field @p{selected}
+ * The boolean field @p selected
* allows restricting this
* operation to certain
* components. In this case,
- * @p{vector} will only have as
+ * @p vector will only have as
* many blocks as there are true
- * values in @p{selected} (no
+ * values in @p selected (no
* blocks of length zero are
* padded in).
*
* from this function.
*
* The argument
- * @p{target_component} allows to
+ * @p target_component allows to
* re-sort and groupt components
* as in
- * @p{DoFRenumbering::component_wise}.
+ * @p DoFRenumbering::component_wise.
*/
template <int dim, typename number>
static void
* numbers of degrees of freedom
* on each level component-wise
* in a single component. Then,
- * assign @p{vector} the
+ * assign @p vector the
* corresponding size.
*
- * The boolean field @p{selected}
+ * The boolean field @p selected
* may be nonzero in a single
* component, indicating the
* block of a block vector the
- * argument @p{v} corresponds to.
+ * argument @p v corresponds to.
*
* Degrees of freedom must be
* sorted by component in order
* from this function.
*
* The argument
- * @p{target_component} allows to
+ * @p target_component allows to
* re-sort and groupt components
* as in
- * @p{DoFRenumbering::component_wise}.
+ * @p DoFRenumbering::component_wise.
*/
template <int dim, typename number>
static void
const unsigned int maxlevel = 0);
/**
- * Access object on level @p{level}.
+ * Access object on level @p level.
*/
Object & operator[] (const unsigned int level);
/**
* Access object on level
- * @p{level}. Constant version.
+ * @p level. Constant version.
*/
const Object & operator[] (const unsigned int level) const;
* Delete all previous contents
* of this object and reset its
* size according to the values
- * of @p{new_minlevel} and
- * @p{new_maxlevel}.
+ * of @p new_minlevel and
+ * @p new_maxlevel.
*/
void resize (const unsigned int new_minlevel,
const unsigned int new_maxlevel);
/**
- * Call @p{clear} on all objects
+ * Call @p clear on all objects
* stored by this object. This
* function is only implemented
- * for some @p{Object} classes,
+ * for some @p Object classes,
* most notably for vectors and
* matrices. Note that if
* <tt>Object==Vector@<T@></tt>,
/**
* Multilevel matrix. This class implements the interface defined by
- * @ref{MGMatrixBase}, using @ref{MGLevelObject} of an arbitrary
+ * MGMatrixBase, using MGLevelObject of an arbitrary
* matrix class.
*
* @author Guido Kanschat, 2002
/**
* Constructor. The argument is
* handed over to the
- * @p{SmartPointer}
+ * @p SmartPointer
* constructor. The matrix object
* must exist longer as the
- * @p{MGMatrix} object, since
+ * @p MGMatrix object, since
* only a pointer is stored.
*/
MGMatrix (MGLevelObject<MATRIX>* = 0);
* Set the matrix object to be
* used. The matrix object must
* exist longer as the
- * @p{MGMatrix} object, since
+ * @p MGMatrix object, since
* only a pointer is stored.
*/
void set_matrix (MGLevelObject<MATRIX>* M);
/**
* Multilevel matrix selecting from block matrices. This class
- * implements the interface defined by @ref{MGMatrixBase}. The
- * template parameter @p{MATRIX} should be a block matrix class like
- * @ref{BlockSparseMatrix} or @p{BlockSparseMatrixEZ}. Then, this
- * class stores a pointer to a @ref{MGLevelObject} of this matrix
- * class. In each @p{vmult}, the block selected on initialization will
+ * implements the interface defined by MGMatrixBase. The
+ * template parameter @p MATRIX should be a block matrix class like
+ * BlockSparseMatrix or @p BlockSparseMatrixEZ. Then, this
+ * class stores a pointer to a MGLevelObject of this matrix
+ * class. In each @p vmult, the block selected on initialization will
* be multiplied with the vector provided.
*
* @author Guido Kanschat, 2002
{
public:
/**
- * Constructor. @p{row} and
- * @p{col} are the coordinate of
+ * Constructor. @p row and
+ * @p col are the coordinate of
* the selected block. The other
* argument is handed over to the
- * @p{SmartPointer} constructor.
+ * @p SmartPointer constructor.
*/
MGMatrixSelect (const unsigned int row = 0,
const unsigned int col = 0,
* Set the matrix object to be
* used. The matrix object must
* exist longer as the
- * @p{MGMatrix} object, since
+ * @p MGMatrix object, since
* only a pointer is stored.
*/
void set_matrix (MGLevelObject<MATRIX>* M);
public:
/**
* Implementation of the
- * interface for @p{Multigrid}.
+ * interface for @p Multigrid.
* This function does nothing,
* which by comparison with the
* definition of this function
* on the interior boundaries between
* the different levels, which are
* needed by the function
- * @p{set_zero_interior_boundaries}.
+ * @p set_zero_interior_boundaries.
*
* Since this function is
* implemented a bit different in
* boundaries between the
* different levels, which are
* needed by the function
- * @p{set_zero_interior_boundaries}.
+ * @p set_zero_interior_boundaries.
*
* The parameter steps indicates
* the number of smoothing steps
- * to be executed by @p{smooth}.
+ * to be executed by @p smooth.
*/
template <int dim>
MGSmootherContinuous (const MGDoFHandler<dim> &mg_dof,
* Reset the values of the degrees of
* freedom on interior boundaries between
* different levels to zero in the given
- * data vector @p{u}.
+ * data vector @p u.
*
* Since the coarsest level (@p{level==0})
* has no interior boundaries, this
*
* This class performs smoothing on each level. The operation can be
* controlled by several parameters. First, the relaxation parameter
- * @p{omega} is used in the underlying relaxation method. @p{steps} is
+ * @p omega is used in the underlying relaxation method. @p steps is
* the number of relaxation steps on the finest level (on all levels
- * if @p{variable} is off). If @p{variable} is @p{true}, the number of
+ * if @p variable is off). If @p variable is @p true, the number of
* smoothing steps is doubled on each coarser level. This results in a
* method having the complexity of the W-cycle, but saving grid
* transfers. This is the method proposed by Bramble at al.
*
- * The option @p{symmetric} switches on alternating between the
+ * The option @p symmetric switches on alternating between the
* smoother and its transpose in each step as proposed by Bramble.
*
- * @p{transpose} and @p{reverse} are similar in the effect that
+ * @p transpose and @p reverse are similar in the effect that
* instead of the smoother the transposed is used. Typically, this is
* off for pre-smoothing and on for post-smoothing. While
- * @p{transpose} is the true transposed smoothing operation,
- * @p{reverse} just uses the transposed of the smoother, but the
+ * @p transpose is the true transposed smoothing operation,
+ * @p reverse just uses the transposed of the smoother, but the
* non-transposed matrix-vector multiplication; this can be used to
* invert the direction of the Gauss-Seidel method.
*
- * If you are using block matrices, the second @p{initialize} function
+ * If you are using block matrices, the second @p initialize function
* offers the possibility to extract a single block for smoothing. In
* this case, the multigrid method must be used only with the vector
* associated to that single block.
*
* The library contains instantiation for @p{SparseMatrix<.>} and
* @p{Vector<.>}, where the template arguments are all combinations of
- * @p{float} and @p{double}. Additional instantiations may be created
+ * @p float and @p double. Additional instantiations may be created
* by including the file mg_smoother.templates.h.
*
* @author Guido Kanschat, 2003
/**
* Initialize for matrices. The
- * parameter @p{matrices} can be
+ * parameter @p matrices can be
* any object having functions
* @p{get_minlevel()} and
* @p{get_maxlevel()} as well as
* an @p{operator[]} returning a
- * reference to @p{MATRIX}. This
+ * reference to @p MATRIX. This
* function stores pointers to
* the level matrices and
* initializes the smoothing
* operator for each level.
*
- * @p{additional_data} is an
+ * @p additional_data is an
* object of type
- * @p{RELAX::AdditionalData} and
+ * @p RELAX::AdditionalData and
* is handed to the
* initialization function of the
* relaxation method.
/**
* Initialize for single blocks
* of matrices. The parameter
- * @p{matrices} can be any object
+ * @p matrices can be any object
* having functions
* @p{get_minlevel()} and
* @p{get_maxlevel()} as well as
* an @p{operator[]} returning a
* reference to a block matrix
* where each block is of type
- * @p{MATRIX}. Of this block
+ * @p MATRIX. Of this block
* matrix, the block indicated by
- * @p{block_row} and
- * @p{block_col} is selected on
+ * @p block_row and
+ * @p block_col is selected on
* each level. This function
* stores pointers to the level
* matrices and initializes the
* smoothing operator for each
* level.
*
- * @p{additional_data} is an
+ * @p additional_data is an
* object of type
- * @p{RELAX::AdditionalData} and
+ * @p RELAX::AdditionalData and
* is handed to the
* initialization function of the
* relaxation method.
/**
* Switch on/off transposed. This
* is mutually exclusive with
- * @ref{reverse}.
+ * reverse().
*/
void set_transpose (const bool);
/**
* Switch on/off reversed. This
* is mutually exclusive with
- * @ref{transpose}.
+ * transpose().
*/
void set_reverse (const bool);
* Transfer from a vector on the
* global grid to vectors defined
* on each of the levels
- * separately, i.a. an @p{MGVector}.
+ * separately, i.a. an @p MGVector.
*/
template <int dim, class InVector>
void
DeclException0(ExcNoProlongation);
/**
- * Call @p{build_matrices}
+ * Call @p build_matrices
* function first.
*/
DeclException0(ExcMatricesNotBuilt);
/**
* Structure that is used to
* disambiguate calls to
- * @p{copy_to_mg} for 1d and
+ * @p copy_to_mg for 1d and
* non-1d. We provide two
- * functions of @p{copy_to_mg},
+ * functions of @p copy_to_mg,
* where the 1d function takes an
* argument of type
* @p{is_1d<true>} and the other
* problems, please contact Guido Kanschat.
*
* In addition to the functionality of
- * @ref{MGTransferPrebuilt}, the operation may be restricted to
+ * MGTransferPrebuilt, the operation may be restricted to
* certain blocks of the vector.
*
* If the restricted mode is chosen, block vectors used in the
* transfer routines may only have as many components as there are
- * @p{true}s in the selected-field.
+ * @p trues in the selected-field.
*
- * See @ref{MGTransferBase} to find out which of the transfer classes
+ * See MGTransferBase to find out which of the transfer classes
* is best for your needs.
*
* @author Guido Kanschat, 2001, 2002
/**
* Structure that is used to
* disambiguate calls to
- * @p{copy_to_mg} for 1d and
+ * @p copy_to_mg for 1d and
* non-1d. We provide two
- * functions of @p{copy_to_mg},
+ * functions of @p copy_to_mg,
* where the 1d function takes an
* argument of type
* @p{is_1d<true>} and the other
/**
* Implementation of the
- * @p{copy_to_mg} function for
+ * @p copy_to_mg function for
* 1d. We have to resort to some
* template trickery because we
* can't specialize template
* meet on conferences seem to deny this.
*
* The function actually performing a multi-level cycle,
- * @p{level_mgstep}, as well as the function @p{vcycle}, calling it,
+ * @p level_mgstep, as well as the function @p vcycle, calling it,
* require several helper classes handed over as template parameters.
* These classes have to meet the following requirements:
*
/**
* Constructor. The
- * @p{MGDoFHandler} is used to
+ * @p MGDoFHandler is used to
* determine the highest possible
- * level. @p{transfer} is an
+ * level. @p transfer is an
* object performing prolongation
* and restriction.
*
* The V-cycle will start on
- * level @p{maxlevel} and goes
- * down to level @p{minlevel},
+ * level @p maxlevel and goes
+ * down to level @p minlevel,
* where the coarse grid solver
* will be used.
*
/**
* Reinit this class according to
- * @p{minlevel} and @p{maxlevel}.
+ * @p minlevel and @p maxlevel.
*/
void reinit (const unsigned int minlevel,
const unsigned int maxlevel);
* Execute one step of the
* v-cycle algorithm. This
* function assumes, that the
- * vector @p{defect} is properly
+ * vector @p defect is properly
* filled with the residual in
* the outer defect correction
* scheme (usually performed by
- * @ref{PreconditionMG}). After
+ * PreconditionMG). After
* execution of @p{vcycle()}, the
* result is in the vector
- * @p{solution}. See
+ * @p solution. See
* @p{copy_*_mg} in class
- * @p{MGTools} if you want to use
+ * @p MGTools if you want to use
* these vectors yourself.
*
* The actual work for this
* function is done in
- * @p{level_mgstep}.
+ * @p level_mgstep.
*/
void vcycle();
/**
* The actual v-cycle multigrid method.
- * @p{level} is the level the
+ * @p level is the level the
* function should work on. It
* will usually be called for the
* highest level from outside,
* but will then call itself
- * recursively for @p{level-1},
- * unless we are on @p{minlevel}
+ * recursively for @p level-1,
+ * unless we are on @p minlevel
* where instead of recursing
* deeper, the coarse grid solver
* is used to solve the matrix of
* Here, we collect all information needed for multi-level preconditioning
* and provide the standard interface for LAC iterative methods.
*
- * The template parameter class @p{MG} is required to inherit @p{MGBase}.
+ * The template parameter class @p MG is required to inherit @p MGBase.
* Furthermore, it needs functions @p{void copy_to_mg(const VECTOR&)}
- * to store @p{src} in the right hand side of the multi-level method and
- * @p{void copy_from_mg(VECTOR&)} to store the result of the v-cycle in @p{dst}.
+ * to store @p src in the right hand side of the multi-level method and
+ * @p{void copy_from_mg(VECTOR&)} to store the result of the v-cycle in @p dst.
*
* @author Guido Kanschat, 1999, 2000, 2001, 2002
*/
/**
* Preconditioning operator.
- * Calls the @p{vcycle} function
- * of the @p{MG} object passed to
+ * Calls the @p vcycle function
+ * of the @p MG object passed to
* the constructor.
*
* This is the operator used by
/**
* Preconditioning operator.
- * Calls the @p{vcycle} function
- * of the @p{MG} object passed to
+ * Calls the @p vcycle function
+ * of the @p MG object passed to
* the constructor.
*/
template<class VECTOR2>
private:
/**
- * Associated @p{MGDoFHandler}.
+ * Associated @p MGDoFHandler.
*/
SmartPointer<const MGDoFHandler<dim> > mg_dof_handler;
/**
* 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 @ref{DoFHandler} object and one or more pointers to
+ * 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.
*
* @sect3{User visible interface}
*
* The user visible interface of this class consists of functions which allow
- * a user to make a @ref{DoFHandler} object known to this class and to add data
+ * a user to make a DoFHandler object known to this class and to add data
* 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:
- * @begin{verbatim}
+ * @verbatim
* ...
* ... // compute solution, which contains nodal values
* ...
* data_out.write_xxx (output_file);
*
* data_out.clear();
- * @end{verbatim}
+ * @endverbatim
*
- * @p{attach_dof_handler} tells this class that all future operations are to take
- * place with the @ref{DoFHandler} object and the triangulation it lives on. We then
+ * @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
* to give a name to each component of the vector, which is done through an object
* of type @p{vector<string>} 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 @ref{DoFHandler} has only one component, then you
- * can use the second @p{add_data_vector} function which takes a @p{string} instead
+ * 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 @p{vector<string>}.
*
* 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 @p 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
+ * @p 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, indicated by @p write_xxx,
* to a file and may want to clear this object as soon as possible to reduce
* memory requirements.
*
- * Please note, that in the example above, an object of type @ref{DataOut} was
+ * Please note, that in the example above, an object of type DataOut was
* used, i.e. an object of a derived class. This is necessary since this
* 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, @ref{DataOutInterface} offers several
+ * 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
+ * (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 @p{if () ... else ...} clauses yourself), and also functions
* and classes offering ways to control the appearance of the output by
* 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 @p build_patches or the like, which fills
+ * the @p 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
* the result of a computation exploiting rotational symmetry in the
* original domain (in which the space dimension of the output would
* be one higher than that of the DoF handler, see the
- * @ref{DataOut_Rotation} class), or one might conceive that one could
+ * DataOut_Rotation() class), or one might conceive that one could
* write a class that only outputs the solution on a cut through the
* domain, in which case the space dimension of the output is less
* than that of the DoF handler. The last template argument denotes
* usually, this dimension is the same as the dimensio of the patches
* themselves (which is also the default value of the template
* parameter), but there might be cases where this is not so. For
- * example, in the @ref{DataOut_Faces} class, patches are generated
+ * example, in the DataOut_Faces() class, patches are generated
* from faces of the triangulation. Thus, the dimension of the patch
* is one less than the dimension of the embedding space, which is, in
* this case, equal to the dimension of the triangulation and DoF
/**
* Type describing what the
* vector given to
- * @ref{add_data_vector} is: a
+ * add_data_vector() is: a
* vector that has one entry per
* degree of freedom in a
- * @ref{DoFHandler} object (such
+ * DoFHandler object (such
* as solution vectors), or one
* entry per cell in the
* triangulation underlying the
- * @ref{DoFHandler} object (such
+ * DoFHandler object (such
* as error per cell data). The
- * value @p{type_automatic} tells
- * @ref{add_data_vector} to find
+ * value @p type_automatic tells
+ * add_data_vector() to find
* out itself (see the
* documentation of
- * @p{add_data_vector} for the
+ * @p add_data_vector for the
* method used).
*/
enum DataVectorType {
* 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},
+ * @p type_automatic to either
+ * @p type_dof_data or @p type_cell_data,
* depending on what the vector
* represents. Apart from this
* corner case, you can leave the
* shall only contain characters
* which are letters, underscore
* and a few other ones. Refer to
- * the @p{ExcInvalidCharacter}
+ * the @p 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 @ref{FEValue} can extract values
+ * which FEValue can extract values
* on a cell using the
- * @p{get_function_values} function.
+ * @p get_function_values function.
*/
template <class VECTOR>
void add_data_vector (const VECTOR &data,
* what this function takes. It
* simply relays its arguments
* after a conversion of the
- * @p{name} to a vector of
+ * @p name to a vector of
* strings, to the other
- * @p{add_data_vector} function
+ * @p add_data_vector function
* above.
*
- * If @p{data} is a vector with
+ * If @p data is a vector with
* multiple components this
* function will generate
* distinct names for all
* components by appending an
* underscore and the number of
- * each component to @p{name}
+ * each component to @p name
*
* The actual type for the template
* argument may be any vector type from
- * which @ref{FEValue} can extract values
+ * which FEValue can extract values
* on a cell using the
- * @p{get_function_values} function.
+ * @p get_function_values function.
*/
template <class VECTOR>
void add_data_vector (const VECTOR &data,
* output of a new set of vectors
* without supplying the DoF
* handler again. Therefore, the
- * @ref{DataOut} object can be used
+ * DataOut object can be used
* in an algebraic context. Note
* that besides the data vectors
* also the patches already
* to data vectors and to the DoF
* handler object. This function
* may be useful when you have
- * called the @p{build_patches}
+ * called the @p build_patches
* function of derived class,
* since then the patches are
* built and the input data is no
* This function can be used to
* merge the patches that were
* created using the
- * @p{build_patches} function of
+ * @p build_patches function of
* the object given as argument
* into the list of patches
* created by this object. This
* for example, a domain
* decomposition algorithm where
* each block is represented by a
- * @ref{DoFHandler} of its own,
+ * DoFHandler of its own,
* but one wants to output the
* solution on all the blocks at
* the same time.
* both objects overlap in space.
*
* If you call
- * @ref{build_patches} for this
+ * build_patches() for this
* object after merging in
* patches, the previous state is
* overwritten, and the merged-in
* data vectors and the DoF
* handler. You have to set all
* data entries again using the
- * @p{add_data_vector}
+ * @p add_data_vector
* function. The pointer to the
* dof handler is cleared as
* well, along with all other
protected:
/**
* For each vector that has been added
- * through the @ref{add_data_vector}
+ * through the add_data_vector()
* functions, we need to keep track of a
* pointer to it, and allow data
* extraction from it when we generate
get_cell_data_value (const unsigned int cell_number) const = 0;
/**
- * Given a @p{FEValuesBase} object,
+ * Given a @p FEValuesBase object,
* extract the values on the present
* cell from the vector we actually
* store.
std::vector<double> &patch_values) const = 0;
/**
- * Given a @p{FEValuesBase} object,
+ * Given a @p FEValuesBase object,
* extract the values on the present
* cell from the vector we actually
* store. This function does the same
get_cell_data_value (const unsigned int cell_number) const;
/**
- * Given a @p{FEValuesBase} object,
+ * Given a @p FEValuesBase object,
* extract the values on the present
* cell from the vector we actually
* store.
std::vector<double> &patch_values) const;
/**
- * Given a @p{FEValuesBase} object,
+ * Given a @p FEValuesBase object,
* extract the values on the present
* cell from the vector we actually
* store. This function does the same
/**
* Abbreviate the somewhat lengthy
- * name for the @p{Patch} class.
+ * name for the @p Patch class.
*/
typedef ::DataOutBase::Patch<patch_dim,patch_space_dim> Patch;
/**
* This is a list of patches that is
- * created each time @p{build_patches}
+ * created each time @p build_patches
* is called. These patches are used
* in the output routines of the base
* classes.
/**
* Make all template siblings
* friends. Needed for the
- * @p{merge_patches} function.
+ * @p merge_patches function.
*/
template <int,int,int> friend class DataOut_DoFData;
/**
* This class is an actual implementation of the functionality proposed by
- * the @ref{DataOut_DoFData} class. It offers a function @p{build_patches} that
+ * the DataOut_DoFData() class. It offers a function @p 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.
*
- * The only thing this class offers is the function @p{build_patches} which
- * loops over all cells of the triangulation stored by the @p{attach_dof_handler}
+ * The only thing this class offers is the function @p build_patches which
+ * loops over all cells of the triangulation stored by the @p attach_dof_handler
* function of the base class and convert the data on these to actual patches
* which are the objects that are later output by the functions of the
* base classes. You can give a parameter to the function which determines
* for quadratic elements you may want to choose two, for cubic elements three,
* and so on.
*
- * Note that after having called @p{build_patches} once, you can call one or
+ * Note that after having called @p build_patches once, you can call one or
* more of the @p{write_*} functions of the base classes. You can therefore
* output the same data in more than one format without having to rebuild
* the patches.
*
* @sect3{User interface information}
*
- * The base classes of this class, @ref{DataOutBase}, @ref{DataOutInterface} and
- * @ref{DataOut_DoFData} offer several interfaces of their own. Refer to the
- * @ref{DataOutBase} class's documentation for a discussion of the different
- * output formats presently supported, @ref{DataOutInterface} for ways of
+ * The base classes of this class, DataOutBase, DataOutInterface and
+ * DataOut_DoFData() offer several interfaces of their own. Refer to the
+ * DataOutBase class's documentation for a discussion of the different
+ * output formats presently supported, DataOutInterface for ways of
* selecting which format to use upon output at run-time and without
* the need to adapt your program when new formats become available, as
- * well as for flags to determine aspects of output. The @ref{DataOut_DoFData}
+ * well as for flags to determine aspects of output. The DataOut_DoFData()
* class's documentation has an example of using nodal data to generate
* output.
*
* small to be seen individually) or because you only want to see a certain
* region of the domain, or for some other reason.
*
- * For this, internally the @p{build_patches} function does not generate
+ * For this, internally the @p build_patches function 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 @p first_cell and @p 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
+ * 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
* for output instead of the exact values on active cells.
*
/**
* Return the next cell after
- * @p{cell} which we want output
+ * @p cell which we want output
* for. If there are no more
* cells, @p{dofs->end()} shall
* be returned.
* other cells in a derived
* class. Note that the default
* implementation assumes that
- * the given @p{cell} is active,
+ * the given @p cell is active,
* which is guaranteed as long as
- * @p{first_cell} is also used
+ * @p first_cell is also used
* from the default
* implementation. Overloading
* only one of the two functions
* globally to avoid allocation
* of memory in the threads.
*
- * The @p{index_to_patch_map} is
+ * The @p index_to_patch_map is
* an array that stores for index
* @p{[i][j]} the number of the
* patch that associated with the
- * cell with index @p{j} on level
- * @p{i}. This information is set
+ * cell with index @p j on level
+ * @p i. This information is set
* up prior to generation of the
* patches, and is needed to
* generate neighborship
std::vector<std::vector<unsigned int> > *cell_to_patch_index_map;
};
/**
- * Builds every @p{n_threads}'s
+ * Builds every @p n_threads's
* patch. This function may be
* called in parallel.
* If multithreading is not
/**
* This class generates output from faces of a triangulation rather
- * than from cells, as do for example the @ref{DataOut} and
- * @ref{DataOut_Rotation} classes. It might be used to generate output
+ * than from cells, as do for example the DataOut and
+ * DataOut_Rotation() classes. It might be used to generate output
* only for the surface of the triangulation (this is the default of
* this class), or for another arbitrary set of faces. The output of
* this class is a set of patches (as defined by the class
- * @ref{DataOutBase::Patch}), one for each face for which output is to
+ * DataOutBase::Patch()), one for each face for which output is to
* be generated. These patches can then be written in several
* graphical data formats by the functions of the underlying classes.
*
* @sect3{Interface}
*
- * The interface of this class is copied from the @ref{DataOut}
+ * The interface of this class is copied from the DataOut
* class. Furthermore, they share the common parent class
- * @ref{DataOut_DoFData}. See the reference of these two classes for a
+ * DataOut_DoFData(). See the reference of these two classes for a
* discussion of the interface.
*
*
* @sect3{Extending this class}
*
* The sequence of faces to generate patches from is generated in the
- * same way as in the @ref{DataOut} class, see there for a description
+ * same way as in the DataOut class, see there for a description
* of the respective interface. For obvious reasons, the functions
* generating the sequence of faces which shall be used to generate
- * output, are called @p{first_face} and @p{next_face} in this class,
- * rather than @p{first_cell} and @p{next_cell}.
+ * output, are called @p first_face and @p next_face in this class,
+ * rather than @p first_cell and @p next_cell.
*
- * Since we need to initialize objects of type @ref{FEValues} with the
+ * Since we need to initialize objects of type FEValues with the
* faces generated from these functions, it is not sufficient that
* they only return face iterators. Rather, we need a pair of cell and
* the number of the face, as the values of finite element fields need
* elements, where the value of the finite element field depend on the
* direction from which you approach a face, thus it is necessary to
* use a pair of cell and face, rather than only a face
- * iterator). Therefore, this class defines a @p{typedef} which
- * creates a type @p{FaceDescriptor} that is an abbreviation for a
- * pair of cell iterator and face number. The functions @p{first_face}
- * and @p{next_face} operate on objects of this type.
+ * iterator). Therefore, this class defines a @p typedef which
+ * creates a type @p FaceDescriptor that is an abbreviation for a
+ * pair of cell iterator and face number. The functions @p first_face
+ * and @p next_face operate on objects of this type.
*
* Extending this class might, for example, be useful if you only want
* output from certain portions of the boundary, e.g. as indicated by
* generate output for. The usual
* way would, of course, be to
* use an object of type
- * @ref{DoFHandler}@p{<dim>::fec_iterator},
+ * DoFHandler@p{<dim>::fec_iterator},
* but since we have to describe
* faces to objects of type
- * @ref{FEValues}, we can only
+ * FEValues, we can only
* represent faces by pairs of a
* cell and the number of the
* face. This pair is here
/**
* Return the next face after
- * @p{face} which we want output
+ * @p face which we want output
* for. If there are no more
* face, @p{dofs->end()} shall be
* returned as the first
* want to return other faces in
* a derived class. Note that the
* default implementation assumes
- * that the given @p{face} is
+ * that the given @p face is
* active, which is guaranteed as
- * long as @p{first_face} is also
+ * long as @p first_face is also
* used from the default
* implementation. Overloading
* only one of the two functions
{}
};
/**
- * Builds every @p{n_threads}'s
+ * Builds every @p n_threads's
* patch. This function may be
* called in parallel.
* If multithreading is not
* This class generates output in the full domain of computations that
* were done using rotational symmetry of domain and solution. In
* particular, if a computation of a three dimensional problem with
- * rotational symmetry around the @p{z}-axis (i.e. in the
- * @p{r-z}-plane) was done, then this class can be used to generate
- * the output in the original @p{x-y-z} space. In order to do so, it
+ * rotational symmetry around the @p z-axis (i.e. in the
+ * @p r-z-plane) was done, then this class can be used to generate
+ * the output in the original @p x-y-z space. In order to do so, it
* generates from each cell in the computational mesh a cell in the
* space with dimension one greater than that of the DoFHandler
* object. The resulting output will then consist of hexahedra forming
* graphical programs can not represent ring-like structures, the
* angular (rotation) variable is discretized into a finite number of
* intervals as well; the number of these intervals must be given to
- * the @p{build_patches} function. It is noted, however, that while
+ * 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</em> large output files.
*
*
* @sect3{Interface}
*
- * The interface of this class is copied from the @ref{DataOut}
+ * The interface of this class is copied from the DataOut
* class. Furthermore, they share the common parent class
- * @ref{DataOut_DoFData}. See the reference of these two classes for a
+ * DataOut_DoFData(). See the reference of these two classes for a
* discussion of the interface and how to extend it by deriving
* further classes from this class.
*
* @sect3{Details for 1d computations}
*
* The one coordinate in the triangulation used by the
- * @ref{DoFHandler} object passed to this class is taken as the radial
+ * DoFHandler object passed to this class is taken as the radial
* variable, and the output will then be either a circle or a ring
* domain. It is in the user's responsibility to assure that the
* radial coordinate only attains non-negative values.
*
* @sect3{Details for 2d computations}
*
- * We consider the computation (represented by the @ref{DoFHandler}
+ * We consider the computation (represented by the DoFHandler
* object that is attached to this class) to have happened in the
- * @p{r-z}-plane, where @p{r} is the radial variable and @p{z} denotes
+ * @p r-z-plane, where @p r is the radial variable and @p z denotes
* the axis of revolution around which the solution is symmetric. The
- * output is in @p{x-y-z} space, where the radial dependence is
- * transformed to the @p{x-y} plane. At present, it is not possible to
+ * output is in @p x-y-z space, where the radial dependence is
+ * transformed to the @p x-y plane. At present, it is not possible to
* exchange the meaning of the first and second variable of the plane
* in which the simulation was made, i.e. generate output from a
* simulation where the first variable denoted the symmetry axis, and
* In addition to the same
* parameters as found in the
* respective function of the
- * @ref{DataOut} class, the first
+ * DataOut class, the first
* parameter denotes into how
* many intervals the angular
* (rotation) variable is to be
first_cell ();
/**
- * Return the next cell after @p{cell} which
+ * Return the next cell after @p cell which
* we want output for.
* If there are no more cells,
* @p{dofs->end()} shall be returned.
* to return other cells in a derived
* class. Note that the default
* implementation assumes that
- * the given @p{cell} is active, which
- * is guaranteed as long as @p{first_cell}
+ * the given @p cell is active, which
+ * is guaranteed as long as @p first_cell
* is also used from the default
* implementation. Overloading only one
* of the two functions might not be
{}
};
/**
- * Builds every @p{n_threads}'s
+ * Builds every @p n_threads's
* patch. This function may be
* called in parallel.
* If multithreading is not
* space-time output file, or for example to connect the results of
* solutions of a parameter dependent equation for several parameter
* value together into one. The interface is mostly modelled after the
- * @ref{DataOut} class.
+ * DataOut class.
*
* We will explain the concept for a time dependent problem, but
* instead of the time any parameter can be substituted. In our
*
* The following little example shall illustrate the different steps
* of use of this class. It is assumed that the finite element used is
- * composed of two components, @p{u} and @p{v}, that the solution vector
- * is named @p{solution} and that a vector @p{error} is computed which
+ * composed of two components, @p u and @p v, that the solution vector
+ * is named @p solution and that a vector @p error is computed which
* contains an error indicator for each spatial cell.
*
- * Note that unlike for the @ref{DataOut} class it is necessary to first
+ * Note that unlike for the DataOut class it is necessary to first
* declare data vectors and the names of the components before first
* use. This is because on all time levels the same data should be
* present to produce reasonable time-space output. The output is
* which is suitable for quadratic finite elements in space, for
* example.
*
- * @begin{verbatim}
+ * @verbatim
* DataOutStack<dim> data_out_stack;
*
* // first declare the vectors
* data_out_stack.build_patches (2);
* data_out_stack.finish_parameter_value ();
* };
- * @end{verbatim}
+ * @endverbatim
*
* @author Wolfgang Bangerth, 1999
*/
/**
* Destructor. Only declared to make
- * it @p{virtual}.
+ * it @p virtual.
*/
virtual ~DataOutStack ();
/**
* Start the next set of data for a
* specific parameter value. The argument
- * @p{parameter_step} denotes the interval
+ * @p parameter_step denotes the interval
* (in backward direction, counted from
- * @p{parameter_value}) with which the
+ * @p parameter_value) with which the
* output will be extended in parameter
* direction, i.e. orthogonal to the
* space directions.
* Attach the DoF handler for the
* grid and data associated with the
* parameter previously set by
- * @p{new_parameter_value}.
+ * @p new_parameter_value.
*
* This has to happen before adding
* data vectors for the present
void attach_dof_handler (const DoFHandler<dim> &dof_handler);
/**
- * Declare a data vector. The @p{vector_type}
+ * Declare a data vector. The @p vector_type
* argument determines whether the data
* vector will be considered as DoF or
* cell data.
*
* This version may be called if the
* finite element presently used by the
- * @ref{DoFHandler} (and previously attached
+ * DoFHandler (and previously attached
* to this object) has only one component
* and therefore only one name needs to
* be given.
const VectorType vector_type);
/**
- * Declare a data vector. The @p{vector_type}
+ * Declare a data vector. The @p vector_type
* argument determines whether the data
* vector will be considered as DoF or
* cell data.
*
* This version must be called if the
* finite element presently used by the
- * @ref{DoFHandler} (and previously attached
+ * DoFHandler (and previously attached
* to this object) has more than one
* component and therefore more than one
* name needs to be given. However, you
*
* This version may be called if the
* finite element presently used by the
- * @ref{DoFHandler} (and previously attached
+ * DoFHandler (and previously attached
* to this object) has only one component
* and therefore only one name needs to
* be given.
*
* The data vector must have been
- * registered using the @p{declare_data_vector}
+ * registered using the @p declare_data_vector
* function before actually using it the
* first time.
*
* Note that a copy of this vector is
- * stored until @p{finish_parameter_value}
+ * stored until @p finish_parameter_value
* is called the next time, so if you are
* short of memory you may want to call
* this function only after all
*
* This version must be called if the
* finite element presently used by the
- * @ref{DoFHandler} (and previously attached
+ * DoFHandler (and previously attached
* to this object) has more than one
* component and therefore more than one
* name needs to be given. However, you
* only one component.
*
* The data vector must have been
- * registered using the @p{declare_data_vector}
+ * registered using the @p declare_data_vector
* function before actually using it the
* first time.
*
* Note that a copy of this vector is
- * stored until @p{finish_parameter_value}
+ * stored until @p finish_parameter_value
* is called the next time, so if you are
* short of memory you may want to call
* this function only after all
* Actually build the patches for output
* by the base classes from the data
* stored in the data vectors and using
- * the previously attached @ref{DoFHandler}
+ * the previously attached DoFHandler
* object.
*
- * By @p{n_subdivisions} you can decide
+ * By @p n_subdivisions you can decide
* into how many subdivisions (in each
* space and parameter direction) each
* patch is divided. This is useful
/**
* Release all data that is no
- * more needed once @p{build_patches}
+ * more needed once @p build_patches
* was called and all other transactions
* for a given parameter value are done.
*
- * Couterpart of @p{new_parameter_value}.
+ * Couterpart of @p new_parameter_value.
*/
void finish_parameter_value ();
* This is the function through
* which derived classes propagate
* preprocessed data in the form of
- * @ref{Patch} structures (declared in
- * the base class @ref{DataOutBase}) to
+ * Patch structures (declared in
+ * the base class DataOutBase) to
* the actual output function.
*/
virtual const std::vector< ::DataOutBase::Patch<dim+1,dim+1> > & get_patches () const;
* \frac{u_h(x_{K'}) - u_h(x_K)}{ \|y_{K'}\| }
* \right).$
* This is a quantity that is easily computed. The value returned for
- * each cell when calling the @p{approximate_gradient} function of
+ * each cell when calling the @p approximate_gradient function of
* this class is the $l_2$ norm of this approximation to the
* gradient. To make this a useful quantity, you may want to scale
* each element by the correct power of the respective cell size.
* these operations that are dependent on the actual order of the
* derivatives to be approximated, as well as the computation of the
* quantities entering the difference quotient, have been separated
- * into auxiliary nested classes (names @p{Gradient} and
- * @p{SecondDerivative}) and the main algorithm is simply passed one
+ * into auxiliary nested classes (names @p Gradient and
+ * @p SecondDerivative) and the main algorithm is simply passed one
* or the other data types and asks them to perform the order
* dependent operations. The main framework that is independent of
* this, such as finding all active neighbors, or setting up the
- * matrix $Y$ is done in the main function @p{approximate}.
+ * matrix $Y$ is done in the main function @p approximate.
*
* Due to this way of operation, the class may be easily extended for
* higher oder derivatives than are presently implemented. Basically,
* only an additional class along the lines of the derivative
- * descriptor classes @p{Gradient} and @p{SecondDerivative} has to be
+ * descriptor classes @p Gradient and @p SecondDerivative has to be
* implemented, with the respective typedefs and functions replaced by
* the appropriate analogues for the derivative that is to be
* approximated.
const unsigned int component = 0);
/**
- * Calls the @p{interpolate}
+ * Calls the @p interpolate
* function, see above, with
* <tt>mapping=MappingQ1@<dim@>()</tt>.
*/
const unsigned int component = 0);
/**
- * Calls the @p{interpolate}
+ * Calls the @p interpolate
* function, see above, with
* <tt>mapping=MappingQ1@<dim@>()</tt>.
*/
/**
* Declare which data fields have
* to be updated for the function
- * @p{get_projected_derivative}
+ * @p get_projected_derivative
* to work.
*/
static const UpdateFlags update_flags;
typedef double ProjectedDerivative;
/**
- * Given an @ref{FEValues} object
+ * Given an FEValues object
* initialized to a cell, and a
* solution vector, extract the
* desired derivative at the
/**
* Declare which data fields have
* to be updated for the function
- * @p{get_projected_derivative}
+ * @p get_projected_derivative
* to work.
*/
static const UpdateFlags update_flags;
typedef Tensor<1,dim> ProjectedDerivative;
/**
- * Given an @ref{FEValues} object
+ * Given an FEValues object
* initialized to a cell, and a
* solution vector, extract the
* desired derivative at the
* this class with the correct
* template first argument and
* then simply calls the
- * @p{approximate} function,
+ * @p approximate function,
* after setting up several
* threads and doing some
* administration that is
* independent of the actual
* derivative to be computed.
*
- * The @p{component} argument
+ * The @p component argument
* denotes which component of the
* solution vector we are to work
* on.
/**
* Print intermediate solutions in solvers. This is derived from a
* solver class provided as template argument. It implements the
- * @p{print_vector} function of the solver using a
- * @ref{DoFHandler}. This way, the intermediate vectors can be viewed
+ * @p print_vector function of the solver using a
+ * DoFHandler. This way, the intermediate vectors can be viewed
* as finite element functions. This class might be used first to
* understand how solvers work (for example to visualize the smoothing
* properties of various solvers, e.g. in a multigrid context), and
* template argument, and with a file name (as a string), with which a
* new file is constructed in each iteration (named
* @p{basename.[step].[suffix]}) and into which the solution is
- * written as a finite element field using the @ref{DataOut} class.
+ * written as a finite element field using the DataOut class.
* Please note that this class may produce enormous amounts of data!
*
* @author Guido Kanschat, 2000
/**
* Constructor. First, we take
* the arguments needed for the
- * solver. @p{data_out} is the
+ * solver. @p data_out is the
* object doing the output as a
* finite element function.
*
* 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 @ref{Triangulation}@p{<dim>::refine_*} functions. This
- * vector contains elements of data type @p{float}, rather than @p{double},
+ * can be used to feed the Triangulation@p{<dim>::refine_*} 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.
*
* is considered, but may lead to wrong results. You may scale the vector
* appropriately afterwards.
*
- * To perform the integration, use is made of the @ref{FEFaceValues} and
- * @ref{FESubfaceValues} classes. The integration is performed by looping
+ * To perform the integration, use is made of the FEFaceValues and
+ * FESubfaceValues classes. The integration is performed by looping
* over all cells and integrating over faces that are not yet treated.
* This way we avoid integration on faces twice, once for each time we
* visit one of the adjacent cells. In a second loop over all cells, we
*
* The integration is done using a quadrature formula on the face.
* For linear trial functions (@ref{FEQ1}), the @ref{QGauss2} or even the
- * @ref{QMidpoint} rule will suffice. For higher order elements, it is
+ * QMidpoint rule will suffice. For higher order elements, it is
* necessary to utilize higher order quadrature formulae as well.
*
- * We store the contribution of each face in a @p{map}, as provided by the
+ * We store the contribution of each face in a @p map, as provided by the
* C++ standard library, with the iterator pointing to that face being the
* key into the map. In fact, we do not store the indicator per face, but
* only the integral listed above. When looping the second time over all
* components at the same time. The main function of this class takes
* a list of flags denoting the components for which components the
* error estimator is to be applied; by default, it is a list of only
- * @p{true}s, meaning that all variables shall be treated.
+ * @p trues, meaning that all variables shall be treated.
*
* In case the different components of a field have different
* physical meaning (for example velocity and pressure in the Stokes
*
* 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:
- * @begin{itemize}
- * @item The face belongs to a Dirichlet boundary. Then the face is not
+ * <ul>
+ * <li> The face belongs to a Dirichlet boundary. Then the face is not
* considered, which can be justified looking at a dual problem technique and
* should hold exactly if the boundary can be approximated exactly by the
* finite element used (i.e. it is a linear boundary for linear finite elements,
* store a zero for this face, which makes summing up the contributions of
* the different faces to the cells easier.
*
- * @item The face belongs to a Neumann boundary. In this case, the
+ * <li> The face belongs to a Neumann boundary. In this case, the
* contribution of the face $F\in\partial K$ looks like
* \f[ \int_F \left|g-a\frac{\partial u_h}{\partial n}\right|^2 ds \f]
* where $g$ is the Neumann boundary function. If the finite element is
* vector-valued, then obviously the function denoting the Neumann boundary
* conditions needs to be vector-valued as well.
*
- * @item No other boundary conditions are considered.
- * @end{itemize}
+ * <li> No other boundary conditions are considered.
+ * </ul>
* The object describing the boundary conditions is obtained from the
* triangulation.
*
*
* 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
- * documentation for the @ref{FESubFaceValues} class for more information about
+ * documentation for the FESubFaceValues class for more information about
* technical issues regarding this topic.
*
* In praxi, since we integrate over each face only once, we do this when we
* then call the functions of this class several times for each
* solution. However, it is observed that the largest factor in the
* computation of the error estimates (in terms of computing time) is
- * initialization of @ref{FEFaceValues} and @ref{FESubFaceValues}
+ * initialization of FEFaceValues and FESubFaceValues
* objects, and iterating through all faces and subfaces. If the
* solution vectors live on the same grid, this effort can be reduced
* significantly by treating all solution vectors at the same time,
- * initializing the @ref{FEFaceValues} objects only once per cell and
+ * initializing the FEFaceValues objects only once per cell and
* for all solution vectors at once, and also only looping through
* the triangulation only once. For this reason, besides the
- * @p{estimate} function in this class that takes a single input
+ * @p estimate function in this class that takes a single input
* vector and returns a single output vector, there is also a
* function that accepts several in- and output vectors at the same
* time.
* components you want to
* evaluate, in case the finite
* element used by the
- * @ref{DoFHandler} object is
+ * DoFHandler object is
* vector-valued. You then have
* to set those entries to true
* in the bit-vector
- * @p{component_mask} for which the
+ * @p component_mask for which the
* respective component is to be
* used in the error
* estimator. The default is to
const unsigned int subdomain_id = deal_II_numbers::invalid_unsigned_int);
/**
- * Calls the @p{estimate}
+ * Calls the @p estimate
* function, see above, with
* <tt>mapping=MappingQ1@<dim@>()</tt>.
*/
const unsigned int subdomain_id = deal_II_numbers::invalid_unsigned_int);
/**
- * Calls the @p{estimate}
+ * Calls the @p estimate
* function, see above, with
* <tt>mapping=MappingQ1@<dim@>()</tt>.
*/
* becomes clear when looking at
* the source code. This function
* is only externalized from
- * @p{estimate_error} to avoid
+ * @p estimate_error to avoid
* ending up with a function of
* 500 lines of code.
*/
* The same applies as for the
* function above, except that
* integration is over face
- * @p{face_no} of @p{cell}, where
+ * @p face_no of @p cell, where
* the respective neighbor is
* refined, so that the
* integration is a bit more
* class. Nevertheless, some
* compilers don't implement this
* resolution yet, so we have to
- * make them @p{friend}, which
+ * make them @p friend, which
* doesn't hurt on the other
* compilers as well.
*/
* components you want to
* evaluate, in case the finite
* element used by the
- * @ref{DoFHandler} object is
+ * DoFHandler object is
* vector-valued. You then have
* to set those entries to true
* in the bit-vector
- * @p{component_mask} for which the
+ * @p component_mask for which the
* respective component is to be
* used in the error
* estimator. The default is to
const unsigned int subdomain_id = deal_II_numbers::invalid_unsigned_int);
/**
- * Calls the @p{estimate}
+ * Calls the @p estimate
* function, see above, with
* @p{mapping=MappingQ1<1>()}.
*/
const unsigned int subdomain_id = deal_II_numbers::invalid_unsigned_int);
/**
- * Calls the @p{estimate}
+ * Calls the @p estimate
* function, see above, with
* @p{mapping=MappingQ1<1>()}.
*/
* @sect3{Ways to generate the intervals}
*
* At present, the following schemes for interval spacing are implemented:
- * @begin{itemize}
- * @item Linear spacing: The intervals are distributed in constant steps
+ * <ul>
+ * <li> Linear spacing: The intervals are distributed in constant steps
* between the minimum and maximum values of the data.
- * @item Logaritmic spacing: The intervals are distributed in constant
+ * <li> Logaritmic spacing: The intervals are distributed in constant
* steps between the minimum and maximum values of the logs of the values.
* This scheme is only useful if the data has only positive values.
* Negative and zero values are sorted into the leftmost interval.
- * @end{itemize}
+ * </ul>
*
* To keep programs extendible, you can use the two functions
- * @p{get_interval_spacing_names} and @p{parse_interval_spacing}, which always
+ * @p get_interval_spacing_names and @p parse_interval_spacing, which always
* give you a complete list of spacing formats presently supported and are
- * able to generate the respective value of the @p{enum}. If you use them,
+ * able to generate the respective value of the @p enum. If you use them,
* you can write your program in a way such that it only needs to be
* recompiled to take effect of newly added formats, without changing your
* code.
* and the number of values in each
* interval will be the y-range (for
* 2d plots) or the z-range (for 3d
- * plots). For 3d plots, the @p{y_values}
+ * plots). For 3d plots, the @p y_values
* parameter is used to assign each
* data set a value in the y direction,
* which is the depth coordinate in the
* resulting plot. For 2d plots,
- * the @p{y_values} are ignored.
+ * the @p y_values are ignored.
*
* If you give only one data set, i.e.
* @p{values.size()==1}, then the
* resulting histogram will be a 2d
* one.
*
- * @p{n_intervals} denotes the number of
+ * @p n_intervals denotes the number of
* intervals into which the data will be
- * sorted; @p{interval_spacing} denotes
+ * sorted; @p interval_spacing denotes
* the way the bounds of the intervals
* are computed. Refer to the general
* documentation for more information
/**
* Write the histogram computed by
- * the @p{evaluate} function to a
+ * the @p evaluate function to a
* stream in a format suitable to
* the GNUPLOT program. The function
* generates 2d or 3d histograms.
* Get a string containing one of the
* names returned by the above function
* and return the respective value of
- * @p{IntervalSpacing}. Throw an error
+ * @p IntervalSpacing. Throw an error
* if the string is no valid one.
*/
static IntervalSpacing parse_interval_spacing (const std::string &name);
* logarithmic case interval spacing
* scheme.
*
- * Return @p{true}, if (@p{n1<n2},
+ * Return @p true, if (@p{n1<n2},
* and (@p{n1>0} or @p{n2<0})), or
* (n2<n1 and n1>0 and n2<=0). This
* in effect sorts all negativ
/**
* Vector holding one set of intervals
* for each data set given to the
- * @p{evaluate} function.
+ * @p evaluate function.
*/
std::vector<std::vector<Interval> > intervals;
/**
* Values for the depth axis of 3d
- * histograms. Stored in the @p{evaluate}
+ * histograms. Stored in the @p evaluate
* function.
*/
std::vector<double> y_values;
*
* @sect3{Conventions for all functions}
*
- * There exist two versions of each function. One with a @ref{Mapping}
+ * There exist two versions of each function. One with a Mapping
* argument and one without. If a code uses a mapping different from
* @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
+ * functions <em>without</em> 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
+ * functions without Mapping argument still exist to ensure
* backward compatibility. Nevertheless it is advised to change the
- * user's codes to store a specific @ref{Mapping} object and to use
- * the functions that take this @p{Mapping} object as argument. This
+ * user's codes to store a specific Mapping object and to use
+ * the functions that take this @p Mapping object as argument. This
* gives the possibility to easily extend the user codes to work also
* on mappings of higher degree, this just by exchanging
- * @ref{MappingQ1} by, for example, a @ref{MappingQ} or another
- * @ref{Mapping} object of interest.
+ * @ref{MappingQ1} by, for example, a MappingQ or another
+ * Mapping object of interest.
*
* All functions take a sparse matrix object to hold the matrix to be
* created. The functions assume that the matrix is initialized with a
- * sparsity pattern (@ref{SparsityPattern}) corresponding to the given degree
+ * 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 @ref{DoFHandler}@p{<dim>::make_sparsity_pattern}
+ * You can do this by calling the DoFHandler@p{<dim>::make_sparsity_pattern}
* function.
*
* Furthermore it is assumed that no relevant data is in the matrix. All
* want to add several matrices and could then condense afterwards
* only once, instead of for every matrix. To actually do computations
* with these matrices, you have to condense the matrix using the
- * @ref{ConstraintMatrix}@p{::condense} function; you also have to
+ * ConstraintMatrix@p ::condense function; you also have to
* condense the right hand side accordingly and distribute the
* solution afterwards.
*
* @sect3{Supported matrices}
*
* At present there are functions to create the following matrices:
- * @begin{itemize}
- * @item @p{create_mass_matrix}: create the matrix with entries
+ * <ul>
+ * <li> @p create_mass_matrix: create the matrix with entries
* $m_{ij} = \int_\Omega \phi_i(x) \phi_j(x) dx$ by numerical
* quadrature. Here, the $\phi_i$ are the basis functions of the
* finite element space given.
* A coefficient may be given to evaluate
* $m_{ij} = \int_\Omega a(x) \phi_i(x) \phi_j(x) dx$ instead.
*
- * @item @p{create_laplace_matrix}: create the matrix with entries
+ * <li> @p create_laplace_matrix: create the matrix with entries
* $m_{ij} = \int_\Omega \nabla\phi_i(x) \nabla\phi_j(x) dx$ by
* numerical quadrature.
*
* Again, a coefficient may be given to evaluate
* $m_{ij} = \int_\Omega a(x) \nabla\phi_i(x) \phi_j(x) dx$ instead.
- * @end{itemize}
+ * </ul>
*
- * Make sure that the order of the @ref{Quadrature} formula given to these
+ * Make sure that the order of the Quadrature formula given to these
* functions is sufficiently high to compute the matrices with the
* required accuracy. For the choice of this quadrature rule you need
- * to take into account the polynomial degree of the @ref{FiniteElement}
- * basis functions, the roughness of the coefficient @p{a}, as well as
- * the degree of the given @p{Mapping}.
+ * to take into account the polynomial degree of the FiniteElement
+ * basis functions, the roughness of the coefficient @p a, as well as
+ * the degree of the given @p Mapping.
*
* Note, that for system elements the mass matrix and the laplace
* matrix is implemented such that each components couples only with
*
* @sect3{Matrices on the boundary}
*
- * The @p{create_boundary_mass_matrix} creates the matrix with entries
+ * The @p create_boundary_mass_matrix creates the matrix with entries
* $m_{ij} = \int_{\Gamma} \phi_i \phi_j dx$, where $\Gamma$ is the
* union of boundary parts with indicators contained in a
- * @ref{FunctioMap}@p{::FunctionMap} passed to the function (i.e. if
+ * FunctioMap@p ::FunctionMap passed to the function (i.e. if
* you want to set up the mass matrix for the parts of the boundary
* with indicators zero and 2, you pass the function a map of
- * @p{unsigned char}s as parameter @p{boundary_functions} containing
+ * @p{unsigned char}s as parameter @p boundary_functions containing
* the keys zero and 2). The $\phi_i$ are the basis functions which
* have at least part of their support on $\Gamma$. The mapping
- * @p{dof_to_boundary_mapping} required by this function maps global
+ * @p dof_to_boundary_mapping required by this function maps global
* DoF numbers to a numbering of the degrees of freedom located on the
* boundary, and can be obtained using the function
- * @p{DoFTools::map_dof_to_boundary_indices}.
+ * @p DoFTools::map_dof_to_boundary_indices.
*
* Since in most cases we are not interested in the pure mass matrix on the
* boundary, but rather need it to compute the projection of a function to
* This function needs to get passed a matrix object to hold the resulting sparse
* matrix. This object is supposed to be initialized with a suitable sparsity
* pattern, which can be created using the
- * @ref{DoFHandler}@p{::make_boundary_sparsity_pattern} function.
+ * DoFHandler@p ::make_boundary_sparsity_pattern function.
*
* The object describing the exact form of the boundary is obtained from the
* triangulation object.
* exists in two versions, one only building the matrix and one also
* building the right hand side vector. If you want to create a right
* hand side vector without creating a matrix, you can use the
- * @ref{VectorTools::create_right_hand_side} function. The use of the
+ * VectorTools::create_right_hand_side() function. The use of the
* latter may be useful if you want to create many right hand side
* vectors.
*
* once.
*
* All functions in this collection use the finite element given to
- * the @ref{DoFHandler} object the last time that the degrees of
+ * the DoFHandler object the last time that the degrees of
* freedom were distributed on the triangulation.
*
* @author Wolfgang Bangerth, 1998, Ralf Hartmann, 2001
* The matrix is assumed to
* already be initialized with a
* suiting sparsity pattern (the
- * @ref{DoFHandler} provides an
+ * DoFHandler provides an
* appropriate function).
*
* If the library is configured
/**
* Version of the same function
- * (without suffix @p{_1}) with
+ * (without suffix @p _1) with
* the same argument list that
* operates only on an interval
* of iterators. Used for
/**
* Version of the same function
- * (without suffix @p{_2}) with
+ * (without suffix @p _2) with
* the same argument list that
* operates only on an interval
* of iterators. Used for
/**
* Version of the same function
- * (without suffix @p{_1}) with
+ * (without suffix @p _1) with
* the same argument list that
* operates only on an interval
* of iterators. Used for
/**
* Version of the same function
- * (without suffix @p{_2}) with
+ * (without suffix @p _2) with
* the same argument list that
* operates only on an interval
* of iterators. Used for
/**
* Version of the same function
- * (without suffix @p{_1}) with
+ * (without suffix @p _1) with
* the same argument list that
* operates only on an interval
* of iterators. Used for
*
* @sect3{Boundary conditions}
*
- * The @p{apply_boundary_values} function inserts boundary conditions
+ * The @p apply_boundary_values function inserts boundary conditions
* of into a system of equations. To actually do this you have to
* specify a list of degree of freedom indices along with the values
* these degrees of freedom shall assume. To see how to get such a
* list, see the discussion of the
- * @ref{VectorTools}@p{::interpolate_boundary_values} function.
+ * VectorTools@p ::interpolate_boundary_values function.
*
* There are two ways to incorporate fixed degrees of freedom such as boundary
* nodes into a linear system, as discussed below.
* solver which can handle nonsymmetric matrices in any case, so there
* may be no need to do the Gauss elimination anyway. In fact, this is
* the way the function works: it takes a parameter
- * (@p{elininate_columns}) that specifies whether the sparsity pattern
+ * (@p elininate_columns) that specifies whether the sparsity pattern
* is symmetric; if so, then the column is eliminated and the right
* hand side is also modified accordingly. If not, then only the row
* is deleted and the column is not touched at all, and all right hand
* remain unchanged.
*
* If the sparsity pattern for your matrix is non-symmetric, you must
- * set the value of this parameter to @p{false} in any case, since then
+ * set the value of this parameter to @p false in any case, since then
* we can't eliminate the column without searching all rows, which
- * would be too expensive (if @p{N} be the number of rows, and @p{m} the
+ * would be too expensive (if @p N be the number of rows, and @p m the
* number of nonzero elements per row, then eliminating one column is
* an @p{O(N*log(m))} operation, since searching in each row takes
* @p{log(m)} operations). If your sparsity pattern is symmetric, but
- * your matrix is not, then you might specify @p{false} as well. If your
+ * your matrix is not, then you might specify @p false as well. If your
* sparsity pattern and matrix are both symmetric, you might want to
- * specify @p{true} (the complexity of eliminating one row is then
- * @p{O(m*log(m))}, since we only have to search @p{m} rows for the
- * respective element of the column). Given the fact that @p{m} is
+ * specify @p true (the complexity of eliminating one row is then
+ * @p{O(m*log(m))}, since we only have to search @p m rows for the
+ * respective element of the column). Given the fact that @p m is
* roughly constant, irrespective of the discretization, and that the
* number of boundary nodes is @p{sqrt(N)} in 2d, the algorithm for
* symmetric sparsity patterns is @p{O(sqrt(N)*m*log(m))}, while it
* values. However, since the modification for boundary values of the
* right hand side vector depends on the original matrix, this is not
* possible without storing the original matrix somewhere and applying
- * the @p{apply_boundary_conditions} function to a copy of it each
+ * the @p apply_boundary_conditions function to a copy of it each
* time we want to solve. In that case, you can use the
- * @ref{FilteredMatrix} class in the @p{LAC} sublibrary. There you can
+ * FilteredMatrix class in the @p LAC sublibrary. There you can
* also find a formal (mathematical) description of the process of
* modifying the matrix and right hand side vectors for boundary
* values.
*
* For a replacement function,
* see the documentation of the
- * @ref{FilteredMatrix} class in
- * the @p{LAC} sublibrary, or use the
+ * FilteredMatrix class in
+ * the @p LAC sublibrary, or use the
* local_apply_boundary_values()
* function..
*/
*
* For a replacement function, see the
* documentation of the
- * @ref{FilteredMatrix} class in the
- * @p{LAC} sublibrary, or use the
+ * FilteredMatrix class in the
+ * @p LAC sublibrary, or use the
* local_apply_boundary_values()
* function.
*/
* As the interpolation while
* coarsening is much more complicated to organize
* (see further documentation below) than interpolation while pure refinement,
- * @p{SolutionTransfer} offers two possible usages.
- * @begin{itemize}
- * @item If the grid will only be purely refined
- * (i.e. not locally coarsened) then use @p{SolutionTransfer} as follows
- * @begin{verbatim}
+ * @p SolutionTransfer offers two possible usages.
+ * <ul>
+ * <li> If the grid will only be purely refined
+ * (i.e. not locally coarsened) then use @p SolutionTransfer as follows
+ * @verbatim
* SolutionTransfer<dim, double> soltrans(*dof_handler);
* // flag some cells for refinement, e.g.
* GridRefinement::refine_and_coarsen_fixed_fraction(
* tria->execute_coarsening_and_refinement();
* // and redistribute dofs.
* dof_handler->distribute_dofs (fe);
- * @end{verbatim}
+ * @endverbatim
*
* Then there are three different possibilities of how to proceed. Either
- * @begin{verbatim}
+ * @verbatim
* // resize and interpolate a solution
* // vector `in-place'
* soltrans.refine_interpolate(solution);
- * @end{verbatim}
+ * @endverbatim
* or, when the old solution vector is still needed,
- * @begin{verbatim}
+ * @verbatim
* // take a copy of the solution vector
* Vector<double> solution_old(solution);
* // resize solution vector to the correct
- * // size, as the @p{refine_interpolate}
+ * // size, as the @p refine_interpolate
* // function requires the vectors to be
* // of right sizes
* solution.reinit(dof_handler->n_dofs());
* // and finally interpolate
* soltrans.refine_interpolate(solution_old, solution);
- * @end{verbatim}
+ * @endverbatim
*
- * Although the @p{refine_interpolate} functions are allowed to be
+ * Although the @p refine_interpolate functions are allowed to be
* called multiple times, e.g. for interpolating several solution
* vectors, there is following possibility of interpolating several
* functions simultaneously.
- * @begin{verbatim}
+ * @verbatim
* vector<Vector<double> > solutions_old(n_vectors, Vector<double> (n));
* ...
* vector<Vector<double> > solutions(n_vectors, Vector<double> (n));
* soltrans.refine_interpolate(solutions_old, solutions);
- * @end{verbatim}
- * @item If the grid will be refined AND coarsened
- * then use @p{SolutionTransfer} as follows
- * @begin{verbatim}
+ * @endverbatim
+ * <li> If the grid will be refined AND coarsened
+ * then use @p SolutionTransfer as follows
+ * @verbatim
* SolutionTransfer<dim, double> soltrans(*dof_handler);
* // flag some cells for refinement
* // and coarsening, e.g.
* // and interpolate the solution
* Vector<double> interpolate_solution(dof_handler->n_dofs());
* soltrans.interpolate(solution, interpolated_solution);
- * @end{verbatim}
+ * @endverbatim
*
* Multiple calls to the function
* @p{interpolate (const Vector<number> &in, Vector<number> &out)}
* are NOT allowed. Interpolating several functions can be performed in one step
* by using
* @p{void interpolate (const vector<Vector<number> >&all_in, vector<Vector<number> >&all_out) const},
- * and using the respective @p{prepare_for_coarsening_and_refinement} function
+ * and using the respective @p prepare_for_coarsening_and_refinement function
* taking several vectors as input before actually refining and coarsening the
* triangulation (see there).
- * @end{itemize}
+ * </ul>
*
- * For deleting all stored data in @p{SolutionTransfer} and reinitializing it
+ * For deleting all stored data in @p SolutionTransfer and reinitializing it
* use the @p{clear()} function.
*
- * Note that the @p{user_pointer} of some cells are used.
+ * Note that the @p user_pointer of some cells are used.
* Be sure that you don't need them otherwise.
*
- * The template argument @p{number} denotes the data type of the vectors you want
+ * The template argument @p number denotes the data type of the vectors you want
* to transfer.
*
*
* @sect3{Implementation}
*
- * @begin{itemize}
- * @item Solution transfer while pure refinement. Assume that we have got a
+ * <ul>
+ * <li> Solution transfer while pure refinement. Assume that we have got a
* 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
- * @ref{DoFHandler}@p{::distribute_dofs(...)} will change at least some of the
+ * DoFHandler@p{::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
+ * 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
+ * @p user_pointers are cleared. All this is
* done by @p{prepare_for_pure_refinement()}.
*
* In the function @p{refine_interpolate(in,out)} and on each cell where the
- * @p{user_pointer} is set (i.e. the cells that were active in the original grid)
- * we can now access the local values of the solution vector @p{in}
+ * @p user_pointer is set (i.e. the cells that were active in the original grid)
+ * we can now access the local values of the solution vector @p in
* on that cell by using the stored DoF indices. These local values are
- * interpolated and set into the vector @p{out} that is at the end the
- * discrete function @p{in} interpolated on the refined mesh.
+ * interpolated and set into the vector @p out that is at the end the
+ * discrete function @p in interpolated on the refined mesh.
*
* The @p{refine_interpolate(in,out)} function can be called multiply for
* arbitrary many discrete functions (solution vectors) on the original grid.
*
- * @item Solution transfer while coarsening and refinement. After
- * calling @ref{Triangulation}@p{::prepare_coarsening_and_refinement} the
+ * <li> Solution transfer while coarsening and refinement. After
+ * calling Triangulation@p ::prepare_coarsening_and_refinement the
* coarsen flags of either all or none of the children of a
* (father-)cell are set. While coarsening
- * (@ref{Triangulation}@p{::execute_coarsening_and_refinement})
- * the cells that are not needed any more will be deleted from the @ref{Triangulation}.
+ * (Triangulation@p ::execute_coarsening_and_refinement)
+ * the cells that are not needed any more will be deleted from the Triangulation.
*
* For the interpolation from the (to be coarsenend) children to their father
* the children cells are needed. Hence this interpolation
* and the storing of the interpolated values of each of the discrete functions
* that we want to interpolate needs to take place before these children cells
- * are coarsened (and deleted!!). Again the @p{user_pointers} of the cells are
+ * are coarsened (and deleted!!). Again the @p user_pointers of the cells are
* set to point to these values (see below).
* Additionally the DoF indices of the cells
* that will not be coarsened need to be stored according to the solution
*
* As we need two different kinds of pointers (@p{vector<unsigned int> *} for the Dof
* indices and @p{vector<Vector<number> > *} for the interpolated DoF values)
- * we use the @p{Pointerstruct} that includes both of these pointers and
- * the @p{user_pointer} of each cell points to these @p{Pointerstructs}.
+ * we use the @p Pointerstruct that includes both of these pointers and
+ * the @p user_pointer of each cell points to these @p Pointerstructs.
* On each cell only one of the two different pointers is used at one time
* hence we could use the
* @p{void * user_pointer} as @p{vector<unsigned int> *} at one time and as
- * @p{vector<Vector<number> > *} at the other but using this @p{Pointerstruct}
+ * @p{vector<Vector<number> > *} at the other but using this @p Pointerstruct
* in between makes the use of these pointers more safe and gives better
* possibility to expand their usage.
*
* to the solution transfer while pure refinement. Additionally, on each
* cell that is coarsened (hence previously was a father cell),
* the values of the discrete
- * functions in @p{all_out} are set to the stored local interpolated values
+ * functions in @p all_out are set to the stored local interpolated values
* that are accessible due to the 'vector<Vector<number> > *' pointer in
- * @p{Pointerstruct} that is pointed to by the @p{user_pointer} of that cell.
+ * @p Pointerstruct that is pointed to by the @p user_pointer of that cell.
* It is clear that @p{interpolate(all_in, all_out)} only can be called with
* the @p{vector<Vector<number> > all_in} that previously was the parameter
* of the @p{prepare_for_coarsening_and_refinement(all_in)} function. Hence
* @p{interpolate(all_in, all_out)} can (in contrast to
* @p{refine_interpolate(in, out)}) only be called once.
- * @end{itemize}
+ * </ul>
*
* @author Ralf Hartmann, 1999
*/
public:
/**
- * Constructor, takes the current @ref{DoFHandler}
+ * Constructor, takes the current DoFHandler
* as argument.
*/
SolutionTransfer(const DoFHandler<dim> &dof);
void clear();
/**
- * Prepares the @p{SolutionTransfer} for
+ * Prepares the @p SolutionTransfer for
* pure refinement. It
* stores the dof indices of each cell.
* After calling this function
- * only calling the @p{refine_interpolate}
+ * only calling the @p refine_interpolate
* functions is allowed.
*/
void prepare_for_pure_refinement();
/**
- * Prepares the @p{SolutionTransfer} for
+ * Prepares the @p SolutionTransfer for
* coarsening and refinement. It
* stores the dof indices of each cell and
* stores the dof values of the vectors in
- * @p{all_in} in each cell that'll be coarsened.
- * @p{all_in} includes all vectors
+ * @p all_in in each cell that'll be coarsened.
+ * @p all_in includes all vectors
* that are to be interpolated
* onto the new (refined and/or
* coarsenend) grid.
/**
* This function
- * interpolates the discrete function @p{in},
+ * interpolates the discrete function @p in,
* which is a vector on the grid before the
- * refinement, to the function @p{out}
+ * refinement, to the function @p out
* which then is a vector on the refined grid.
* It assumes the vectors having the
* right sizes (i.e. @p{in.size()==n_dofs_old},
* @p{out.size()==n_dofs_refined})
*
* Calling this function is allowed only
- * if @p{prepare_for_pure_refinement} is called
+ * if @p prepare_for_pure_refinement is called
* and the refinement is
* executed before.
* Multiple calling of this function is
/**
* Same as @p{interpolate(in,out)}
* but it interpolates
- * just 'in-place'. Therefore @p{vec} will be
+ * just 'in-place'. Therefore @p vec will be
* reinitialized to the new needed vector
* dimension.
*/
/**
* This function
* interpolates the discrete functions
- * that are stored in @p{all_out} onto
+ * that are stored in @p all_out onto
* the refined and/or coarsenend grid.
- * It assumes the vectors in @p{all_in}
+ * It assumes the vectors in @p all_in
* denote the same vectors
- * as in @p{all_in} as parameter of
+ * as in @p all_in as parameter of
* @p{prepare_for_refinement_and_coarsening(all_in)}.
* However, there is no way of verifying
* this internally, so be careful here.
*
* Calling this function is
* allowed only if first
- * @ref{Triangulation}@p{::prepare_coarsening_and_refinement},
+ * Triangulation@p ::prepare_coarsening_and_refinement,
* second
- * @p{SolutionTransfer::prepare_for_coarsening_and_refinement},
+ * @p SolutionTransfer::prepare_for_coarsening_and_refinement,
* an then third
- * @ref{Triangulation}@p{::execute_coarsening_and_refinement}
+ * Triangulation@p ::execute_coarsening_and_refinement
* are called before. Multiple
* calling of this function is
* NOT allowed. Interpolating
* vectors. Also, the sizes of
* the output vectors are assumed
* to be of the right size
- * (@p{n_dofs_refined}). Otherwise
+ * (@p n_dofs_refined). Otherwise
* an assertion will be thrown.
*/
void interpolate (const std::vector<Vector<number> >&all_in,
/**
* Declaration of
- * @p{PreparationState} that
+ * @p PreparationState that
* denotes the three possible
* states of the
- * @p{SolutionTransfer}: being
+ * @p SolutionTransfer: being
* prepared for 'pure
* refinement', prepared for
* 'coarsening and refinement' or
/**
- * Is used for @p{prepare_for_refining}
+ * Is used for @p prepare_for_refining
* (of course also for
- * @p{repare_for_refining_and_coarsening})
+ * @p repare_for_refining_and_coarsening)
* and stores all dof indices
* of the cells that'll be refined
*/
* the dof values)
* should be accessable from each cell.
* As each cell has got only one
- * @p{user_pointer}, multiple pointers to the
+ * @p user_pointer, multiple pointers to the
* data need to be packetized in a structure.
* Note that in our case on each cell
* either the
* will be refined) or the
* @p{vector<double> dof_values} (if the
* children of this cell will be deleted)
- * is needed, hence one @p{user_pointer} should
+ * is needed, hence one @p user_pointer should
* be sufficient, but to allow some errorchecks
* and to preserve the user from making
- * user errors the @p{user_pointer} will be
+ * user errors the @p user_pointer will be
* 'multiplied' by this structure.
*/
struct Pointerstruct {
};
/**
- * Vector of all @p{Pointerstructs} (cf. there).
+ * Vector of all @p Pointerstructs (cf. there).
* It makes it
* easier to delete all these structs
* (without going over all @p{cell->user_pointer})
/**
* Is used for
- * @p{prepare_for_refining_and_coarsening}
+ * @p prepare_for_refining_and_coarsening
* The interpolated dof values
* of all cells that'll be coarsened
* will be stored in this vector.
* perform another sweep on these refined meshes. A total run will therefore
* often be a sequence of several sweeps. The global setup therefore looks
* like this:
- * @begin{verbatim}
+ * @verbatim
* for sweep=0 to n_sweeps-1
* {
* for i=0 to n_timesteps-1
* notify timestep i of the end of the sweep, e.g. for cleanups,
* deletion of temporary files, etc.
* }
- * @end{verbatim}
+ * @endverbatim
* The user may specify that a loop shall run forward or backward (the latter
* being needed for the solution of global dual problems, for example).
*
* stepping scheme which needs to look ahead one time step and needs the
* data of the last two time steps, the following pseudocode described
* what the centeral loop function of this class will do when we move
- * from timestep @p{n-1} to timestep @p{n}:
- * @begin{verbatim}
+ * from timestep @p n-1 to timestep @p n:
+ * @verbatim
* wake up timestep n+1 with signal 1
* wake up timestep n with signal 0
* do computation on timestep n
* let timestep n-2 sleep with signal 2
*
* move from n to n+1
- * @end{verbatim}
+ * @endverbatim
* The signal number here denotes the distance of the timestep being sent
* the signal to the timestep where computations are done on. The calls to
- * the @p{wake_up} and @p{sleep} functions with signal 0 could in principle
+ * the @p wake_up and @p sleep functions with signal 0 could in principle
* be absorbed into the function doing the computation; we use these
* redundant signals, however, in order to separate computations and data
* management from each other, allowing to put all stuff around grid
*
* In the example above, possible actions might be: timestep @p{n+1} rebuilds
* the computational grid (there is a specialized class which can do this
- * for you); timestep @p{n} builds matrices sets solution vectors to the right
+ * for you); timestep @p n builds matrices sets solution vectors to the right
* size, maybe using an initial guess; then it does the computations; then
* it deletes the matrices since they are not needed by subsequent timesteps;
- * timestep @p{n-1} deletes those data vectors which are only needed by one
- * timestep ahead; timestep @p{n-2} deletes the remaining vectors and deletes
+ * timestep @p n-1 deletes those data vectors which are only needed by one
+ * timestep ahead; timestep @p n-2 deletes the remaining vectors and deletes
* the computational grid, somewhere storing information how to rebuild it
* eventually.
*
* From the given sketch above, it is clear that each time step object sees
* the following sequence of events:
- * @begin{verbatim}
+ * @verbatim
* wake up with signal 1
* wake up signal 0
* do computation
* sleep with signal 0
* sleep with signal 1
* sleep with signal 2
- * @end{verbatim}
+ * @endverbatim
* This pattern is repeated for each loop in each sweep.
*
* For the different loops within each sweep, the numbers of timesteps
- * to look ahead (i.e. the maximum signal number to the @p{wake_up} function)
- * and the look-behind (i.e. the maximum signal number to the @p{sleep}
+ * to look ahead (i.e. the maximum signal number to the @p wake_up function)
+ * and the look-behind (i.e. the maximum signal number to the @p sleep
* function) can be chosen separately. For example, it is usually only
* needed to look one time step behind when computing error estimation
* (in some cases, it may vene be possible to not look ahead or back
*
* Finally, a note on the direction of look-ahead and look-back is in
* place: look-ahead always refers to the direction the loop is running
- * in, i.e. for loops running forward, @p{wake_up} is called for timestep
+ * in, i.e. for loops running forward, @p wake_up is called for timestep
* objects with a greater time value than the one previously computed on,
- * while @p{sleep} is called for timesteps with a lower time. If the loop
+ * while @p sleep is called for timesteps with a lower time. If the loop
* runs in the opposite direction, e.g. when solving a global dual
* problem, this order is reversed.
*
* The main loop of a program using this class will usually look like
* the following one, taken modified from an application program that
* isn't distributed as part of the library:
- * @begin{verbatim}
+ * @verbatim
* template <int dim>
* void TimeDependent_Wave<dim>::run_sweep (const unsigned int sweep_no)
* {
* for (unsigned int sweep=0; sweep<number_of_sweeps; ++sweep)
* timestep_manager.run_sweep (sweep);
* };
- * @end{verbatim}
- * Here, @p{timestep_manager} is an object of type @ref{TimeDependent_Wave}, which
- * is a class derived from @ref{TimeDependent}. @p{start_sweep},
- * @p{solve_primal_problem}, @p{solve_dual_problem}, @p{postprocess} and @p{end_sweep}
+ * @endverbatim
+ * Here, @p timestep_manager is an object of type TimeDependent_Wave(), which
+ * is a class derived from TimeDependent. @p start_sweep,
+ * @p solve_primal_problem, @p solve_dual_problem, @p postprocess and @p end_sweep
* are functions inherited from this class. They all do a loop over all
* timesteps within this object and call the respective function on each of
* these objects. For example, here are two of the functions as they are
* implemented by the library:
- * @begin{verbatim}
+ * @verbatim
* void TimeDependent::start_sweep (const unsigned int s)
* {
* sweep_no = s;
* timestepping_data_primal,
* forward);
* };
- * @end{verbatim}
+ * @endverbatim
* The latter function shows rather clear how most of the loops are
- * invoked (@p{solve_primal_problem}, @p{solve_dual_problem}, @p{postprocess},
- * @p{refine_grids} and @p{write_statistics} all have this form, where the
+ * invoked (@p solve_primal_problem, @p solve_dual_problem, @p postprocess,
+ * @p refine_grids and @p write_statistics all have this form, where the
* latter two give functions of the derived timestep class, rather than
- * from the base class). The function @ref{TimeStepBase}@p{::init_for_primal_problem}
+ * from the base class). The function TimeStepBase@p ::init_for_primal_problem
* and the respective ones for the other operations defined by that class
* are only used to store the type of operation which the loop presently
* performed will do.
*
- * As can be seen, most of the work is done by the @p{do_loop} function of
+ * As can be seen, most of the work is done by the @p do_loop function of
* this class, which takes the addresses of two functions which are used
* to initialize all timestep objects for the loop and to actually perform
* some action. The next parameter gives some information on the look-ahead
* and look-back and the last one denotes in which direction the loop is
* to be run.
*
- * Using function pointers through the @p{mem_fun} functions provided by
+ * Using function pointers through the @p mem_fun functions provided by
* the @p{C++} standard library, it is possible to do neat tricks, like
* the following, also taken from the wave program, in this case from
- * the function @p{refine_grids}:
- * @begin{verbatim}
+ * the function @p refine_grids:
+ * @verbatim
* ...
* compute the thresholds for refinement
* ...
* bottom_threshold)),
* TimeDependent::TimeSteppingData (0,1),
* TimeDependent::forward);
- * @end{verbatim}
- * @ref{TimeStepBase_Wave}@p{::refine_grid} is a function taking an argument, unlike
+ * @endverbatim
+ * TimeStepBase_Wave()@p ::refine_grid is a function taking an argument, unlike
* all the other functions used above within the loops. However, in this special
* case the parameter was the same for all timesteps and known before the loop
* was started, so we fixed it and made a function object which to the outside
* world does not take parameters.
*
* Since it is the central function of this class, we finally present a
- * stripped down version of the @p{do_loop} method, which is shown in order
+ * stripped down version of the @p do_loop method, which is shown in order
* to provide a better understanding of the internals of this class. For
* brevity we have omitted the parts that deal with backward running loops
* as well as the checks whether wake-up and sleep operations act on timesteps
* outside @p{0..n_timesteps-1}.
- * @begin{verbatim}
+ * @verbatim
* template <typename InitFunctionObject, typename LoopFunctionObject>
* void TimeDependent::do_loop (InitFunctionObject init_function,
* LoopFunctionObject loop_function,
* for (int look_back=0; look_back<=timestepping_data.look_back; ++look_back)
* timesteps[step-look_back]->sleep(look_back);
* };
- * @end{verbatim}
+ * @endverbatim
*
*
* @author Wolfgang Bangerth, 1999
* ahead of the present one we shall
* start waking up timestep objects
* and how many timesteps behind
- * we shall call their @p{sleep}
+ * we shall call their @p sleep
* method.
*/
struct TimeSteppingData
* The value of this number determines,
* how many time steps ahead the
* time step manager start to call
- * the @p{wake_up} function for each
+ * the @p wake_up function for each
* time step.
*/
const unsigned int look_ahead;
* steps after having done
* computations on a tim level
* the time step manager will
- * call the @p{sleep} function for
+ * call the @p sleep function for
* each time step.
*/
const unsigned int look_back;
/**
* Enum offering the different directions
* in which a loop executed by
- * @p{do_loop} may be run.
+ * @p do_loop may be run.
*/
enum Direction {
forward, backward
* Destructor. This will delete the
* objects pointed to by the pointers
* given to the @p{insert_*} and
- * @p{add_timestep} functions, i.e.
+ * @p add_timestep functions, i.e.
* it will delete the objects doing
* the computations on each time step.
*/
* position is a pointer to an existing
* time step object, or a null pointer
* denoting the end of the timestep
- * sequence. If @p{position} is non-null,
+ * sequence. If @p position is non-null,
* the new time step will be inserted
* before the respective element.
*
* Note that by giving an object
* to this function, the
- * @ref{TimeDependent} object assumes
+ * TimeDependent object assumes
* ownership of the object; it will
* therefore also take care of
* deletion of the objects its manages.
*
* There is another function,
- * @p{add_timestep}, which inserts a
+ * @p add_timestep, which inserts a
* time step at the end of the list.
*
* Note that this function does not
* within the other timestep objects,
* nor does it set the timestep number
* of this new timestep. This is only
- * done upon calling the @p{start_sweep}
+ * done upon calling the @p start_sweep
* function. In not changing the timestep
* numbers, it is simpler to operate
* on a space-time triangulation since
TimeStepBase *new_timestep);
/**
- * Just like @p{insert_timestep}, but
+ * Just like @p insert_timestep, but
* insert at the end.
*
* This mechanism usually will result
* in a set-up loop like this
- * @begin{verbatim}
+ * @verbatim
* for (i=0; i<N; ++i)
* manager.add_timestep(new MyTimeStep());
- * @end{verbatim}
+ * @endverbatim
*/
void add_timestep (TimeStepBase *new_timestep);
* numbers stored within the
* other timestep objects. This
* is only done upon calling the
- * @p{start_sweep} function. In not
+ * @p start_sweep function. In not
* changing the timestep numbers,
* it is simpler to operate on a
* space-time triangulation since
/**
* Solve the primal problem; uses the
- * functions @p{init_for_primal_problem}
- * and @p{solve_primal_problem} of the
- * @ref{TimeStepBase} class through the
- * @p{do_loop} function of this class.
+ * functions @p init_for_primal_problem
+ * and @p solve_primal_problem of the
+ * TimeStepBase class through the
+ * @p do_loop function of this class.
*
* Look ahead and look back are
- * determined by the @p{timestepping_data_primal}
+ * determined by the @p timestepping_data_primal
* object given to the constructor.
*/
void solve_primal_problem ();
/**
* Solve the dual problem; uses the
- * functions @p{init_for_dual_problem}
- * and @p{solve_dual_problem} of the
- * @ref{TimeStepBase} class through the
- * @p{do_loop} function of this class.
+ * functions @p init_for_dual_problem
+ * and @p solve_dual_problem of the
+ * TimeStepBase class through the
+ * @p do_loop function of this class.
*
* Look ahead and look back are
- * determined by the @p{timestepping_data_dual}
+ * determined by the @p timestepping_data_dual
* object given to the constructor.
*/
void solve_dual_problem ();
/**
* Do a postprocessing round; uses the
- * functions @p{init_for_postprocessing}
- * and @p{postprocess} of the
- * @ref{TimeStepBase} class through the
- * @p{do_loop} function of this class.
+ * functions @p init_for_postprocessing
+ * and @p postprocess of the
+ * TimeStepBase class through the
+ * @p do_loop function of this class.
*
* Look ahead and look back are
- * determined by the @p{timestepping_data_postprocess}
+ * determined by the @p timestepping_data_postprocess
* object given to the constructor.
*/
void postprocess ();
/**
* Do a loop over all timesteps, call the
- * @p{init_function} at the beginning and
- * the @p{loop_function} of each time step.
- * The @p{timestepping_data} determine how
+ * @p init_function at the beginning and
+ * the @p loop_function of each time step.
+ * The @p timestepping_data determine how
* many timesteps in front and behind
- * the present one the @p{wake_up} and
- * @p{sleep} functions are called.
+ * the present one the @p wake_up and
+ * @p sleep functions are called.
*
* To see how this function work, note that
- * the function @p{solve_primal_problem} only
+ * the function @p solve_primal_problem only
* consists of a call to
* <tt>do_loop (mem_fun(&TimeStepBase::init_for_primal_problem),
* mem_fun(&TimeStepBase::solve_primal_problem),
*
* Note also, that the given class from which
* the two functions are taken needs not
- * necessarily be @ref{TimeStepBase}, but it
+ * necessarily be TimeStepBase, but it
* could also be a derived class, that is
- * @p{static_cast}able from a @ref{TimeStepBase}.
+ * @p static_castable from a TimeStepBase.
* The function may be a virtual function
* (even a pure one) of that class, which
* should help if the actual class where it
* is implemented is one which is derived
* through virtual base classes and thus
- * unreachable by @p{static_cast} from the
- * @ref{TimeStepBase} class.
+ * unreachable by @p static_cast from the
+ * TimeStepBase class.
*
* Instead of using the above form, you can
* equally well use
* @p{bind2nd(mem_fun1(&X::unary_function), arg)}
- * which lets the @p{do_loop}
+ * which lets the @p do_loop
* function call teh given function with
* the specified parameter. Note that you
* need to bind the second parameter since
* deleted) and transmit the number of
* the present sweep to these objects.
*
- * It also calls the @p{init_for_sweep}
+ * It also calls the @p init_for_sweep
* function of each time step object,
* after the numbers above are set.
*
* should be called bottom-up.
*
* The default implementation of this
- * function calls @p{start_sweep} on all
+ * function calls @p start_sweep on all
* time step objects.
*/
virtual void start_sweep (const unsigned int sweep_no);
/**
* Analogon to the above
- * function, calling @p{end_sweep}
+ * function, calling @p end_sweep
* of each time step object. The
* same applies with respect to
- * the @p{virtual}ness of this
+ * the @p virtualness of this
* function as for the previous
* one.
*
* This function does not
- * guarantee that @p{end_sweep} is
+ * guarantee that @p end_sweep is
* called for successive time
* steps, rather the order of
* time steps for which the
* function has been called for
* previous time steps
* already. If in multithread
- * mode, the @p{end_sweep} function
+ * mode, the @p end_sweep function
* of several time steps is
* called at once, so you should
* use synchronization
/**
* Number of the present sweep. This is
- * reset by the @p{start_sweep} function
+ * reset by the @p start_sweep function
* called at the outset of each sweep.
*/
unsigned int sweep_no;
/**
* Some flags telling the
- * @p{solve_primal_problem} function what to
+ * @p solve_primal_problem function what to
* do. See the documentation of this struct
* for more information.
*/
/**
* Some flags telling the
- * @p{solve_dual_problem} function what to
+ * @p solve_dual_problem function what to
* do. See the documentation of this struct
* for more information.
*/
/**
* Some flags telling the
- * @p{postprocess} function what to
+ * @p postprocess function what to
* do. See the documentation of this struct
* for more information.
*/
/**
* Base class for a time step in time dependent problems. This class provides
* barely more than the basic framework, defining the necessary virtual
- * functions (namely @p{sleep} and @p{wake_up}), the interface to previous
+ * functions (namely @p sleep and @p wake_up), the interface to previous
* and following grids, and some functions to be called before a new loop
* over all time steps is started.
*
/**
* This is the opposite function
- * to @p{wake_up}. It is used to
+ * to @p wake_up. It is used to
* delete data or save it to disk
* after they are no more needed
* for the present sweep. Typical
* and so on. You should take good care,
* however, not to install large objects,
* which should be deferred until the
- * @p{wake_up} function is called.
+ * @p wake_up function is called.
*
* A typical action of this function
* would be sorting out names of
* process of solving, etc.
*
* At the time this function is called,
- * the values of @p{timestep_no}, @p{sweep_no}
+ * the values of @p timestep_no, @p sweep_no
* and the pointer to the previous and
* next time step object already have
* their correct value.
* function is called (i.e. before the
* solution takes place on the first
* time level). By default, this function
- * sets the @p{next_action} variable of
+ * sets the @p next_action variable of
* this class. You may overload this
* function, but you should call this
* function within your own one.
* manager object when solving the
* primal problem on this time level
* is needed. It is called after
- * the @p{wake_up} function was
- * called and before the @p{sleep}
+ * the @p wake_up function was
+ * called and before the @p sleep
* function will be called. There
* is no default implementation for
* obvious reasons, so you have
* manager object when solving the
* dual problem on this time level
* is needed. It is called after
- * the @p{wake_up} function was
- * called and before the @p{sleep}
+ * the @p wake_up function was
+ * called and before the @p sleep
* function will be called. There
* is a default implementation
* doing plain nothing since some
* manager object when postprocessing
* this time level
* is needed. It is called after
- * the @p{wake_up} function was
- * called and before the @p{sleep}
+ * the @p wake_up function was
+ * called and before the @p sleep
* function will be called. There
* is a default implementation
* doing plain nothing since some
* value to return in that case would
* not be zero, since valid computation
* can be done with that, but would
- * be a denormalized value such as @p{NaN}.
+ * be a denormalized value such as @p NaN.
* However, there is not much difference
* in finding that the results of a
* computation are all denormalized values
/**
* Namespace in which some classes are declared that encapsulate flags
- * for the @ref{TimeStepBase_Tria} class. These used to be local data
+ * for the TimeStepBase_Tria() class. These used to be local data
* types of that class, but some compilers choked on some aspects, so
* we put them into a namespace of their own.
*
namespace TimeStepBase_Tria_Flags
{
/**
- * This structure is used to tell the @ref{TimeStepBase_Tria} class how grids should
+ * This structure is used to tell the TimeStepBase_Tria() class how grids should
* be handled. It has flags defining the moments where grids shall be
* re-made and when they may be deleted. Also, one variable states whether
* grids should be kept in memory or should be deleted between to uses to
/**
* This flag determines whether
- * the @p{sleep} and
- * @p{wake_up} functions shall
+ * the @p sleep and
+ * @p wake_up functions shall
* delete and rebuild the
* triangulation. While for
* small problems, this is not
/**
* This number denotes the
- * parameter to the @p{wake_up}
+ * parameter to the @p wake_up
* function at which it shall
* rebuild the grid. Obviously,
* it shall be less than or
- * equal to the @p{look_ahead}
+ * equal to the @p look_ahead
* number passed to the time
* step management object; if
* it is equal, then the grid
* is rebuilt the first time
- * the @p{wake_up} function is
+ * the @p wake_up function is
* called. If
- * @p{delete_and_rebuild_tria}
- * is @p{false}, this number
+ * @p delete_and_rebuild_tria
+ * is @p false, this number
* has no meaning.
*/
const unsigned int wakeup_level_to_build_grid;
/**
* This is the opposite flag to
* the one above: it determines
- * at which call to * @p{sleep}
+ * at which call to * @p sleep
* the grid shall be deleted.
*/
const unsigned int sleep_level_to_delete_grid;
/**
- * This structure is used to tell the @ref{TimeStepBase_Tria} class how grids should
+ * This structure is used to tell the TimeStepBase_Tria() class how grids should
* be refined. Before we explain all the different variables, fist some terminology:
- * @begin{itemize}
- * @item Correction: after having flagged some cells of the triangulation for
+ * <ul>
+ * <li> Correction: after having flagged some cells of the triangulation for
* following some given criterion, we may want to change the number of flagged
* cells on this grid according to another criterion that the number of cells
* may be only a certain fraction more or less then the number of cells on
* the previous grid. This change of refinement flags will be called
* "correction" in the sequel.
- * @item Adaption: in order to make the change between one grid and the next not
+ * <li> Adaption: in order to make the change between one grid and the next not
* to large, we may want to flag some additional cells on one of the two
* grids such that there are not too grave differences. This process will
* be called "adaption".
- * @end{itemize}
+ * </ul>
*
*
* @sect3{Description of flags}
*
- * @begin{itemize}
- * @item @p{max_refinement_level}: Cut the refinement of cells at a given level.
+ * <ul>
+ * <li> @p max_refinement_level: Cut the refinement of cells at a given level.
* This flag does not influence the flagging of cells, so not more cells
* on the coarser levels are flagged than usual. Rather, the flags are all
* set, but when it comes to the actual refinement, the maximum refinement
* refinement with adaptive refinement when you don't want the latter
* to refine more than the global refinement.
*
- * @item @p{first_sweep_with_correction}: When using cell number correction
+ * <li> @p first_sweep_with_correction: When using cell number correction
* as defined above, it may be worth while to start with this only in
* later sweeps, not already in the first one. If this variable is
* zero, then start with the first sweep, else with a higher one. The
* the sweeps where we start to be interested in the actual results of
* the computations.
*
- * @item @p{min_cells_for_correction}: If we want a more free process of
+ * <li> @p min_cells_for_correction: If we want a more free process of
* grid development, we may want to impose less rules for grids with few
* cells also. This variable sets a lower bound for the cell number of
* grids where corrections are to be performed.
*
- * @item @p{cell_number_corridor_top}: Fraction of the number of cells by
+ * <li> @p cell_number_corridor_top: Fraction of the number of cells by
* which the number of cells of one grid may be higher than that on the
* previous grid. Common values are 10 per cent (i.e. 0.1). The naming
* of the variable results from the goal to define a target corridor
* for the number of cells after refinement has taken place.
*
- * @item @p{cell_number_corridor_bottom}: Fraction of the number of cells by
+ * <li> @p cell_number_corridor_bottom: Fraction of the number of cells by
* which the number of cells of one grid may be lower than that on the
* previous grid. Common values are 5 per cent (i.e. 0.05). Usually this
- * number will be smaller than @p{cell_number_corridor_top} since an
+ * number will be smaller than @p cell_number_corridor_top since an
* increase of the number of cells is not harmful (though it increases
* the numerical amount of work needed to solve the problem) while a
* sharp decrease may reduce the accuracy of the final result even if
* direction is reversed, so the two values defining the cell number
* corridor should be about equal.
*
- * @item @p{correction_relaxations}: This is a list of pairs of number with the
- * following meaning: just as for @p{min_cells_for_correction}, it may be
+ * <li> @p correction_relaxations: This is a list of pairs of number with the
+ * following meaning: just as for @p min_cells_for_correction, it may be
* worth while to reduce the requirements upon grids if the have few cells.
* The present variable stores a list of cell numbers along with some values
* which tell us that the cell number corridor should be enlarged by a
* are applied, for cell numbers below 200 they are to be multiplied by 3,
* and so on.
*
- * @p{correction_relaxations} is actually a vector of such list. Each entry
+ * @p correction_relaxations is actually a vector of such list. Each entry
* in this vector denotes the relaxation rules for one sweep. The last
* entry defines the relaxation rules for all following sweeps. This
* scheme is adopted to allow for stricter corrections in later sweeps
* while the relaxations may be more generous in the first sweeps.
*
- * There is a static variable @p{default_correction_relaxations} which you
+ * There is a static variable @p default_correction_relaxations which you
* can use as a default value. It is an empty list and thus defines no
* relaxations.
*
- * @item @p{cell_number_correction_steps}: Usually, if you want the number of
+ * <li> @p cell_number_correction_steps: Usually, if you want the number of
* cells to be corrected, the target corridor for the cell number is computed
* and some additional cells are flagged or flags are removed. But since
* the cell number resulting after flagging and deflagging can not be
* regularly. Setting the variable to zero will result in no correction
* steps at all.
*
- * @item @p{mirror_flags_to_previous_grid}: If a cell on the present grid is
+ * <li> @p mirror_flags_to_previous_grid: If a cell on the present grid is
* flagged for refinement, also flag the corresponding cell on the previous
* grid. This is useful if, for example, error indicators are computed for
* space-time cells, but are stored for the second grid only. Now, since the
* may be useful to flag both if necessary. This is done if the present
* variable is set.
*
- * @item @p{adapt_grids}: adapt the present grid to the previous one in the sense
+ * <li> @p adapt_grids: adapt the present grid to the previous one in the sense
* defined above. What is actually done here is the following: if going from
* the previous to the present grid would result in double refinement or
* double coarsening of some cells, then we try to flag these cells for
* by looping iteratively through all grids, back and forth, until nothing
* changes anymore, which is obviously impossible if there are many time steps
* with very large grids.
- * @end{itemize}
+ * </ul>
*/
template <int dim>
struct RefinementFlags
* Structure given to the actual refinement function, telling it which
* thresholds to take for coarsening and refinement. The actual refinement
* criteria are loaded by calling the virtual function
- * @p{get_tria_refinement_criteria}.
+ * @p get_tria_refinement_criteria.
*/
template <int dim>
struct RefinementData
/**
- * Specialisation of @ref{TimeStepBase} which addresses some aspects of grid handling.
+ * Specialisation of TimeStepBase which addresses some aspects of grid handling.
* In particular, this class is thought to make handling of grids available that
* are adaptively refined on each time step separately or with a loose coupling
* between time steps. It also takes care of deleting and rebuilding grids when
- * memory resources are a point, through the @p{sleep} and @p{wake_up} functions
+ * memory resources are a point, through the @p sleep and @p wake_up functions
* declared in the base class.
*
* In addition to that, it offers functions which do some rather hairy refinement
public:
/**
* Typedef the data types of the
- * @ref{TimeStepBase_Tria_Flags}
+ * TimeStepBase_Tria_Flags()
* namespace into local scope.
*/
typedef typename TimeStepBase_Tria_Flags::Flags<dim> Flags;
* stored to disk, etc. By default,
* this function rebuilds the triangulation
* if the respective flag has been set to
- * destroy it in the @p{sleep} function.
+ * destroy it in the @p sleep function.
* It does so also the first time we
- * hit this function and @p{wakeup_level}
+ * hit this function and @p wakeup_level
* equals @p{flags.wakeup_level_to_build_grid},
* independently of the value of the
* mentioned flag. (Actually, it does so
* whenever the triangulation pointer
* equals the Null pointer and the
- * value of @p{wakeup_level} is right.)
+ * value of @p wakeup_level is right.)
*
* Since this is an important task, you
* should call this function from your
/**
* This is the opposite function
- * to @p{wake_up}. It is used to
+ * to @p wake_up. It is used to
* delete data or save it to disk
* after they are no more needed
* for the present sweep. Typical
* in the flags for this object, the
* triangulation is deleted and the
* refinement history saved such that
- * the respective @p{wake_up} function can
+ * the respective @p wake_up function can
* rebuild it. You should therefore call
* this function from your overloaded
* version, preferrably at the end so
* Respective init function for the
* refinement loop; does nothing in
* the default implementation, apart from
- * setting @p{next_action} to
- * @p{grid_refinement} but can
+ * setting @p next_action to
+ * @p grid_refinement but can
* be overloaded.
*/
virtual void init_for_refinement ();
* Virtual function that should fill
* the vector with the refinement
* criteria for the present triangulation.
- * It is used within the @p{refine_grid}
+ * It is used within the @p refine_grid
* function to get the criteria for
* the present time step, since they
* can't be passed through its
* base class. Note that the
* triangulation is frequently
* deleted and rebuilt by the
- * functions @p{sleep} and
- * @p{wake_up} to save memory, if
+ * functions @p sleep and
+ * @p wake_up to save memory, if
* such a behaviour is specified
- * in the @p{flags} structure.
+ * in the @p flags structure.
*/
Triangulation<dim> *tria;
*
* The selection whether the projection to the boundary first is
* needed is done with the <tt>project_to_boundary_first</tt> flag
- * passed to the function. If @p{false} is given, the additional
+ * passed to the function. If @p false is given, the additional
* quadrature formula for faces is ignored.
*
* You should be aware of the fact that if no projection to the boundary
* important case, which tells the function to enforce zero boundary values
* on the respective boundary parts. Since enforced zero boundary values
* could also have been reached through projection, but are more economically
- * obtain using other methods, the @p{project_to_boundary_first} flag is
- * ignored if the @p{enforce_zero_boundary} flag is set.
+ * obtain using other methods, the @p project_to_boundary_first flag is
+ * ignored if the @p enforce_zero_boundary flag is set.
*
* The solution of the linear system is presently done using a simple CG
* method without preconditioning and without multigrid. This is clearly not
* too efficient, but sufficient in many cases and simple to implement. This
* detail may change in the future.
*
- * @item Creation of right hand side vectors:
- * The @p{create_right_hand_side} function computes the vector
+ * <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
- * @ref{MatrixCreator}@p{::create_*} functions which take a right hand side do,
+ * MatrixCreator@p{::create_*} functions which take a right hand side do,
* but without assembling a matrix.
*
- * @item Creation of boundary right hand side vectors: The
- * @p{create_boundary_right_hand_side} function computes the vector
+ * <li> Creation of boundary right hand side vectors: The
+ * @p create_boundary_right_hand_side function computes the vector
* $f_i = \int_{\partial\Omega} g(x) \phi_i(x) dx$. This is the
* right hand side contribution of boundary forces when having
* inhomogeneous Neumann boundary values in Laplace's equation or
* optional argument denoting over which parts of the boundary the
* integration shall extend.
*
- * @item Interpolation of boundary values:
- * The @ref{MatrixTools}@p{::apply_boundary_values} function takes a list
+ * <li> Interpolation of boundary values:
+ * The MatrixTools@p ::apply_boundary_values function takes a list
* of boundary nodes and their values. You can get such a list by interpolation
- * of a boundary function using the @p{interpolate_boundary_values} function.
+ * of a boundary function using the @p interpolate_boundary_values function.
* To use it, you have to
* specify a list of pairs of boundary indicators (of type @p{unsigned char};
- * see the section in the documentation of the @ref{Triangulation} class for more
+ * see the section in the documentation of the Triangulation class for more
* details) and the according functions denoting the dirichlet boundary values
* of the nodes on boundary faces with this boundary indicator.
*
* Within this function, boundary values are interpolated, i.e. a node is given
* the point value of the boundary function. In some cases, it may be necessary
* to use the L2-projection of the boundary function or any other method. For
- * this purpose we refer to the @ref{VectorTools}@p{::project_boundary_values}
+ * this purpose we refer to the VectorTools@p ::project_boundary_values
* function below.
*
* You should be aware that the boundary function may be evaluated at nodes
* index 1 in the map. The respective boundary functions are then evaluated at
* the place of the respective boundary point.
*
- * @item Projection of boundary values:
- * The @p{project_boundary_values} function acts similar to the
- * @p{interpolate_boundary_values} function, apart from the fact that it does
+ * <li> Projection of boundary values:
+ * The @p project_boundary_values function acts similar to the
+ * @p interpolate_boundary_values function, apart from the fact that it does
* not get the nodal values of boundary nodes by interpolation but rather
* through the <i>L<sup>2</sup></i>-projection of the trace of the function to the boundary.
*
* The projection takes place on all boundary parts with boundary
- * indicators listed in the map (@ref{FunctioMap}@p{::FunctionMap})
+ * indicators listed in the map (FunctioMap@p ::FunctionMap)
* of boundary functions. These boundary parts may or may not be
* continuous. For these boundary parts, the mass matrix is
* assembled using the
- * @ref{MatrixTools}@p{::create_boundary_mass_matrix} function, as
+ * MatrixTools@p ::create_boundary_mass_matrix function, as
* well as the appropriate right hand side. Then the resulting
* system of equations is solved using a simple CG method (without
* preconditioning), which is in most cases sufficient for the
* present purpose.
*
- * @item Computing errors:
- * The function @p{integrate_difference} performs the calculation of the error
+ * <li> Computing errors:
+ * The function @p integrate_difference performs the calculation of the error
* between the finite element solution and a given (continuous) reference
* function in different norms. The integration is performed using a given
* quadrature formulae and assumes that the given finite element objects equals
* that used for the computation of the solution.
*
- * The result is stored in a vector (named @p{difference}), where each entry
+ * The result is stored in a vector (named @p difference), where each entry
* equals the given norm of the difference on a cell. The order of entries
- * is the same as a @p{cell_iterator} takes when started with @p{begin_active} and
+ * is the same as a @p cell_iterator takes when started with @p begin_active and
* promoted with the @p{++} operator.
*
- * You can use the @p{distribute_cell_to_dof_vector} function of the
- * @ref{DoFHandler} class to convert cell based data to a data
+ * You can use the @p distribute_cell_to_dof_vector function of the
+ * DoFHandler class to convert cell based data to a data
* vector with values on the degrees of freedom, which can then be
- * added to a @ref{DataOut} object to be printed. But also you can
- * add a cell based data vector itself to a @ref{DataOut} object,
- * see the @p{DataOut::add_data_vector} functions.
+ * added to a DataOut object to be printed. But also you can
+ * add a cell based data vector itself to a DataOut object,
+ * see the @p DataOut::add_data_vector functions.
*
* Presently, there is the possibility to compute the following values from the
- * difference, on each cell: @p{mean}, @p{L1_norm}, @p{L2_norm}, @p{Linfty_norm},
- * @p{H1_seminorm} and @p{H1_norm}, see @p{VectorTools::NormType}.
+ * difference, on each cell: @p mean, @p L1_norm, @p L2_norm, @p Linfty_norm,
+ * @p H1_seminorm and @p H1_norm, see @p VectorTools::NormType.
* For the mean difference value, the reference function minus the numerical
* solution is computed, not the other way round.
*
* and the square of the <i>L<sup>2</sup></i> norm.
*
* To get the global <i>L<sup>1</sup></i> error, you have to sum up the
- * entries in @p{difference}, e.g. using
- * @ref{Vector}@p{<double>::l1_norm} function. For the global <i>L<sup>2</sup></i>
+ * entries in @p difference, e.g. using
+ * Vector@p{<double>::l1_norm} 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
- * @ref{Vector}@p{<double>::l2_norm}. These two operations
+ * Vector@p{<double>::l2_norm}. 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 @ref{Vector}@p{<double>::linfty_norm} function.
+ * using the Vector@p{<double>::linfty_norm} 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.
- * @end{itemize}
+ * </ul>
*
- * All functions use the finite element given to the @ref{DoFHandler} object the last
+ * All functions use the finite element given to the DoFHandler object the last
* time that the degrees of freedom were distributed over the triangulation. Also,
* if access to an object describing the exact form of the boundary is needed, the
* pointer stored within the triangulation object is accessed.
/**
* Compute the interpolation of
- * @p{function} at the support
+ * @p function at the support
* points to the finite element
* space. It is assumed that the
* number of components of
- * @p{function} matches that of
+ * @p function matches that of
* the finite element used by
- * @p{dof}.
+ * @p dof.
*
* Note that you may have to call
* @p{hanging_nodes.distribute(vec)}
* with the hanging nodes from
- * space @p{dof} afterwards, to
+ * space @p dof afterwards, to
* make the result continuous
* again.
*
VECTOR &vec);
/**
- * Calls the @p{interpolate}
+ * Calls the @p interpolate
* function above with
* <tt>mapping=MappingQ1@<dim>@()</tt>.
*/
* Interpolate different finite
* element spaces. The
* interpolation of vector
- * @p{data_1} is executed from the
+ * @p data_1 is executed from the
* FE space represented by
- * @p{dof_1} to the vector @p{data_2}
- * on FE space @p{dof_2}. The
+ * @p dof_1 to the vector @p data_2
+ * on FE space @p dof_2. The
* interpolation on each cell is
* represented by the matrix
- * @p{transfer}. Curved boundaries
+ * @p transfer. Curved boundaries
* are neglected so far.
*
* Note that you may have to call
* @p{hanging_nodes.distribute(data_2)}
* with the hanging nodes from
- * space @p{dof_2} afterwards, to
+ * space @p dof_2 afterwards, to
* make the result continuous
* again.
*/
/**
* Compute the projection of
- * @p{function} to the finite element space.
+ * @p function to the finite element space.
*
* By default, projection to the boundary
* and enforcement of zero boundary values
* space on the present grid. To
* this end, the mass matrix is
* assembled exactly using the
- * @p{create_mass_matrix}
+ * @p create_mass_matrix
* function in the
- * @ref{MatrixTools}
+ * MatrixTools
* collection. This function
* performs numerical quadrature
* using the given quadrature
const bool project_to_boundary_first = false);
/**
- * Calls the @p{project}
+ * Calls the @p project
* function, see above, with
* @p{mapping=MappingQ1@<dim@>()}.
*/
/**
* Create a right hand side
* vector. Prior content of the
- * given @p{rhs_vector} vector is
+ * given @p rhs_vector vector is
* deleted.
*
* See the general documentation of this
Vector<double> &rhs_vector);
/**
- * Calls the @p{create_right_hand_side}
+ * Calls the @p create_right_hand_side
* function, see above, with
* @p{mapping=MappingQ1@<dim@>()}.
*/
* Create a right hand side
* vector from boundary
* forces. Prior content of the
- * given @p{rhs_vector} vector is
+ * given @p rhs_vector vector is
* deleted.
*
* See the general documentation of this
/**
* Calls the
- * @p{create_boundary_right_hand_side}
+ * @p create_boundary_right_hand_side
* function, see above, with
* @p{mapping=MappingQ1@<dim@>()}.
*/
* be assigned to them, by
* interpolation around the
* boundary. If the
- * @p{boundary_values} contained
+ * @p boundary_values contained
* values before, the new ones
* are added, or the old ones
* overwritten if a node of the
* map of boundary values.
*
* The parameter
- * @p{boundary_component}
+ * @p boundary_component
* corresponds to the number
- * @p{boundary_indicator} of the
+ * @p boundary_indicator of the
* face. 255 is an illegal
* value, since it is reserved
* for interior faces.
*
* The flags in the last
- * parameter, @p{component_mask}
+ * parameter, @p component_mask
* denote which components of the
* finite element space shall be
* interpolated. If it is left as
*
* It is assumed that the number
* of components of the function
- * in @p{boundary_function} matches that
+ * in @p boundary_function matches that
* of the finite element used by
- * @p{dof}.
+ * @p dof.
*
* If the finite element used has
* shape functions that are
* corresponding to the
* components of these
* non-primitive shape functions
- * must be @p{false}.
+ * must be @p false.
*
* See the general doc for more
* information.
/**
* Calls the other
- * @p{interpolate_boundary_values}
+ * @p interpolate_boundary_values
* function, see above, with
* @p{mapping=MappingQ1@<dim@>()}.
*/
/**
* Calls the other
- * @p{interpolate_boundary_values}
+ * @p interpolate_boundary_values
* function, see above, with
* @p{mapping=MappingQ1@<dim@>()}.
*/
/**
- * Project @p{function} to the boundary
+ * Project @p function to the boundary
* of the domain, using the given quadrature
* formula for the faces. If the
- * @p{boundary_values} contained values
+ * @p boundary_values contained values
* before, the new ones are added, or
* the old one overwritten if a node
* of the boundary part to be projected
*
* It is assumed that the number
* of components of
- * @p{boundary_function}
+ * @p boundary_function
* matches that of the finite
- * element used by @p{dof}.
+ * element used by @p dof.
*
* See the general documentation of this
* class for further information.
std::map<unsigned int,double> &boundary_values);
/**
- * Calls the @p{project_boundary_values}
+ * Calls the @p project_boundary_values
* function, see above, with
* @p{mapping=MappingQ1@<dim@>()}.
*/
* is given as a continuous function
* object.
*
- * The value of @p{exponent} is
+ * The value of @p exponent is
* used for computing $L^p$-norms
* and $W^{1,p}$-norms.
*
* The additional argument
- * @p{weight} allows to evaluate
+ * @p weight allows to evaluate
* weighted norms. The weight
* function may be
* one-dimensional, establishing
*
* It is assumed that the number
* of components of the function
- * @p{exact_solution} matches that
+ * @p exact_solution matches that
* of the finite element used by
- * @p{dof}.
+ * @p dof.
*
* See the general documentation of this
* class for more information.
const double exponent = 2.);
/**
- * Calls the @p{integrate_difference}
+ * Calls the @p integrate_difference
* function, see above, with
* @p{mapping=MappingQ1@<dim@>()}.
*/
* value zero. The mean value is
* understood in the l1-sense.
*
- * Apart from the vector @p{v} to
+ * Apart from the vector @p v to
* operate on, this function
* takes a bit vector. This has a
* true entry for every component
const unsigned int component);
/**
- * Calls the @p{compute_mean_value}
+ * Calls the @p compute_mean_value
* function, see above, with
* @p{mapping=MappingQ1@<dim@>()}.
*/
/**
* Default
* constructor. Initialize for
- * @p{n_blocks} blocks and set
+ * @p n_blocks blocks and set
* all block sizes to zero.
*/
BlockIndices (const unsigned int n_blocks = 0);
/**
* Constructor. Initialize the
* number of entries in each
- * block @p{i} as @p{n[i]}. The
+ * block @p i as @p{n[i]}. The
* number of blocks will be the
* size of the vector
*/
* indices within each block from
* the given argument. The number
* of blocks will be adjusted to
- * the size of @p{n} and the size
- * of block @p{i} is set to
+ * the size of @p n and the size
+ * of block @p i is set to
* @p{n[i]}.
*/
inline void reinit (const std::vector<unsigned int> &n);
/**
* Return the block and the
* index within that block
- * for the global index @p{i}. The
+ * for the global index @p i. The
* first element of the pair is
* the block, the second the
* index within it.
/**
* Return the global index of
- * @p{index} in block @p{block}.
+ * @p index in block @p block.
*/
unsigned int local_to_global (const unsigned int block,
const unsigned int index) const;
inline unsigned int total_size () const;
/**
- * Return the size of the @p{i}th
+ * Return the size of the @p ith
* block.
*/
unsigned int block_size (const unsigned int i) const;
/**
- * Global function @p{swap} which overloads the default implementation
+ * Global function @p swap which overloads the default implementation
* of the C++ standard library which uses a temporary object. The
* function simply exchanges the data of the two objects.
*
/**
* A matrix with several copies of the same block on the diagonal.
*
- * This matrix implements an @p{m} by @p{m} block matrix. Each
+ * This matrix implements an @p m by @p m block matrix. Each
* diagonal block consists of the same (non-block) matrix, while
* off-diagonal blocks are void.
*
* One special application is a one by one block matrix, allowing to
- * apply the @p{vmult} of the original matrix (or preconditioner) to a
+ * apply the @p vmult of the original matrix (or preconditioner) to a
* block vector.
*
* @author Guido Kanschat, 2000
{
public:
/**
- * Constructor for an @p{n_blocks}
- * by @p{n_blocks} matrix with
- * diagonal blocks @p{M}.
+ * Constructor for an @p n_blocks
+ * by @p n_blocks matrix with
+ * diagonal blocks @p M.
*/
BlockDiagonalMatrix (const MATRIX &M,
const unsigned int n_blocks);
/**
* Block matrix composed of different single matrices.
*
- * Given a set of arbitrary matrices @p{A_i}, this class implements a
+ * Given a set of arbitrary matrices @p A_i, this class implements a
* block matrix with block entries of the form @p{M_{jk} = s_{jk}A_i}.
- * Each @p{A_i} may be used several times with different prefix.
+ * Each @p A_i may be used several times with different prefix.
*
- * Non-zero entries are registered by the function @p{enter}, zero
- * entries are not stored at all. Using @p{enter} with the same
+ * Non-zero entries are registered by the function @p enter, zero
+ * entries are not stored at all. Using @p enter with the same
* location @p{(i,j)} several times will add the corresponding
* matrices in matrix-vector multiplications.
*
* @sect3{Requirements}
*
- * The template argument @p{MATRIX} is a class providing the the
- * matrix-vector multiplication functions @p{vmult} etc. defined in
- * this class, but with arguments of type @p{VECTOR} instead of
- * @p{BlockVector<VECTOR>}. @ref{SparseMatrix} is a possible entry
+ * The template argument @p MATRIX is a class providing the the
+ * matrix-vector multiplication functions @p vmult etc. defined in
+ * this class, but with arguments of type @p VECTOR instead of
+ * @p{BlockVector<VECTOR>}. SparseMatrix is a possible entry
* type.
*
* @author Guido Kanschat, 2000, 2001
/**
* Matrix-vector multiplication
- * adding to @p{dst}.
+ * adding to @p dst.
*/
template <class number>
void vmult_add (BlockVector<number>& dst,
/**
* Transposed matrix-vector
* multiplication adding to
- * @p{dst}.
+ * @p dst.
*/
template <class number>
void Tvmult_add (BlockVector<number>& dst,
* Internal data structure.
*
* For each entry of a
- * @p{BlockMatrixArray}, its
+ * @p BlockMatrixArray, its
* position, matrix, prefix and
* optional transposition must be
* stored. This structure
* matrix. Then, forward or backward insertion is performed
* block-wise. The diagonal blocks are NOT inverted for this purpose!
*
- * While block indices may be duplicated (see @ref{BlockMatrixArray})
+ * While block indices may be duplicated (see BlockMatrixArray)
* to add blocks, this is not allowed on the diagonal. A short
* computation reveals why.
*
* Like for all preconditioners, the preconditioning operation is
- * performed by the @p{vmult} member function.
+ * performed by the @p vmult member function.
*
* The implementation may be a little clumsy, but it should be
* sufficient as long as the block sizes are much larger than the
/**
* Preconditioning
- * adding to @p{dst}.
+ * adding to @p dst.
*/
template <class number>
void vmult_add (BlockVector<number>& dst,
/**
* Transposed preconditioning
- * adding to @p{dst}.
+ * adding to @p dst.
*/
template <class number>
void Tvmult_add (BlockVector<number>& dst,
* 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 @p SmartPointer
* class.
*/
SmartPointer<const BlockSparsityPattern> sparsity_pattern;
/**
- * A block matrix consisting of blocks of type @p{SparseMatrixEZ}.
+ * A block matrix consisting of blocks of type @p 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
+ * @p SparseMatrixEZ, when it comes to access to entries. Then, there
+ * are functions for the multiplication with @p BlockVector and
* access to the individual blocks.
*
* @author Guido Kanschat, 2002, 2003
* of the same number of block
* rows and columns. Since it
* calls the copy constructor of
- * @ref{SparseMatrixEZ}, the
+ * SparseMatrixEZ, the
* block s must be empty.
*/
BlockSparseMatrixEZ (const BlockSparseMatrixEZ<Number>&);
* initialized
* subsequently. After setting
* the sizes of the blocks,
- * @ref{collect_sizes} must be
+ * collect_sizes() must be
* called to update internal data
* structures.
*/
/**
* Set the element @p{(i,j)} to
- * @p{value}. Throws an error if
+ * @p value. Throws an error if
* the entry does not
* exist. Still, it is allowed to
* store zero values in
const Number value);
/**
- * Add @p{value} to the element
+ * Add @p value to the element
* @p{(i,j)}. Throws an error if
* the entry does not
* exist. Still, it is allowed to
* let $dst = M^T*src$ with $M$
* being this matrix. This
* function does the same as
- * @p{vmult} but takes the
+ * @p 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 @p vmult_add but takes
* the transposed matrix.
*/
template <typename somenumber>
/**
- * Print statistics. If @p{full}
- * is @p{true}, prints a
+ * Print statistics. If @p full
+ * is @p true, prints a
* histogram of all existing row
* lengths and allocated row
* lengths. Otherwise, just the
* and compressed sparsity pattern classes. It has not much
* functionality, but only administrates an array of sparsity pattern
* objects and delegates work to them. It has mostly the same
- * interface as has the @ref{SparsityPattern} and
- * @ref{CompressedSparsityPattern} classes, and simply transforms
+ * interface as has the SparsityPattern and
+ * CompressedSparsityPattern classes, and simply transforms
* calls to its member functions to calls to the respective member
* functions of the member sparsity patterns.
*
- * The largest difference between the @ref{SparsityPattern} and
- * @ref{CompressedSparsityPattern} classes and this class is that
+ * The largest difference between the SparsityPattern and
+ * CompressedSparsityPattern classes and this class is that
* mostly, the matrices have different properties and you will want to
* work on the blocks making up the matrix rather than the whole
* matrix. You can access the different blocks using the
/**
* Define a value which is used
* to indicate that a certain
- * value in the @p{colnums} array
+ * value in the @p colnums array
* is unused, i.e. does not
* represent a certain column
* number index.
*
* This value is only an alias to
* the respective value of the
- * @p{SparsityPattern} class.
+ * @p 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 @p 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 @p 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
+ * @p 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 @p reinit
* functions of the blocks
* themselves. Do not forget to
- * call @p{collect_sizes} after
+ * call @p 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 @p SparsityPattern
* class here but rather let the
* user call whatever function
* she desires.
* This function compresses the
* sparsity structures that this
* object represents. It simply
- * calls @p{compress} for all
+ * calls @p compress for all
* sub-objects.
*/
void compress ();
/**
* Make the block sparse matrix a
* friend, so that it can use our
- * @p{row_indices} and
- * @p{column_indices} objects.
+ * @p row_indices and
+ * @p 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 @p 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 @p collect_sizes after
* you assign them sizes.
*/
BlockSparsityPattern (const unsigned int n_rows,
/**
* Copy data from an object of
* type
- * @ref{CompressedBlockSparsityPattern},
+ * CompressedBlockSparsityPattern,
* i.e. resize this object to the
* size of the given argument,
* and copy over the contents of
/**
* This class extends the base class to implement an array of
* compressed sparsity patterns that can be used to initialize objects
- * of type @ref{BlockSparsityPattern}. It does not add additional
- * member functions, but rather acts as a @p{typedef} to introduce the
+ * of type BlockSparsityPattern. It does not add additional
+ * member functions, but rather acts as a @p typedef to introduce the
* name of this class, without requiring the user to specify the
* templated name of the base class. For information on the interface
* of this class refer to the base class.
* member variables in other
* classes. You can make the
* structure usable by calling
- * the @p{reinit} function.
+ * the @p 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 @p collect_sizes after
* you assign them sizes.
*/
CompressedBlockSparsityPattern (const unsigned int n_rows,
* A vector composed of several blocks each representing a vector of
* its own.
*
- * The BlockVector is a collection of normal LAC-@ref{Vector}s. Each of
+ * The BlockVector is a collection of normal LAC-Vectors. Each of
* the vectors inside can have a different size. The special case of a
* block vector with constant block size is supported by constructor
* and reinit() functions.
*/
bool all_zero () const;
/**
- * Return @p{true} if the vector has no
+ * Return @p true if the vector has no
* negative entries, i.e. all entries are
* zero or positive. This function is
* used, for example, to check whether
/**
* This class acts as an intermediate form of the
- * @ref{SparsityPattern} class. From the interface it mostly
- * represents a @ref{SparsityPattern} object that is kept compressed
+ * SparsityPattern class. From the interface it mostly
+ * represents a SparsityPattern object that is kept compressed
* at all times. However, since the final sparsity pattern is not
* known while constructing it, keeping the pattern compressed at all
* times can only be achieved at the expense of either increased
* it memory conservative, but the chosen data format is too unsuited
* to be used for actual matrices. It is therefore necessary to first
* copy the data of this object over to an object of type
- * @ref{SparsityPattern} before using it in actual matrices.
+ * SparsityPattern before using it in actual matrices.
*
* Another viewpoint is that this class does not need up front
* allocation of a certain amount of memory, but grows as necessary.
* 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
- * @ref{DoFHandler}@p{::max_couplings_per_dof} which returns an
+ * 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 @ref{SparsityPattern} object has allocated much too much
+ * empty SparsityPattern object has allocated much too much
* memory. Although this unnecessarily allocated memory is later freed
- * when @ref{SparsityPattern}@p{::compress} is called, this
+ * 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.
*
* but store a set of column indices indicating possible nonzero
* entries in the sparsity pattern for each row. This is very much
* like the final "compressed" format used in the
- * @ref{SparsityPattern} object after compression, but uses a less
+ * SparsityPattern object after compression, but uses a less
* compact memory storage format, since the exact number of entries
* per row is only known a posteriori and since it may change (for the
- * @ref{SparsityPattern} class, no more changes are allowed after
+ * SparsityPattern class, no more changes are allowed after
* compressing it). We can therefore not store all the column indices
* in a big array, but have to use a vector of sets. This can later be
- * used to actually initialize a @ref{SparsityPattern} object with the
+ * used to actually initialize a SparsityPattern object with the
* then final set of necessary indices.
*
*
* @sect3{Interface}
*
* Since this class is intended as an intermediate replacement of the
- * @ref{SparsityPattern} class, it has mostly the same interface, with
- * small changes where necessary. In particular, the @ref{add}
+ * SparsityPattern class, it has mostly the same interface, with
+ * small changes where necessary. In particular, the add()
* function, and the functions inquiring properties of the sparsity
* pattern are the same.
*
* @sect3{Usage}
*
* Use this class as follows:
- * @begin{verbatim}
+ * @verbatim
* CompressedSparsityPattern compressed_pattern (dof_handler.n_dofs());
* DoFTools::make_sparsity_pattern (dof_handler,
* compressed_pattern);
*
* SparsityPattern sp;
* sp.copy_from (compressed_pattern);
- * @end{verbatim}
+ * @endverbatim
*
*
* @author Wolfgang Bangerth, 2001
* member variables in other
* classes. You can make the
* structure usable by calling
- * the @p{reinit} function.
+ * the @p reinit function.
*/
CompressedSparsityPattern ();
* on classes like this, e.g. to write
* such statements like
* @p{v.push_back (CompressedSparsityPattern());},
- * with @p{v} a vector of @p{CompressedSparsityPattern}
+ * with @p v a vector of @p CompressedSparsityPattern
* objects.
*
* Usually, it is sufficient to
/**
* Initialize a rectangular
- * matrix with @p{m} rows and
- * @p{n} columns.
+ * matrix with @p m rows and
+ * @p n columns.
*/
CompressedSparsityPattern (const unsigned int m,
const unsigned int n);
/**
* Initialize a square matrix of
- * dimension @p{n}.
+ * dimension @p n.
*/
CompressedSparsityPattern (const unsigned int n);
/**
* Reallocate memory and set up
* data structures for a new
- * matrix with @p{m} rows and
- * @p{n} columns, with at most
- * @p{max_per_row} nonzero
+ * matrix with @p m rows and
+ * @p n columns, with at most
+ * @p max_per_row nonzero
* entries per row.
*/
void reinit (const unsigned int m,
* but is declared to make the
* interface of this class as
* much alike as that of the
- * @ref{SparsityPattern} class.
+ * SparsityPattern class.
*/
void compress ();
/**
* Print the sparsity of the matrix
- * in a format that @p{gnuplot} understands
+ * in a format that @p gnuplot understands
* and which can be used to plot the
* sparsity pattern in a graphical
* way. The format consists of pairs
* Print the sparsity pattern in
* gnuplot by setting the data style
* to dots or points and use the
- * @p{plot} command.
+ * @p plot command.
*/
void print_gnuplot (std::ostream &out) const;
/**
* Access to column number field.
* Return the column number of
- * the @p{index}th entry in @p{row}.
+ * the @p indexth entry in @p row.
*/
unsigned int column_number (const unsigned int row,
const unsigned int index) const;
virtual ~EigenPower ();
/**
- * Power method. @p{x} is the
+ * Power method. @p x is the
* (not necessarily normalized,
* but nonzero) start vector for
* the power method. After the
- * iteration, @p{value} is the
+ * iteration, @p value is the
* approximated eigenvalue and
- * @p{x} is the corresponding
+ * @p x is the corresponding
* eigenvector, normalized with
* respect to the l2-norm.
*/
* 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 @p 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 @p 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 @p AdditionalData::start_adaption, which
* indicates the first iteration step in which the shift value should
* be adapted.
*
virtual ~EigenInverse ();
/**
- * Inverse method. @p{value} is
+ * Inverse method. @p value is
* the start guess for the
- * eigenvalue and @p{x} is the
+ * eigenvalue and @p x is the
* (not necessarily normalized,
* but nonzero) start vector for
* the power method. After the
- * iteration, @p{value} is the
+ * iteration, @p value is the
* approximated eigenvalue and
- * @p{x} is the corresponding
+ * @p x is the corresponding
* eigenvector, normalized with
* respect to the l2-norm.
*/
* then clears again. This class is a wrapper to this procedure, it
* takes a pointer to a matrix with which to perform matrix-vector
* products, and does the cleaning of constrained elements itself.
- * This class therefore implements an overloaded @p{vmult} function
- * that does the matrix-vector product, as well as @p{Tvmult} for
- * transpose matrix-vector multiplication and @p{residual} for
+ * This class therefore implements an overloaded @p vmult function
+ * that does the matrix-vector product, as well as @p Tvmult for
+ * transpose matrix-vector multiplication and @p residual for
* residual computation, and can thus be used as a matrix replacement
* in lineaer solvers.
*
* It also has the ability to generate the modification of the right
- * hand side, through the @ref{apply_constraints} function.
+ * hand side, through the apply_constraints() function.
*
*
* @sect3{Connection to other classes}
*
- * The function @p{MatrixTools::apply_boundary_values} does exactly
+ * The function @p 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
+ * @p 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.
*
* Usage is simple: create an object of this type, point it to a
* matrix that shall be used for $A$ above (either through the
* constructor, the copy constructor, or the
- * @ref{set_referenced_matrix} function), specify the list of boundary
- * values or other constraints (through the @ref{add_constraints}
+ * set_referenced_matrix() function), specify the list of boundary
+ * values or other constraints (through the add_constraints()
* function), and then for each required solution modify the right
- * hand side vector (through @ref{apply_constraints}) and use this
+ * hand side vector (through apply_constraints()) and use this
* object as matrix object in a linear solver. As linear solvers
- * should only use @ref{vmult} and @ref{residual} functions of a
+ * should only use vmult() and residual() functions of a
* matrix class, this class should be as a good a matrix as any other
* for that purpose.
*
- * Furthermore, also the @ref{precondition_Jacobi} function is
+ * Furthermore, also the precondition_Jacobi() function is
* provided (since the computation of diagonal elements of the
* filtered matrix $A_X$ is simple), so you can use this as a
* preconditioner. Some other function useful for matrices are also
* available.
*
* A typical code snippet showing the above steps is as follows:
- * @begin{verbatim}
+ * @verbatim
* ... // set up sparse matrix A and right hand side b somehow
*
* // initialize filtered matrix with
*
* // solve for solution vector x
* solver.solve (filtered_A, x, b, prec);
- * @end{verbatim}
+ * @endverbatim
*
*
* @sect3{Template arguments}
*
* This class takes as template arguments a matrix and a vector
- * class. The former must provide @p{vmult}, @p{Tvmult}, and
- * @p{residual} member function that operate on the vector type (the
+ * class. The former must provide @p vmult, @p Tvmult, and
+ * @p residual member function that operate on the vector type (the
* second template argument). The latter template parameter must
* provide access to indivual elements through @p{operator()},
* assignment through @p{operator=}.
*
* The functions that operate as a matrix and do not change the
* internal state of this object are synchronised and thus
- * threadsafe. You need not serialize calls to @p{vmult} or
- * @p{residual} therefore. Because these functions require the use of
+ * threadsafe. You need not serialize calls to @p vmult or
+ * @p residual therefore. Because these functions require the use of
* a temporary, they block mutual execution, however. It is necessary
* to allocate this temporary vector in class space since otherwise we
* would have to allocate such a vector each time one of the member
* Default constructor. You will
* have to set the matrix to be
* used later using the
- * @p{set_referenced_matrix}
+ * @p set_referenced_matrix
* function.
*/
FilteredMatrix ();
* Set the matrix to be used
* further on. You will probably
* also want to call the
- * @ref{clear_constraints}
+ * clear_constraints()
* function if constraits were
* previously added.
*/
* enforced on the respective
* solution vector's entry. Thus,
* the data type might be, for
- * example, a @p{std::list} or
- * @p{std::vector} of
- * @ref{IndexValuePair} objects,
+ * example, a @p std::list or
+ * @p std::vector of
+ * IndexValuePair objects,
* but also a
* @p{std::map<unsigned,value_type>}.
*
* is symmetric (i.e. the matrix
* itself, not only its sparsity
* pattern), set the second
- * parameter to @p{true} to use a
+ * parameter to @p true to use a
* faster algorithm.
*/
void apply_constraints (VECTOR &v,
* let $dst = M^T*src$ with $M$
* being this matrix. This
* function does the same as
- * @p{vmult} but takes the
+ * @p vmult but takes the
* transposed matrix. (This
* matrix is the filtered one to
* which we store a reference.)
* Compute the residual of an
* equation @p{Mx=b}, where the
* residual is defined to be
- * @p{r=b-Mx} with @p{x}
+ * @p{r=b-Mx} with @p x
* typically being an approximate
* of the true solution of the
* equation. Write the residual
- * into @p{dst}. The l2 norm of
+ * into @p dst. The l2 norm of
* the residual vector is
* returned.
*
* Note that it is assumed that
- * @p{b} is a vector that has been
+ * @p b is a vector that has been
* treated by the
- * @ref{modify_rhs} function,
+ * modify_rhs() function,
* since we can then assume that
* the components of the residual
* which correspond to
* Apply the Jacobi
* preconditioner, which
* multiplies every element of
- * the @p{src} vector by the
+ * the @p src vector by the
* inverse of the respective
* diagonal element and
* multiplies the result with the
- * damping factor @p{omega}.
+ * damping factor @p omega.
*/
void precondition_Jacobi (VECTOR &dst,
const VECTOR &src,
{
/**
* Function comparing the
- * pairs @p{i1} and @p{i2}
+ * pairs @p i1 and @p i2
* for their keys.
*/
bool operator () (const IndexValuePair &i1,
* 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 @p SmartPointer
* class.
*/
SmartPointer<const MATRIX> matrix;
* since the amount of code
* needed grows quickly. For
* larger matrices, the method
- * @ref{gauss_jordan} is invoked
+ * gauss_jordan() is invoked
* implicitly.
*/
template <typename number2>
/**
* Matrix-vector product, adding to
- * @p{dst}.
+ * @p dst.
*/
virtual void vmult_add (VECTOR& dst,
const VECTOR& src) const;
/**
* Tranposed matrix-vector product,
- * adding to @p{dst}.
+ * adding to @p dst.
*/
virtual void Tvmult_add (VECTOR& dst,
const VECTOR& src) const;
/**
- * Mean value filter. The @p{vmult} functions of this matrix filter
+ * Mean value filter. The @p 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
+ * @p BlockVector, then an additional parameter selects a single
* component for this operation.
*
* @author Guido Kanschat, 2002, 2003
MeanValueFilter(unsigned int component = deal_II_numbers::invalid_unsigned_int);
/**
- * Subtract mean value from @p{v}.
+ * Subtract mean value from @p v.
*/
template <typename number>
void filter (Vector<number>& v) const;
/**
- * Subtract mean value from @p{v}.
+ * Subtract mean value from @p v.
*/
template <typename number>
void filter (BlockVector<number>& v) const;
* of the base class.
*
* A typical usage of this class would be as follows:
- * @begin{verbatim}
+ * @verbatim
* FullMatrix<double> M;
* ... // fill matrix M with some values
*
* std::ofstream out ("M.gnuplot");
* matrix_out.build_patches (M, "M");
* matrix_out.write_gnuplot (out);
- * @end{verbatim}
+ * @endverbatim
* Of course, you can as well choose a different graphical output
* format. Also, this class supports any matrix, not only of type
- * @ref{FullMatrix}, as long as it satisfies a number of requirements,
+ * 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 @p build_patches function
* can be modified by giving it an object holding certain flags. See
- * the documentation of the members of the @ref{Options} class for a
+ * the documentation of the members of the Options class for a
* description of these flags.
*
*
* @sect3{Internals}
*
* To avoid a compiler error in Sun's Forte compiler, we derive
- * privately from @ref{DataOutBase}. Since the base class
- * @ref{DataOutInterface} does so as well, this does no harm, but
+ * privately from DataOutBase. Since the base class
+ * DataOutInterface does so as well, this does no harm, but
* calms the compiler which is suspecting an access control conflict
* otherwise. Testcase here:
- * @begin{verbatim}
+ * @verbatim
* template <typename T> class V {};
*
* struct B1 {
* };
*
* D d;
- * @end{verbatim}
+ * @endverbatim
*
*
* @author Wolfgang Bangerth, 2001
* Class holding various
* variables which are used to
* modify the output of the
- * @ref{MatrixOut} class.
+ * MatrixOut class.
*/
struct Options
{
/**
- * If @p{true}, only show the
+ * If @p true, only show the
* absolute values of the
* matrix entries, rather
* than their true values
* including the
* sign. Default value is
- * @p{false}.
+ * @p false.
*/
bool show_absolute_values;
* requires that we can extract
* elements of the matrix, which
* is done using the
- * @p{get_element} function
+ * @p 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 @p Patch
* class.
*
* Note that we have to indicate
* the global scope using the
- * @p{::} in front of
- * @p{DataOutBase}, since
+ * @p :: in front of
+ * @p DataOutBase, since
* otherwise the C++ rules
* specify that this here
- * indicates the @p{DataOutBase}
+ * indicates the @p 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 @p 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
+ * @p build_patches is
* called. These patches are used
* in the output routines of the
* base classes.
public:
/**
* Create a full matrix of dimensions
- * @p{m} times @p{n}.
+ * @p m times @p n.
*/
FullMatrix (const unsigned int m,
const unsigned int n);
* matrix.
*
* The interface of this class is modeled after the existing
- * @ref{SparseMatrix} class in deal.II. It has almost the same member
+ * SparseMatrix class in deal.II. It has almost the same member
* 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 @p PetscScalar to.
*
* Note that PETSc only guarantees that operations do what you expect if the
- * functions @p{MatAssemblyBegin} and @p{MatAssemblyEnd} have been called
+ * functions @p MatAssemblyBegin and @p MatAssemblyEnd have been called
* after matrix assembly. Therefore, you need to call
- * @ref{SparseMatrix::compress} before you actually use the matrix. This also
- * calls @p{MatCompress} that compresses the storage format for sparse
+ * SparseMatrix::compress() before you actually use the matrix. This also
+ * calls @p MatCompress that compresses the storage format for sparse
* matrices by discarding unused elements. PETSc allows to continue with
* assembling the matrix after calls to these functions, but since there are
* no more free entries available after that any more, it is better to only
- * call @ref{SparseMatrix::compress} once at the end of the assembly stage and
+ * call SparseMatrix::compress() once at the end of the assembly stage and
* before the matrix is actively used.
*
* @author Wolfgang Bangerth, 2004
/**
* PETSc matrices store their own
* sparsity patterns. So, in analogy to
- * our own @ref{SparsityPattern} class,
+ * our own SparsityPattern class,
* this function compresses the
* sparsity pattern and allows the
* resulting matrix to be used in all
* always take care where to call this
* function. In contrast to the
* respective function in the
- * @p{MatrixBase} class, we don't
+ * @p MatrixBase class, we don't
* throw an exception if the respective
* entry doesn't exist in the sparsity
* pattern of this class, since PETSc
*
* The implementation of this function
* is not as efficient as the one in
- * the @p{MatrixBase} class used in
+ * the @p MatrixBase class used in
* deal.II (i.e. the original one, not
* the PETSc wrapper class) since PETSc
* doesn't support this operation and
*
* The implementation of this function
* is not as efficient as the one in
- * the @p{MatrixBase} class used in
+ * the @p MatrixBase class used in
* deal.II (i.e. the original one, not
* the PETSc wrapper class) since PETSc
* doesn't support this operation and
* involves copying data, and is thus
* expensive.
*
- * The @p{is_symmetric} flag determines
+ * The @p is_symmetric flag determines
* whether we should tell PETSc that
* the matrix is going to be symmetric
* (as indicated by the call
* that one cannot form an ILU
* decomposition of a matrix for which
* this flag has been set. The default
- * value of this flag is @p{false}.
+ * value of this flag is @p false.
*/
SparseMatrix (const MPI_Comm &communicator,
const unsigned int m,
* row, but this involves copying data,
* and is thus expensive.
*
- * The @p{is_symmetric} flag determines
+ * The @p is_symmetric flag determines
* whether we should tell PETSc that
* the matrix is going to be symmetric
* (as indicated by the call
* that one cannot form an ILU
* decomposition of a matrix for which
* this flag has been set. The default
- * value of this flag is @p{false}.
+ * value of this flag is @p false.
*/
SparseMatrix (const MPI_Comm &communicator,
const unsigned int m,
/**
* Set all components of the vector to
- * the given number @p{s}. Simply pass
+ * the given number @p s. Simply pass
* this down to the base class, but we
* still need to declare this function
* to make the example given in the
* over the partitioning into local
* sizes as well as the MPI
* communicator. The same applies as
- * for the other @p{reinit} function.
+ * for the other @p reinit function.
*
* The elements of @p v are not
* copied, i.e. this function is the
protected:
/**
* Create a vector of length
- * @p{n}. For this class, we create a
+ * @p n. For this class, we create a
* parallel vector. @p n denotes
* the total size of the vector to be
* created. @p local_size denotes
* to have an MPI communicator context
* over which computations are
* parallelized. By default,
- * @p{PETSC_COMM_SELF} is used here,
+ * @p PETSC_COMM_SELF is used here,
* but you can change this. Note that
* for single processor (non-MPI)
* versions, this parameter does not
* to have an MPI communicator context
* over which computations are
* parallelized. By default,
- * @p{PETSC_COMM_SELF} is used here,
+ * @p PETSC_COMM_SELF is used here,
* but you can change this. Note that
* for single processor (non-MPI)
* versions, this parameter does not
* to have an MPI communicator context
* over which computations are
* parallelized. By default,
- * @p{PETSC_COMM_SELF} is used here,
+ * @p PETSC_COMM_SELF is used here,
* but you can change this. Note that
* for single processor (non-MPI)
* versions, this parameter does not
* to have an MPI communicator context
* over which computations are
* parallelized. By default,
- * @p{PETSC_COMM_SELF} is used here,
+ * @p PETSC_COMM_SELF is used here,
* but you can change this. Note that
* for single processor (non-MPI)
* versions, this parameter does not
* to have an MPI communicator context
* over which computations are
* parallelized. By default,
- * @p{PETSC_COMM_SELF} is used here,
+ * @p PETSC_COMM_SELF is used here,
* but you can change this. Note that
* for single processor (non-MPI)
* versions, this parameter does not
* to have an MPI communicator context
* over which computations are
* parallelized. By default,
- * @p{PETSC_COMM_SELF} is used here,
+ * @p PETSC_COMM_SELF is used here,
* but you can change this. Note that
* for single processor (non-MPI)
* versions, this parameter does not
* to have an MPI communicator context
* over which computations are
* parallelized. By default,
- * @p{PETSC_COMM_SELF} is used here,
+ * @p PETSC_COMM_SELF is used here,
* but you can change this. Note that
* for single processor (non-MPI)
* versions, this parameter does not
* to have an MPI communicator context
* over which computations are
* parallelized. By default,
- * @p{PETSC_COMM_SELF} is used here,
+ * @p PETSC_COMM_SELF is used here,
* but you can change this. Note that
* for single processor (non-MPI)
* versions, this parameter does not
* to have an MPI communicator context
* over which computations are
* parallelized. By default,
- * @p{PETSC_COMM_SELF} is used here,
+ * @p PETSC_COMM_SELF is used here,
* but you can change this. Note that
* for single processor (non-MPI)
* versions, this parameter does not
* to have an MPI communicator context
* over which computations are
* parallelized. By default,
- * @p{PETSC_COMM_SELF} is used here,
+ * @p PETSC_COMM_SELF is used here,
* but you can change this. Note that
* for single processor (non-MPI)
* versions, this parameter does not
* to have an MPI communicator context
* over which computations are
* parallelized. By default,
- * @p{PETSC_COMM_SELF} is used here,
+ * @p PETSC_COMM_SELF is used here,
* but you can change this. Note that
* for single processor (non-MPI)
* versions, this parameter does not
* involves copying data, and is thus
* expensive.
*
- * The @p{is_symmetric} flag determines
+ * The @p is_symmetric flag determines
* whether we should tell PETSc that
* the matrix is going to be symmetric
* (as indicated by the call
* that one cannot form an ILU
* decomposition of a matrix for which
* this flag has been set. The default
- * value of this flag is @p{false}.
+ * value of this flag is @p false.
*/
SparseMatrix (const unsigned int m,
const unsigned int n,
* row, but this involves copying data,
* and is thus expensive.
*
- * The @p{is_symmetric} flag determines
+ * The @p is_symmetric flag determines
* whether we should tell PETSc that
* the matrix is going to be symmetric
* (as indicated by the call
* that one cannot form an ILU
* decomposition of a matrix for which
* this flag has been set. The default
- * value of this flag is @p{false}.
+ * value of this flag is @p false.
*/
SparseMatrix (const unsigned int m,
const unsigned int n,
/**
* Constructor. Set dimension to
- * @p{n} and initialize all
+ * @p n and initialize all
* elements with zero.
*
* The constructor is made explicit to
/**
* Set all components of the vector to
- * the given number @p{s}. Simply pass
+ * the given number @p s. Simply pass
* this down to the base class, but we
* still need to declare this function
* to make the example given in the
protected:
/**
- * Create a vector of length @p{n}. For
+ * Create a vector of length @p n. For
* this class, we create a sequential
* vector. @p n denotes the total
* size of the vector to be
* base class. Derived classes will then only have to provide the
* functionality to create one or the other kind of vector.
*
- * The interface of this class is modeled after the existing @ref{Vector}
+ * The interface of this class is modeled after the existing Vector
* class in deal.II. It has almost the same member 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.
+ * @p PetscScalar to.
*
* Note that PETSc only guarantees that operations do what you expect if the
- * functions @p{VecAssemblyBegin} and @p{VecAssemblyEnd} have been called
- * after vector assembly. Therefore, you need to call @ref{Vector::compress}
+ * functions @p VecAssemblyBegin and @p VecAssemblyEnd have been called
+ * after vector assembly. Therefore, you need to call Vector::compress()
* before you actually use the vector.
*
* @author Wolfgang Bangerth, 2004
/**
* Set all components of the vector to
- * the given number @p{s}.
+ * the given number @p s.
*/
VectorBase & operator = (const PetscScalar s);
bool all_zero () const;
/**
- * Return @p{true} if the vector has no
+ * Return @p true if the vector has no
* negative entries, i.e. all entries
* are zero or positive. This function
* is used, for example, to check
VectorBase & operator -= (const VectorBase &V);
/**
- * Addition of @p{s} to all
- * components. Note that @p{s} is a
+ * Addition of @p s to all
+ * components. Note that @p s is a
* scalar and not a vector.
*/
void add (const PetscScalar s);
/**
* Print to a
- * stream. @p{precision} denotes
+ * stream. @p precision denotes
* the desired precision with
* which values shall be printed,
- * @p{scientific} whether
+ * @p scientific whether
* scientific notation shall be
- * used. If @p{across} is
- * @p{true} then the vector is
+ * used. If @p across is
+ * @p true then the vector is
* printed in a line, while if
- * @p{false} then the elements
+ * @p false then the elements
* are printed on a separate line
* each.
*/
/**
* Swap the contents of this
* vector and the other vector
- * @p{v}. One could do this
+ * @p v. One could do this
* operation with a temporary
* variable and copying over the
* data elements, but this
* data around.
*
* This function is analog to the
- * the @p{swap} function of all C++
+ * the @p swap function of all C++
* standard containers. Also,
* there is a global function
* @p{swap(u,v)} that simply calls
/**
* Store whether the last action was a
* write or add operation. This
- * variable is @p{mutable} so that the
+ * variable is @p mutable so that the
* accessor classes can write to it,
* even though the vector object they
* refer to is constant.
// ------------------- inline and template functions --------------
/**
- * Global function @p{swap} which overloads the default implementation
+ * Global function @p swap which overloads the default implementation
* of the C++ standard library which uses a temporary object. The
* function simply exchanges the data of the two vectors.
*
* This was defined to make this
* matrix a possible template
* argument to
- * @ref{BlockMatrixArray}.
+ * BlockMatrixArray.
*/
typedef typename VECTOR::value_type value_type;
/**
* Matrix-vector product, adding to
- * @p{dst}.
+ * @p dst.
*/
virtual void vmult_add (VECTOR& dst,
const VECTOR& src) const = 0;
/**
* Tranposed matrix-vector product,
- * adding to @p{dst}.
+ * adding to @p dst.
*/
virtual void Tvmult_add (VECTOR& dst,
const VECTOR& src) const = 0;
* argument is stored in this
* class. As usual, the lifetime of
* @p{*M} must be longer than the
- * one of the @p{PointerMatrix}.
+ * one of the @p PointerMatrix.
*
- * If @p{M} is zero, no matrix is stored.
+ * If @p M is zero, no matrix is stored.
*/
PointerMatrix (const MATRIX* M=0);
/**
* Matrix-vector product, adding to
- * @p{dst}.
+ * @p dst.
*/
virtual void vmult_add (VECTOR& dst,
const VECTOR& src) const;
/**
* Tranposed matrix-vector product,
- * adding to @p{dst}.
+ * adding to @p dst.
*/
virtual void Tvmult_add (VECTOR& dst,
const VECTOR& src) const;
/**
- * Base class for @p{PreconditionBlockJacobi},
- * @p{PreconditionBlockSOR}, ... This class assumes the
+ * Base class for @p PreconditionBlockJacobi,
+ * @p PreconditionBlockSOR, ... This class assumes the
* @p{SparseMatrix<number>} consisting of invertible blocks of
- * @p{blocksize} on the diagonal and provides the inversion of the
+ * @p blocksize on the diagonal and provides the inversion of the
* diagonal blocks of the matrix. NOT only block diagonal matrices are
* allowed but all matrices of arbitrary structure with the minimal
* property of having invertible blocks on the diagonal!
* empty above the diagonal blocks.
*
* For all matrices that are empty above and below the diagonal blocks
- * (i.e. for all block diagonal matrices) the @p{BlockJacobi}
+ * (i.e. for all block diagonal matrices) the @p BlockJacobi
* preconditioner is a direct solver. For all matrices that are empty
* only above the diagonal blocks (e.g. the matrices one gets by the
- * DG method with downstream numbering) @p{BlockSOR} is a direct
+ * DG method with downstream numbering) @p BlockSOR is a direct
* solver.
*
- * This first implementation of the @p{PreconditionBlock} assumes the
+ * This first implementation of the @p PreconditionBlock assumes the
* matrix has blocks each of the same block size. Varying block sizes
* within the matrix must still be implemented if needed.
*
/**
* Stores the inverse of the
* diagonal blocks in
- * @p{inverse}. This costs some
+ * @p inverse. This costs some
* additional memory - for DG
* methods about 1/3 (for double
* inverses) or 1/6 (for float
*
* After this function is called,
* the lock on the matrix given
- * through the @p{use_matrix}
+ * through the @p use_matrix
* function is released, i.e. you
* may overwrite of delete it.
* You may want to do this in
* sure that the matrix exists as
* long as this class needs it,
* i.e. until calling
- * @p{invert_diagblocks}, or (if
+ * @p invert_diagblocks, or (if
* the inverse matrices should
* not be stored) until the last
* call of the preconditoining
- * @p{vmult} function of the
+ * @p vmult function of the
* derived classes.
*/
SmartPointer<const MATRIX> A;
/**
* Storage of the original diagonal blocks.
- * These are only filled if @p{store_diagonals}
- * is @p{true}.
+ * These are only filled if @p store_diagonals
+ * is @p true.
*
* Used by the blocked SSOR method.
*/
/**
* Block Jacobi preconditioning.
- * See @ref{PreconditionBlock} for requirements on the matrix.
+ * See PreconditionBlock for requirements on the matrix.
* @author Ralf Hartmann, Guido Kanschat, 1999, 2000, 2003
*/
template<class MATRIX, typename inverse_type = typename MATRIX::value_type>
void vmult (Vector<number2>&, const Vector<number2>&) const;
/**
- * Same as @p{vmult}, since Jacobi is symmetric.
+ * Same as @p vmult, since Jacobi is symmetric.
*/
template <typename number2>
void Tvmult (Vector<number2>&, const Vector<number2>&) const;
/**
* Execute block Jacobi
- * preconditioning, adding to @p{dst}.
+ * preconditioning, adding to @p dst.
*
* This function will
* automatically use the inverse
void vmult_add (Vector<number2>&, const Vector<number2>&) const;
/**
- * Same as @p{vmult_add}, since Jacobi is symmetric.
+ * Same as @p vmult_add, since Jacobi is symmetric.
*/
template <typename number2>
void Tvmult_add (Vector<number2>&, const Vector<number2>&) const;
/**
* STL-like iterator with the
- * first entry of row @p{r}.
+ * first entry of row @p r.
*/
const_iterator begin (const unsigned int r) const;
/**
- * Final iterator of row @p{r}.
+ * Final iterator of row @p r.
*/
const_iterator end (const unsigned int r) const;
* Actual implementation of the
* preconditioner.
*
- * Depending on @p{adding}, the
+ * Depending on @p adding, the
* result of preconditioning is
* added to the destination vector.
*/
/**
* Block SOR preconditioning.
*
- * The functions @p{vmult} and @p{Tvmult} execute a (transposed)
- * block-SOR step, based on the blocks in @ref{PreconditionBlock}. The
+ * The functions @p vmult and @p Tvmult execute a (transposed)
+ * block-SOR step, based on the blocks in PreconditionBlock. The
* elements outside the diagonal blocks may be distributed
* arbitrarily.
*
- * See @ref{PreconditionBlock} for requirements on the matrix.
+ * See PreconditionBlock for requirements on the matrix.
* @author Ralf Hartmann, Guido Kanschat, 1999, 2000, 2001, 2002, 2003
*/
template<class MATRIX, typename inverse_type = typename MATRIX::value_type>
* preconditioning.
*
* Warning: this function
- * performs normal @p{vmult}
+ * performs normal @p vmult
* without adding. The reason for
* its existence is that
- * @ref{BlockMatrixArray}
+ * BlockMatrixArray
* requires the adding version by
* default. On the other hand,
* adding requires an additional
void vmult_add (Vector<number2>&, const Vector<number2>&) const;
/**
- * Backward application of @ref{vmult}.
+ * Backward application of vmult().
*
* In the current implementation,
* this is not the transpose of
- * @ref{vmult}. It is a
+ * vmult(). It is a
* transposed Gauss-Seidel
* algorithm applied to the whole
* matrix, but the diagonal
* preconditioning.
*
* Warning: this function
- * performs normal @p{vmult}
+ * performs normal @p vmult
* without adding. The reason for
* its existence is that
- * @ref{BlockMatrixArray}
+ * BlockMatrixArray
* requires the adding version by
* default. On the other hand,
* adding requires an additional
* Actual implementation of the
* preconditioning algorithm.
*
- * The parameter @p{adding} does
+ * The parameter @p adding does
* not have any function, yet.
*/
template <typename number2>
* Actual implementation of the
* preconditioning algorithm.
*
- * The parameter @p{adding} does
+ * The parameter @p adding does
* not have any function, yet.
*/
template <typename number2>
/**
* Block SSOR preconditioning.
*
- * The functions @p{vmult} and @p{Tvmult} execute a block-SSOR step,
- * based on the implementation in @ref{PreconditionBlockSOR}. This
+ * The functions @p vmult and @p Tvmult execute a block-SSOR step,
+ * based on the implementation in PreconditionBlockSOR. This
* class requires storage of the diagonal blocks and their inverses.
*
- * See @ref{PreconditionBlock} for requirements on the matrix.
+ * See PreconditionBlock for requirements on the matrix.
* @author Ralf Hartmann, Guido Kanschat, 1999, 2000
*/
template<class MATRIX, typename inverse_type = typename MATRIX::value_type>
void vmult (Vector<number2>&, const Vector<number2>&) const;
/**
- * Same as @ref{vmult}
+ * Same as vmult()
*/
template <typename number2>
void Tvmult (Vector<number2>&, const Vector<number2>&) const;
// row, column are the global numbering
// of the unkowns.
- // set the @p{var_inverse} array to the right
+ // set the @p var_inverse array to the right
// size. we could do it like this:
// var_inverse = vector<>(nblocks,FullMatrix<>())
// but this would involve copying many
/**
* Selects the preconditioner. The constructor of this class takes
* the name of the preconditioning and the damping parameter
- * @p{omega} of the preconditioning and the @p{use_matrix} function takes
+ * @p omega of the preconditioning and the @p use_matrix function takes
* the matrix that is used
* by the matrix-builtin precondition functions. Each time, the @p{operator()} function
* is called, this preselected preconditioner, this matrix and
- * this @p{omega} is used
+ * this @p omega is used
* for the preconditioning. This class is designed for being used as
- * argument of the @p{solve} function of a @p{Solver} and it covers the
+ * argument of the @p solve function of a @p Solver and it covers the
* selection of all matrix-builtin precondition functions. The selection
* of other preconditioners, like BlockSOR or ILU should be handled in
* derived classes by the user.
*
* @sect3{Usage}
* The simplest use of this class is the following:
- * @begin{verbatim}
- * // generate a @p{SolverControl} and
- * // a @p{VectorMemory}
+ * @verbatim
+ * // generate a @p SolverControl and
+ * // a @p VectorMemory
* SolverControl control;
* VectorMemory<Vector<double> > memory;
* // generate a solver
* SolverCG<SparseMatrix<double>, Vector<double> > solver(control, memory);
- * // generate a @p{PreconditionSelector}
+ * // generate a @p PreconditionSelector
* PreconditionSelector<SparseMatrix<double>, Vector<double> >
* preconditioning("jacobi", 1.);
* // give a matrix whose diagonal entries
* // Generally the matrix of the linear
* // equation system Ax=b.
* preconditioning.use_matrix(A);
- * // call the @p{solve} function with this
+ * // call the @p solve function with this
* // preconditioning as last argument
* solver.solve(A,x,b,preconditioning);
- * @end{verbatim}
- * The same example where also the @p{SolverSelector} class is used reads
- * @begin{verbatim}
- * // generate a @p{SolverControl} and
- * // a @p{VectorMemory}
+ * @endverbatim
+ * The same example where also the @p SolverSelector class is used reads
+ * @verbatim
+ * // generate a @p SolverControl and
+ * // a @p VectorMemory
* SolverControl control;
* VectorMemory<Vector<double> > memory;
- * // generate a @p{SolverSelector} that
- * // calls the @p{SolverCG}
+ * // generate a @p SolverSelector that
+ * // calls the @p SolverCG
* SolverSelector<SparseMatrix<double>, Vector<double> >
* solver_selector("cg", control, memory);
- * // generate a @p{PreconditionSelector}
+ * // generate a @p PreconditionSelector
* PreconditionSelector<SparseMatrix<double>, Vector<double> >
* preconditioning("jacobi", 1.);
*
* preconditioning.use_matrix(A);
*
* solver_selector.solve(A,x,b,preconditioning);
- * @end{verbatim}
- * Now the use of the @p{SolverSelector} in combination with the @p{PreconditionSelector}
+ * @endverbatim
+ * Now the use of the @p SolverSelector in combination with the @p PreconditionSelector
* allows the user to select both, the solver and the preconditioner, at the
* beginning of his program and each time the
* solver is started (that is several times e.g. in a nonlinear iteration) this
public:
/**
- * Constructor. @p{omega} denotes
+ * Constructor. @p omega denotes
* the damping parameter of
* the preconditioning.
*/
/**
* Takes the matrix that is needed
* for preconditionings that involves a
- * matrix. e.g. for @p{precondition_jacobi},
+ * matrix. e.g. for @p precondition_jacobi,
* @p{~_sor}, @p{~_ssor}.
*/
void use_matrix(const Matrix &M);
/**
* Matrix that is used for the
* matrix-builtin preconditioning function.
- * cf. also @p{PreconditionUseMatrix}.
+ * cf. also @p PreconditionUseMatrix.
*/
SmartPointer<const Matrix> A;
/**
* Schur complement of a block matrix.
*
- * Given a non-singular matrix @p{A} (often positive definite) and a
- * positive semi-definite matrix @p{C} as well as matrices @p{B} and
- * @p{Dt} of full rank, this class implements a new matrix, the Schur
+ * Given a non-singular matrix @p A (often positive definite) and a
+ * positive semi-definite matrix @p C as well as matrices @p B and
+ * @p Dt of full rank, this class implements a new matrix, the Schur
* complement a the system of equations of the structure
*
- * @begin{verbatim}
+ * @verbatim
* / \ / \ / \
* | A Dt | | u | - | f |
* | -B C | | p | - | g |
* \ / \ / \ /
- * @end{verbatim}
+ * @endverbatim
*
- * Multiplication with the Schur matrix @p{S} is the operation
- * @begin{verbatim}
+ * Multiplication with the Schur matrix @p S is the operation
+ * @verbatim
* S p = C p + B A-inverse Dt-transpose p,
- * @end{verbatim}
- * which is an operation within the space for @p{p}.
+ * @endverbatim
+ * which is an operation within the space for @p p.
*
* The data handed to the Schur matrix are as follows:
*
- * @p{A}: the inverse of @p{A} is stored, instead of @p{A}. This
+ * @p A: the inverse of @p A is stored, instead of @p A. This
* allows the application to use the most efficient form of inversion,
* iterative or direct.
*
- * @p{B}, @p{C}: these matrices are stored "as is".
+ * @p B, @p C: these matrices are stored "as is".
*
- * @p{Dt}: the computation of the Schur complement involves the
- * function @p{Tvmult} of the matrix @p{Dt}, not @p{vmult}! This way,
- * it is sufficient to build only one matrix @p{B} for the symmetric
+ * @p Dt: the computation of the Schur complement involves the
+ * function @p Tvmult of the matrix @p Dt, not @p vmult! This way,
+ * it is sufficient to build only one matrix @p B for the symmetric
* Schur complement and use it twice.
*
* All matrices involved are of arbitrary type and vectors are
- * @ref{BlockVector}s. This way, @p{SchurMatrix} can be coupled with
- * any matrix classes providing @p{vmult} and @p{Tvmult} and can be
- * even nested. Since @ref{SmartPointer}s of matrices are stored, the
- * matrix blocks should be derived from @ref{Subscriptor}.
+ * BlockVectors. This way, @p SchurMatrix can be coupled with
+ * any matrix classes providing @p vmult and @p Tvmult and can be
+ * even nested. Since SmartPointers of matrices are stored, the
+ * matrix blocks should be derived from Subscriptor.
*
* Since the Schur complement of a matrix corresponds to a Gaussian
* block elimination, the right hand side of the condensed system must
* be preprocessed. Furthermore, the eliminated variable must be
* reconstructed after solving.
*
- * @begin{verbatim}
+ * @verbatim
* g = g + B A-inverse f
* u = A-inverse (f - D-transpose p)
- * @end{verbatim}
+ * @endverbatim
*
* Applying these transformations, the solution of the system above by a
- * @p{SchurMatrix} @p{schur} is coded as follows:
+ * @p SchurMatrix @p schur is coded as follows:
*
- * @begin{verbatim}
+ * @verbatim
* schur.prepare_rhs (g, f);
* solver.solve (schur, p, g, precondition);
* schur.postprocess (u, p);
- * @end{verbatim}
+ * @endverbatim
*
* @author Guido Kanschat, 2000, 2001, 2002
*/
* for obtaining block vectors.
*
* Optionally, the length of the
- * @p{u}-vector can be provided.
+ * @p u-vector can be provided.
*
* For the meaning of the matrices
* see the class documentation.
* first argument, which is also
* part of the input data. If it is
* necessary to conserve the data,
- * @p{dst} must be copied before
+ * @p dst must be copied before
* calling this function. This is
* reasonable, since in many cases,
* only the pre-processed right
VectorMemory<BlockVector<double> >& mem;
/**
- * Optional signature of the @p{u}-vector.
+ * Optional signature of the @p u-vector.
*/
std::vector<unsigned int> signature;
* that the matrix and vector classes within this library of course
* conform to this interface.
*
- * @begin{verbatim}
+ * @verbatim
* class Matrix
* {
* public:
* // return the l2 norm of the vector
* double l2_norm () const;
* };
- * @end{verbatim}
+ * @endverbatim
*
* In addition, for some solvers there has to be a global function
* @p{swap(VECTOR &a, VECTOR &b)} that exchanges the values of the two vectors.
*
* The preconditioners used must have the same interface as matrices,
- * i.e. in particular they have to provide a member function @p{vmult}
+ * i.e. in particular they have to provide a member function @p vmult
* which denotes the application of the preconditioner.
*
*
* @sect3{AdditionalData}
*
- * Several solvers need additional data, like the damping parameter @p{omega}
- * of the @p{SolverRichardson} class or the maximum number of temporary
- * vectors of the @p{SolverGMRES}. To have a standardized constructor for
+ * Several solvers need additional data, like the damping parameter @p omega
+ * of the @p SolverRichardson class or the maximum number of temporary
+ * vectors of the @p SolverGMRES. To have a standardized constructor for
* each solver class the @p{struct AdditionalData} has been introduced to each
- * solver class. Some solvers need no additional data, like @p{SolverCG} or
- * @p{SolverBicgstab}. For these solvers the struct @p{AdditionalData} is
+ * solver class. Some solvers need no additional data, like @p SolverCG or
+ * @p SolverBicgstab. For these solvers the struct @p AdditionalData is
* empty and calling the constructor may be done without giving the additional
- * structure as an argument as a default @p{AdditionalData} is set by default.
+ * structure as an argument as a default @p AdditionalData is set by default.
*
* Now the generating of a solver looks like
- * @begin{verbatim}
+ * @verbatim
* // GMRES with 50 tmp vectors
* SolverGMRES solver_gmres (solver_control, vector_memory,
* SolverGMRES::AdditionalData(50));
*
* // CG with default AdditionalData
* SolverCG solver_cg (solver_control, vector_memory);
- * @end{verbatim}
+ * @endverbatim
*
* Using a unified constructor parameter list for all solvers was introduced
- * when the @p{SolverSelector} class was written; the unified interface
+ * when the @p SolverSelector class was written; the unified interface
* enabled us to use this class unchanged even if the number of types of
* parameters to a certain solver changes and it is still possible in a simple
- * way to give these additional data to the @p{SolverSelector} object for each
+ * way to give these additional data to the @p SolverSelector object for each
* solver which it may use.
*
* @author Wolfgang Bangerth, Guido Kanschat, Ralf Hartmann, 1997-2001
* Bicgstab algorithm by van der Vorst.
*
* For the requirements on matrices and vectors in order to work with
- * this class, see the documentation of the @ref{Solver} base class.
+ * this class, see the documentation of the Solver base class.
*
* Like all other solver classes, this class has a local structure called
- * @p{AdditionalData} which is used to pass additional parameters to the
+ * @p AdditionalData which is used to pass additional parameters to the
* solver, like damping parameters or the number of temporary vectors. We
* use this additional structure instead of passing these values directly
- * to the constructor because this makes the use of the @p{SolverSelector} and
+ * to the constructor because this makes the use of the @p SolverSelector and
* other classes much easier and guarantees that these will continue to
* work even if number or type of the additional parameters for a certain
* solver changes.
*
* The Bicgstab-method has two additional parameters: the first is a
* boolean, deciding whether to compute the actual residual in each
- * step (@p{true}) or to use the length of the computed orthogonal
- * residual (@p{false}). Remark, that computing the residual causes a
+ * step (@p true) or to use the length of the computed orthogonal
+ * residual (@p false). Remark, that computing the residual causes a
* third matrix-vector-multiplication, though no additional
* preconditioning, in each step. The reason for doing this is, that
* the size of the orthogonalized residual computed during the
* iteration may be larger by orders of magnitude than the true
* residual. This is due to numerical instabilities related to badly
* conditioned matrices. Since this instability results in a bad
- * stopping criterion, the default for this parameter is @p{true}.
+ * stopping criterion, the default for this parameter is @p true.
*
* The second parameter is the size of a breakdown criterion. It is
* difficult to find a general good criterion, so if things do not
/**
* There are two possibilities to compute
* the residual: one is an estimate using
- * the computed value @p{tau}. The other
+ * the computed value @p tau. The other
* is exact computation using another matrix
* vector multiplication.
*
* Preconditioned cg method.
*
* For the requirements on matrices and vectors in order to work with
- * this class, see the documentation of the @ref{Solver} base class.
+ * this class, see the documentation of the Solver base class.
*
* Like all other solver classes, this class has a local structure
- * called @p{AdditionalData} which is used to pass additional
+ * called @p AdditionalData which is used to pass additional
* parameters to the solver, like damping parameters or the number of
* temporary vectors. For this class, there is a switch allowing for
* additional output for the computation of eigenvalues of the matrix.
*
* The cg-method performs an orthogonal projection of the original
* preconditioned linear system to another system of smaller
- * dimension. Furthermore, the projected matrix @p{T} is
+ * dimension. Furthermore, the projected matrix @p T is
* tri-diagonal. Since the projection is orthogonal, the eigenvalues
- * of @p{T} approximate those of the original preconditioned matrix
- * @p{PA}. In fact, after @p{n} steps, where @p{n} is the dimension of
+ * of @p T approximate those of the original preconditioned matrix
+ * @p PA. In fact, after @p n steps, where @p n is the dimension of
* the original system, the eigenvalues of both matrices are
* equal. But, even for small numbers of iteration steps, the
- * condition number of @p{T} is a good estimate for the one of @p{PA}.
+ * condition number of @p T is a good estimate for the one of @p PA.
*
- * With the coefficients @p{alpha} and @p{beta} written to the log
+ * With the coefficients @p alpha and @p beta written to the log
* file if @p{AdditionalData::log_coefficients = true}, the matrix
- * @p{T_m} after @p{m} steps is the tri-diagonal matrix with diagonal
+ * @p T_m after @p m steps is the tri-diagonal matrix with diagonal
* elements @p{1/alpha_0}, @p{1/alpha_1 + beta_0/alpha_0}, ...,
* @p{1/alpha_{m-1}+beta_{m-2}/alpha_{m-2}} and off-diagonal elements
* @p{sqrt(beta_0)/alpha_0}, ..., @p{sqrt(beta_{m-2})/alpha_{m-2}}.
/**
* Temporary vectors, allocated through
- * the @p{VectorMemory} object at the start
+ * the @p VectorMemory object at the start
* of the actual solution process and
* deallocated at the end.
*/
* Within the iteration loop, the
* square of the residual vector is
* stored in this variable. The
- * function @p{criterion} uses this
+ * function @p criterion uses this
* variable to compute the convergence
* value, which in this class is the
* norm of the residual vector and thus
- * the square root of the @p{res2} value.
+ * the square root of the @p res2 value.
*/
double res2;
* called in each iteration with the current iteration step and the
* value indicating convergence (usually the residual).
*
- * After the iteration has terminated, the functions @p{last_value} and
- * @p{last_step} can be used to obtain information about the final state
+ * After the iteration has terminated, the functions @p last_value and
+ * @p last_step can be used to obtain information about the final state
* of the iteration.
*
* @p{check()} can be replaced in derived classes to allow for more
*
*
* @sect2{State}
- * The return states of the check function are of type @p{State},
+ * The return states of the check function are of type @p State,
* which is an enum local to this class. It indicates the state the
* solver is in.
*
* The possible values of State are
- * @begin{itemize}
- * @item @p{iterate = 0}: continue the iteration.
- * @item @p{success}: the goal is reached, the iterative method can terminate
+ * <ul>
+ * <li> @p{iterate = 0}: continue the iteration.
+ * <li> @p success: the goal is reached, the iterative method can terminate
* successfully.
- * @item @p{failure}: the iterative method should stop because convergence
+ * <li> @p failure: the iterative method should stop because convergence
* could not be achieved or at least was not achieved within the given
* maximal number of iterations.
- * @end{itemize}
+ * </ul>
*/
class SolverControl : public Subscriptor
{
public:
/**
- * @p{Enum} denoting the different
+ * @p Enum denoting the different
* states a solver can be in. See
* the general documentation of
* this class for more
/**
* Constructor. The parameters
- * @p{n} and @p{tol} are the
+ * @p n and @p tol are the
* maximum number of iteration
* steps before failure and the
* tolerance to determine success
* of the iteration.
*
- * @p{log_history} specifies
+ * @p log_history specifies
* whether the history (i.e. the
* value to be checked and the
* number of the iteration step)
* shall be printed to
- * @p{deallog} stream. Default
+ * @p deallog stream. Default
* is: do not print. Similarly,
- * @p{log_result} specifies the
+ * @p log_result specifies the
* whether the final result is
- * logged to @p{deallog}. Default
+ * logged to @p deallog. Default
* is yes.
*/
SolverControl (const unsigned int n = 100,
* to determine, whether the
* allowed number of steps has
* been exceeded and returns
- * @p{failure} in this case. If
- * @p{check_value} is below the
+ * @p failure in this case. If
+ * @p check_value is below the
* prescribed tolerance, it
- * returns @p{success}. In all
- * other cases @p{iterate} is
+ * returns @p success. In all
+ * other cases @p iterate is
* returned to suggest
* continuation of the iterative
* procedure.
* The iteration is also aborted
* if the residual becomes a
* denormalized value
- * (@p{NaN}). Note, however, that
+ * (@p NaN). Note, however, that
* this check is only performed
- * if the @p{isnan} function is
+ * if the @p isnan function is
* provided by the operating
* system, which is not always
- * true. The @p{configure}
+ * true. The @p configure
* scripts checks for this and
- * sets the flag @p{HAVE_ISNAN}
+ * sets the flag @p HAVE_ISNAN
* in the file
* @p{Make.global_options} if
* this function was found.
*
* @p{check()} additionally
- * preserves @p{step} and
- * @p{check_value}. These
+ * preserves @p step and
+ * @p check_value. These
* values are accessible by
* @p{last_value()} and
* @p{last_step()}.
* Derived classes may overload
* this function, e.g. to log the
* convergence indicators
- * (@p{check_value}) or to do
+ * (@p check_value) or to do
* other computations.
*/
virtual State check (const unsigned int step,
/**
* Return the convergence value of last
- * iteration step for which @p{check} was
+ * iteration step for which @p check was
* called by the solver.
*/
double last_value() const;
/**
* Enables the failure
* check. Solving is stopped with
- * @p{ReturnState} @p{failure} if
+ * @p ReturnState @p failure if
* @p{residual>failure_residual} with
* @p{failure_residual:=rel_failure_residual*first_residual}.
*/
/**
* Disables failure check and
* resets
- * @p{relative_failure_residual}
- * and @p{failure_residual} to
+ * @p relative_failure_residual
+ * and @p failure_residual to
* zero.
*/
void clear_failure_criterion ();
/**
* Log each iteration step. Use
- * @p{log_frequency} for skipping
+ * @p log_frequency for skipping
* steps.
*/
void log_history (const bool);
/**
- * Returns the @p{log_history} flag.
+ * Returns the @p log_history flag.
*/
bool log_history () const;
void log_result (const bool);
/**
- * Returns the @p{log_result} flag.
+ * Returns the @p log_result flag.
*/
bool log_result () const;
unsigned int lstep;
/**
- * Is set to @p{true} by
- * @p{set_failure_criterion} and
+ * Is set to @p true by
+ * @p set_failure_criterion and
* enables failure checking.
*/
bool check_failure;
/*
* Stores the
- * @p{rel_failure_residual} set by
- * @p{set_failure_criterion}
+ * @p rel_failure_residual set by
+ * @p set_failure_criterion
*/
double relative_failure_residual;
/**
- * @p{failure_residual} equals the
+ * @p failure_residual equals the
* first residual multiplied by
- * @p{relative_crit} set by
- * @p{set_failure_criterion} (see there).
+ * @p relative_crit set by
+ * @p set_failure_criterion (see there).
*
* Until the first residual is
* known it is 0.
/**
* Log convergence history to
- * @p{deallog}.
+ * @p deallog.
*/
bool m_log_history;
/**
/**
* Log iteration result to
- * @p{deallog}. If true, after
+ * @p deallog. If true, after
* finishing the iteration, a
* statement about failure or
- * success together with @p{lstep}
- * and @p{lvalue} are logged.
+ * success together with @p lstep
+ * and @p lvalue are logged.
*/
bool m_log_result;
};
//! Control of the stopping criterion depending on the initial residual.
/**
- * Specialization of @p{SolverControl} which returns @p{success} if either
+ * Specialization of @p SolverControl which returns @p success if either
* the specified tolerance is achieved or if the initial residual (or
* whatever criterion was chosen by the solver class) is reduced by a
* given factor. This is useful in cases where you don't want to solve
public:
/**
* Constructor. Prepares an
- * array of @p{VECTOR} of
- * length @p{max_size}.
+ * array of @p VECTOR of
+ * length @p max_size.
*/
TmpVectors(const unsigned int max_size,
VectorMemory<VECTOR> &vmem);
/**
* Get vector number
- * @p{i}. If this vector was
+ * @p i. If this vector was
* unused before, an error
* occurs.
*/
/**
* Get vector number
- * @p{i}. Allocate it if
+ * @p i. Allocate it if
* necessary.
*
* If a vector must be
- * allocated, @p{temp} is
+ * allocated, @p temp is
* used to reinit it to the
* proper dimensions.
*/
* the number of iterations needed to solve the problem to the given
* criterion, an intermediate solution is computed and a restart is
* performed. If you don't want to use the restarted method, you can
- * limit the number of iterations (stated in the @p{SolverControl}
+ * limit the number of iterations (stated in the @p SolverControl
* object given to the constructor) to be below the number of
* temporary vectors minus three. Note the subtraction, which is due
* to the fact that three vectors are used for other purposes, so the
* possibilities is to use a good preconditioner.
*
* Like all other solver classes, this class has a local structure
- * called @p{AdditionalData} which is used to pass additional
+ * called @p AdditionalData which is used to pass additional
* parameters to the solver, like the number of temporary vectors for
* example. We use this additional structure instead of passing these
* values directly to the constructor because this makes the use of
- * the @p{SolverSelector} and other classes much easier and guarantees
+ * the @p SolverSelector and other classes much easier and guarantees
* that these will continue to work even if number or type of the
* additional parameters for a certain solver changes.
*
- * For the GMRes method, the @p{AdditionalData} structure contains the number
+ * For the GMRes method, the @p AdditionalData structure contains the number
* of temporary vectors as commented upon above. By default, the number of
- * these vectors is set to 30. The @p{AdditionalData} also containes a flag
+ * these vectors is set to 30. The @p AdditionalData also containes a flag
* indicating the use of right or left preconditioning. The default is left
* preconditioning. Finally it includes a flag indicating whether or not the
* default residual is used as stopping criterion. By default, the left
* preconditioned GMRes uses the preconditioned residual and the right
* preconditioned GMRes uses the normal, i.e. unpreconditioned, residual as
- * stopping criterion. If the @p{use_default_residual} flag is @p{false}, the
+ * stopping criterion. If the @p use_default_residual flag is @p false, the
* left preconditioned GMRes uses as stopping criterion the unpreconditioned
* residual and the right preconditioned GMRes the preconditioned
* residual. But be aware that the non-default residuals are not automatically
* @p{use_default_residual=false} only for debugging/testing purposes.
*
* For the requirements on matrices and vectors in order to work with
- * this class, see the documentation of the @ref{Solver} base class.
+ * this class, see the documentation of the Solver base class.
*
* @author Wolfgang Bangerth, Guido Kanschat, Ralf Hartmann.
*/
*/
FullMatrix<double> H;
/**
- * Auxiliary matrix for inverting @p{H}
+ * Auxiliary matrix for inverting @p H
*/
FullMatrix<double> H1;
*/
FullMatrix<double> H;
/**
- * Auxiliary matrix for inverting @p{H}
+ * Auxiliary matrix for inverting @p H
*/
FullMatrix<double> H1;
};
// are temporary vectors. the
// number of steps actually
// been done is propagated
- // outside through the @p{dim}
+ // outside through the @p dim
// variable
for (unsigned int inner_iteration=0;
((inner_iteration < n_tmp_vectors-2)
* Preconditioned MinRes method.
*
* For the requirements on matrices and vectors in order to work with
- * this class, see the documentation of the @ref{Solver} base class.
+ * this class, see the documentation of the Solver base class.
*
* Like all other solver classes, this class has a local structure called
- * @p{AdditionalData} which is used to pass additional parameters to the
+ * @p AdditionalData which is used to pass additional parameters to the
* solver, like damping parameters or the number of temporary vectors. We
* use this additional structure instead of passing these values directly
- * to the constructor because this makes the use of the @p{SolverSelector} and
+ * to the constructor because this makes the use of the @p SolverSelector and
* other classes much easier and guarantees that these will continue to
* work even if number or type of the additional parameters for a certain
* solver changes.
/**
* Temporary vectors, allocated through
- * the @p{VectorMemory} object at the start
+ * the @p VectorMemory object at the start
* of the actual solution process and
* deallocated at the end.
*/
* Within the iteration loop, the
* square of the residual vector is
* stored in this variable. The
- * function @p{criterion} uses this
+ * function @p criterion uses this
* variable to compute the convergence
* value, which in this class is the
* norm of the residual vector and thus
- * the square root of the @p{res2} value.
+ * the square root of the @p res2 value.
*/
double res2;
};
* inverse.
*
* For the requirements on matrices and vectors in order to work with
- * this class, see the documentation of the @ref{Solver} base class.
+ * this class, see the documentation of the Solver base class.
*
* Like all other solver classes, this class has a local structure called
- * @p{AdditionalData} which is used to pass additional parameters to the
+ * @p AdditionalData which is used to pass additional parameters to the
* solver, like damping parameters or the number of temporary vectors. We
* use this additional structure instead of passing these values directly
- * to the constructor because this makes the use of the @p{SolverSelector} and
+ * to the constructor because this makes the use of the @p SolverSelector and
* other classes much easier and guarantees that these will continue to
* work even if number or type of the additional parameters for a certain
* solver changes.
*
* There are two possibilities to compute
* the residual: one is an estimate using
- * the computed value @p{tau}. The other
+ * the computed value @p tau. The other
* is exact computation using another matrix
* vector multiplication.
*
/**
* Temporary vectors, allocated through
- * the @p{VectorMemory} object at the start
+ * the @p VectorMemory object at the start
* of the actual solution process and
* deallocated at the end.
*/
* Within the iteration loop, the
* square of the residual vector is
* stored in this variable. The
- * function @p{criterion} uses this
+ * function @p criterion uses this
* variable to compute the convergence
* value, which in this class is the
* norm of the residual vector and thus
- * the square root of the @p{res2} value.
+ * the square root of the @p res2 value.
*/
double res2;
/**
* is the norm of the residual.
*
* For the requirements on matrices and vectors in order to work with
- * this class, see the documentation of the @ref{Solver} base class.
+ * this class, see the documentation of the Solver base class.
*
* Like all other solver classes, this class has a local structure called
- * @p{AdditionalData} which is used to pass additional parameters to the
+ * @p AdditionalData which is used to pass additional parameters to the
* solver, like damping parameters or the number of temporary vectors. We
* use this additional structure instead of passing these values directly
- * to the constructor because this makes the use of the @p{SolverSelector} and
+ * to the constructor because this makes the use of the @p SolverSelector and
* other classes much easier and guarantees that these will continue to
* work even if number or type of the additional parameters for a certain
* solver changes.
*
* For the Richardson method, the additional data is the damping parameter,
- * which is the only content of the @p{AdditionalData} structure. By default,
+ * which is the only content of the @p AdditionalData structure. By default,
* the constructor of the structure sets it to one.
*
* @author Ralf Hartmann
/**
* Temporary vectors, allocated through
- * the @p{VectorMemory} object at the start
+ * the @p VectorMemory object at the start
* of the actual solution process and
* deallocated at the end.
*/
* Within the iteration loop, the
* norm of the residual is
* stored in this variable. The
- * function @p{criterion} uses this
+ * function @p criterion uses this
* variable to compute the convergence
* value, which in this class is the
* norm of the residual vector and thus
- * the square root of the @p{res2} value.
+ * the square root of the @p res2 value.
*/
typename VECTOR::value_type res;
};
//! Selects a solver by changing a parameter.
/**
- * By calling the @p{solve} function of this @p{SolverSelector}, it selects
- * the @p{solve} function of that @p{Solver} that was specified in the constructor
+ * By calling the @p solve function of this @p SolverSelector, it selects
+ * the @p solve function of that @p Solver that was specified in the constructor
* of this class.
*
* @sect3{Usage}
* The simplest use of this class is the following:
- * @begin{verbatim}
- * // generate a @p{SolverControl} and
- * // a @p{VectorMemory}
+ * @verbatim
+ * // generate a @p SolverControl and
+ * // a @p VectorMemory
* SolverControl control;
* VectorMemory<Vector<double> > memory;
* // Line 3:
* //
- * // generate a @p{SolverSelector} that
- * // calls the @p{SolverCG}
+ * // generate a @p SolverSelector that
+ * // calls the @p SolverCG
* SolverSelector<SparseMatrix<double>, Vector<double> >
* solver_selector("cg", control, memory);
- * // generate e.g. a @p{PreconditionRelaxation}
+ * // generate e.g. a @p PreconditionRelaxation
* PreconditionRelaxation<SparseMatrix<double>, Vector<double> >
* preconditioning(A, &SparseMatrix<double>
* ::template precondition_SSOR<double>,0.8);
- * // call the @p{solve} function with this
+ * // call the @p solve function with this
* // preconditioning as last argument
* solver_selector.solve(A,x,b,preconditioning);
- * @end{verbatim}
- * But the full usefulness of the @p{SolverSelector} class is not
+ * @endverbatim
+ * But the full usefulness of the @p SolverSelector class is not
* clear until the presentation of the following example that assumes
- * the user using the @p{ParameterHandler} class and having declared a
+ * the user using the @p ParameterHandler class and having declared a
* "solver" entry, e.g. with
- * @begin{verbatim}
+ * @verbatim
* Parameter_Handler prm;
* prm.declare_entry ("solver", "none",
* Patterns::Sequence(SolverSelector::get_solver_names()));
* ...
- * @end{verbatim}
+ * @endverbatim
* Assuming that in the users parameter file there exists the line
- * @begin{verbatim}
+ * @verbatim
* set solver = cg
- * @end{verbatim}
+ * @endverbatim
* then `Line 3' of the above example reads
- * @begin{verbatim}
+ * @verbatim
* SolverSelector<SparseMatrix<double>, Vector<double> >
* solver_selector(prm.get("solver"), control, memory);
- * @end{verbatim}
+ * @endverbatim
*
*
* If at some time there exists a new solver "xyz" then the user does not need
- * to change his program. Only in the implementation of the @p{SolverSelector}
+ * to change his program. Only in the implementation of the @p SolverSelector
* the calling of this solver has to be added and each user with program lines
* quoted above only needs to 'set solver = xyz' in his parameter file to get
* access to that new solver. :-)
*
- * (By the way, thanks to Wolfgang for implementing the @p{ParameterHandler}.)
+ * (By the way, thanks to Wolfgang for implementing the @p ParameterHandler.)
*
* @author Ralf Hartmann, 1999
*/
public:
/**
- * Constructor. Takes the @p{SolverName},
- * the @p{SolverControl} and the
- * @p{VectorMemory} as argument.
+ * Constructor. Takes the @p SolverName,
+ * the @p SolverControl and the
+ * @p VectorMemory as argument.
*/
SolverSelector (const std::string &solvername,
SolverControl &control,
~SolverSelector();
/**
- * Solver procedure. Calls the @p{solve}
+ * Solver procedure. Calls the @p solve
* function
- * of the @p{solver} whose @p{SolverName}
+ * of the @p solver whose @p SolverName
* was specified in the constructor.
*
*/
/**
* Set the additional data. For more
- * info see the @p{Solver} class.
+ * info see the @p Solver class.
*/
void set_data(const typename SolverRichardson<VECTOR>
::AdditionalData &data);
/**
* Set the additional data. For more
- * info see the @p{Solver} class.
+ * info see the @p Solver class.
*/
void set_data(const typename SolverCG<VECTOR>
::AdditionalData &data);
/**
* Set the additional data. For more
- * info see the @p{Solver} class.
+ * info see the @p Solver class.
*/
void set_data(const typename SolverBicgstab<VECTOR>
::AdditionalData &data);
/**
* Set the additional data. For more
- * info see the @p{Solver} class.
+ * info see the @p Solver class.
*/
void set_data(const typename SolverGMRES<VECTOR>
::AdditionalData &data);
/**
* Set the additional data. For more
- * info see the @p{Solver} class.
+ * info see the @p Solver class.
*/
void set_data(const typename SolverFGMRES<VECTOR>
::AdditionalData &data);
std::string solver_name;
/**
- * Stores the @p{SolverControl} that
+ * Stores the @p SolverControl that
* is needed in the constructor of
- * each @p{Solver} class.
+ * each @p Solver class.
*/
SmartPointer<SolverControl> control;
/**
- * Stores the @p{VectorMemory} that
+ * Stores the @p VectorMemory that
* is needed in the constructor of
- * each @p{Solver} class.
+ * each @p Solver class.
*/
SmartPointer<VectorMemory<VECTOR> > vector_memory;
* to the sparse direct solver routines are not multithreading-safe,
* i.e. at each time there may only be one call to these functions
* active. You have to synchronise your calls to the functions
- * provided by this class using mutexes (see the @ref{Threads}
+ * provided by this class using mutexes (see the Threads
* namespace for such classes) to avoid multiple active calls at the
* same time if you use multithreading. Since you may use this class
* in different parts of your program, and may not want to use a
* to the sparse direct solver routines is not multithreading-capable,
* i.e. at each time there may only be one call to these functions
* active. You have to synchronise your calls to the functions
- * provided by this class using mutexes (see the @ref{Threads}
+ * provided by this class using mutexes (see the Threads
* namespace for such classes) to avoid multiple active calls at the
* same time if you use multithreading. Since you may use this class
* in different parts of your program, and may not want to use a
* in the decomposition that do not fit into the sparsity structure of this
* object are discarded.
*
- * The algorithm used by this class is as follows (indices run from @p{0}
- * to @p{N-1}):
- * @begin{verbatim}
+ * The algorithm used by this class is as follows (indices run from @p 0
+ * to @p N-1):
+ * @verbatim
* copy original matrix into a[i,j]
*
* for i=1..N-1
* for j=k+1..N-1
* if (a[i,j] exists & a[k,j] exists)
* a[i,j] -= a[i,k] * a[k,j]
- * @end{verbatim}
+ * @endverbatim
*
*
* @sect2{Usage and state management}
*
- * Refer to @ref{SparseLUDecomposition} documentation for suggested
+ * Refer to SparseLUDecomposition documentation for suggested
* usage and state management.
*
*
/**
* Constructor. Does nothing.
*
- * Call the @p{initialize}
+ * Call the @p initialize
* function before using this
* object as preconditioner
- * (@p{vmult}).
+ * (@p vmult).
*/
SparseILU ();
SparseILU (const SparsityPattern &sparsity);
/**
- * Make the @p{AdditionalData}
+ * Make the @p AdditionalData
* type in the base class
* accessible to this class as
* well.
* class documentation of
* SparseLUDecomposition and the
* documentation of the
- * @p{SparseLUDecomposition::AdditionalData}
+ * @p SparseLUDecomposition::AdditionalData
* class.
*
* According to the
- * @p{parameters}, this function
+ * @p parameters, this function
* creates a new SparsityPattern
* or keeps the previous sparsity
* or takes the sparsity given by
- * the user to @p{data}. Then,
+ * the user to @p data. Then,
* this function performs the LU
* decomposition.
*
* i.e. do one forward-backward step
* $dst=(LU)^{-1}src$.
*
- * The @p{initialize} function
+ * The @p initialize function
* needs to be called beforehand.
*/
template <typename somenumber>
*
* Instead of using a pre-assembled sparsity pattern, this matrix
* builds the pattern on the fly. Filling the matrix may consume more
- * time as with @p{SparseMatrix}, since large memory movements may be
+ * time as with @p SparseMatrix, since large memory movements may be
* involved. To help optimizing things, an expected row-length may be
* provided to the constructor, as well as an increment size
* for rows.
*
* The storage structure: like with the usual sparse matrix, it is
* attempted to store only non-zero elements. these are stored in a
- * single data array @p{data}. They are ordered by row and inside each
+ * single data array @p data. They are ordered by row and inside each
* row by column number. Each row is described by its starting point
* in the data array and its length. These are stored in the
- * @p{row_info} array, together with additional useful information.
+ * @p row_info array, together with additional useful information.
*
* Due to the structure, gaps may occur between rows. Whenever a new
* entry must be created, an attempt is made to use the gap in its
* operation and should be avoided as much as possible.
*
* This is, where the optimization parameters, provided to the
- * constructor or to the function @p{reinit} come
- * in. @p{default_row_length} is the amount of entries that will be
+ * constructor or to the function @p reinit come
+ * in. @p default_row_length is the amount of entries that will be
* allocated for each row on initialization (the actual length of the
- * rows is still zero). This means, that @p{default_row_length}
+ * rows is still zero). This means, that @p default_row_length
* entries can be added to this row without shifting other rows. If
* less entries are added, the additional memory will be wasted.
*
* If the space for a row is not sufficient, then it is enlarged by
- * @p{default_increment} entries. This way, the subsequent rows are
+ * @p default_increment entries. This way, the subsequent rows are
* not shifted by single entries very often.
*
- * Finally, the @p{default_reserve} allocates extra space at the end
+ * Finally, the @p default_reserve allocates extra space at the end
* of the data array. This space is used whenever a row must be
- * enlarged. Since @p{std::vector} doubles the capacity everytime it
+ * enlarged. Since @p std::vector doubles the capacity everytime it
* must increase it, this value should allow for all the growth needed.
*
- * Suggested settings: @p{default_row_length} should be the length of
+ * Suggested settings: @p default_row_length should be the length of
* a typical row, for instance the size of the stencil in regular
- * parts of the grid. Then, @p{default_increment} may be the expected
+ * parts of the grid. Then, @p default_increment may be the expected
* amount of entries added to the row by having one hanging node. This
* way, a good compromise between memory consumption and speed should
- * be achieved. @p{default_reserve} should then be an estimate for the
- * number of hanging nodes times @p{default_increment}.
+ * be achieved. @p default_reserve should then be an estimate for the
+ * number of hanging nodes times @p default_increment.
*
- * Letting @p{default_increment} zero causes an exception whenever a
+ * Letting @p default_increment zero causes an exception whenever a
* row overflows.
*
* If the rows are expected to be filled more or less from first to
- * last, using a @p{default_row_length} of zero may not be such a bad
+ * last, using a @p default_row_length of zero may not be such a bad
* idea.
*
* The name of this matrix is in reverence to a publication of the
{
/**
* Standard constructor. Sets
- * @p{column} to
- * @p{invalid}.
+ * @p column to
+ * @p invalid.
*/
Entry();
*
* If you really want to copy a whole
* matrix, you can do so by using the
- * @p{copy_from} function.
+ * @p copy_from function.
*/
SparseMatrixEZ (const SparseMatrixEZ &);
* matrix of the given size,
* ready to be filled. The
* optional parameters
- * @p{default_row_length} and
- * @p{default_increment} allow
+ * @p default_row_length and
+ * @p default_increment allow
* for preallocating
* memory. Providing these
* properly is essential for an
* The matrix will have no
* entries at this point. The
* optional parameters
- * @p{default_row_length},
- * @p{default_increment} and
- * @p{reserve} allow
+ * @p default_row_length,
+ * @p default_increment and
+ * @p reserve allow
* for preallocating
* memory. Providing these
* properly is essential for an
/**
* Set the element @p{(i,j)} to
- * @p{value}. Allocates the entry,
+ * @p value. Allocates the entry,
* if it does not exist and
- * @p{value} is non-zero.
+ * @p value is non-zero.
*/
void set (const unsigned int i, const unsigned int j,
const number value);
/**
- * Add @p{value} to the element
+ * Add @p value to the element
* @p{(i,j)}. Allocates the entry
* if it does not exist. Filters
* out zeroes automatically.
* symmetrization. Symmetrization
* of the sparsity pattern can be
* obtain by the
- * @ref{SparsityPattern}@p{::symmetrize}
+ * SparsityPattern@p ::symmetrize
* function.
*/
// void symmetrize ();
* data type of this matrix.
*
* The function returns a reference to
- * @p{this}.
+ * @p this.
*/
template <class MATRIX>
SparseMatrixEZ<number> &
/**
* This function is complete
* analogous to the
- * @ref{SparsityPattern}@p{::copy_from}
+ * SparsityPattern@p ::copy_from
* function in that it allows to
* initialize a whole matrix in
* one step. See there for more
* objects which the inner
* iterator points to need to be
* of type @p{std::pair<unsigned int, value},
- * where @p{value}
+ * where @p value
* needs to be convertible to the
* element type of this class, as
- * specified by the @p{number}
+ * specified by the @p number
* template argument.
*
* Previous content of the matrix
// void copy_from (const FullMatrix<somenumber> &matrix);
/**
- * Add @p{matrix} scaled by
- * @p{factor} to this matrix.
+ * Add @p matrix scaled by
+ * @p factor to this matrix.
*
* The source matrix may be a
* matrix of arbitrary type, as
* long as its data type is
* convertible to the data type
* of this matrix and it has the
- * standard @p{const_iterator}.
+ * standard @p const_iterator.
*/
template <class MATRIX>
void add_scaled (const number factor,
* that returns zero instead (for
* entries that are not in the
* sparsity pattern of the
- * matrix), use the @p{el}
+ * matrix), use the @p el
* function.
*/
number operator () (const unsigned int i,
/**
* Return the main diagonal element in
- * the @p{i}th row. This function throws an
+ * the @p ith row. This function throws an
* error if the matrix is not square.
*
* This function is considerably
* let $dst = M^T*src$ with $M$
* being this matrix. This
* function does the same as
- * @p{vmult} but takes the
+ * @p 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 @p vmult_add but takes
* the transposed matrix.
*/
template <typename somenumber>
* Apply the Jacobi
* preconditioner, which
* multiplies every element of
- * the @p{src} vector by the
+ * the @p src vector by the
* inverse of the respective
* diagonal element and
* multiplies the result with the
- * damping factor @p{omega}.
+ * damping factor @p omega.
*/
template <typename somenumber>
void precondition_Jacobi (Vector<somenumber> &dst,
/**
* Apply SSOR preconditioning to
- * @p{src}.
+ * @p src.
*/
template <typename somenumber>
void precondition_SSOR (Vector<somenumber> &dst,
const number om = 1.) const;
/**
- * Apply SOR preconditioning matrix to @p{src}.
+ * Apply SOR preconditioning matrix to @p src.
* The result of this method is
* $dst = (om D - L)^{-1} src$.
*/
const number om = 1.) const;
/**
- * Apply transpose SOR preconditioning matrix to @p{src}.
+ * Apply transpose SOR preconditioning matrix to @p src.
* The result of this method is
* $dst = (om D - U)^{-1} src$.
*/
const number om = 1.) const;
/**
- * Add the matrix @p{A}
- * conjugated by @p{B}, that is,
+ * Add the matrix @p A
+ * conjugated by @p B, that is,
* $B A B^T$ to this object. If
- * the parameter @p{transpose} is
+ * the parameter @p transpose is
* true, compute $B^T A B$.
*
* This function requires that
- * @p{B} has a @p{const_iterator}
+ * @p B has a @p const_iterator
* traversing all matrix entries
- * and that @p{A} has a function
+ * and that @p A has a function
* @p{el(i,j)} for access to a
* specific entry.
*/
/**
* STL-like iterator with the
- * first entry of row @p{r}. If
+ * first entry of row @p r. If
* this row is empty, the result
* is @p{end(r)}, which does NOT
- * point into row @p{r}..
+ * point into row @p r..
*/
const_iterator begin (const unsigned int r) const;
/**
* Final iterator of row
- * @p{r}. The result may be
+ * @p r. The result may be
* different from @p{end()}!
*/
const_iterator end (const unsigned int r) const;
*
* The parameters allow for a
* flexible setting of the output
- * format: @p{precision} and
- * @p{scientific} are used to
+ * format: @p precision and
+ * @p scientific are used to
* determine the number format,
- * where @p{scientific} = @p{false}
+ * where @p scientific = @p false
* means fixed point notation. A
- * zero entry for @p{width} makes
+ * zero entry for @p width makes
* the function compute a width,
* but it may be changed to a
* positive value, if output is
/**
* Read data that has previously
* been written by
- * @p{block_write}.
+ * @p block_write.
*
* The object is resized on this
* operation, and all previous
unsigned int memory_consumption () const;
/**
- * Print statistics. If @p{full}
- * is @p{true}, prints a
+ * Print statistics. If @p full
+ * is @p true, prints a
* histogram of all existing row
* lengths and allocated row
* lengths. Otherwise, just the
const unsigned int col);
/**
- * Version of @p{vmult} which only
+ * Version of @p vmult which only
* performs its actions on the
* region defined by
* @p{[begin_row,end_row)}. This
- * function is called by @p{vmult}
+ * function is called by @p vmult
* in the case of enabled
* multithreading.
*/
/**
* Version of
- * @p{matrix_norm_square} which
+ * @p matrix_norm_square which
* only performs its actions on
* the region defined by
* @p{[begin_row,end_row)}. This
* function is called by
- * @p{matrix_norm_square} in the
+ * @p matrix_norm_square in the
* case of enabled
* multithreading.
*/
/**
* Version of
- * @p{matrix_scalar_product} which
+ * @p matrix_scalar_product which
* only performs its actions on
* the region defined by
* @p{[begin_row,end_row)}. This
* function is called by
- * @p{matrix_scalar_product} in the
+ * @p matrix_scalar_product in the
* case of enabled
* multithreading.
*/
/**
* Modified incomplete Cholesky (MIC(0)) preconditioner. This class
* conforms to the state and usage specification in
- * @ref{SparseLUDecomposition}.
+ * SparseLUDecomposition.
*
*
* @sect2{The decomposition}
public:
/**
* Constructor. Does nothing, so
- * you have to call @p{reinit}
+ * you have to call @p reinit
* sometimes afterwards.
*/
SparseMIC ();
virtual void clear();
/**
- * Make the @p{AdditionalData}
+ * Make the @p AdditionalData
* type in the base class
* accessible to this class as
* well.
void reinit (const SparsityPattern &sparsity);
/**
- * Same as @p{decompose}.
+ * Same as @p decompose.
*/
template <typename somenumber>
void initialize (const SparseMatrix<somenumber> &matrix,
* i.e. do one forward-backward step
* $dst=(LU)^{-1}src$.
*
- * Call @p{initialize} before
+ * Call @p initialize before
* calling this function.
*/
template <typename somenumber>
* For each selected degree of freedom, a local system of equations is built
* by the degree of freedom itself and all other values coupling immediately,
* i.e. the set of degrees of freedom considered for the local system of
- * equations for degree of freedom @p{i} is @p{i} itself and all @p{j} such that
+ * equations for degree of freedom @p i is @p i itself and all @p j such that
* the element @p{(i,j)} is a nonzero entry in the sparse matrix under
* consideration. The elements @p{(j,i)} are not considered. We now pick all
* matrix entries from rows and columns out of the set of degrees of freedom
* This little example is taken from a program doing parameter optimization.
* The Lagrange multiplier is the third component of the finite element
* used. The system is solved by the GMRES method.
- * @begin{verbatim}
+ * @verbatim
* // tag the Lagrange multiplier variable
* vector<bool> signature(3);
* signature[0] = signature[1] = false;
* // solve
* gmres.solve (global_matrix, solution, right_hand_side,
* vanka);
- * @end{verbatim}
+ * @endverbatim
*
*
* @sect4{Implementor's remark}
/**
* Constructor. Gets the matrix
* for preconditioning and a bit
- * vector with entries @p{true} for
+ * vector with entries @p true for
* all rows to be updated. A
* reference to this vector will
* be stored, so it must persist
* object. The same is true for
* the matrix.
*
- * The matrix @p{M} which is passed
+ * The matrix @p M which is passed
* here may or may not be the
* same matrix for which this
* object shall act as
* where the matrix changes in
* each step slightly.
*
- * If @p{conserve_mem} is @p{false},
+ * If @p conserve_mem is @p false,
* then the inverses of the local
* systems are computed now, if
- * the flag is @p{true}, then they
+ * the flag is @p true, then they
* are computed every time the
* preconditioner is
* applied. This saves some
* memory, but makes
* preconditioning very
* slow. Note also, that if the
- * flag is @p{false}, the the
- * contents of the matrix @p{M} at
+ * flag is @p false, the the
+ * contents of the matrix @p M at
* the time of calling this
* constructor are used, while if
- * the flag is @p{true}, then the
- * values in @p{M} at the time of
+ * the flag is @p true, then the
+ * values in @p M at the time of
* preconditioning are used. This
* may lead to different results,
- * obviously, of @p{M} changes.
+ * obviously, of @p M changes.
*
- * The parameter @p{n_threads}
+ * The parameter @p n_threads
* determines how many threads
* shall be used in parallel when
* building the inverses of the
/**
* Do the preconditioning.
* This function takes the residual
- * in @p{src} and returns the resulting
- * update vector in @p{dst}.
+ * in @p src and returns the resulting
+ * update vector in @p dst.
*/
template<typename number2>
void vmult (Vector<number2> &dst,
/**
* Apply the inverses
* corresponding to those degrees
- * of freedom that have a @p{true}
- * value in @p{dof_mask}, to the
- * @p{src} vector and move the
- * result into @p{dst}. Actually,
+ * of freedom that have a @p true
+ * value in @p dof_mask, to the
+ * @p src vector and move the
+ * result into @p dst. Actually,
* only values for allowed
- * indices are written to @p{dst},
+ * indices are written to @p dst,
* so the application of this
* function only does what is
* announced in the general
* parallelize the
* application. Then, it is
* important to only write to
- * some slices of @p{dst}, in order
+ * some slices of @p dst, in order
* to eliminate the dependencies
* of threads of each other.
*
* If a null pointer is passed
* instead of a pointer to the
- * @p{dof_mask} (as is the default
+ * @p dof_mask (as is the default
* value), then it is assumed
* that we shall work on all
* degrees of freedom. This is
* function with a
* @p{vector<bool>(n_dofs,true)}.
*
- * The @p{vmult} of this class
+ * The @p vmult of this class
* of course calls this function
* with a null pointer
*/
* Array of inverse matrices,
* one for each degree of freedom.
* Only those elements will be used
- * that are tagged in @p{selected}.
+ * that are tagged in @p selected.
*/
mutable std::vector<SmartPointer<FullMatrix<float> > > inverses;
/**
* Compute the inverse of the
* block located at position
- * @p{row}. Since the vector is
+ * @p row. Since the vector is
* used quite often, it is
* generated only once in the
* caller of this function and
* is actually necessary, since
* derived classes can only
* access non-public members
- * through their @p{this}
+ * through their @p this
* pointer, but not access these
* members as member functions of
* other objects of the type of
* this base class (i.e. like
- * @p{x.f()}, where @p{x} is an
+ * @p{x.f()}, where @p x is an
* object of the base class, and
- * @p{f} one of it's non-public
+ * @p f one of it's non-public
* member functions).
*
* Now, in the case of the
- * @p{SparseBlockVanka} class, we
+ * @p SparseBlockVanka class, we
* would like to take the address
* of a function of the base
* class in order to call it
*
* This class is probably useless if you don't have a multiprocessor
* system, since then the amount of work per preconditioning step is
- * the same as for the @p{SparseVanka} class, but preconditioning
+ * the same as for the @p SparseVanka class, but preconditioning
* properties are worse. On the other hand, if you have a
* multiprocessor system, the worse preconditioning quality (leading
* to more iterations of the linear solver) usually is well balanced
*
* To facilitate writing portable code, if the number of blocks into
* which the matrix is to be subdivided, is set to one, then this
- * class acts just like the @p{SparseVanka} class. You may therefore
+ * class acts just like the @p SparseVanka class. You may therefore
* want to set the number of blocks equal to the number of processors
* you have.
*
* to be solved is equal between blocks. The reason for this strategy
* to subdivision is load-balancing for multithreading. There are
* several possibilities to actually split the matrix into blocks,
- * which are selected by the flag @p{blocking_strategy} that is passed
+ * which are selected by the flag @p blocking_strategy that is passed
* to the constructor. By a block, we will in the sequel denote a list
* of indices of degrees of freedom; the algorithm will work on each
* block separately, i.e. the solutions of the local systems
* a consecutive list of indices, as in the first alternative below,
* or a nonconsecutive list of indices. Of course, we assume that the
* intersection of each two blocks is empty and that the union of all
- * blocks equals the interval @p{[0,N)}, where @p{N} is the number of
+ * blocks equals the interval @p{[0,N)}, where @p N is the number of
* degrees of freedom of the system of equations.
*
- * @begin{itemize}
- * @item @p{index_intervals}:
+ * <ul>
+ * <li> @p index_intervals:
* Here, we chose the blocks to be intervals @p{[a_i,a_{i+1})},
* i.e. consecutive degrees of freedom are usually also within the
* same block. This is a reasonable strategy, if the degrees of
* the matrix is usually restricted to the vicinity of the diagonal
* as well, and we can simply cut the matrix into blocks.
*
- * The bounds of the intervals, i.e. the @p{a_i} above, are chosen
+ * The bounds of the intervals, i.e. the @p a_i above, are chosen
* such that the number of degrees of freedom on which we shall
* work (i.e. usually the degrees of freedom corresponding to
* Lagrange multipliers) is about the same in each block; this does
* preconditioner useless if the degrees of freedom are numbered by
* component, i.e. all Lagrange multipliers en bloc.
*
- * @item @p{adaptive}: This strategy is a bit more clever in cases where
+ * <li> @p adaptive: This strategy is a bit more clever in cases where
* the Langrange DoFs are clustered, as in the example above. It
* works as follows: it first groups the Lagrange DoFs into blocks,
* using the same strategy as above. However, instead of grouping
* does not differ much. However, unlike the first strategy, the
* performance of the second strategy does not deteriorate if the
* DoFs are renumbered by component.
- * @end{itemize}
+ * </ul>
*
*
* @sect3{Typical results}
* optimization, which leads to a series of saddle point problems,
* each of which is solved using GMRES with Vanka as
* preconditioner. The equation had approx. 850 degrees of
- * freedom. With the non-blocked version @p{SparseVanka} (or
- * @p{SparseBlockVanka} with @p{n_blocks==1}), the following numbers of
+ * freedom. With the non-blocked version @p SparseVanka (or
+ * @p SparseBlockVanka with @p{n_blocks==1}), the following numbers of
* iterations is needed to solver the linear system in each nonlinear
* step:
- * @begin{verbatim}
+ * @verbatim
* 101 68 64 53 35 21
- * @end{verbatim}
+ * @endverbatim
*
* With four blocks, we need the following numbers of iterations
- * @begin{verbatim}
+ * @verbatim
* 124 88 83 66 44 28
- * @end{verbatim}
+ * @endverbatim
* As can be seen, more iterations are needed. However, in terms of
* computing time, the first version needs 72 seconds wall time (and
* 79 seconds CPU time, which is more than wall time since some other
/**
* Constructor. Pass all
* arguments except for
- * @p{n_blocks} to the base class.
+ * @p n_blocks to the base class.
*/
SparseBlockVanka (const SparseMatrix<number> &M,
const std::vector<bool> &selected,
* for each block which degrees
* of freedom belong to it. Thus,
* if @p{dof_masks[i][j]==true},
- * then DoF @p{j} belongs to block
- * @p{i}. Of course, no other
+ * then DoF @p j belongs to block
+ * @p i. Of course, no other
* @p{dof_masks[l][j]} may be
- * @p{true} for @p{l!=i}. This
+ * @p true for @p{l!=i}. This
* computation is done in the
* constructor, to avoid
* recomputing each time the
/**
* Compute the contents of the
- * field @p{dof_masks}. This
+ * field @p dof_masks. This
* function is called from the
* constructor.
*/
row_length);
// collect the dofs that couple
- // with @p{row}
+ // with @p row
local_indices.resize (row_length);
for (unsigned int i=0; i<row_length; ++i)
local_indices[i] = structure.column_number(row, i);
// patterns, the first element
// of each entry simply denotes
// all degrees of freedom that
- // couple with @p{row}.
+ // couple with @p row.
local_index.clear ();
for (unsigned int i=0; i<row_length; ++i)
local_index.insert(std::pair<unsigned int, unsigned int>
// couple with the present DoF
const unsigned int irow = is->first;
// index of DoF irow in the matrix
- // row corresponding to DoF @p{row}.
+ // row corresponding to DoF @p row.
// runs between 0 and row_length
const unsigned int i = is->second;
// number of DoFs coupling to
// this dof
const unsigned int col = structure.column_number(irow, j);
// find out whether this DoF
- // (that couples with @p{irow},
+ // (that couples with @p irow,
// which itself couples with
- // @p{row}) also couples with
- // @p{row}.
+ // @p row) also couples with
+ // @p row.
const std::map<unsigned int, unsigned int>::const_iterator js
= local_index.find(col);
// if not, then still use
++access_count[block_number][structure.column_number(row, i)];
};
- // now we know that block @p{i}
- // wants to write to DoF @p{j}
+ // now we know that block @p i
+ // wants to write to DoF @p j
// as often as
// @p{access_count[i][j]}
- // times. Let @p{j} be allotted
+ // times. Let @p j be allotted
// to the block which
// accesses it most often.
//
* The following picture will illustrate the relation between the
* SparsityPattern an the SparseMatrix.
*
- * @begin{verbatim}
+ * @verbatim
* SparsityPattern: \
* |
* _________________________ |
* /_________colnums[0] |
* |
* /
- * @end{verbatim}
+ * @endverbatim
*
- * @begin{verbatim}
+ * @verbatim
* For row = 0
*
* there are: (0| 3) = colnums[0]
* (1| 4) = colnums[5]
* ....
*
- * @end{verbatim}
+ * @endverbatim
*
- * @begin{verbatim}
+ * @verbatim
* SparseMatrix: \
* |
* _____________________________ |
* |
* |
* /
- * @end{verbatim}
+ * @endverbatim
*
* If you want to get the <tt>3</tt> you need to get its position in
* the table above and its value by returning the value of the element
* represented by a sequence of
* pairs of column indices and
* values. In the present
- * context, the @ref{begin} and
- * @ref{end} parameters designate
+ * context, the begin() and
+ * end() parameters designate
* iterators (of forward iterator
* type) into a container, one
* representing one row. The
- * distance between @ref{begin}
- * and @ref{end} should therefore
+ * distance between begin()
+ * and end() should therefore
* be equal to
- * @ref{n_rows}. These iterators
+ * n_rows(). These iterators
* may be iterators of
* <tt>std::vector</tt>,
* <tt>std::list</tt>, pointers into a
*
* After calling this function, the
* output array will have values between
- * zero and @p{n_partitions-1} for each
+ * zero and @p n_partitions-1 for each
* node (i.e. row or column of the
* matrix).
*
* This function will generate an error
* if METIS is not installed unless
- * @p{n_partitions} is one. I.e., you can
+ * @p n_partitions is one. I.e., you can
* write a program so that it runs in the
* single-processor single-partition case
* without METIS installed, and only
* methods you will want to partition the
* mesh, not the matrix. This can be done
* by calling
- * @p{GridTools::partition_triangulation}.
+ * @p GridTools::partition_triangulation.
*/
void partition (const unsigned int n_partitions,
std::vector<unsigned int> &partition_indices) const;
* read-only.
*
* Use of this function is highly
- * deprecated. Use @p{row_length} and
- * @p{column_number} instead. Also, using
+ * deprecated. Use @p row_length and
+ * @p column_number instead. Also, using
* iterators may get you most of the
* information you may want.
*
const unsigned int * get_rowstart_indices () const;
/**
- * @deprecated. Use @p{row_length} and
- * @p{column_number} instead. Also, using
+ * @deprecated. Use @p row_length and
+ * @p column_number instead. Also, using
* iterators may get you most of the
* information you may want.
*
*
* At the beginning, all elements
* of this array are set to
- * @p{-1} indicating invalid
+ * @p -1 indicating invalid
* (unused) column numbers
* (diagonal elements are preset
* if optimized storage is
* element. When compress is
* called, unused elements
* (indicated by column numbers
- * @p{-1}) are eliminated by
+ * @p -1) are eliminated by
* copying the column number of
* subsequent rows and the column
* numbers within each row (with
*/
/**
- * This class is a wrapper to the @p{Vector} class which allows to swap
+ * This class is a wrapper to the @p Vector class which allows to swap
* out the data to a file and reload it later on. It handles the
* management of the name of the file where the data is to be stored
* temporarily and removes the file is necessary at the end of the
* lifetime of the vector.
*
* There are functions to swap the data to a file, and to reload
- * it. There is also a function @p{alert} that can be used to signal to
+ * it. There is also a function @p alert that can be used to signal to
* an object of this class that the data will be needed shortly, so
* the object can initiate that the data be loaded already. While in
- * non-multithreading mode, this function has no effect since @p{reload}
+ * non-multithreading mode, this function has no effect since @p reload
* has to be called afterwards anyway. On the other hand, in
* multithreading mode, the data is preloaded in the background using
* a thread on its own, and may already be available at the time when
- * @p{reload} is called. If it is not available, @p{reload} waits until
+ * @p reload is called. If it is not available, @p reload waits until
* the detached thread has loaded the data.
*
*
/**
* Copy constructor. Copies the
- * data if @p{v} contains some, but
- * does not do so if @p{v} is empty
+ * data if @p v contains some, but
+ * does not do so if @p v is empty
* or has its data swapped
* out. In the latter case, warn
* about that. In particular do
* not take over ownership of any
- * files that @p{v} might own (as,
+ * files that @p v might own (as,
* for example, @p{C++}'s
- * @p{auto_ptr} objects would do).
+ * @p auto_ptr objects would do).
*/
SwappableVector (const SwappableVector &v);
* ownership of this file is
* assumed by this object. The
* file is deleted either upon
- * calling @p{kill_file}, or on
+ * calling @p kill_file, or on
* destruction of this object.
*
* The content of the vector is
*
* If this object owns another
* file, for example when
- * @p{swap_out} but no @p{kill_file}
+ * @p swap_out but no @p kill_file
* has previously been called,
* then that is deleted first.
*/
* Reload the data of this vector
* from the file to which it has
* been stored previously using
- * @p{swap_out}. Since the file is
+ * @p swap_out. Since the file is
* not deleted after reloading,
- * you can call @p{reload} multiple
+ * you can call @p reload multiple
* times, in between you may do
* everything with the vector,
* including changing its size.
* This function resets the size
* of the vector to the number of
* elements there were upon
- * calling @p{swap_out} before.
+ * calling @p swap_out before.
*/
void reload ();
* that reads the data in
* parallel to the usual
* execution of the program, such
- * that when @p{reload} is called,
+ * that when @p reload is called,
* the data may eventually be
* available already. It might
* therefore be wirthwhile to
* a local tmp directory.
*
* Calling this function multiple
- * times before calling @p{reload}
+ * times before calling @p reload
* is allowed and has no effect
* for subsequent calls. Calling
* this function while the data
* time. After this, the object
* does not own any file any
* more, so of course you can't
- * call @p{reload} no more.
+ * call @p reload no more.
*
* If this object does not own a
* file, for example since
- * @p{swap_out} was not called, or
- * because @p{kill_file} has been
+ * @p swap_out was not called, or
+ * because @p kill_file has been
* called previously, then this
* function does nothing.
*/
* Return the name of the file to
* which the data was stored the
* last time you called
- * @p{swap_out}. If @p{swap_out} was
+ * @p swap_out. If @p swap_out was
* not called, or if in between
- * @p{kill_file} was called, then
+ * @p kill_file was called, then
* the filename is an empty
* string.
*/
* was swapped out. If no data is
* presently swapped out
* (i.e. before calling
- * @p{swap_out} and after
- * @p{kill_file}), the string is
+ * @p swap_out and after
+ * @p kill_file), the string is
* empty, indicating no ownership
* of files.
*/
/**
* If in multithread mode, then
- * the @p{alert} function has
+ * the @p alert function has
* functionality, but needs to
- * coordinate with the @p{reload}
+ * coordinate with the @p reload
* function. This is done through
* the following lock.
*
Threads::ThreadMutex lock;
/**
- * Flag by which the @p{alert}
+ * Flag by which the @p alert
* function signifies that the
* data has been preloaded
* already. This flag is always
- * @p{false} in non-MT mode.
+ * @p false in non-MT mode.
*/
bool data_is_preloaded;
/**
* Internal function that
* actually reloads the
- * vector. Called from @p{reload}
- * and @p{alert}.
+ * vector. Called from @p reload
+ * and @p alert.
*
* The parameter specifies
* whether the function shall set
- * @p{data_is_preloaded} or
+ * @p data_is_preloaded or
* not. The calling functions
* can't sometimes do this
* themselves, since they call
Threads::ThreadMutex::ScopedLock lock(this->lock);
// check that we have not called
- // @p{alert} without the respective
- // @p{reload} function
+ // @p alert without the respective
+ // @p reload function
Assert (data_is_preloaded == false, ExcInternalError());
std::ofstream tmp_out(filename.c_str());
void SwappableVector<number>::reload ()
{
// if in MT mode: synchronise with
- // possibly existing @p{alert}
+ // possibly existing @p alert
// calls. if not in MT mode, this
// is a no-op
lock.acquire ();
* second type support the abgebraic operation for vectors. The third
* und last type helps us to manipulate the components of the vector.
* As opposed to the array of the C++ standard library called
- * @p{vector} (with a lowercase "v"), this class implements an element
+ * @p vector (with a lowercase "v"), this class implements an element
* of a vector space suitable for numerical computations.
*
*
// * Copy constructor taking a vector of
// * another data type. This will fail if
// * there is no conversion path from
-// * @p{OtherNumber} to @p{Number}. Note that
+// * @p OtherNumber to @p Number. Note that
// * you may lose accuracy when copying
// * to a vector with data elements with
// * less accuracy.
/**
* Constructor. Set dimension to
- * @p{n} and initialize all
+ * @p n and initialize all
* elements with zero.
*
* The constructor is made
* given range of values pointed
* to by the iterators. This
* function is there in analogy
- * to the @p{std::vector} class.
+ * to the @p std::vector class.
*/
template <typename InputIterator>
Vector (const InputIterator first,
/**
* This function does nothing but is
* there for compatibility with the
- * @p{PETScWrappers::Vector} class.
+ * @p PETScWrappers::Vector class.
*
* For the PETSc vector wrapper class,
* thios function compresses the
/**
* Change the dimension of the vector to
- * @p{N}. The reserved memory for this
+ * @p N. The reserved memory for this
* vector remains unchanged if possible,
* to make things faster; this may waste
* some memory, so keep this in mind.
/**
* Change the dimension to that of the
- * vector @p{V}. The same applies as for
- * the other @p{reinit} function.
+ * vector @p V. The same applies as for
+ * the other @p reinit function.
*
- * The elements of @p{V} are not copied,
+ * The elements of @p V are not copied,
* i.e. this function is the same as
* calling @p{reinit (V.size(), fast)}.
*/
/**
* Swap the contents of this
* vector and the other vector
- * @p{v}. One could do this
+ * @p v. One could do this
* operation with a temporary
* variable and copying over the
* data elements, but this
* data around.
*
* This function is analog to the
- * the @p{swap} function of all C++
+ * the @p swap function of all C++
* standard containers. Also,
* there is a global function
* @p{swap(u,v)} that simply calls
/**
* Set all components of the vector to
- * the given number @p{s}.
+ * the given number @p s.
*/
Vector<Number> & operator= (const Number s);
* Return the scalar product of
* two vectors. The return type
* is the underlying type of
- * @p{this} vector, so the return
+ * @p this vector, so the return
* type and the accuracy with
* which it the result is
* computed depend on the order
bool all_zero () const;
/**
- * Return @p{true} if the vector has no
+ * Return @p true if the vector has no
* negative entries, i.e. all entries are
* zero or positive. This function is
* used, for example, to check whether
bool is_non_negative () const;
/**
- * Make the @p{Vector} class a bit like the
+ * Make the @p Vector class a bit like the
* @p{vector<>} class of the C++ standard
* library by returning iterators to
* the start and end of the elements of this
*/
//@{
/**
- * Access the value of the @p{i}th
+ * Access the value of the @p ith
* component.
*/
Number operator() (const unsigned int i) const;
/**
- * Access the @p{i}th component
+ * Access the @p ith component
* as a writeable reference.
*/
Number& operator() (const unsigned int i);
Vector<Number> & operator -= (const Vector<Number> &V);
/**
- * Addition of @p{s} to all
- * components. Note that @p{s} is a
+ * Addition of @p s to all
+ * components. Note that @p s is a
* scalar and not a vector.
*/
void add (const Number s);
/**
* Print to a
- * stream. @p{precision} denotes
+ * stream. @p precision denotes
* the desired precision with
* which values shall be printed,
- * @p{scientific} whether
+ * @p scientific whether
* scientific notation shall be
- * used. If @p{across} is
- * @p{true} then the vector is
+ * used. If @p across is
+ * @p true then the vector is
* printed in a line, while if
- * @p{false} then the elements
+ * @p false then the elements
* are printed on a separate line
* each.
*/
* Amount of memory actually
* reserved for this vector. This
* number may be greater than
- * @p{dim} if a @p{reinit} was
+ * @p dim if a @p reinit was
* called with less memory
* requirements than the vector
* needed last time. At present
- * @p{reinit} does not free
+ * @p reinit does not free
* memory when the number of
* needed elements is reduced.
*/
/**
- * Global function @p{swap} which overloads the default implementation
+ * Global function @p swap which overloads the default implementation
* of the C++ standard library which uses a temporary object. The
* function simply exchanges the data of the two vectors.
*
//! Keeps all vectors and avoids reallocation.
/**
- * Memory keeping allocated vectors. This @p{VectorMemory} is able to
+ * Memory keeping allocated vectors. This @p VectorMemory is able to
* grow infinitely (according to computer memory). A vector once
* allocated will stay in the memory pool, though, and it will be
* reused in later allocation.
projects / dealii-svn.git / commitdiff