/**
* 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>}
- * 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,
+ * from. By default, <tt>DoFObjectAccessor<celldim,dim></tt> derives from
+ * the @p typedef in the general <tt>DoFObjectAccessor_Inheritance<celldim,dim></tt>
+ * class, which is <tt>TriaObjectAccessor<celldim,dim></tt>,
+ * but if <tt>celldim==dim</tt>, then the specialization <tt>DoFObjectAccessor_Inheritance<dim,dim></tt>
+ * is used which declares its local type to be <tt>CellAccessor<dim></tt>. Therefore,
* the inheritance is automatically chosen to be from CellAccessor if the
* object under consideration has full dimension, i.e. constitutes a cell.
*
/**
* 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>}
- * 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,
+ * from. By default, <tt>DoFObjectAccessor<celldim,dim></tt> derives from
+ * the @p typedef in the general <tt>DoFObjectAccessor_Inheritance<celldim,dim></tt>
+ * class, which is <tt>TriaObjectAccessor<celldim,dim></tt>,
+ * but if <tt>celldim==dim</tt>, then the specialization <tt>DoFObjectAccessor_Inheritance<dim,dim></tt>
+ * is used which declares its local type to be <tt>CellAccessor<dim></tt>. Therefore,
* the inheritance is automatically chosen to be from CellAccessor if the
* object under consideration has full dimension, i.e. constitutes a cell.
*
* active cells.
*
* The input vector may be either a
- * @p{Vector<float>},
- * Vector@p{<double>}, or a
- * BlockVector@p{<double>}, or a
+ * <tt>Vector<float></tt>,
+ * Vector<tt><double></tt>, or a
+ * BlockVector<tt><double></tt>, or a
* PETSc vector if deal.II is compiled to
* support PETSc. It is in the
* responsibility of the caller to assure
* to this function.
*
* The output vector may be either a
- * Vector@p{<float>},
- * Vector@p{<double>}, or a
- * BlockVector@p{<double>}, or a
+ * Vector<tt><float></tt>,
+ * Vector<tt><double></tt>, or a
+ * BlockVector<tt><double></tt>, or a
* PETSc vector if deal.II is compiled to
* support PETSc. It is in the
* responsibility of the caller to assure
/**
* This function does much the same as
* the
- * @p{distribute_local_to_global(Vector,Vector)}
+ * <tt>distribute_local_to_global(Vector,Vector)</tt>
* function, but operates on matrices
* instead of vectors. The sparse matrix
* is supposed to have non-zero entry
*
* @sect3{Notes about the class hierarchy structure}
*
- * 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
+ * Inheritance from <tt>DoFObjectAccessor_Inheritance<1,dim>::BaseClass</tt> yields
+ * inheritance from <tt>CellAccessor<1></tt> if <tt>dim==1</tt> and from
+ * <tt>TriaObjectAccessor<1,dim></tt> 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.
*
* cells.
*
* The input vector may be either a
- * Vector@p{<float>},
- * Vector@p{<double>}, or a
- * BlockVector@p{<double>}, or a
+ * Vector<tt><float></tt>,
+ * Vector<tt><double></tt>, or a
+ * BlockVector<tt><double></tt>, or a
* PETSc vector if deal.II is compiled to
* support PETSc. It is in the
* responsibility of the caller to assure
* have the right size beforehand.
*
* The output vector may be either a
- * Vector@p{<float>},
- * Vector@p{<double>}, or a
- * BlockVector@p{<double>}, or a
+ * Vector<tt><float></tt>,
+ * Vector<tt><double></tt>, or a
+ * BlockVector<tt><double></tt>, or a
* PETSc vector if deal.II is compiled to
* support PETSc. It is in the
* responsibility of the caller to assure
/**
* This function does much the same as
* the
- * @p{distribute_local_to_global(Vector,Vector)}
+ * <tt>distribute_local_to_global(Vector,Vector)</tt>
* function, but operates on matrices
* instead of vectors. The sparse matrix
* is supposed to have non-zero entry
* cells.
*
* The input vector may be either a
- * Vector@p{<float>},
- * Vector@p{<double>}, or a
- * BlockVector@p{<double>}, or a
+ * Vector<tt><float></tt>,
+ * Vector<tt><double></tt>, or a
+ * BlockVector<tt><double></tt>, or a
* PETSc vector if deal.II is compiled to
* support PETSc. It is in the
* responsibility of the caller to assure
* have the right size beforehand.
*
* The output vector may be either a
- * Vector@p{<float>},
- * Vector@p{<double>}, or a
- * BlockVector@p{<double>}, or a
+ * Vector<tt><float></tt>,
+ * Vector<tt><double></tt>, or a
+ * BlockVector<tt><double></tt>, or a
* PETSc vector if deal.II is compiled to
* support PETSc. It is in the
* responsibility of the caller to assure
/**
* This function does much the same as
* the
- * @p{distribute_local_to_global(Vector,Vector)}
+ * <tt>distribute_local_to_global(Vector,Vector)</tt>
* function, but operates on matrices
* instead of vectors. The sparse matrix
* is supposed to have non-zero entry
* cells.
*
* The input vector may be either a
- * Vector@p{<float>},
- * Vector@p{<double>}, or a
- * BlockVector@p{<double>}, or a
+ * Vector<tt><float></tt>,
+ * Vector<tt><double></tt>, or a
+ * BlockVector<tt><double></tt>, or a
* PETSc vector if deal.II is compiled to
* support PETSc. It is in the
* responsibility of the caller to assure
* have the right size beforehand.
*
* The output vector may be either a
- * Vector@p{<float>},
- * Vector@p{<double>}, or a
- * BlockVector@p{<double>}, or a
+ * Vector<tt><float></tt>,
+ * Vector<tt><double></tt>, or a
+ * BlockVector<tt><double></tt>, or a
* PETSc vector if deal.II is compiled to
* support PETSc. It is in the
* responsibility of the caller to assure
/**
* This function does much the same as
* the
- * @p{distribute_local_to_global(Vector,Vector)}
+ * <tt>distribute_local_to_global(Vector,Vector)</tt>
* function, but operates on matrices
* instead of vectors. The sparse matrix
* is supposed to have non-zero entry
/**
* Grant access to the degrees of freedom on a cell. In fact, since all
* access to the degrees of freedom has been enabled by the classes
- * @p{DoFObjectAccessor<1, 1>} and @p{DoFObjectAccessor<2, 2>} for the space dimension
+ * <tt>DoFObjectAccessor<1, 1></tt> and <tt>DoFObjectAccessor<2, 2></tt> for the space dimension
* 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
+ * together by deriving from the appropriate <tt>DoF*Accessor</tt> and the
+ * right <tt>CellAccessor<dim></tt> and finally adding two functions which give
* access to the neighbors and children as DoFCellAccessor objects
* rather than CellAccessor objects (the latter function was inherited
- * from the @p{CellAccessor<dim>} class).
+ * from the <tt>CellAccessor<dim></tt> class).
*
- * Note that since for the class we derive from, i.e. @p{DoFObjectAccessor<dim,dim>},
+ * Note that since for the class we derive from, i.e. <tt>DoFObjectAccessor<dim,dim></tt>,
* the two template parameters are equal, the base class is actually derived from
* CellAccessor, which makes the functions of this class available to the
* DoFCellAccessor class as well.
* objects.
*
* The output vector may be either a
- * Vector@p{<float>},
- * Vector@p{<double>}, or a
- * BlockVector@p{<double>}, or a
+ * Vector<tt><float></tt>,
+ * Vector<tt><double></tt>, or a
+ * BlockVector<tt><double></tt>, or a
* PETSc vector if deal.II is compiled to
* support PETSc. It is in the
* responsibility of the caller to assure
* @p condensed be zero.
*
* The @p VectorType may be a
- * Vector@p{<float>},
- * Vector@p{<double>},
- * BlockVector@p{<...>}, a PETSc
+ * Vector<tt><float></tt>,
+ * Vector<tt><double></tt>,
+ * BlockVector<tt><...></tt>, 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
- * Vector@p{<float>},
- * Vector@p{<double>},
- * BlockVector@p{<...>}, a PETSc
+ * Vector<tt><float></tt>,
+ * Vector<tt><double></tt>,
+ * BlockVector<tt><...></tt>, a PETSc
* vector wrapper class, or any other
* type having the same interface.
*/
* @p condense.
*
* The @p VectorType may be a
- * Vector@p{<float>},
- * Vector@p{<double>},
- * BlockVector@p{<...>}, a PETSc
+ * Vector<tt><float></tt>,
+ * Vector<tt><double></tt>,
+ * BlockVector<tt><...></tt>, 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 Vector@p{<float>},
- * Vector@p{<double>},
- * BlockVector@p{<...>}, a PETSc
+ * may be a Vector<tt><float></tt>,
+ * Vector<tt><double></tt>,
+ * BlockVector<tt><...></tt>, 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
- * Vector@p{<float>},
- * Vector@p{<double>},
- * BlockVector@p{<...>}, a PETSc
+ * Vector<tt><float></tt>,
+ * Vector<tt><double></tt>,
+ * BlockVector<tt><...></tt>, a PETSc
* vector wrapper class, or any other
* type having the same interface.
*/
* This function writes out all entries
* in the constraint matrix lines with
* their value in the form
- * @p{row col : value}. Unconstrained lines
+ * <tt>row col : value</tt>. Unconstrained lines
* containing only one identity entry are
* not stored in this object and are not
* printed.
* at the end, so the order is
* unspecified after all entries are
* inserted. Sorting of the entries takes
- * place when calling the @p{close()} function.
+ * place when calling the <tt>close()</tt> function.
*
* We could, instead of using a vector, use
* an associative array, like a map to
* 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
+ * by offering <tt>begin()</tt> and <tt>end()</tt> 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 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 <tt>++</tt> and @p -- operators
* is the same as that for the alike triangulation iterators.
*
* This class also provides functions to create the sparsity patterns of
* @sect3{Distribution of indices for degrees of freedom}
*
* The degrees of freedom (`dofs') are distributed on the given triangulation
- * by the function @p{distribute_dofs()}. It gets passed a finite element object
+ * by the function <tt>distribute_dofs()</tt>. It gets passed a finite element object
* describing how many degrees of freedom are located on vertices, lines, etc.
* It traverses the triangulation cell by cell and numbers the dofs of that
* cell if not yet numbered. For non-multigrid algorithms, only active cells
* 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
- * @p{renumber_dofs(vector<unsigned int>)} function is called, which actually
+ * <tt>renumber_dofs(vector<unsigned int>)</tt> function is called, which actually
* does the change from old DoF indices to the ones given in the
* array. In some cases, however, a user may want to compute her own
* renumbering order; in this case, allocate an array with one element
* respective degree of freedom shall be assigned. This number may,
* for example, be obtained by sorting the support points of the
* degrees of freedom in downwind direction. Then call the
- * @p{renumber_dofs(vector<unsigned int>)} with the array, which converts old
+ * <tt>renumber_dofs(vector<unsigned int>)</tt> with the array, which converts old
* into new degree of freedom indices.
*
*
* Return an iterator which is the first
* iterator not on level. If @p level is
* the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
cell_iterator end (const unsigned int level) const;
* Return a raw iterator which is the first
* iterator not on level. If @p level is
* the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
raw_cell_iterator end_raw (const unsigned int level) const;
* Return an active iterator which is the
* first iterator not on level. If @p level
* is the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
active_cell_iterator end_active (const unsigned int level) const;
* Return an iterator which is the first
* iterator not on level. If @p level is
* the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
face_iterator end_face (const unsigned int level) const;
* Return a raw iterator which is the first
* iterator not on level. If @p level is
* the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
raw_face_iterator end_raw_face (const unsigned int level) const;
* Return an active iterator which is the
* first iterator not on level. If @p level
* is the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
active_face_iterator end_active_face (const unsigned int level) const;
* Return an iterator which is the first
* iterator not on level. If @p level is
* the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
line_iterator end_line (const unsigned int level) const;
* Return a raw iterator which is the first
* iterator not on level. If @p level is
* the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
raw_line_iterator end_raw_line (const unsigned int level) const;
* Return an active iterator which is the
* first iterator not on level. If @p level
* is the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
active_line_iterator end_active_line (const unsigned int level) const;
* Return an iterator which is the first
* iterator not on level. If @p level is
* the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
quad_iterator end_quad (const unsigned int level) const;
* Return a raw iterator which is the first
* iterator not on level. If @p level is
* the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
raw_quad_iterator end_raw_quad (const unsigned int level) const;
* Return an active iterator which is the
* first iterator not on level. If @p level
* is the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
active_quad_iterator end_active_quad (const unsigned int level) const;
* Return an iterator which is the first
* iterator not on level. If @p level is
* the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
hex_iterator end_hex (const unsigned int level) const;
* Return a raw iterator which is the first
* iterator not on level. If @p level is
* the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
raw_hex_iterator end_raw_hex (const unsigned int level) const;
* Return an active iterator which is the
* first iterator not on level. If @p level
* is the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
active_hex_iterator end_active_hex (const unsigned int level) const;
* the DoF handler, we subscribe to
* the finite element object. To unlock
* the FE before the end of the lifetime
- * of this DoF handler, use the @p{clear()}
+ * of this DoF handler, use the <tt>clear()</tt>
* function (this clears all data of
* this object as well, though).
*/
/**
* Reserve enough space in the
- * @p{levels[]} objects to store the
+ * <tt>levels[]</tt> objects to store the
* numbers of the degrees of freedom
* needed for the given element. The
* given element is that one which
/**
* Space to store the DoF numbers for the
* different levels. Analogous to the
- * @p{levels[]} tree of the Triangulation
+ * <tt>levels[]</tt> tree of the Triangulation
* objects.
*/
std::vector<DoFLevel<dim>*> levels;
*
* @sect3{Information for all DoFLevel classes}
*
- * The DoFLevel@p{<N>} classes
+ * The DoFLevel<tt><N></tt> classes
* store the global indices of the degrees of freedom for each cell on a
* certain level. The index or number of a degree of freedom is the zero-based
* index of the according value in the solution vector and the row and column
* $\ldots, u_1^m, u_2^m, u_1^{m+1}, u_2^{m+1},\ldots$ with $m$ denoting the
* $m$th basis function, or $\ldots, u_1^m, u_1^{m+1}, u_1^{m+2}, \ldots,
* u_2^m, u_2^{m+1}, u_2^{m+2}, \ldots$, respectively). Likewise, the
- * constraint matrix returned by DoFHandler@p{::make_hanging_node_constraints ()}
+ * constraint matrix returned by DoFHandler<tt>::make_hanging_node_constraints ()</tt>
* is then
* to be understood as a block matrix.
*
* The storage format of the degrees of freedom indices (short: DoF
* indices) is somewhat like a mirror of the data structures of the
* triangulation classes. There is a hierarchy of
- * DoFLevel@p{<dim>} classes for the different dimensions which
+ * DoFLevel<tt><dim></tt> classes for the different dimensions which
* have objects named @p line_dofs, @p quad_dofs and so on, in which
* the indices of DoFs located on lines and quads, respectively, are
* stored. The indices are stored levelwise. The layout in these
* arrays is as follows: if for a selected finite element (use
- * DoFHandler@p{::distribute_dofs()} to select a finite element)
+ * DoFHandler<tt>::distribute_dofs()</tt> to select a finite element)
* the number of DoFs on each line (without those in the vertices) is
* @p N, then the length of the @p line_dofs array is @p N times
* the number of lines on this level. The DoF indices for the @p ith
- * line are at the positions @p{N*i...(N+1)*i-1}.
+ * line are at the positions <tt>N*i...(N+1)*i-1</tt>.
*
* The DoF indices for vertices are not stored this way, since they
* need different treatment in multigrid environments. If no multigrid
* function.
*
* The algorithm is stable, i.e. if
- * two dofs i,j have @p{i<j} and belong
+ * two dofs i,j have <tt>i<j</tt> and belong
* to the same subdomain, then they
* will be in this order also after
* reordering.
* of hanging nodes. They have
* to be taken care of by a call
* to
- * ConstraintMatrix@p{::condense()}
+ * ConstraintMatrix<tt>::condense()</tt>
* afterwards.
*
* Remember using
- * SparsityPattern@p{::compress()}
+ * SparsityPattern<tt>::compress()</tt>
* after generating the pattern.
*
* The actual type of the
* nodes. The sparsity pattern
* is not compressed, since if
* you want to call
- * ConstraintMatrix@p{::condense(1)}
+ * ConstraintMatrix<tt>::condense(1)</tt>
* afterwards, new entries have
* to be added. However, if you
* don't want to call
- * ConstraintMatrix@p{::condense(1)},
+ * ConstraintMatrix<tt>::condense(1)</tt>,
* you have to compress the
* matrix yourself, using
- * SparsityPattern@p{::compress()}.
+ * SparsityPattern<tt>::compress()</tt>.
*
* The actual type of the
* sparsity pattern may be
* It is assumed that the output
* vector @p dof_data already
* has the right size,
- * i.e. @p{n_dofs()} elements.
+ * i.e. <tt>n_dofs()</tt> elements.
*
* This function cannot be used
* if the finite element in use
* in the finite element used by
* @p dof. The size of
* @p selected_dofs shall equal
- * @p{dof_handler.n_dofs()}. Previous
+ * <tt>dof_handler.n_dofs()</tt>. Previous
* contents of this array or
* overwritten.
*
* element used by @p dof. The
* size of @p selected_dofs shall
* equal
- * @p{dof_handler.n_dofs()}. Previous
+ * <tt>dof_handler.n_dofs()</tt>. Previous
* contents of this array or
* overwritten.
*
*
* The size of @p selected_dofs
* shall equal
- * @p{dof_handler.n_dofs()}. Previous
+ * <tt>dof_handler.n_dofs()</tt>. Previous
* contents of this array or
* overwritten.
*/
/**
* For each DoF, return in the output
* array to which subdomain (as given by
- * the @p{cell->subdomain_id()} function)
+ * the <tt>cell->subdomain_id()</tt> function)
* it belongs. The output array is
* supposed to have the right size
* already when calling this function.
* of freedom indices to the
* index of that degree of
* freedom on the boundary. After
- * this operation, @p{mapping[dof]}
+ * this operation, <tt>mapping[dof]</tt>
* gives the index of the
* degree of freedom with global
* number @p dof in the list of
* boundary. If the degree of
* freedom requested is not on
* the boundary, the value of
- * @p{mapping[dof]} is
+ * <tt>mapping[dof]</tt> is
* @p invalid_dof_index. This
* function is mainly used when
* setting up matrices and
* Access to base element
* objects. If the element is
* scalar, then
- * @p{base_element(0)} is
+ * <tt>base_element(0)</tt> is
* @p this.
*/
virtual
* @p update_each compute which
* values must really be
* computed. Then, the
- * @p{fill_*_values} functions
+ * <tt>fill_*_values</tt> functions
* are called with the result of
* these.
*
* approximate second
* derivatives.
*
- * The ordering is @p{p+hx},
- * @p{p+hy}, @p{p+hz},
+ * The ordering is <tt>p+hx</tt>,
+ * <tt>p+hy</tt>, <tt>p+hz</tt>,
* @p p-hx, @p p-hy,
* @p p-hz, where unused
* entries in lower dimensions
* brackets, and the polynomial
* degree and whatever else is
* necessary in parentheses. For
- * example, @p{FE_Q<2>(3)} is the
+ * example, <tt>FE_Q<2>(3)</tt> is the
* value returned for a cubic
* element in 2d.
*
* concatenation, not the sum of
* the cell matrices
* @p P_i. That is, if the same
- * non-zero entry @p{j,k} exists
+ * non-zero entry <tt>j,k</tt> exists
* in in two different child
* matrices @p P_i, the value
* should be the same in both
* and they are not implemented. This
* function could be used to check
* whether a call to
- * @p{get_prolongation_matrix()} will
+ * <tt>get_prolongation_matrix()</tt> will
* succeed; however, one then still needs
* to cope with the lack of information
* this just expresses.
* node constraints and they are
* not implemented. This function
* could be used to check whether
- * a call to @p{constraints()}
+ * a call to <tt>constraints()</tt>
* will succeed; however, one
* then still needs to cope with
* the lack of information this
* finite element to the present
* one. The size of the matrix is
* then @p dofs_per_cell times
- * @p{source.dofs_per_cell}.
+ * <tt>source.dofs_per_cell</tt>.
*
* Derived elements will have to
* implement this function. They
* element. The order of points
* in the array matches that
* returned by the
- * @p{cell->get_dof_indices}
+ * <tt>cell->get_dof_indices</tt>
* function.
*
* See the class documentation
* (@p dofs_per_face). The order
* of points in the array matches
* that returned by the
- * @p{cell->get_dof_indices}
+ * <tt>cell->get_dof_indices</tt>
* function.
*
* See the class documentation
* that case, the component with
* the single zero is also the
* first element of what
- * @p{system_to_component_index(i)}
+ * <tt>system_to_component_index(i)</tt>
* returns.
*
* Only for those
* The result of the function is
* @p true if and only if the
* result of
- * @p{n_nonzero_components(i)} is
+ * <tt>n_nonzero_components(i)</tt> is
* equal to one.
*/
bool
/**
* Array of embedding matrices. See
- * @p{get_prolongation_matrix()} above.
+ * <tt>get_prolongation_matrix()</tt> above.
*
* Matrices in this array are
* automatically initialized to
* Return a string that uniquely
* identifies a finite
* element. This class returns
- * @p{FE_DGP<dim>(degree)}, with
+ * <tt>FE_DGP<dim>(degree)</tt>, with
* @p dim and @p degree
* replaced by appropriate
* values.
* constraint and embedding
* matrices. The definition of
* the various static fields are
- * in the files @p{fe_dgp_[123]d.cc}
+ * in the files <tt>fe_dgp_[123]d.cc</tt>
* in the source directory.
*/
struct Matrices
* finite element to the present
* one. The size of the matrix is
* then @p dofs_per_cell times
- * @p{source.dofs_per_cell}.
+ * <tt>source.dofs_per_cell</tt>.
*
* These matrices are only
* available if the source
* Return a string that uniquely
* identifies a finite
* element. This class returns
- * @p{FE_DGPNonparametric<dim>(degree)},
+ * <tt>FE_DGPNonparametric<dim>(degree)</tt>,
* with @p dim and @p degree
* replaced by appropriate
* values.
/**
* Access to base element
* objects. Since this element is
- * scalar, @p{base_element(0)} is
+ * scalar, <tt>base_element(0)</tt> is
* @p this, and all other
* indices throw an error.
*/
* Multiplicity of base element
* @p index. Since this is a
* scalar element,
- * @p{element_multiplicity(0)}
+ * <tt>element_multiplicity(0)</tt>
* returns one, and all other
* indices will throw an error.
*/
* constraint and embedding
* matrices. The definition of
* the various static fields are
- * in the files @p{fe_dgp_[123]d.cc}
+ * in the files <tt>fe_dgp_[123]d.cc</tt>
* in the source directory.
*/
struct Matrices
* finite element to the present
* one. The size of the matrix is
* then @p dofs_per_cell times
- * @p{source.dofs_per_cell}.
+ * <tt>source.dofs_per_cell</tt>.
*
* These matrices are only
* available if the source
* constraint and embedding
* matrices. The definition of
* the various static fields are
- * in the files @p{fe_dgq_[123]d.cc}
+ * in the files <tt>fe_dgq_[123]d.cc</tt>
* in the source directory.
*/
struct Matrices
*
* 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
+ * (i.e. <tt>p==1</tt>) are implemented. For a general overview of this
* element and its properties, see the report by Anna Schneebeli that
* is linked from the general documentation page of the library.
*
* Return a string that uniquely
* identifies a finite
* element. This class returns
- * @p{FE_Nedelec<dim>(degree)}, with
+ * <tt>FE_Nedelec<dim>(degree)</tt>, with
* @p dim and @p degree
* replaced by appropriate
* values.
/**
* Access to base element
* objects. Since this element is
- * atomic, @p{base_element(0)} is
+ * atomic, <tt>base_element(0)</tt> is
* @p this, and all other
* indices throw an error.
*/
* Multiplicity of base element
* @p index. Since this is an
* atomic element,
- * @p{element_multiplicity(0)}
+ * <tt>element_multiplicity(0)</tt>
* returns one, and all other
* indices will throw an error.
*/
* constraint and embedding
* matrices. The definition of
* the various static fields are
- * in the files @p{fe_nedelec_[23]d.cc}
+ * in the files <tt>fe_nedelec_[23]d.cc</tt>
* in the source directory.
*/
struct Matrices
* is listed in the following:
*
* <ul>
- * <li> @p{dim==1}
+ * <li> <tt>dim==1</tt>
* <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}
+ * <li> <tt>dim==2</tt>
* <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}
+ * <li> <tt>dim==3</tt>
* <ul>
* <li> the @p interface_constraints up to degree 2,
* <li> the @p prolongation matrices up to degree 2, and
* The respective coordinate values of the support points of the degrees
* of freedom are as follows:
* <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 0: <tt>[0, 0, 0]</tt>;
+ * <li> Index 1: <tt>[1, 0, 0]</tt>;
+ * <li> Index 2: <tt>[1, 0, 1]</tt>;
+ * <li> Index 3: <tt>[0, 0, 1]</tt>;
+ * <li> Index 4: <tt>[0, 1, 0]</tt>;
+ * <li> Index 5: <tt>[1, 1, 0]</tt>;
+ * <li> Index 6: <tt>[1, 1, 1]</tt>;
+ * <li> Index 7: <tt>[0, 1, 1]</tt>;
* </ul>
* </ul>
* @sect4{Q2 elements}
* The respective coordinate values of the support points of the degrees
* of freedom are as follows:
* <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]};
+ * <li> Index 0: <tt>[0, 0, 0]</tt>;
+ * <li> Index 1: <tt>[1, 0, 0]</tt>;
+ * <li> Index 2: <tt>[1, 0, 1]</tt>;
+ * <li> Index 3: <tt>[0, 0, 1]</tt>;
+ * <li> Index 4: <tt>[0, 1, 0]</tt>;
+ * <li> Index 5: <tt>[1, 1, 0]</tt>;
+ * <li> Index 6: <tt>[1, 1, 1]</tt>;
+ * <li> Index 7: <tt>[0, 1, 1]</tt>;
+ * <li> Index 8: <tt>[1/2, 0, 0]</tt>;
+ * <li> Index 9: <tt>[1, 0, 1/2]</tt>;
+ * <li> Index 10: <tt>[1/2, 0, 1]</tt>;
+ * <li> Index 11: <tt>[0, 0, 1/2]</tt>;
+ * <li> Index 12: <tt>[1/2, 1, 0]</tt>;
+ * <li> Index 13: <tt>[1, 1, 1/2]</tt>;
+ * <li> Index 14: <tt>[1/2, 1, 1]</tt>;
+ * <li> Index 15: <tt>[0, 1, 1/2]</tt>;
+ * <li> Index 16: <tt>[0, 1/2, 0]</tt>;
+ * <li> Index 17: <tt>[1, 1/2, 0]</tt>;
+ * <li> Index 18: <tt>[1, 1/2, 1]</tt>;
+ * <li> Index 19: <tt>[0, 1/2, 1]</tt>;
+ * <li> Index 20: <tt>[1/2, 0, 1/2]</tt>;
+ * <li> Index 21: <tt>[1/2, 1, 1/2]</tt>;
+ * <li> Index 22: <tt>[1/2, 1/2, 0]</tt>;
+ * <li> Index 23: <tt>[1, 1/2, 1/2]</tt>;
+ * <li> Index 24: <tt>[1/2, 1/2, 1]</tt>;
+ * <li> Index 25: <tt>[0, 1/2, 1/2]</tt>;
+ * <li> Index 26: <tt>[1/2, 1/2, 1/2]</tt>;
* </ul>
* </ul>
* @sect4{Q3 elements}
* Return a string that uniquely
* identifies a finite
* element. This class returns
- * @p{FE_Q<dim>(degree)}, with
+ * <tt>FE_Q<dim>(degree)</tt>, with
* @p dim and @p degree
* replaced by appropriate
* values.
* finite element to the present
* one. The size of the matrix is
* then @p dofs_per_cell times
- * @p{source.dofs_per_cell}.
+ * <tt>source.dofs_per_cell</tt>.
*
* These matrices are only
* available if the source
* constraint and embedding
* matrices. The definition of
* the various static fields are
- * in the files @p{fe_q_[123]d.cc}
+ * in the files <tt>fe_q_[123]d.cc</tt>
* in the source directory.
*/
struct Matrices
* 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
+ * <tt>[0,1]</tt> 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
* 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 <tt>0.5</tt> 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
* The respective coordinate values of the support points of the degrees
* of freedom are as follows:
* <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 0: <tt>[0, 0, 0]</tt>;
+ * <li> Index 1: <tt>[1, 0, 0]</tt>;
+ * <li> Index 2: <tt>[1, 0, 1]</tt>;
+ * <li> Index 3: <tt>[0, 0, 1]</tt>;
+ * <li> Index 4: <tt>[0, 1, 0]</tt>;
+ * <li> Index 5: <tt>[1, 1, 0]</tt>;
+ * <li> Index 6: <tt>[1, 1, 1]</tt>;
+ * <li> Index 7: <tt>[0, 1, 1]</tt>;
* </ul>
* </ul>
* @sect4{Q2 elements}
* The respective coordinate values of the support points of the degrees
* of freedom are as follows:
* <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]};
+ * <li> Index 0: <tt>[0, 0, 0]</tt>;
+ * <li> Index 1: <tt>[1, 0, 0]</tt>;
+ * <li> Index 2: <tt>[1, 0, 1]</tt>;
+ * <li> Index 3: <tt>[0, 0, 1]</tt>;
+ * <li> Index 4: <tt>[0, 1, 0]</tt>;
+ * <li> Index 5: <tt>[1, 1, 0]</tt>;
+ * <li> Index 6: <tt>[1, 1, 1]</tt>;
+ * <li> Index 7: <tt>[0, 1, 1]</tt>;
+ * <li> Index 8: <tt>[1/2, 0, 0]</tt>;
+ * <li> Index 9: <tt>[1, 0, 1/2]</tt>;
+ * <li> Index 10: <tt>[1/2, 0, 1]</tt>;
+ * <li> Index 11: <tt>[0, 0, 1/2]</tt>;
+ * <li> Index 12: <tt>[1/2, 1, 0]</tt>;
+ * <li> Index 13: <tt>[1, 1, 1/2]</tt>;
+ * <li> Index 14: <tt>[1/2, 1, 1]</tt>;
+ * <li> Index 15: <tt>[0, 1, 1/2]</tt>;
+ * <li> Index 16: <tt>[0, 1/2, 0]</tt>;
+ * <li> Index 17: <tt>[1, 1/2, 0]</tt>;
+ * <li> Index 18: <tt>[1, 1/2, 1]</tt>;
+ * <li> Index 19: <tt>[0, 1/2, 1]</tt>;
+ * <li> Index 20: <tt>[1/2, 0, 1/2]</tt>;
+ * <li> Index 21: <tt>[1/2, 1, 1/2]</tt>;
+ * <li> Index 22: <tt>[1/2, 1/2, 0]</tt>;
+ * <li> Index 23: <tt>[1, 1/2, 1/2]</tt>;
+ * <li> Index 24: <tt>[1/2, 1/2, 1]</tt>;
+ * <li> Index 25: <tt>[0, 1/2, 1/2]</tt>;
+ * <li> Index 26: <tt>[1/2, 1/2, 1/2]</tt>;
* </ul>
* </ul>
* @sect4{Q3 elements}
* Return a string that uniquely
* identifies a finite
* element. This class returns
- * @p{FE_Q_Hierarchical<dim>(degree)},
+ * <tt>FE_Q_Hierarchical<dim>(degree)</tt>,
* with @p dim and @p degree
* replaced by appropriate
* values.
* Return a string that uniquely
* identifies a finite
* element. This class returns
- * @p{FE_RaviartThomas<dim>(degree)}, with
+ * <tt>FE_RaviartThomas<dim>(degree)</tt>, with
* @p dim and @p degree
* replaced by appropriate
* values.
* finite element to the present
* one. The size of the matrix is
* then @p dofs_per_cell times
- * @p{source.dofs_per_cell}.
+ * <tt>source.dofs_per_cell</tt>.
*
* These matrices are only
* available if the source
/**
* Access to base element
* objects. Since this element is
- * atomic, @p{base_element(0)} is
+ * atomic, <tt>base_element(0)</tt> is
* @p this, and all other
* indices throw an error.
*/
* Multiplicity of base element
* @p index. Since this is an
* atomic element,
- * @p{element_multiplicity(0)}
+ * <tt>element_multiplicity(0)</tt>
* returns one, and all other
* indices will throw an error.
*/
* subobject. For example, for a element of three components in one
* space dimension, the first two components being cubic lagrange
* elements and the third being a quadratic lagrange element, the
- * ordering for the system @p{s=(u,v,p)} is:
+ * ordering for the system <tt>s=(u,v,p)</tt> is:
*
* <ul>
- * <li> First vertex: @p{u0, v0, p0 = s0, s1, s2}
- * <li> Second vertex: @p{u1, v1, p1 = s3, s4, s5}
+ * <li> First vertex: <tt>u0, v0, p0 = s0, s1, s2</tt>
+ * <li> Second vertex: <tt>u1, v1, p1 = s3, s4, s5</tt>
* <li> First component on the line:
- * @p{u2, u3 = s4, s5}
+ * <tt>u2, u3 = s4, s5</tt>
* <li> Second component on the line:
- * @p{v2, v3 = s6, s7}.
+ * <tt>v2, v3 = s6, s7</tt>.
* <li> Third component on the line:
- * @p{p2 = s8}.
+ * <tt>p2 = s8</tt>.
* </ul>
* Do not rely on this numbering in your application as these
* internals might change in future. Rather use the functions
* @p name1...@p nameN returned
* by the basis elements. From
* these, we create a sequence
- * @p{FESystem<dim>[name1^m1-name2^m2-...-nameN^mN]},
+ * <tt>FESystem<dim>[name1^m1-name2^m2-...-nameN^mN]</tt>,
* where @p mi are the
* multiplicities of the basis
* elements. If a multiplicity is
* finite element to the present
* one. The size of the matrix is
* then @p dofs_per_cell times
- * @p{source.dofs_per_cell}.
+ * <tt>source.dofs_per_cell</tt>.
*
* These matrices are available
* if source and destination
* Passes on control to
* @p compute_fill that does the
* work for all three
- * @p{fill_fe*_values}
+ * <tt>fill_fe*_values</tt>
* functions.
*/
virtual void
* Passes on control to
* @p compute_fill that does the
* work for all three
- * @p{fill_fe*_values} functions.
+ * <tt>fill_fe*_values</tt> functions.
*/
virtual void
fill_fe_face_values (const Mapping<dim> &mapping,
* Passes on control to
* @p compute_fill that does the
* work for all three
- * @p{fill_fe*_values} functions.
+ * <tt>fill_fe*_values</tt> functions.
*/
virtual void
fill_fe_subface_values (const Mapping<dim> &mapping,
/**
* Do the work for the three
- * @p{fill_fe*_values} functions.
+ * <tt>fill_fe*_values</tt> functions.
*
* Calls (among other things)
- * @p{fill_fe_([sub]face)_values}
+ * <tt>fill_fe_([sub]face)_values</tt>
* of the base elements. Calls
* @p fill_fe_values if
- * @p{face_no==invalid_face_no}
+ * <tt>face_no==invalid_face_no</tt>
* and
- * @p{sub_no==invalid_face_no};
+ * <tt>sub_no==invalid_face_no</tt>;
* calls @p fill_fe_face_values
* if
- * @p{face_no==invalid_face_no}
+ * <tt>face_no==invalid_face_no</tt>
* and
- * @p{sub_no!=invalid_face_no};
+ * <tt>sub_no!=invalid_face_no</tt>;
* and calls
* @p fill_fe_subface_values if
- * @p{face_no!=invalid_face_no}
+ * <tt>face_no!=invalid_face_no</tt>
* and
- * @p{sub_no!=invalid_face_no}.
+ * <tt>sub_no!=invalid_face_no</tt>.
*/
template <int dim_1>
void compute_fill (const Mapping<dim> &mapping,
/**
* Deletes the
* @p FEValuesData the
- * @p{fe_datas[base_no]}
+ * <tt>fe_datas[base_no]</tt>
* pointer is pointing
* to. Sets
- * @p{fe_datas[base_no]} to
+ * <tt>fe_datas[base_no]</tt> to
* zero.
*
* This function is used to
* 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)}.
+ * <tt>(fe2.dofs_per_cell, fe1.dofs_per_cell)</tt>.
*
* Note, that if the finite element
* space @p fe1 is a subset of
* @p fe1-function on
* each cell. The interpolation_matrix
* needs to be of size
- * @p{(fe1.dofs_per_cell, fe1.dofs_per_cell)}.
+ * <tt>(fe1.dofs_per_cell, fe1.dofs_per_cell)</tt>.
*
* Note, that this function only
* makes sense if the finite element
* back interpolation matrix.
* The @p difference_matrix
* needs to be of size
- * @p{(fe1.dofs_per_cell, fe1.dofs_per_cell)}.
+ * <tt>(fe1.dofs_per_cell, fe1.dofs_per_cell)</tt>.
*
* This function gives
* the matrix that transforms a
* space dimension in the form of
* a template argument after the
* name of the class (for example
- * @p{FE_Q<2>}, you can omit the
+ * <tt>FE_Q<2></tt>, you can omit the
* dimension argument altogether,
* or replace it with the string
* <tt>@<dim@></tt>. The reason
* follows: we allocate one row
* for each non-zero component as
* indicated by the
- * @p{FiniteElement::get_nonzero_components()}
+ * <tt>FiniteElement::get_nonzero_components()</tt>
* function, and the rows are in
* ascending order exactly those
* non-zero components.
* and you have to walk over all (or only the non-zero) components of
* the shape function using this set of functions.
*
- * <li> @p get_function_values, @p get_function_grads, @p{...}:
+ * <li> @p get_function_values, @p get_function_grads, <tt>...</tt>:
* Compute a finite element function or its derivative
* in quadrature points.
*
* correct size.
*
* The actual data type of the input
- * vector may be either a @p{Vector<T>},
- * @p{BlockVector<T>}, or one of the
+ * vector may be either a <tt>Vector<T></tt>,
+ * <tt>BlockVector<T></tt>, or one of the
* PETSc vector wrapper classes. It
* represents a global vector of
* DoF values associated with the
* elements.
*
* The actual data type of the input
- * vector may be either a @p{Vector<T>},
- * @p{BlockVector<T>}, or one of the
+ * vector may be either a <tt>Vector<T></tt>,
+ * <tt>BlockVector<T></tt>, or one of the
* PETSc vector wrapper classes. It
* represents a global vector of
* DoF values associated with the
* right size.
*
* The actual data type of the input
- * vector may be either a @p{Vector<T>},
- * @p{BlockVector<T>}, or one of the
+ * vector may be either a <tt>Vector<T></tt>,
+ * <tt>BlockVector<T></tt>, or one of the
* PETSc vector wrapper classes. It
* represents a global vector of
* DoF values associated with the
* elements.
*
* The actual data type of the input
- * vector may be either a @p{Vector<T>},
- * @p{BlockVector<T>}, or one of the
+ * vector may be either a <tt>Vector<T></tt>,
+ * <tt>BlockVector<T></tt>, or one of the
* PETSc vector wrapper classes. It
* represents a global vector of
* DoF values associated with the
* function.
*
* The actual data type of the input
- * vector may be either a @p{Vector<T>},
- * @p{BlockVector<T>}, or one of the
+ * vector may be either a <tt>Vector<T></tt>,
+ * <tt>BlockVector<T></tt>, or one of the
* PETSc vector wrapper classes..It
* represents a global vector of
* DoF values associated with the
* vector-valued finite elements.
*
* The actual data type of the input
- * vector may be either a @p{Vector<T>},
- * @p{BlockVector<T>}, or one of the
+ * vector may be either a <tt>Vector<T></tt>,
+ * <tt>BlockVector<T></tt>, or one of the
* PETSc vector wrapper classes. It
* represents a global vector of
* DoF values associated with the
* Store the cell selected last time
* the @p reinit function was called
* to make access
- * to the @p{get_function_*} functions
+ * to the <tt>get_function_*</tt> functions
* safer.
*/
typename DoFHandler<dim>::cell_iterator present_cell;
* 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
+ * @p FEFaceValues it is <tt>2*dim</tt>, while for
* the @p FESubfaceValues class it is
- * @p{2*dim*(1<<(dim-1))}, i.e. the number
+ * <tt>2*dim*(1<<(dim-1))</tt>, i.e. the number
* of faces times the number of subfaces
* per face.
*/
* cheaper to compute the
* boundary form immediately, use
* this value to integrate
- * @p{n.ds}.
+ * <tt>n.ds</tt>.
*/
const Tensor<1,dim> & boundary_form (const unsigned int i) const;
* 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
- * FiniteElement. Then call @p{get_*_data} and with the or'd
+ * FiniteElement. Then call <tt>get_*_data</tt> 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
+ * structures. On the first cell, call <tt>fill_fe_*_values</tt> 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
+ * <tt>fill_fe_*_values</tt> with the result of @p update_each to compute
* values for a special cell.
*
* A hint to implementators: no function except the two functions
UpdateFlags update_each;
/**
- * If @p{first_cell==true}
+ * If <tt>first_cell==true</tt>
* this function returns
* @p update_flags,
- * i.e. @p{update_once|update_each}.
- * If @p{first_cell==false}
+ * i.e. <tt>update_once|update_each</tt>.
+ * If <tt>first_cell==false</tt>
* it returns
* @p update_each.
*/
/**
* Give class @p FEValues access
- * to the private @p{get_...data}
- * and @p{fill_fe_...values}
+ * to the private <tt>get_...data</tt>
+ * and <tt>fill_fe_...values</tt>
* functions.
*/
friend class FEValues<dim>;
protected:
/**
- * For @p{dim=2,3}. Append the
+ * For <tt>dim=2,3</tt>. Append the
* support points of all shape
* functions located on bounding
* lines to the vector
* included.
*
* Needed by the
- * @p{compute_support_points_simple(laplace)}
- * functions. For @p{dim=1} this
+ * <tt>compute_support_points_simple(laplace)</tt>
+ * functions. For <tt>dim=1</tt> this
* function is empty.
*
* This function chooses the
std::vector<Point<dim> > &a) const;
/**
- * For @p{dim=3}. Append the
+ * For <tt>dim=3</tt>. Append the
* support points of all shape
* functions located on bounding
* faces (quads in 3d) to the
*
* Needed by the
* @p compute_support_points_laplace
- * function. For @p{dim=1} and 2
+ * function. For <tt>dim=1</tt> and 2
* this function is empty.
*
* This function chooses the
* equidistant (on the unit cell) support points.
*
* For more details about Qp-mappings, see the `mapping' report at
- * @p{deal.II/doc/reports/mapping_q/index.html} in the `Reports'
+ * <tt>deal.II/doc/reports/mapping_q/index.html</tt> in the `Reports'
* section of `Documentation'.
*
* @author Ralf Hartmann, Guido Kanschat 2000, 2001
/**
* Flag that is set by the
- * @p{fill_fe_[[sub]face]_values}
+ * <tt>fill_fe_[[sub]face]_values</tt>
* function.
*
* If this flag is @p true
typename std::vector<Point<dim> > &normal_vectors) const ;
/**
- * For @p{dim=2,3}. Append the
+ * For <tt>dim=2,3</tt>. Append the
* support points of all shape
* functions located on bounding
* lines to the vector
*
* Needed by the
* @p compute_support_points_laplace
- * function . For @p{dim=1} this
+ * function . For <tt>dim=1</tt> this
* function is empty.
*
* This function is made virtual
std::vector<Point<dim> > &a) const;
/**
- * For @p{dim=3}. Append the
+ * For <tt>dim=3</tt>. Append the
* support points of all shape
* functions located on bounding
* faces (quads in 3d) to the
*
* Needed by the
* @p compute_support_points_laplace
- * function. For @p{dim=1} and
- * @p{dim=2} this function is
+ * function. For <tt>dim=1</tt> and
+ * <tt>dim=2</tt> this function is
* empty.
*
* This function is made virtual
/**
* This function is needed by the
- * constructor of @p{MappingQ<dim>}
- * for @p{dim=} 2 and 3.
+ * constructor of <tt>MappingQ<dim></tt>
+ * for <tt>dim=</tt> 2 and 3.
*
- * For @p{degree<4} this function
+ * For <tt>degree<4</tt> this function
* sets the
* @p laplace_on_quad_vector to
* the hardcoded data. For
- * @p{degree>=4} and MappingQ<2>
+ * <tt>degree>=4</tt> and MappingQ<2>
* this vector is computed.
*
* For the definition of the
/**
* This function is needed by the
- * constructor of @p{MappingQ<3>}.
+ * constructor of <tt>MappingQ<3></tt>.
*
- * For @p{degree==2} this function
+ * For <tt>degree==2</tt> this function
* sets the
* @p laplace_on_hex_vector to
* the hardcoded data. For
- * @p{degree>2} this vector is
+ * <tt>degree>2</tt> this vector is
* computed.
*
* For the definition of the
/**
* Computes the
- * @p{laplace_on_quad(hex)_vector}.
+ * <tt>laplace_on_quad(hex)_vector</tt>.
*
* Called by the
- * @p{set_laplace_on_quad(hex)_vector}
+ * <tt>set_laplace_on_quad(hex)_vector</tt>
* functions if the data is not
* yet hardcoded.
*
* For the definition of the
- * @p{laplace_on_quad(hex)_vector}
+ * <tt>laplace_on_quad(hex)_vector</tt>
* please refer to equation (8)
* of the `mapping' report.
*/
/**
* Takes a
- * @p{laplace_on_hex(quad)_vector}
+ * <tt>laplace_on_hex(quad)_vector</tt>
* and applies it to the vector
* @p a to compute the inner
* support points as a linear
/**
* Needed by the
* @p laplace_on_quad function
- * (for @p{dim==2}). Filled by the
+ * (for <tt>dim==2</tt>). Filled by the
* constructor.
*
* Sizes:
/**
* Needed by the
* @p laplace_on_hex function
- * (for @p{dim==3}). Filled by the
+ * (for <tt>dim==3</tt>). Filled by the
* constructor.
*
* For the definition of this
/**
* Default value of this flag
- * is @p true. If @p{*this}
+ * is @p true. If <tt>*this</tt>
* is an object of a derived
* class, this flag is set to
* @p false.
* this class or that of the
* derived class, depending on
* whether
- * @p{data.is_mapping_q1_data}
+ * <tt>data.is_mapping_q1_data</tt>
* equals @p true or @p false.
*/
void compute_shapes (const std::vector<Point<dim> > &unit_points,
/**
* Do the computation for the
- * @p{fill_*} functions.
+ * <tt>fill_*</tt> functions.
*/
void compute_fill (const typename DoFHandler<dim>::cell_iterator &cell,
const unsigned int npts,
/**
* Do the computation for the
- * @p{fill_*} functions.
+ * <tt>fill_*</tt> functions.
*/
void compute_fill_face (const typename DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no,
* In many cases, the shift vector will also be the solution vector of
* the problem under investigation. If this is not the case (i.e. the
* number of components of the solution variable is not equal to the
- * space dimension, e.g. for scalar problems in @p{dim>1} where the
+ * space dimension, e.g. for scalar problems in <tt>dim>1</tt> 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 DoFHandler has to be set up on the
/**
* Constructor. It takes a
- * @p{Vector<double> &} as its
+ * <tt>Vector<double> &</tt> as its
* first argument to specify the
* transformation of the whole
* problem from the reference to
* of a nonlinear problem.
* Alternatively, the @p Vector
* can be initialized by
- * @p{DoFObjectAccessor::set_dof_values()}.
+ * <tt>DoFObjectAccessor::set_dof_values()</tt>.
*/
MappingQ1Eulerian (const Vector<double> &euler_transform_vectors,
const DoFHandler<dim> &shiftmap_dof_handler);
*
* The object that represent the condition an iterator has to satisfy
* only have to provide an interface that allows to call the
- * evaluation operator, i.e. @p{operator()}. This includes function
- * pointers as well as classes that implement an @p{operator ()}.
+ * evaluation operator, i.e. <tt>operator()</tt>. This includes function
+ * pointers as well as classes that implement an <tt>operator ()</tt>.
*
* An example of a simple valid predicate is the following: given the function
* @verbatim
* const unsigned int subdomain_id;
* };
* @endverbatim
- * Objects like @p{SubdomainEqualTo(3)} can then be used as predicates.
+ * Objects like <tt>SubdomainEqualTo(3)</tt> can then be used as predicates.
*
* Since whenever a predicate is evaluated it is checked that the
* iterator checked is actually valid (i.e. not past the end), no
* however, a value is given to the constructor, that value has either
* to be past the end, or has to satisfy the predicate. For example,
* if the predicate only evaluates to true if the level of an object
- * is equal to three, then @p{tria.begin_active(3)} would be a valid
- * choice while @p{tria.begin()} would not since the latter also
+ * is equal to three, then <tt>tria.begin_active(3)</tt> would be a valid
+ * choice while <tt>tria.begin()</tt> would not since the latter also
* returns iterators to non-active cells which always start at level
* 0.
*
* 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
- * iterator). Like the @p{operator=} they return the resulting value
+ * iterator). Like the <tt>operator=</tt> they return the resulting value
* of the filtered iterator.
*
*
* Since comparison between filtered and unfiltered iterators is
* 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
+ * <tt>Triangulation<dim>::active_cell_iterator</tt> since it is unchanged
* and its value does not depend on the filter.
*
* @author Wolfgang Bangerth, 2002
* List of numbers which
* denotes which face is opposite
* to a given face. In 1d, this
- * list is @p{{1,0}}, in 2d @p{{2, 3, 0, 1}},
- * in 3d @p{{1, 0, 4, 5, 2, 3}}.
+ * list is <tt>{1,0</tt>}, in 2d <tt>{2, 3, 0, 1</tt>},
+ * in 3d <tt>{1, 0, 4, 5, 2, 3</tt>}.
*/
static const unsigned int opposite_face[faces_per_cell];
* written in OpenDX format, each
* entry in this field contains
* the number of a vertex in
- * @p{deal.II} that corresponds
+ * <tt>deal.II</tt> that corresponds
* to the DX numbering at this
* location.
*
* what you want. You can inquire
* about the face orientation
* using the
- * @p{cell->face_orientation}
+ * <tt>cell->face_orientation</tt>
* function, and the function to
* ask for a neighbor's cell
* behind a given face and
* subface is
- * @p{cell->neighbor_child_on_subface}.
+ * <tt>cell->neighbor_child_on_subface</tt>.
* The latter function, in
* contrast to the present one,
* also takes into account the
static Point<dimension> unit_cell_vertex (const unsigned int vertex);
/**
- * Report, for @p{vertex=0,1} the
+ * Report, for <tt>vertex=0,1</tt> the
* indices of the two vertices
* adjacent to the line with
* index @p line among the lines
* children, return any one of
* their indices. The result is
* always less than
- * @p{GeometryInfo<dimension>::children_per_cell}.
+ * <tt>GeometryInfo<dimension>::children_per_cell</tt>.
*
* The order of child cells is
* described the documentation of
* dimension, we provide a useless
* 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}.
+ * <tt>for (i=0; i<vertices_per_face; ++i)</tt>,
+ * at least if @p i is an <tt>unsigned int</tt>.
*/
static const unsigned int vertices_per_face = 0;
* dimension, we provide a useless
* 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}.
+ * <tt>for (i=0; i<vertices_per_face; ++i)</tt>,
+ * at least if @p i is an <tt>unsigned int</tt>.
*/
static const unsigned int vertices_per_face = 1;
* List of numbers which
* denotes which face is opposite
* to a given face. In 1d, this
- * list is @p{{1,0}}, in 2d @p{{2, 3, 0, 1}},
- * in 3d @p{{1, 0, 4, 5, 2, 3}}.
+ * list is <tt>{1,0</tt>}, in 2d <tt>{2, 3, 0, 1</tt>},
+ * in 3d <tt>{1, 0, 4, 5, 2, 3</tt>}.
*/
static const unsigned int opposite_face[faces_per_cell];
* written in OpenDX format, each
* entry in this field contains
* the number of a vertex in
- * @p{deal.II} that corresponds
+ * <tt>deal.II</tt> that corresponds
* to the DX numbering at this
* location.
*
* you want. You can inquire
* about the face orientation
* using the
- * @p{cell->face_orientation}
+ * <tt>cell->face_orientation</tt>
* function, and the function to
* ask for a neighbor's cell
* behind a given face and
* subface is
- * @p{cell->neighbor_child_on_subface}.
+ * <tt>cell->neighbor_child_on_subface</tt>.
* The latter function, in
* contrast to the present one,
* also takes into account the
static Point<1> unit_cell_vertex (const unsigned int vertex);
/**
- * Report, for @p{vertex=0,1} the
+ * Report, for <tt>vertex=0,1</tt> the
* indices of the two vertices
* adjacent to the line with
* index @p line among the lines
* children, return any one of
* their indices. The result is
* always less than
- * @p{GeometryInfo<dim>::children_per_cell}.
+ * <tt>GeometryInfo<dim>::children_per_cell</tt>.
*
* The order of child cells is
* described the documentation of
* dimension, we provide a useless
* 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}.
+ * <tt>for (i=0; i<vertices_per_face; ++i)</tt>,
+ * at least if @p i is an <tt>unsigned int</tt>.
*/
static const unsigned int vertices_per_face = 2;
* List of numbers which
* denotes which face is opposite
* to a given face. In 1d, this
- * list is @p{{1,0}}, in 2d @p{{2, 3, 0, 1}},
- * in 3d @p{{1, 0, 4, 5, 2, 3}}.
+ * list is <tt>{1,0</tt>}, in 2d <tt>{2, 3, 0, 1</tt>},
+ * in 3d <tt>{1, 0, 4, 5, 2, 3</tt>}.
*/
static const unsigned int opposite_face[faces_per_cell];
* written in OpenDX format, each
* entry in this field contains
* the number of a vertex in
- * @p{deal.II} that corresponds
+ * <tt>deal.II</tt> that corresponds
* to the DX numbering at this
* location.
*
* you want. You can inquire
* about the face orientation
* using the
- * @p{cell->face_orientation}
+ * <tt>cell->face_orientation</tt>
* function, and the function to
* ask for a neighbor's cell
* behind a given face and
* subface is
- * @p{cell->neighbor_child_on_subface}.
+ * <tt>cell->neighbor_child_on_subface</tt>.
* The latter function, in
* contrast to the present one,
* also takes into account the
static Point<2> unit_cell_vertex (const unsigned int i);
/**
- * Report, for @p{vertex=0,1} the
+ * Report, for <tt>vertex=0,1</tt> the
* indices of the two vertices
* adjacent to the line with
* index @p line among the lines
* children, return any one of
* their indices. The result is
* always less than
- * @p{GeometryInfo<dim>::children_per_cell}.
+ * <tt>GeometryInfo<dim>::children_per_cell</tt>.
*
* The order of child cells is
* described the documentation of
* dimension, we provide a useless
* 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}.
+ * <tt>for (i=0; i<vertices_per_face; ++i)</tt>,
+ * at least if @p i is an <tt>unsigned int</tt>.
*/
static const unsigned int vertices_per_face = 4;
* List of numbers which
* denotes which face is opposite
* to a given face. In 1d, this
- * list is @p{{1,0}}, in 2d @p{{2, 3, 0, 1}},
- * in 3d @p{{1, 0, 4, 5, 2, 3}}.
+ * list is <tt>{1,0</tt>}, in 2d <tt>{2, 3, 0, 1</tt>},
+ * in 3d <tt>{1, 0, 4, 5, 2, 3</tt>}.
*/
static const unsigned int opposite_face[faces_per_cell];
* written in OpenDX format, each
* entry in this field contains
* the number of a vertex in
- * @p{deal.II} that corresponds
+ * <tt>deal.II</tt> that corresponds
* to the DX numbering at this
* location.
*
* you want. You can inquire
* about the face orientation
* using the
- * @p{cell->face_orientation}
+ * <tt>cell->face_orientation</tt>
* function, and the function to
* ask for a neighbor's cell
* behind a given face and
* subface is
- * @p{cell->neighbor_child_on_subface}.
+ * <tt>cell->neighbor_child_on_subface</tt>.
* The latter function, in contrast
* to the present one, also takes
* into account the actual
static Point<3> unit_cell_vertex (const unsigned int i);
/**
- * Report, for @p{vertex=0,1} the
+ * Report, for <tt>vertex=0,1</tt> the
* indices of the two vertices
* adjacent to the line with
* index @p line among the lines
* children, return any one of
* their indices. The result is
* always less than
- * @p{GeometryInfo<dim>::children_per_cell}.
+ * <tt>GeometryInfo<dim>::children_per_cell</tt>.
*
* The order of child cells is
* described the documentation of
* dimension, we provide a useless
* 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}.
+ * <tt>for (i=0; i<vertices_per_face; ++i)</tt>,
+ * at least if @p i is an <tt>unsigned int</tt>.
*/
static const unsigned int vertices_per_face = 8;
* @p repetitions cells. Thus,
* the number of cells filling
* the given volume is
- * @p{repetitions^d}.
+ * <tt>repetitions^d</tt>.
*/
template <int dim>
static void subdivided_hyper_cube (Triangulation<dim> &tria,
* diagonally opposite corner
* points @p p1 and @p p2. In
* dimension @p i,
- * @p{repetitions[i]} cells are
+ * <tt>repetitions[i]</tt> cells are
* generated.
*
* To get cells with an aspect
/**
* Create a cylinder around the
* x-axis. The cylinder extends
- * from @p{x=-half_length} to
- * @p{x=+half_length} and its
+ * from <tt>x=-half_length</tt> to
+ * <tt>x=+half_length</tt> and its
* projection into the
* @p yz-plane is a circle of
* radius @p radius.
* Initialize the given
* triangulation with a hyper-L
* consisting of exactly
- * @p{2^dim-1} cells. See the
+ * <tt>2^dim-1</tt> cells. See the
* general documentation for a
* description of the
* L-region. The limits default
* Initialize the given
* Triangulation with a hypercube
* with a slit. The slit goes
- * from @p{(x=0,y=-1)} to
- * @p{(0,0)} in 2d.
+ * from <tt>(x=0,y=-1)</tt> to
+ * <tt>(0,0)</tt> in 2d.
*
* The triangulation needs to be
* void upon calling this
* 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.
*
- * <li> @p{DB mesh} format: this format is used by the @p BAMG mesh
+ * <li> <tt>DB mesh</tt> 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
* | | |
* 0---1---2
* @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 Triangulation
+ * may be characterised by the vertex numbers <tt>(0 1 4 3)</tt> and
+ * <tt>(1 2 5 4)</tt>, since the middle line would get the direction <tt>1->4</tt>
+ * when viewed from both cells. The numbering <tt>(0 1 4 3)</tt> and
+ * <tt>(5 4 1 2)</tt> would not be allowed, since the left quad would give the
+ * common line the direction <tt>1->4</tt>, while the right one would want
+ * to use <tt>4->1</tt>, 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
- * indices @p{(4 1 2 5)}, since then it would have to rotate by one
+ * indices <tt>(4 1 2 5)</tt>, since then it would have to rotate by one
* element or three, the decision which to take is not yet
* implemented.
*
* dimensions, where faces and lines have orientations that need to be
* taken care of.
*
- * For this reason, the @p{read_*} functions of this class that read
+ * For this reason, the <tt>read_*</tt> functions of this class that read
* 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
/**
* Skip lines of comment that
* start with the indicated
- * character (e.g. @p{#})
+ * character (e.g. <tt>#</tt>)
* following the point where the
* given input stream presently
* is. After the call to this
* Remove vertices that are not
* referenced by any of the
* cells. This function is called
- * by all @p{read_*} functions to
+ * by all <tt>read_*</tt> functions to
* eliminate vertices that are
* listed in the input files but
* are not used by the cells in
* they might be lengthy.
*
* This function is called by all
- * @p{read_*} functions as the
+ * <tt>read_*</tt> functions as the
* triangulation class requires
* them to be called with used
* vertices only. This is so,
/**
* This function can write the
* raw cell data objects created
- * by the @p{read_*} functions in
+ * by the <tt>read_*</tt> functions in
* Gnuplot format to a
* stream. This is sometimes
* handy if one would like to see
*
* The format of the cell
* number written is
- * @p{level.index}, or simply
+ * <tt>level.index</tt>, or simply
* @p index, depending on the
* value of the following flag.
*/
* flag, then the value of this
* flag determines whether the
* format shall be
- * @p{level.index}, or simply
+ * <tt>level.index</tt>, or simply
* @p index. If @p true, the
* first format is
* taken. Default is @p true.
* 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_...}
+ * Available output formats can be found in the functions with names <tt>write_...</tt>
*
* @sect3{Usage}
* Usage is simple: either you use the direct form
* ofstream output_file("some_filename" + GridOut::default_suffix(output_format));
* GridOut().write (tria, output_file, output_format);
* @endverbatim
- * The function @p{get_output_format_names()} provides a list of possible names of
+ * The function <tt>get_output_format_names()</tt> provides a list of possible names of
* output formats in a string that is understandable by the ParameterHandler class.
*
* 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
+ * one of its <tt>write_*</tt> functions. This looks like as if the respective function
* 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
* 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
- * be done by calling @p{grid_out.set_flags (GridOutFlags::Ucd());}, since the
+ * be done by calling <tt>grid_out.set_flags (GridOutFlags::Ucd());</tt>, since the
* default constructor of each of the flags structures sets the parameters
* to their initial values.
*
* explicitly. This is useful,
* if you want to re-read the
* grid later on, since
- * @p{deal.II} sets the boundary
+ * <tt>deal.II</tt> sets the boundary
* indicator to zero by default;
* therefore, to obtain the
* same triangulation as before,
* Write data and grid to @p out according
* to the given data format. This function
* simply calls the appropriate
- * @p{write_*} function.
+ * <tt>write_*</tt> function.
*/
template <int dim>
void write (const Triangulation<dim> &tria,
* usually has. At present the following
* formats are defined:
* <ul>
- * <li> @p OpenDX: @p{.dx}
- * <li> @p gnuplot: @p{.gnuplot}
- * <li> @p ucd: @p{.inp}
- * <li> @p eps: @p{.eps}.
+ * <li> @p OpenDX: <tt>.dx</tt>
+ * <li> @p gnuplot: <tt>.gnuplot</tt>
+ * <li> @p ucd: <tt>.inp</tt>
+ * <li> @p eps: <tt>.eps</tt>.
* </ul>
*
* Since this function does not need data
* To get a list of presently available
* format names, e.g. to give it to the
* ParameterHandler class, use the
- * function @p{get_output_format_names ()}.
+ * function <tt>get_output_format_names ()</tt>.
*/
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{`|'})
+ * separated by vertical bar signs (<tt>`|'</tt>)
* as used by the ParameterHandler
* classes.
*/
* This function unfortunately can not
* be included in the regular @p write_ucd
* function, since it needs special
- * treatment for the case @p{dim==1}, in
+ * treatment for the case <tt>dim==1</tt>, in
* which case the face iterators are
- * @p{void*}'s and lack the member functions
+ * <tt>void*</tt>'s and lack the member functions
* which are called. We would not actually
* call these functions, but the compiler
* would complain anyway when compiling
- * the function for @p{dim==1}. Bad luck.
+ * the function for <tt>dim==1</tt>. Bad luck.
*/
template <int dim>
void write_ucd_faces (const Triangulation<dim> &tria,
* triangulation which have a boundary
* indicator not equal to zero. Only
* these faces are explicitly printed
- * in the @p{write_*} functions;
+ * in the <tt>write_*</tt> functions;
* all faces with indicator 255 are
* interior ones and an indicator with
* value zero for faces at the boundary
* This class provides several function that flag certain cells for
* coarsening or refinement based on a vector of ``error''
* indicators and some selection algorithm. The central function is
- * @p{refine (const Vector &criterion, const double threshold)}:
+ * <tt>refine (const Vector &criterion, const double threshold)</tt>:
* it takes a vector of values, one per active cell,
* which denote the criterion according to which the triangulation
* is to be refined. It marks all cells for which the criterion is
* greater than the threshold being given as the second
* argument. Analogously,
- * @p{coarsen (const Vector &criterion, const double threshold)}
+ * <tt>coarsen (const Vector &criterion, const double threshold)</tt>
* flags those cells for
* coarsening for which the criterion is less than the threshold.
*
* 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
- * @p{fraction times n_active_cells} highest criterion. For example, if
+ * <tt>fraction times n_active_cells</tt> highest criterion. For example, if
* 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
* 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 <tt>C++</tt> standard
* library, which takes only linear time in the number of elements, rather
- * than @p{N log N} for sorting all values.
+ * than <tt>N log N</tt> for sorting all values.
*
* A typical value for the fraction of cells to be refined is 0.3.
* However, for singular functions or singular error functionals, you may
* refinement, call
* @p execute_coarsening_and_refinement.
*
- * @p{*_fraction} shall be a
+ * <tt>*_fraction</tt> shall be a
* values between zero and one.
*
* Refer to the general doc of
* | | |
* 0---1---2
* @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.
+ * may be characterised by the vertex numbers <tt>(0 1 4 3)</tt> and
+ * <tt>(1 2 5 4)</tt>, since the middle line would get the direction <tt>1->4</tt>
+ * when viewed from both cells. The numbering <tt>(0 1 4 3)</tt> and
+ * <tt>(5 4 1 2)</tt> would not be allowed, since the left quad would give the
+ * common line the direction <tt>1->4</tt>, while the right one would want
+ * to use <tt>4->1</tt>, leading to an ambiguity.
*
* As a sidenote, we remark that if one adopts the idea that having
* directions of faces is useful, then the orientation of the four
* ^ ^ \ |
* 0->-1------2
* @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
+ * (This could for example be done by using the indices <tt>(0 1 4 3)</tt>, <tt>(3 4 7 6)</tt>,
+ * <tt>(6 7 10 9)</tt> for the three cells). Now, you will not find a way of giving
* indices for the right cells, without introducing either ambiguity for
* one line or other, or without violating that within each cells, there must be
* one vertex from which both lines are directed away and the opposite one to
*
* 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)}:
+ * the top left cell by <tt>(9 6 7 10)</tt>:
* @verbatim
* 9->-10-----11
* v v / |
* @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)}
+ * cell (the one which we could order as <tt>(9 6 7 10)</tt>
* above). However, since opposite lines have to have the same
* direction, this in turn would force us to rotate the cell left of
* it, and then the one left to that, and so on until we reach the
* @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
+ * vertex indices <tt>0 1 2 3</tt> and <tt>6 7 4 5</tt>. Then, if we follow this
* orientation, the grid after creating the lines for these two cells
* would look like this:
* @verbatim
* where node N has as many children as there are possible
* orientations of node N+1 (in two space dimensions, there are four
* orientations in which each cell can be constructed from its four
- * vertices; for example, if the vertex indicaes are @p{(0 1 2 3)},
- * then the four possibilities would be @p{(0 1 2 3)}, @p{(1 2 3 0)},
- * @p{(2 3 0 1)}, and @p{(3 0 1 2)}). When adding one cell after the
+ * vertices; for example, if the vertex indicaes are <tt>(0 1 2 3)</tt>,
+ * then the four possibilities would be <tt>(0 1 2 3)</tt>, <tt>(1 2 3 0)</tt>,
+ * <tt>(2 3 0 1)</tt>, and <tt>(3 0 1 2)</tt>). When adding one cell after the
* other, we traverse this tree in a depth-first (pre-order)
* fashion. When we encounter that one path from the root (cell 0) to
* a leaf (the last cell) is not allowed (i.e. that the orientations
* stop following all paths below this point and track back
* immediately.
*
- * Nevertheless, it is already obvious that the tree has @p{4**N}
+ * Nevertheless, it is already obvious that the tree has <tt>4**N</tt>
* leaves in two space dimensions, since each of the N cells can be
* added in four orientations. Most of these nodes can be discarded
* rapidly, since firstly the orientation of the first cell is
* that has already been added, then there are already only two
* possible orientations left, so the total number of checks we have
* to make until we find a valid way is significantly smaller than
- * @p{4**N}. However, the algorithm is still exponential in time and
+ * <tt>4**N</tt>. However, the algorithm is still exponential in time and
* linear in memory (we only have to store the information for the
* present path in form of a stack of orientations of cells that have
* already been added).
* 0-----1-----2-----3
* @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
+ * described the first cell 0 by the vertex numbers <tt>2 3 7 6</tt>, and
+ * cell 5 by <tt>15 14 10 11</tt>, and assume that cells 1, 2, 3, and 4 are
* numbered such that 5 can be added in initial rotation. All other
* cells are numbered in the usual way, i.e. starting at the bottom
* left and counting counterclockwise. Given this description 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
- * Triangulation@p{<dim>::create_triangulation} function.
+ * Triangulation<tt><dim>::create_triangulation</tt> function.
*
* @author Wolfgang Bangerth, 2000, Michael Anderson 2003
*/
* function-like syntax, i.e. the
* predicate is either an object
* of a type that has an
- * @p{operator()}, or it is a
+ * <tt>operator()</tt>, or it is a
* pointer to the function. In
* either case, argument and
* return value have to be of
- * type @p{Point<dim>}.
+ * type <tt>Point<dim></tt>.
*/
template <int dim, typename Predicate>
static
* cell on the coarse grid, and
* then recursively checking its
* sibling cells. The complexity
- * is thus @p{O(M+log N)} where
+ * is thus <tt>O(M+log N)</tt> where
* @p M is the number of coarse
* grid cells, and @p N the
* total number of cells.
* values between zero and
* @p n_partitions-1. You can access the
* subdomain id of a cell by using
- * @p{cell->subdomain_id()}.
+ * <tt>cell->subdomain_id()</tt>.
*
* This function will generate an error
* if METIS is not installed unless
/**
* For each active cell, return in the
* output array to which subdomain (as
- * given by the @p{cell->subdomain_id()}
+ * given by the <tt>cell->subdomain_id()</tt>
* function) it belongs. The output array
* is supposed to have the right size
* already when calling this function.
* This class provides a map between two grids which are derived from
* the same coarse grid. For each cell iterator of the source map, it provides
* the respective cell iterator on the destination map, through its
- * @p{operator []}.
+ * <tt>operator []</tt>.
*
* Usually, the two grids will be refined differently. Then, the value
* returned for an iterator on the source grid will be either:
* offering iterator functions and some minor additional requirements is
* simple.
*
- * Note that this class could in principle be based on the C++ @p{map<Key,Value>}
+ * Note that this class could in principle be based on the C++ <tt>map<Key,Value></tt>
* data type. Instead, it uses another data format which is more effective both
* in terms of computing time for access as well as with regard to memory
* consumpion.
* @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
+ * <tt>InterGridMap<DoFHandler,2></tt>, i.e. the dimension is given explicitly and
* no dimension is attributed to the first parameter, which here is
* DoFHandler (and could equally well be Triangulation or MGDoFHandler).
*
* 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
+ * Triangulation<tt><dim>::clear ()</tt> 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()}.
+ * used withing <tt>restore()</tt>.
*
* @author Wolfgang Bangerth, 1999
*/
* underlying triangulation is
* not empty, i.e. it will only
* succeed if this object is
- * newly created or @p{clear()}
+ * newly created or <tt>clear()</tt>
* was called on it before.
*
* Repeatedly calls the
- * @p{restore(unsigned int)}
+ * <tt>restore(unsigned int)</tt>
* function in a loop over all
* refinement steps.
*/
* is in just the state it were
* if restore would have been
* called from
- * @p{step=0...step_no-1} before.
+ * <tt>step=0...step_no-1</tt> before.
*/
void restore (const unsigned int step_no);
/**
* Reads all refine and coarsen flags
* that previously were written by
- * @p{write_flags(...)}. This is especially
+ * <tt>write_flags(...)</tt>. This is especially
* useful for rebuilding the triangulation
* after the end or breakdown of a program
* and its restart.
/**
* Structure which is passed to the
- * Triangulation@p{<dim>::create_triangulation} function. It
+ * Triangulation<tt><dim>::create_triangulation</tt> 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 Triangulation@p{<dim>::create_triangulation}
+ * Structure to be passed to the Triangulation<tt><dim>::create_triangulation</tt>
* function to describe boundary information.
*
* This structure is the same for all dimensions, since we use an input
* This function checks whether the vectors
* which may not be used in a given
* dimension are really empty. I.e.,
- * whether the @p{boundary_*} arrays are
+ * whether the <tt>boundary_*</tt> arrays are
* empty when in one space dimension
* and whether the @p boundary_quads
* array is empty when in two 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 lines member variable of a <tt>Triangulation<1></tt> object. An
* @p active_line_iterator only operates on the active lines.
* @p raw_line_iterator objects operate on all lines, used or not.
*
* @endverbatim
*
* 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
+ * <tt>Triangulation<1></tt>, the @p quad_iterators are declared as
+ * <tt>void *</tt>. Thus these types exist, but are useless and will
* certainly make any involuntary use visible. The same holds
* for hexahedron iterators.
*
* 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 lines member variable of a <tt>Triangulation<2></tt> 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
* @p active_quad_iterator are declared.
*
* 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
+ * <tt>Triangulation<[12]></tt>, the @p hex_iterators are declared as
+ * <tt>void *</tt>. 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:
* These are the declararions for the 3D case only.
*
* For the declarations of the data types, more or less the same holds
- * as for lower dimensions (see @p{TriaDimensionInfo<[12]>}). The
+ * as for lower dimensions (see <tt>TriaDimensionInfo<[12]></tt>). The
* dimension specific data types are here, since we are in three dimensions:
* @verbatim
* typedef raw_hex_iterator raw_cell_iterator;
* dimensions).
*
* <li> @p raw_quad_iterator: loop over all quads, used or not (declared only
- * for @p{dim>=2}).
+ * for <tt>dim>=2</tt>).
*
* <li> @p quad_iterator: loop over all quads (declared only for @p dim>=2).
*
* by providing a list of vertices and a list of cells. Each such cell
* consists of a vector storing the indices of the vertices of this cell
* in the vertex list. To see how this works, you can take a look at the
- * GridIn@p{<dim>::read_*} functions. The appropriate function to be
- * called is @p{Triangulation<dim>::create_triangulation ()}.
+ * GridIn<tt><dim>::read_*</tt> functions. The appropriate function to be
+ * called is <tt>Triangulation<dim>::create_triangulation ()</tt>.
*
* Creating the hierarchical information needed for this
* library from cells storing only vertex information can be
* the vertex numbering within cells. They do not only hold for
* the data read from an UCD or any other input file, but also
* for the data passed to the
- * @p{Triangulation<dim>::create_triangulation ()}
+ * <tt>Triangulation<dim>::create_triangulation ()</tt>
* function. See the documentation for the GridIn class
* for more details on this, and above all to the
* GridReordering class that explains many of the
* interface between regions of different materials.
*
* Finally, there is a special function for folks who like bad grids:
- * @p{Triangulation<dim>::distort_random}. It moves all the vertices in the
+ * <tt>Triangulation<dim>::distort_random</tt>. It moves all the vertices in the
* grid a bit around by a random value, leaving behind a distorted mesh.
* Note that you should apply this function to the final mesh, since
* refinement smoothes the mesh a bit.
* 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
* 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
+ * function call <tt>i->set_refine_flag()</tt> 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
* 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.
+ * <tt>i->set_coarsen_flag</tt> 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
* 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.
+ * <tt>execute_*</tt> stand for @p execute_coarsening_and_refinement.
*
* For the purpose of smoothing, the
* Triangulation constructor takes an argument specifying whether a
- * smoothing step shall be performed on the grid each time @p{execute_*}
+ * smoothing step shall be performed on the grid each time <tt>execute_*</tt>
* 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
- * cases. If switched on, calling @p{execute_*} results in
+ * cases. If switched on, calling <tt>execute_*</tt> results in
* flagging additional cells for refinement to avoid
* vertices as the ones mentioned. The algorithms for both regularization
* and smoothing of triangulations are described below in the section on
* technical issues. The reason why this parameter must be given to the
- * constructor rather than to @p{execute_*} is that it would result
- * in algorithmic problems if you called @p{execute_*} once without
+ * constructor rather than to <tt>execute_*</tt> is that it would result
+ * in algorithmic problems if you called <tt>execute_*</tt> once without
* and once with smoothing, since then in some refinement steps would need
* to be refined twice.
*
* 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
+ * bitwise by the constants defined in the <tt>enum MeshSmoothing</tt>. The meaning
* of these constants is explained in the following:
* <ul>
* <li> @p limit_level_difference_at_vertices:
* name of the flag may indicate. However, no better name came to mind to
* the author by now.
*
- * <li> @p{eliminate_refined_*_islands}:
+ * <li> <tt>eliminate_refined_*_islands</tt>:
* 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
* adds additional cells, but their number may be depending on the smoothing
* level.
*
- * There actually are two sets of @p{save_*_flags} and @p{load_*_flags} functions.
+ * There actually are two sets of <tt>save_*_flags</tt> and <tt>load_*_flags</tt> functions.
* One takes a stream as argument and reads/writes the information from/to the
* stream, thus enabling storing flags to files. The other set takes an
- * argument of type @p{vector<bool>}. This enables the user to temporarily store
+ * argument of type <tt>vector<bool></tt>. This enables the user to temporarily store
* some flags, e.g. if another function needs them, and restore them
* afterwards.
*
*
* As for the refinement and coarsening flags, there exist two versions of these
* functions, one which reads/writes from a stream and one which does so from
- * a @p{vector<bool>}. The latter is used to store flags temporarily, while the
+ * a <tt>vector<bool></tt>. The latter is used to store flags temporarily, while the
* first is used to store them in a file.
*
* It is convention to clear the user flags using the
- * @p{Triangulation<>::clear_user_flags()} function before usage, since it is
+ * <tt>Triangulation<>::clear_user_flags()</tt> function before usage, since it is
* often necessary to use the flags in more than one function consecutively and
* is then error prone to dedicate one of these to clear the flags.
*
* It is recommended that a functions using the flags states so in its
* documentation.
*
- * There is another set of user data, namely a @p{void *}, for each
+ * There is another set of user data, namely a <tt>void *</tt>, for each
* 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
+ * functions <tt>user_pointer()</tt>, <tt>clear_user_pointer()</tt> and
+ * <tt>set_user_pointer(p)</tt> in the accessor classes. These pointers are
* 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
* placed. The boundary indicator of the face will be used to
* 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>}):
+ * (let @p Ball be a class derived from Boundary<tt><2></tt>):
*
* @verbatim
* void main () {
* will need refinement, we will need additional loops of regularization
* and smoothing over all cells until nothing changes any more.
*
- * <li> @p{eliminate_refined_*_islands}:
+ * <li> <tt>eliminate_refined_*_islands</tt>:
* 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
* preserved upon refinement.
*
* Further we define, that child lines have the same direction as their parent,
- * i.e. that @p{subline(0).vertex(0)==line.vertex(0)} and
- * @p{subline(1).vertex(1)==line.vertex(1)}. This also implies, that the
- * first subline (@p{subline(0)}) is the one at vertex(0) of the old line.
+ * i.e. that <tt>subline(0).vertex(0)==line.vertex(0)</tt> and
+ * <tt>subline(1).vertex(1)==line.vertex(1)</tt>. This also implies, that the
+ * first subline (<tt>subline(0)</tt>) is the one at vertex(0) of the old line.
*
* Similarly we define, that the four children of a quad are adjacent to the
* vertex with the same number of the old quad.
* *-------------->x
* @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)}.
+ * coordinates <tt>(1,0)</tt>, vertex 2 at <tt>(1,1)</tt> and vertex 3 at <tt>(0,1)</tt>.
*
*
* @sect3{Implementation conventions for three spatial dimensions}
* which case the lines that make up a cell would have reverted
* 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
+ * orientation by calling <tt>cell->face_orientation(face_no)</tt>: if
* 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
* avoid having to query the standard orientation of the faces of
* the two cells every time in such cases, you should use a function
* call like
- * @p{cell->neighbor_child_on_subface(face_no,subface_no)}, which
+ * <tt>cell->neighbor_child_on_subface(face_no,subface_no)</tt>, which
* returns the correct result both in 2d (where face orientations
* are immaterial) and 3d (where it is necessary to query the face
* orientation and possibly swap the result of
- * @p{GeometryInfo<3>::child_cell_on_face}). In general, the use of
- * @p{GeometryInfo<3>::child_cell_on_face} is best avoided due to
+ * <tt>GeometryInfo<3>::child_cell_on_face</tt>). In general, the use of
+ * <tt>GeometryInfo<3>::child_cell_on_face</tt> is best avoided due to
* these problems.
*
* @sect4{Coordinate systems}
* *------>x 0-------1 0-------1
* @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)}
+ * unfortunate, since the vertices 0 through 3 have the coordinates <tt>(x,0,z)</tt>
* 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.
+ * <tt>(x,y,0)</tt>. However, the vertex numbering was historically chosen as shown.
*
* By the convention laid down as above, the vertices have the following
* coordinates:
* <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)}.
+ * <li> Vertex 0: <tt>(0,0,0)</tt>;
+ * <li> Vertex 1: <tt>(1,0,0)</tt>;
+ * <li> Vertex 2: <tt>(1,0,1)</tt>;
+ * <li> Vertex 3: <tt>(0,0,1)</tt>;
+ * <li> Vertex 4: <tt>(0,1,0)</tt>;
+ * <li> Vertex 5: <tt>(1,1,0)</tt>;
+ * <li> Vertex 6: <tt>(1,1,1)</tt>;
+ * <li> Vertex 7: <tt>(0,1,1)</tt>.
* </ul>
*
*
* refinement and is dangerous
* afterwards. Removal of a
* boundary object is done by
- * @p{set_boundary(number)}, which
+ * <tt>set_boundary(number)</tt>, which
* uses the default argument of this
* function and replaces the boundary
* approximation by a piecewise
* Create a triangulation from a
* list of vertices and a list of
* cells, each of the latter
- * being a list of @p{1<<dim}
+ * being a list of <tt>1<<dim</tt>
* vertex indices. The
* triangulation must be empty
* upon calling this function and
* active lines adjacent to this
* vertex. Note that @p factor
* should obviously be well below
- * @p{0.5}.
+ * <tt>0.5</tt>.
*
* If @p keep_boundary is set to
* @p true (which is the
* Refine all cells @p times
* times, by alternatingly
* calling
- * @p{set_all_refine_flags()}
+ * <tt>set_all_refine_flags()</tt>
* and
- * @p{execute_coarsening_and_refinement()}.
+ * <tt>execute_coarsening_and_refinement()</tt>.
* This function actually starts
* the refinement process, so
* you have no way to store the
* Regarding the refinement
* process it fixes the closure
* of the refinement in
- * @p{dim>=2} (make sure that no
+ * <tt>dim>=2</tt> (make sure that no
* two cells are adjacent with a
* refinement level differing
* with more than one), etc. It
* Return an iterator which is the first
* iterator not on level. If @p level is
* the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
cell_iterator end (const unsigned int level) const;
* Return a raw iterator which is the first
* iterator not on level. If @p level is
* the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
raw_cell_iterator end_raw (const unsigned int level) const;
* Return an active iterator which is the
* first iterator not on level. If @p level
* is the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
active_cell_iterator end_active (const unsigned int level) const;
* Return an iterator which is the first
* iterator not on level. If @p level is
* the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
face_iterator end_face (const unsigned int level) const;
* Return a raw iterator which is the first
* iterator not on level. If @p level is
* the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
raw_face_iterator end_raw_face (const unsigned int level) const;
* Return an active iterator which is the
* first iterator not on level. If @p level
* is the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
active_face_iterator end_active_face (const unsigned int level) const;
* Return an iterator which is the first
* iterator not on level. If @p level is
* the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
line_iterator end_line (const unsigned int level) const;
* Return a raw iterator which is the first
* iterator not on level. If @p level is
* the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
raw_line_iterator end_raw_line (const unsigned int level) const;
* Return an active iterator which is the
* first iterator not on level. If @p level
* is the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
active_line_iterator end_active_line (const unsigned int level) const;
* Return an iterator which is the first
* iterator not on level. If @p level is
* the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
quad_iterator end_quad (const unsigned int level) const;
* Return a raw iterator which is the first
* iterator not on level. If @p level is
* the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
raw_quad_iterator end_raw_quad (const unsigned int level) const;
* Return an active iterator which is the
* first iterator not on level. If @p level
* is the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
active_quad_iterator end_active_quad (const unsigned int level) const;
* Return an iterator which is the first
* iterator not on level. If @p level is
* the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
hex_iterator end_hex (const unsigned int level) const;
* Return a raw iterator which is the first
* iterator not on level. If @p level is
* the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
raw_hex_iterator end_raw_hex (const unsigned int level) const;
* Return an active iterator which is the
* first iterator not on level. If @p level
* is the last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
active_hex_iterator end_active_hex (const unsigned int level) const;
/**
* Return total number of used cells,
* active or not.
- * Maps to @p{n_lines()} in one space
+ * Maps to <tt>n_lines()</tt> in one space
* dimension and so on.
*/
unsigned int n_cells () const;
/**
* Return total number of used cells,
* active or not, on level @p level.
- * Maps to @p{n_lines(level)} in one space
+ * Maps to <tt>n_lines(level)</tt> in one space
* dimension and so on.
*/
unsigned int n_cells (const unsigned int level) const;
/**
* Return total number of active cells.
- * Maps to @p{n_active_lines()} in one space
+ * Maps to <tt>n_active_lines()</tt> in one space
* dimension and so on.
*/
unsigned int n_active_cells () const;
/**
* Return total number of active cells
* on level @p level.
- * Maps to @p{n_active_lines(level)} in one
+ * Maps to <tt>n_active_lines(level)</tt> in one
* space dimension and so on.
*/
unsigned int n_active_cells (const unsigned int level) const;
* The flags are stored in a binary
* format: for each @p true, a @p 1
* bit is stored, a @p 0 bit otherwise.
- * The bits are stored as @p{unsigned char},
+ * The bits are stored as <tt>unsigned char</tt>,
* thus avoiding endianess. They are
* written to @p out in plain text, thus
* amounting to 3.6 bits per active cell
/**
* Array of pointers pointing to the
- * @p{TriangulationLevel<dim>} objects
+ * <tt>TriangulationLevel<dim></tt> objects
* storing the data on the different
* levels.
*
- * Usage is like @p{levels[3]->quads}.
+ * Usage is like <tt>levels[3]->quads</tt>.
*/
std::vector<TriangulationLevel<dim>*> levels;
/**
* Copy operator. This is normally
* used in a context like
- * @p{iterator a,b; *a=*b;}. Since
+ * <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
/**
* Copy the data of a line. Only
* implemented for
- * @p{celldim==1}.
+ * <tt>celldim==1</tt>.
*/
void set (const Line&) const;
/**
* Copy the data of the given
* quad. Only implemented for
- * @p{celldim==2}.
+ * <tt>celldim==2</tt>.
*/
void set (const Quad&) const;
/**
* Copy the data of the given
* hex. Only implemented for
- * @p{celldim==3}.
+ * <tt>celldim==3</tt>.
*/
void set (const Hexahedron&) const;
* Pointer to the @p ith line
* bounding this object.
*
- * Implemented only for @p{celldim>1}.
+ * Implemented only for <tt>celldim>1</tt>.
*/
TriaIterator<dim,TriaObjectAccessor<1, dim> >
line (const unsigned int i) const;
* the same as that of the
* object.
*
- * Implemented only for @p{celldim>1}.
+ * Implemented only for <tt>celldim>1</tt>.
*/
unsigned int line_index (const unsigned int i) const;
* Pointer to the @p ith quad
* bounding this object.
*
- * Implemented only for @p{celldim>2}.
+ * Implemented only for <tt>celldim>2</tt>.
*/
TriaIterator<dim,TriaObjectAccessor<2, dim> >
quad (const unsigned int i) const;
* quad. The level is naturally
* the same as that of the object.
*
- * Implemented only for @p{celldim>2}.
+ * Implemented only for <tt>celldim>2</tt>.
*/
unsigned int quad_index (const unsigned int i) const;
* style cast operator to
* maintain a minimum of
* typesafety, e.g.
- * @p{A *a=static_cast<A*>(cell->user_pointer());}.
+ * <tt>A *a=static_cast<A*>(cell->user_pointer());</tt>.
*/
void * user_pointer () const;
* dimension less than the
* dimension of a cell, this
* function issues an error if
- * @p{dim<4}.
+ * <tt>dim<4</tt>.
*/
unsigned char boundary_indicator () const;
/**
* Set the boundary indicator.
* The same applies as for the
- * @p{boundary_indicator()}
+ * <tt>boundary_indicator()</tt>
* function.
*
* Caution: Never set the
* the interior of the
* domain. Obviously, the use of
* this function is only possible
- * for @p{dim>celldim}; however,
- * for @p{dim==celldim}, an
+ * for <tt>dim>celldim</tt>; however,
+ * for <tt>dim==celldim</tt>, an
* object is a cell and the
* CellAccessor class
* offers another possibility to
/**
* Copy operator. This is normally
* used in a context like
- * @p{iterator a,b; *a=*b;}. Since
+ * <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
*
* The previous element is
* previous on this level if
- * @p{index>0}. If the present
+ * <tt>index>0</tt>. If the present
* element is the first on this
* level, the last on the
* previous level is accessed.
/**
* Return the index of vertex
- * @p{i=0,1} of a line.
+ * <tt>i=0,1</tt> of a line.
*
* Note that the returned value is only
* the index of the geometrical
* style cast operator to
* maintain a minimum of
* typesafety, e.g.
- * @p{A *a=static_cast<A*>(cell->user_pointer());}.
+ * <tt>A *a=static_cast<A*>(cell->user_pointer());</tt>.
*/
void * user_pointer () const;
* structures with a dimension
* less than the dimension of a
* cell, this function issues an
- * error if @p{dim<2}.
+ * error if <tt>dim<2</tt>.
*
* If the return value is 255,
* then this line is in the
* Set the boundary indicator of
* this line. The same applies
* as for the
- * @p{boundary_indicator()}
+ * <tt>boundary_indicator()</tt>
* function.
*
* You should be careful with
* field, which is always 255 if
* the line is in the interior of
* the domain. Obviously, this is
- * only possible for @p{dim>1};
- * however, for @p{dim==1}, a
+ * only possible for <tt>dim>1</tt>;
+ * however, for <tt>dim==1</tt>, a
* line is a cell and the
* CellAccessor class
* offers another possibility to
/**
* Copy operator. This is normally
* used in a context like
- * @p{iterator a,b; *a=*b;}. Since
+ * <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
*
* The previous element is
* previous on this level if
- * @p{index>0}. If the present
+ * <tt>index>0</tt>. If the present
* element is the first on this
* level, the last on the
* previous level is accessed.
/**
* 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 <tt>dim>=2</tt>
* 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.
* style cast operator to
* maintain a minimum of
* typesafety, e.g.
- * @p{A *a=static_cast<A*>(cell->user_pointer());}.
+ * <tt>A *a=static_cast<A*>(cell->user_pointer());</tt>.
*/
void * user_pointer () const;
* structures with a dimension
* less than the dimension of a
* cell, this function issues an
- * error if @p{dim<3}.
+ * error if <tt>dim<3</tt>.
*
* If the return value is 255,
* then this quad is in the
* Set the boundary indicator of
* this quad. The same applies
* as for the
- * @p{boundary_indicator()}
+ * <tt>boundary_indicator()</tt>
* function.
*
* You should be careful with
* the quad is in the interior of
* the domain. Obviously, this
* function is only useful for
- * @p{dim>2}; however, for
- * @p{dim==2}, a quad is a cell
+ * <tt>dim>2</tt>; however, for
+ * <tt>dim==2</tt>, a quad is a cell
* and the CellAccessor
* class offers another
* possibility to determine
*
* The previous element is
* previous on this level if
- * @p{index>0}. If the present
+ * <tt>index>0</tt>. If the present
* element is the first on this
* level, the last on the
* previous level is accessed.
/**
* Accessor to dereference the data of hexahedra. This accessor is
* used to point to hexs in @p dim space dimensions (only
- * @p{dim>=3} seems reasonable to me). There is a derived class for
+ * <tt>dim>=3</tt> 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.
*
* style cast operator to
* maintain a minimum of
* typesafety, e.g.
- * @p{A *a=static_cast<A*>(cell->user_pointer());}.
+ * <tt>A *a=static_cast<A*>(cell->user_pointer());</tt>.
*/
void * user_pointer () const;
* structures with a dimension
* less than the dimension of a
* cell, this function issues an
- * error if @p{dim<4}.
+ * error if <tt>dim<4</tt>.
*
* If the return value is 255,
* then this line is in the
* Set the boundary indicator of
* this hex. The same applies as
* for the
- * @p{boundary_indicator()}
+ * <tt>boundary_indicator()</tt>
* function.
*
* You should be careful with
* the hex is in the interior of
* the domain. Obviously, the use
* of this function is only
- * possible for @p{dim>3};
- * however, for @p{dim==3}, a hex
+ * possible for <tt>dim>3</tt>;
+ * however, for <tt>dim==3</tt>, a hex
* is a cell and the
* CellAccessor class
* offers another possibility to
/**
* Copy operator. This is normally
* used in a context like
- * @p{iterator a,b; *a=*b;}. Since
+ * <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
*
* The previous element is
* previous on this level if
- * @p{index>0}. If the present
+ * <tt>index>0</tt>. If the present
* element is the first on this
* level, the last on the
* previous level is accessed.
/**
* Return the how-many'th
* neighbor this cell is of
- * @p{cell->neighbor(neighbor)},
+ * <tt>cell->neighbor(neighbor)</tt>,
* i.e. return the number @p n
* such that
- * @p{cell->neighbor(neighbor)->neighbor(n)==cell}. This
+ * <tt>cell->neighbor(neighbor)->neighbor(n)==cell</tt>. This
* function is the right one if
* you want to know how to get
* back from a neighbor to the
* only useful if the neighbor is
* not on a coarser level than
* the present cell
- * (i.e. @p{cell->neighbor(neighbor)->level()}
+ * (i.e. <tt>cell->neighbor(neighbor)->level()</tt>
* needs to be equal to
- * @p{cell->level()}. Use the
+ * <tt>cell->level()</tt>. Use the
* @p neighbor_of_coarser_neighbor
* function in that case.
*/
* pair of numbers, face_no and
* subface_no, with the following
* property:
- * @p{cell->neighbor(neighbor)->face(face_no)->child(subface_no)==cell->face(neighbor)}.
+ * <tt>cell->neighbor(neighbor)->face(face_no)->child(subface_no)==cell->face(neighbor)</tt>.
*
* This function is impossible
- * for @p{dim==1}.
+ * for <tt>dim==1</tt>.
*/
std::pair<unsigned int, unsigned int>
neighbor_of_coarser_neighbor (const unsigned int neighbor) const;
* the normals at the vertices of
* a face of a cell. Thus, there
* are
- * @p{GeometryInfo<dim>::vertices_per_face}
+ * <tt>GeometryInfo<dim>::vertices_per_face</tt>
* normal vectors, that define
* the tangent spaces of the
* boundary at the vertices. Note
* given @p quad are refined, so
* you may want to use the
* information provided by
- * @p{quad->line(i)->child(j)},
- * @p{i=0...3}, @p{j=0,1}.
+ * <tt>quad->line(i)->child(j)</tt>,
+ * <tt>i=0...3</tt>, <tt>j=0,1</tt>.
*
* Because in 2D, this function
* is not needed, it is not made
* vector @p points. It is
* required that this number is a
* square of another integer,
- * i.e. @p{n=points.size()=m*m}. It
+ * i.e. <tt>n=points.size()=m*m</tt>. It
* is the task of the derived
* classes to arrange the points
* such they split the quad into
- * @p{(m+1)(m+1)} approximately
+ * <tt>(m+1)(m+1)</tt> approximately
* equal-sized subquads.
*
* This function is called by the
- * @p{MappingQ<3>} class. This
+ * <tt>MappingQ<3></tt> class. This
* happens each face quad of
* cells in 3d that has got at
* least one boundary face quad.
get_new_point_on_quad (const typename Triangulation<dim>::quad_iterator &quad) const;
/**
- * Gives @p{n=points.size()}
+ * Gives <tt>n=points.size()</tt>
* points that splits the
* p{StraightBoundary} line into
* p{n+1} partitions of equal
std::vector<Point<dim> > &points) const;
/**
- * Gives @p{n=points.size()=m*m}
+ * Gives <tt>n=points.size()=m*m</tt>
* points that splits the
* p{StraightBoundary} quad into
- * @p{(m+1)(m+1)} subquads of equal
+ * <tt>(m+1)(m+1)</tt> subquads of equal
* size.
*
* Refer to the general
*
* 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.
+ * StraightBoundary<tt><dim>::in_between(neighbors)</tt> function.
*
* @author Guido Kanschat, 2001
*/
* and the documentation of the
* base class.
*
- * Only implemented for @p{dim=3}
- * and for @p{points.size()==1}.
+ * Only implemented for <tt>dim=3</tt>
+ * and for <tt>points.size()==1</tt>.
*/
virtual void
get_intermediate_points_on_quad (const typename Triangulation<dim>::quad_iterator &quad,
*
* 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.
+ * StraightBoundary<tt><dim>::in_between(neighbors)</tt> function.
*
* @author Wolfgang Bangerth, 1998, Ralf Hartmann, 2001
*/
* and the documentation of the
* base class.
*
- * Only implemented for @p{dim=3}
- * and for @p{points.size()==1}.
+ * Only implemented for <tt>dim=3</tt>
+ * and for <tt>points.size()==1</tt>.
*/
virtual void
get_intermediate_points_on_quad (const typename Triangulation<dim>::quad_iterator &quad,
const double radius = 1.0);
/**
- * Check if on the line @p{x==0},
+ * Check if on the line <tt>x==0</tt>,
* otherwise pass to the base
* class.
*/
get_new_point_on_line (const typename Triangulation<dim>::line_iterator &line) const;
/**
- * Check if on the line @p{x==0},
+ * Check if on the line <tt>x==0</tt>,
* otherwise pass to the base
* class.
*/
* and the documentation of the
* base class.
*
- * Only implemented for @p{dim=3}
- * and for @p{points.size()==1}.
+ * Only implemented for <tt>dim=3</tt>
+ * and for <tt>points.size()==1</tt>.
*/
virtual void
get_intermediate_points_on_quad (const typename Triangulation<dim>::quad_iterator &quad,
* and the documentation of the
* base class.
*
- * Only implemented for @p{dim=3}
- * and for @p{points.size()==1}.
+ * Only implemented for <tt>dim=3</tt>
+ * and for <tt>points.size()==1</tt>.
*/
virtual void
get_intermediate_points_on_quad (const typename Triangulation<dim>::quad_iterator &quad,
* A heaxhedron itself has one index, as far as the topological part
* handled in the triangulation is concerned: the index in the level
* it belongs to. The level index is implicitly given by the
- * position in the @p{hexes.hexes} list attached to the information
+ * position in the <tt>hexes.hexes</tt> list attached to the information
* of each level of the triangulation.
*
* For conventions on the numbering of faces, lines and vertices
/**
* Dereferencing operator, returns a
* reference to an accessor.
- * Usage is thus like @p{(*i).index ();}
+ * Usage is thus like <tt>(*i).index ();</tt>
*
* This function has to be specialized
* explicitly for the different
* @p Pointees, to allow an
- * @p{iterator<1,TriangulationLevel<1>::LinesData>}
- * to point to @p{tria->lines.lines[index]} while
+ * <tt>iterator<1,TriangulationLevel<1>::LinesData></tt>
+ * to point to <tt>tria->lines.lines[index]</tt> while
* for one dimension higher it has
- * to point to @p{tria->quads.quads[index]}.
+ * to point to <tt>tria->quads.quads[index]</tt>.
*
* You must not dereference invalid or
* past the end iterators.
/**
* Dereferencing operator, returns a
* reference of the cell pointed to.
- * Usage is thus like @p{i->index ();}
+ * Usage is thus like <tt>i->index ();</tt>
*
* There is a @p const and a non-@p const
* version.
/**@name Advancement of iterators*/
/*@{*/
/**
- * Prefix @p{++} operator: @p{++i}. This
+ * Prefix <tt>++</tt> operator: <tt>++i</tt>. This
* operator advances the iterator to
* the next element and returns
- * a reference to @p{*this}.
+ * a reference to <tt>*this</tt>.
*
* The next element is next on this
* level if there are more. If the
TriaRawIterator & operator ++ ();
/**
- * Postfix @p{++} operator: @p{i++}. This
+ * Postfix <tt>++</tt> operator: <tt>i++</tt>. This
* operator advances the iterator to
* the next element, but
* returns an iterator to the element
* operation and since an
* @p iterator is quite a large
* object for a pointer, use the
- * prefix operator @p{++i} whenever
+ * prefix operator <tt>++i</tt> whenever
* possible, especially in the head
* of for loops
- * (@p{for (; i!=end; ++i)}) since there
+ * (<tt>for (; i!=end; ++i)</tt>) since there
* you normally never need the
* returned value.
*/
* Prefix @p -- operator: @p --i. This
* operator advances the iterator to
* the previous element and returns
- * a reference to @p{*this}.
+ * a reference to <tt>*this</tt>.
*
* The previous element is previous on
- * this level if @p{index>0}. If the
+ * this level if <tt>index>0</tt>. If the
* present element is the first on
* this level, the last on the
* previous level is accessed.
* prefix operator @p --i whenever
* possible, especially in the head
* of for loops
- * (@p{for (; i!=end; --i)}) since there
+ * (<tt>for (; i!=end; --i)</tt>) since there
* you normally never need the
* returned value.
*/
/**
* Print the iterator to @p out. The
- * format is like @p{level.index}.
+ * format is like <tt>level.index</tt>.
*/
void print (std::ostream &out) const;
/**@name Advancement of iterators*/
/*@{*/
/**
- * Prefix @p{++} operator: @p{++i}. This
+ * Prefix <tt>++</tt> operator: <tt>++i</tt>. This
* operator advances the iterator to
* the next used element and returns
- * a reference to @p{*this}.
+ * a reference to <tt>*this</tt>.
*/
TriaIterator<dim,Accessor> & operator ++ ();
/**
- * Postfix @p{++} operator: @p{i++}. This
+ * Postfix <tt>++</tt> operator: <tt>i++</tt>. This
* operator advances the iterator to
* the next used element, but
* returns an iterator to the element
* operation and since an
* @p active_iterator is quite a large
* object for a pointer, use the
- * prefix operator @p{++i} whenever
+ * prefix operator <tt>++i</tt> whenever
* possible, especially in the head
* of for loops
- * (@p{for (; i!=end; ++i)}) since there
+ * (<tt>for (; i!=end; ++i)</tt>) since there
* you normally never need the
* returned value.
*/
* Prefix @p -- operator: @p --i. This
* operator advances the iterator to
* the previous used element and returns
- * a reference to @p{*this}.
+ * a reference to <tt>*this</tt>.
*/
TriaIterator<dim,Accessor> & operator -- ();
* raw iterators. Since usual iterators
* are also raw iterators, this constructor
* works also for parameters of type
- * @p{TriaIterator<dim,OtherAccessor>}.
+ * <tt>TriaIterator<dim,OtherAccessor></tt>.
*/
template <typename OtherAccessor>
TriaActiveIterator (const TriaRawIterator<dim,OtherAccessor> &i);
operator = (const TriaIterator<dim,Accessor> &);
/**
- * Prefix @p{++} operator: @p{++i}. This
+ * Prefix <tt>++</tt> operator: <tt>++i</tt>. This
* operator advances the iterator to
* the next active element and returns
- * a reference to @p{*this}.
+ * a reference to <tt>*this</tt>.
*/
TriaActiveIterator<dim,Accessor> & operator ++ ();
/**@name Advancement of iterators*/
/*@{*/
/**
- * Postfix @p{++} operator: @p{i++}. This
+ * Postfix <tt>++</tt> operator: <tt>i++</tt>. This
* operator advances the iterator to
* the next active element, but
* returns an iterator to the element
* operation and since an
* @p active_iterator is quite a large
* object for a pointer, use the
- * prefix operator @p{++i} whenever
+ * prefix operator <tt>++i</tt> whenever
* possible, especially in the head
* of for loops
- * (@p{for (; i!=end; ++i)}) since there
+ * (<tt>for (; i!=end; ++i)</tt>) since there
* you normally never need the
* returned value.
*/
* Prefix @p -- operator: @p --i. This
* operator advances the iterator to
* the previous active element and
- * returns a reference to @p{*this}.
+ * returns a reference to <tt>*this</tt>.
*/
TriaActiveIterator<dim,Accessor> & operator -- ();
/**
* 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
+ * address is given by the pair <tt>(level,index)</tt>, 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
+ * address is given by the pair <tt>(level,index)</tt>, 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
+ * address is given by the pair <tt>(level,index)</tt>, where @p index is
* an index relative to the level in which the object is that is
* pointed to.
*
* are stored in the fields following
* $i*(2*real_space_dimension)$, e.g. in
* one spatial dimension, the neighbors
- * of cell 0 are stored in @p{neighbors[0]}
- * and @p{neighbors[1]}, the neighbors of
- * cell 1 are stored in @p{neighbors[2]}
- * and @p{neighbors[3]}, and so on.
+ * of cell 0 are stored in <tt>neighbors[0]</tt>
+ * and <tt>neighbors[1]</tt>, the neighbors of
+ * cell 1 are stored in <tt>neighbors[2]</tt>
+ * and <tt>neighbors[3]</tt>, and so on.
*
- * In neighbors, @p{neighbors[i].first} is
- * the level, while @p{neighbors[i].first}
+ * In neighbors, <tt>neighbors[i].first</tt> is
+ * the level, while <tt>neighbors[i].first</tt>
* is the index of the neighbor.
*
* If a neighbor does not exist (cell is
- * at the boundary), @p{level=index=-1}
+ * at the boundary), <tt>level=index=-1</tt>
* is set.
*
* <em>Conventions:</em> The
* level, you have to give to total number
* of cells, not only the number of newly
* to accomodate ones, like in the
- * @p{TriangulationLevel<N>::reserve_space}
- * functions, with @p{N>0}.
+ * <tt>TriangulationLevel<N>::reserve_space</tt>
+ * functions, with <tt>N>0</tt>.
*
* Since the
* number of neighbors per cell depends
* stored in this list. A line is
* called active if it has no
* children. The function
- * TriaIterator@p{::active()}
+ * TriaIterator<tt>::active()</tt>
* tests for this.
*/
std::vector<int> children;
* already been processed.
*
* You can clear all used flags using
- * Triangulation@p{::clear_user_flags()}.
+ * Triangulation<tt>::clear_user_flags()</tt>.
*/
std::vector<bool> user_flags;
* Assert that enough space is allocated
* to accomodate @p new_lines new lines.
* This function does not only call
- * @p{vector::reserve()}, but does really
+ * <tt>vector::reserve()</tt>, but does really
* append the needed elements.
* There are pendants for higher
* dimensions, which you have to call
*
* It is fully analogous to the
* @ref{TriangulationLevel<1>::LinesData} structure inherited from
- * Triangulation@p{<1>}.
+ * Triangulation<tt><1></tt>.
*/
struct QuadsData
{
* a @p false value.
*
* In effect, this field has
- * @p{6*n_cells} elements,
+ * <tt>6*n_cells</tt> elements,
* being the number of cells
* times the six faces each
* has.
* A line itself has one index, as far as the topological part handled in
* the triangulation is concerned: the index in the level
* it belongs to. The level index is implicitly given by the position
- * in the @p{lines.lines} list attached to the information of each level.
+ * in the <tt>lines.lines</tt> list attached to the information of each level.
*
* @author Wolfgang Bangerth, 1998
*/
* A quad itself has one index, as far as the topological part handled in
* the triangulation is concerned: the index in the level
* it belongs to. The level index is implicitly given by the position
- * in the @p{quads.quads} list attached to the information of each level
+ * in the <tt>quads.quads</tt> list attached to the information of each level
* of the triangulation.
*
* @author Wolfgang Bangerth, 1998
/**
* 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>}
- * 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,
+ * from. By default, <tt>MGDoFObjectAccessor<celldim,dim></tt> derives from
+ * the @p typedef in the general <tt>MGDoFObjectAccessor_Inheritance<celldim,dim></tt>
+ * class, which is <tt>DoFObjectAccessor<celldim,dim></tt>,
+ * but if <tt>celldim==dim</tt>, then the specialization <tt>MGDoFObjectAccessor_Inheritance<dim,dim></tt>
+ * is used which declares its local type to be <tt>DoFCellAccessor<dim></tt>. Therefore,
* the inheritance is automatically chosen to be from @p DoFCellAccessor if the
* object under consideration has full dimension, i.e. constitutes a cell.
*
/**
* 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>}
- * 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,
+ * from. By default, <tt>DoFObjectAccessor<celldim,dim></tt> derives from
+ * the @p typedef in the general <tt>DoFObjectAccessor_Inheritance<celldim,dim></tt>
+ * class, which is <tt>TriaObjectAccessor<celldim,dim></tt>,
+ * but if <tt>celldim==dim</tt>, then the specialization <tt>TriaObjectAccessor<dim,dim></tt>
+ * is used which declares its local type to be <tt>CellAccessor<dim></tt>. Therefore,
* the inheritance is automatically chosen to be from @p CellAccessor if the
* object under consideration has full dimension, i.e. constitutes a cell.
*
*
* @sect3{Notes about the class hierarchy structure}
*
- * 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
+ * Inheritance from <tt>MGDoFObjectAccessor_Inheritance<1,dim>::BaseClass</tt> yields
+ * inheritance from <tt>DoFCellAccessor<1></tt> if <tt>dim==1</tt> and from
+ * <tt>TriaObjectAccessor<1,dim></tt> 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.
*
/**
* Constructor. The @p local_data
* argument is assumed to be a pointer
- * to a @p{MGDoFHandler<dim>} object.
+ * to a <tt>MGDoFHandler<dim></tt> object.
*/
MGDoFObjectAccessor (const Triangulation<dim> *tria,
const int level,
/**
* Grant access to the degrees of freedom on a cell. In fact, since all
* access to the degrees of freedom has been enabled by the classes
- * @p{DoFObjectAccessor<1, 1>} and @p{DoFObjectAccessor<2, 2>} for the space dimension
+ * <tt>DoFObjectAccessor<1, 1></tt> and <tt>DoFObjectAccessor<2, 2></tt> for the space dimension
* 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
+ * together by deriving from the appropriate <tt>DoF*Accessor</tt> and the
+ * right <tt>CellAccessor<dim></tt> 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
- * from the @p{CellAccessor<dim>} class).
+ * from the <tt>CellAccessor<dim></tt> class).
*
* @author Wolfgang Bangerth, 1998
*/
* the first iterator not on
* level. If @p level is the
* last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
cell_iterator end (const unsigned int level) const;
* the first iterator not on
* level. If @p level is the
* last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
raw_cell_iterator end_raw (const unsigned int level) const;
* which is the first iterator
* not on level. If @p level is
* the last level, then this
- * returns @p{end()}.
+ * returns <tt>end()</tt>.
*/
active_cell_iterator end_active (const unsigned int level) const;
* the first iterator not on
* level. If @p level is the
* last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
face_iterator end_face (const unsigned int level) const;
* the first iterator not on
* level. If @p level is the
* last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
raw_face_iterator end_raw_face (const unsigned int level) const;
* which is the first iterator
* not on level. If @p level is
* the last level, then this
- * returns @p{end()}.
+ * returns <tt>end()</tt>.
*/
active_face_iterator end_active_face (const unsigned int level) const;
* the first iterator not on
* level. If @p level is the
* last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
line_iterator end_line (const unsigned int level) const;
* the first iterator not on
* level. If @p level is the
* last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
raw_line_iterator end_raw_line (const unsigned int level) const;
* which is the first iterator
* not on level. If @p level is
* the last level, then this
- * returns @p{end()}.
+ * returns <tt>end()</tt>.
*/
active_line_iterator end_active_line (const unsigned int level) const;
* the first iterator not on
* level. If @p level is the
* last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
quad_iterator end_quad (const unsigned int level) const;
* the first iterator not on
* level. If @p level is the
* last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
raw_quad_iterator end_raw_quad (const unsigned int level) const;
* which is the first iterator
* not on level. If @p level is
* the last level, then this
- * returns @p{end()}.
+ * returns <tt>end()</tt>.
*/
active_quad_iterator end_active_quad (const unsigned int level) const;
* the first iterator not on
* level. If @p level is the
* last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
hex_iterator end_hex (const unsigned int level) const;
* the first iterator not on
* level. If @p level is the
* last level, then this returns
- * @p{end()}.
+ * <tt>end()</tt>.
*/
raw_hex_iterator end_raw_hex (const unsigned int level) const;
* which is the first iterator
* not on level. If @p level is
* the last level, then this
- * returns @p{end()}.
+ * returns <tt>end()</tt>.
*/
active_hex_iterator end_active_hex (const unsigned int level) const;
* creating the actual matrix
* you have to compress the
* matrix yourself, using
- * @p{SparseMatrixStruct::compress()}.
+ * <tt>SparseMatrixStruct::compress()</tt>.
*
* There is no need to consider
* hanging nodes here, since only
* for each level a vector
* containing the number of dofs
* for each component (access is
- * @p{result[level][component]}).
+ * <tt>result[level][component]</tt>).
*/
template <int dim>
static void count_dofs_per_component (const MGDoFHandler<dim>& mg_dof,
* different levels to zero in the given
* data vector @p u.
*
- * Since the coarsest level (@p{level==0})
+ * Since the coarsest level (<tt>level==0</tt>)
* has no interior boundaries, this
* function does nothing in this case.
*/
* 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
+ * The library contains instantiation for <tt>SparseMatrix<.></tt> and
+ * <tt>Vector<.></tt>, where the template arguments are all combinations of
* @p float and @p double. Additional instantiations may be created
* by including the file mg_smoother.templates.h.
*
* Initialize for matrices. The
* parameter @p matrices can be
* any object having functions
- * @p{get_minlevel()} and
- * @p{get_maxlevel()} as well as
- * an @p{operator[]} returning a
+ * <tt>get_minlevel()</tt> and
+ * <tt>get_maxlevel()</tt> as well as
+ * an <tt>operator[]</tt> returning a
* reference to @p MATRIX. This
* function stores pointers to
* the level matrices and
* of matrices. The parameter
* @p matrices can be any object
* having functions
- * @p{get_minlevel()} and
- * @p{get_maxlevel()} as well as
- * an @p{operator[]} returning a
+ * <tt>get_minlevel()</tt> and
+ * <tt>get_maxlevel()</tt> as well as
+ * an <tt>operator[]</tt> returning a
* reference to a block matrix
* where each block is of type
* @p MATRIX. Of this block
* Copies data from active
* portions of an MGVector into
* the respective positions of a
- * @p{Vector<number>}. In order to
+ * <tt>Vector<number></tt>. In order to
* keep the result consistent,
* constrained degrees of freedom
* are set to zero.
* functions of @p copy_to_mg,
* where the 1d function takes an
* argument of type
- * @p{is_1d<true>} and the other
- * one of type @p{is_1d<false>}.
+ * <tt>is_1d<true></tt> and the other
+ * one of type <tt>is_1d<false></tt>.
*/
template <bool> struct is_1d {};
* functions of @p copy_to_mg,
* where the 1d function takes an
* argument of type
- * @p{is_1d<true>} and the other
- * one of type @p{is_1d<false>}.
+ * <tt>is_1d<true></tt> and the other
+ * one of type <tt>is_1d<false></tt>.
*/
template <bool> struct is_1d {};
* @code
* void COARSE::operator() (VECTOR& x, const VECTOR& b)
* @endcode
- * returning the solution to the system @p{Ax=b} on the coarsest level
+ * returning the solution to the system <tt>Ax=b</tt> on the coarsest level
* in <i>x</i>.
*
* @author Guido Kanschat, 1999 - 2004
* the outer defect correction
* scheme (usually performed by
* PreconditionMG). After
- * execution of @p{vcycle()}, the
+ * execution of <tt>vcycle()</tt>, the
* result is in the vector
* @p solution. See
- * @p{copy_*_mg} in class
+ * <tt>copy_*_mg</tt> in class
* @p MGTools if you want to use
* these vectors yourself.
*
* and provide the standard interface for LAC iterative methods.
*
* The template parameter class @p MG is required to inherit @p MGBase.
- * Furthermore, it needs functions @p{void copy_to_mg(const VECTOR&)}
+ * Furthermore, it needs functions <tt>void copy_to_mg(const VECTOR&)</tt>
* 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.
+ * <tt>void copy_from_mg(VECTOR&)</tt> to store the result of the v-cycle in @p dst.
*
* @author Guido Kanschat, 1999, 2000, 2001, 2002
*/
* components ("x-displacement" and "y-displacement") while the error estimator
* probably is a vector holding cell data. When attaching a data vector, you have
* to give a name to each component of the vector, which is done through an object
- * of type @p{vector<string>} as second argument; if only one component is in the
+ * of type <tt>vector<string></tt> as second argument; if only one component is in the
* vector, for example if we are adding cell data as in the second case, or if
* the finite element used by the DoFHandler has only one component, then you
* can use the second @p add_data_vector function which takes a @p string instead
- * of the @p{vector<string>}.
+ * of the <tt>vector<string></tt>.
*
* You should note that this class does not copy the vector given to it through
* the @p add_data_vector functions, for memory consumption reasons. It only
* functions to ease programming with run-time determinable output formats
* (i.e. you need not use a fixed format by calling @p write_xxx in the above
* example, but you can select it by a run-time parameter without having
- * to write the @p{if () ... else ...} clauses yourself), and also functions
+ * to write the <tt>if () ... else ...</tt> clauses yourself), and also functions
* and classes offering ways to control the appearance of the output by
* setting flags for each output format.
*
* stored, so you have to make
* sure the vector exists at that
* address at least as long as
- * you call the @p{write_*}
+ * you call the <tt>write_*</tt>
* functions.
*
* It is assumed that the vector
* and so on.
*
* 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
+ * more of the <tt>write_*</tt> functions of the base classes. You can therefore
* output the same data in more than one format without having to rebuild
* the patches.
*
* mode. The default number of
* threads to be used to build
* the patches is set to
- * @p{multithread_info.n_default_threads}.
+ * <tt>multithread_info.n_default_threads</tt>.
*/
virtual void build_patches (const unsigned int n_subdivisions = 1,
const unsigned int n_threads = multithread_info.n_default_threads);
* Return the next cell after
* @p cell which we want output
* for. If there are no more
- * cells, @p{dofs->end()} shall
+ * cells, <tt>dofs->end()</tt> shall
* be returned.
*
* The default implementation
*
* The @p index_to_patch_map is
* an array that stores for index
- * @p{[i][j]} the number of the
+ * <tt>[i][j]</tt> the number of the
* patch that associated with the
* cell with index @p j on level
* @p i. This information is set
* mode. The default number of
* threads to be used to build
* the patches is set to
- * @p{multithread_info.n_default_threads}.
+ * <tt>multithread_info.n_default_threads</tt>.
*/
virtual void
build_patches (const unsigned int n_subdivisions = 1,
* generate output for. The usual
* way would, of course, be to
* use an object of type
- * DoFHandler@p{<dim>::fec_iterator},
+ * DoFHandler<tt><dim>::fec_iterator</tt>,
* but since we have to describe
* faces to objects of type
* FEValues, we can only
* Return the next face after
* @p face which we want output
* for. If there are no more
- * face, @p{dofs->end()} shall be
+ * face, <tt>dofs->end()</tt> shall be
* returned as the first
* component of the return value.
*
* mode. The default number of
* threads to be used to build
* the patches is set to
- * @p{multithread_info.n_default_threads}.
+ * <tt>multithread_info.n_default_threads</tt>.
*/
virtual void build_patches (const unsigned int n_patches_per_circle,
const unsigned int n_subdivisions = 1,
* Return the next cell after @p cell which
* we want output for.
* If there are no more cells,
- * @p{dofs->end()} shall be returned.
+ * <tt>dofs->end()</tt> shall be returned.
*
* The default
* implementation returns the next
* component and therefore more than one
* name needs to be given. However, you
* can also call this function with a
- * @p{vector<string>} containing only one
+ * <tt>vector<string></tt> containing only one
* element if the finite element has
* only one component.
*/
* component and therefore more than one
* name needs to be given. However, you
* can also call this function with a
- * @p{vector<string>} containing only one
+ * <tt>vector<string></tt> containing only one
* element if the finite element has
* only one component.
*
* Objects of this class are provided with a solver class through a
* 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
+ * <tt>basename.[step].[suffix]</tt>) and into which the solution is
* written as a finite element field using the DataOut class.
* Please note that this class may produce enormous amounts of data!
*
* finite element function.
*
* One output file with the name
- * @p{basename.[step].[suffix]}
+ * <tt>basename.[step].[suffix]</tt>
* will be produced for each
* iteration step.
*/
* the conormal derivative $a\frac{du}{dn} = g$.
*
* The error estimator returns a vector of estimated errors per cell which
- * can be used to feed the Triangulation@p{<dim>::refine_*} functions. This
+ * can be used to feed the Triangulation<tt><dim>::refine_*</tt> functions. This
* vector contains elements of data type @p float, rather than @p double,
* since accuracy is not so important here, and since this can save rather
* a lot of memory, when using many cells.
* The estimator supports
* multithreading and splits the
* cells to
- * @p{multithread_info.n_default_threads}
+ * <tt>multithread_info.n_default_threads</tt>
* (default) threads. The number
* of threads to be used in
* multithreaded mode can be set
* on one cell
*
* Let psi be a short name
- * for @p{a grad u_h}, where
+ * for <tt>a grad u_h</tt>, where
* the third index be the
* component of the finite
* element, and the second
* Computates the error on all cells
* of the domain with the number n,
* satisfying
- * @p{n=this_thread (mod n_threads)}
+ * <tt>n=this_thread (mod n_threads)</tt>
* This enumeration is chosen to
* generate a random distribution
* of all cells.
*
* The estimator supports multithreading
* and splits the cells to
- * @p{multithread_info.n_default_threads}
+ * <tt>multithread_info.n_default_threads</tt>
* (default) threads. The number of
* threads to be used in multithreaded
* mode can be set with the last
/**
* Calls the @p estimate
* function, see above, with
- * @p{mapping=MappingQ1<1>()}.
+ * <tt>mapping=MappingQ1<1>()</tt>.
*/
template <typename InputVector>
static void estimate (const DoFHandler<1> &dof,
/**
* Calls the @p estimate
* function, see above, with
- * @p{mapping=MappingQ1<1>()}.
+ * <tt>mapping=MappingQ1<1>()</tt>.
*/
template <typename InputVector>
static void estimate (const DoFHandler<1> &dof,
*
* The histograms will be arranged such
* that the computed intervals of the
- * @p{values[i][j]} form the x-range,
+ * <tt>values[i][j]</tt> form the x-range,
* and the number of values in each
* interval will be the y-range (for
* 2d plots) or the z-range (for 3d
* the @p y_values are ignored.
*
* If you give only one data set, i.e.
- * @p{values.size()==1}, then the
+ * <tt>values.size()==1</tt>, then the
* resulting histogram will be a 2d
* one.
*
* logarithmic case interval spacing
* scheme.
*
- * Return @p true, if (@p{n1<n2},
- * and (@p{n1>0} or @p{n2<0})), or
+ * Return @p true, if (<tt>n1<n2</tt>,
+ * and (<tt>n1>0</tt> or <tt>n2<0</tt>)), or
* (n2<n1 and n1>0 and n2<=0). This
* in effect sorts all negativ
* numbers to be larger than the
* created. The functions assume that the matrix is initialized with a
* sparsity pattern (SparsityPattern) corresponding to the given degree
* of freedom handler, i.e. the sparsity structure is already as needed.
- * You can do this by calling the DoFHandler@p{<dim>::make_sparsity_pattern}
+ * You can do this by calling the DoFHandler<tt><dim>::make_sparsity_pattern</tt>
* function.
*
* Furthermore it is assumed that no relevant data is in the matrix. All
*
* If you want to use boundary conditions with the matrices generated
* by the functions of this class, you have to use a function like
- * @p{ProblemBase<>::apply_dirichlet_bc} to matrix and right hand
+ * <tt>ProblemBase<>::apply_dirichlet_bc</tt> to matrix and right hand
* side.
*
*
* 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
+ * <tt>unsigned char</tt>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
* pairs of DoF handler cell
* iterators. This type works
* just like a
- * @p{std::pair<iterator,iterator>}
+ * <tt>std::pair<iterator,iterator></tt>
* but is templatized on the
* space dimension.
*/
* 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
* 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
+ * an <tt>O(N*log(m))</tt> operation, since searching in each row takes
+ * <tt>log(m)</tt> operations). If your sparsity pattern is symmetric, but
* 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
+ * <tt>O(m*log(m))</tt>, 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
- * would be @p{O(N*sqrt(N)*log(m))} for the general case; the latter
+ * number of boundary nodes is <tt>sqrt(N)</tt> in 2d, the algorithm for
+ * symmetric sparsity patterns is <tt>O(sqrt(N)*m*log(m))</tt>, while it
+ * would be <tt>O(N*sqrt(N)*log(m))</tt> for the general case; the latter
* is too expensive to be performed.
*
* It seems as if we had to make clear not to overwrite the lines of
* @endverbatim
*
* Multiple calls to the function
- * @p{interpolate (const Vector<number> &in, Vector<number> &out)}
+ * <tt>interpolate (const Vector<number> &in, Vector<number> &out)</tt>
* 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},
+ * <tt>void interpolate (const vector<Vector<number> >&all_in, vector<Vector<number> >&all_out) const</tt>,
* 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).
* </ul>
*
* For deleting all stored data in @p SolutionTransfer and reinitializing it
- * use the @p{clear()} function.
+ * use the <tt>clear()</tt> function.
*
* Note that the @p user_pointer of some cells are used.
* Be sure that you don't need them otherwise.
* solution vector on the current (original) grid.
* Each entry of this vector belongs to one of the
* DoFs of the discretisation. If we now refine the grid then the calling of
- * DoFHandler@p{::distribute_dofs(...)} will change at least some of the
+ * DoFHandler<tt>::distribute_dofs(...)</tt> will change at least some of the
* DoF indices. Hence we need to store the DoF indices of all active cells
* before the refinement. The @p user_pointer of each active cell
* is used to point to the vector of these DoF indices of that cell, all other
* @p user_pointers are cleared. All this is
- * done by @p{prepare_for_pure_refinement()}.
+ * done by <tt>prepare_for_pure_refinement()</tt>.
*
- * In the function @p{refine_interpolate(in,out)} and on each cell where the
+ * In the function <tt>refine_interpolate(in,out)</tt> and on each cell where the
* @p user_pointer is set (i.e. the cells that were active in the original grid)
* 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.
*
- * The @p{refine_interpolate(in,out)} function can be called multiply for
+ * The <tt>refine_interpolate(in,out)</tt> function can be called multiply for
* arbitrary many discrete functions (solution vectors) on the original grid.
*
* <li> Solution transfer while coarsening and refinement. After
* Additionally the DoF indices of the cells
* that will not be coarsened need to be stored according to the solution
* transfer while pure refinement (cf there). All this is performed by
- * @p{prepare_for_coarsening_and_refinement(all_in)} where the
- * @p{vector<Vector<number> >vector all_in} includes
+ * <tt>prepare_for_coarsening_and_refinement(all_in)</tt> where the
+ * <tt>vector<Vector<number> >vector all_in</tt> includes
* all discrete functions to be interpolated onto the new grid.
*
- * 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)
+ * As we need two different kinds of pointers (<tt>vector<unsigned int> *</tt> for the Dof
+ * indices and <tt>vector<Vector<number> > *</tt> 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.
* 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
+ * <tt>void * user_pointer</tt> as <tt>vector<unsigned int> *</tt> at one time and as
+ * <tt>vector<Vector<number> > *</tt> 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.
*
- * In @p{interpolate(all_in, all_out)} the refined cells are treated according
+ * In <tt>interpolate(all_in, all_out)</tt> the refined cells are treated according
* 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
* 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.
- * 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.
+ * It is clear that <tt>interpolate(all_in, all_out)</tt> only can be called with
+ * the <tt>vector<Vector<number> > all_in</tt> that previously was the parameter
+ * of the <tt>prepare_for_coarsening_and_refinement(all_in)</tt> function. Hence
+ * <tt>interpolate(all_in, all_out)</tt> can (in contrast to
+ * <tt>refine_interpolate(in, out)</tt>) only be called once.
* </ul>
*
* @author Ralf Hartmann, 1999
* 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})
+ * right sizes (i.e. <tt>in.size()==n_dofs_old</tt>,
+ * <tt>out.size()==n_dofs_refined</tt>)
*
* Calling this function is allowed only
* if @p prepare_for_pure_refinement is called
Vector<number> &out) const;
/**
- * Same as @p{interpolate(in,out)}
+ * Same as <tt>interpolate(in,out)</tt>
* but it interpolates
* just 'in-place'. Therefore @p vec will be
* reinitialized to the new needed vector
* It assumes the vectors in @p all_in
* denote the same vectors
* as in @p all_in as parameter of
- * @p{prepare_for_refinement_and_coarsening(all_in)}.
+ * <tt>prepare_for_refinement_and_coarsening(all_in)</tt>.
* However, there is no way of verifying
* this internally, so be careful here.
*
* Same as the previous function.
* It interpolates only one function.
* It assumes the vectors having the
- * right sizes (i.e. @p{in.size()==n_dofs_old},
- * @p{out.size()==n_dofs_refined})
+ * right sizes (i.e. <tt>in.size()==n_dofs_old</tt>,
+ * <tt>out.size()==n_dofs_refined</tt>)
*
* Multiple calling of this function is
* NOT allowed. Interpolating
* several functions can be performed
* in one step by using
- * @p{interpolate (all_in, all_out)}
+ * <tt>interpolate (all_in, all_out)</tt>
*/
void interpolate (const Vector<number> &in,
Vector<number> &out) const;
* data need to be packetized in a structure.
* Note that in our case on each cell
* either the
- * @p{vector<unsigned int> indices} (if the cell
+ * <tt>vector<unsigned int> indices</tt> (if the cell
* will be refined) or the
- * @p{vector<double> dof_values} (if the
+ * <tt>vector<double> dof_values</tt> (if the
* children of this cell will be deleted)
* is needed, hence one @p user_pointer should
* be sufficient, but to allow some errorchecks
* Vector of all @p Pointerstructs (cf. there).
* It makes it
* easier to delete all these structs
- * (without going over all @p{cell->user_pointer})
+ * (without going over all <tt>cell->user_pointer</tt>)
* after they are not used any more, and
* collecting all these structures in a vector
* helps avoiding fraqmentation of the memory.
* management, data reload and storage into one set of functions and
* computations into another.
*
- * In the example above, possible actions might be: timestep @p{n+1} rebuilds
+ * In the example above, possible actions might be: timestep <tt>n+1</tt> 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
* size, maybe using an initial guess; then it does the computations; then
* to be run.
*
* 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 <tt>C++</tt> 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:
* @verbatim
* 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}.
+ * outside <tt>0..n_timesteps-1</tt>.
* @verbatim
* template <typename InitFunctionObject, typename LoopFunctionObject>
* void TimeDependent::do_loop (InitFunctionObject init_function,
/**
* Destructor. This will delete the
* objects pointed to by the pointers
- * given to the @p{insert_*} and
+ * given to the <tt>insert_*</tt> and
* @p add_timestep functions, i.e.
* it will delete the objects doing
* the computations on each time step.
*
* Instead of using the above form, you can
* equally well use
- * @p{bind2nd(mem_fun1(&X::unary_function), arg)}
+ * <tt>bind2nd(mem_fun1(&X::unary_function), arg)</tt>
* which lets the @p do_loop
* function call teh given function with
* the specified parameter. Note that you
private:
/**
- * Do the work of @p{end_sweep()}
+ * Do the work of <tt>end_sweep()</tt>
* for some timesteps only. This
* is useful in multithread mode.
*/
* problem is actual, or any of
* the other actions
* specified. This variable is
- * set by the @p{init_for_*}
+ * set by the <tt>init_for_*</tt>
* functions.
*/
unsigned int next_action;
* 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
- * certain factor. For example, if this list was @p{((100 5) (200 3) (500 2))},
+ * certain factor. For example, if this list was <tt>((100 5) (200 3) (500 2))</tt>,
* this would mean that for grids with a cell number below 100, the
- * @p{cell_number_corridor_*} variables are to be multiplied by 5 before they
+ * <tt>cell_number_corridor_*</tt> variables are to be multiplied by 5 before they
* are applied, for cell numbers below 200 they are to be multiplied by 3,
* and so on.
*
* destroy it in the @p sleep function.
* It does so also the first time we
* hit this function and @p wakeup_level
- * equals @p{flags.wakeup_level_to_build_grid},
+ * equals <tt>flags.wakeup_level_to_build_grid</tt>,
* independently of the value of the
* mentioned flag. (Actually, it does so
* whenever the triangulation pointer
* <li> Creation of right hand side vectors:
* The @p create_right_hand_side function computes the vector
* $f_i = \int_\Omega f(x) \phi_i(x) dx$. This is the same as what the
- * MatrixCreator@p{::create_*} functions which take a right hand side do,
+ * MatrixCreator<tt>::create_*</tt> functions which take a right hand side do,
* but without assembling a matrix.
*
* <li> Creation of boundary right hand side vectors: The
* 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.
* To use it, you have to
- * specify a list of pairs of boundary indicators (of type @p{unsigned char};
+ * specify a list of pairs of boundary indicators (of type <tt>unsigned char</tt>;
* 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.
* 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
- * promoted with the @p{++} operator.
+ * promoted with the <tt>++</tt> operator.
*
* You can use the @p distribute_cell_to_dof_vector function of the
* DoFHandler class to convert cell based data to a data
*
* To get the global <i>L<sup>1</sup></i> error, you have to sum up the
* entries in @p difference, e.g. using
- * Vector@p{<double>::l1_norm} function. For the global <i>L<sup>2</sup></i>
+ * Vector<tt><double>::l1_norm</tt> function. For the global <i>L<sup>2</sup></i>
* difference, you have to sum up the squares of the entries and
* take the root of the sum, e.g. using
- * Vector@p{<double>::l2_norm}. These two operations
+ * Vector<tt><double>::l2_norm</tt>. These two operations
* represent the $l_1$ and $l_2$ norms of the vectors, but you need
* not take the absolute value of each entry, since the cellwise
* norms are already positive.
*
* To get the global mean difference, simply sum up the elements as above.
* To get the $L_\infty$ norm, take the maximum of the vector elements, e.g.
- * using the Vector@p{<double>::linfty_norm} function.
+ * using the Vector<tt><double>::linfty_norm</tt> function.
*
* For the global <i>H<sup>1</sup></i> norm and seminorm, the same rule applies as for the
* <i>L<sup>2</sup></i> norm: compute the $l_2$ norm of the cell error vector.
* @p dof.
*
* Note that you may have to call
- * @p{hanging_nodes.distribute(vec)}
+ * <tt>hanging_nodes.distribute(vec)</tt>
* with the hanging nodes from
* space @p dof afterwards, to
* make the result continuous
* are neglected so far.
*
* Note that you may have to call
- * @p{hanging_nodes.distribute(data_2)}
+ * <tt>hanging_nodes.distribute(data_2)</tt>
* with the hanging nodes from
* space @p dof_2 afterwards, to
* make the result continuous
/**
* Calls the @p project
* function, see above, with
- * @p{mapping=MappingQ1@<dim@>()}.
+ * <tt>mapping=MappingQ1@<dim@>()</tt>.
*/
template <int dim>
static void project (const DoFHandler<dim> &dof,
/**
* Calls the @p create_right_hand_side
* function, see above, with
- * @p{mapping=MappingQ1@<dim@>()}.
+ * <tt>mapping=MappingQ1@<dim@>()</tt>.
*/
template <int dim>
static void create_right_hand_side (const DoFHandler<dim> &dof,
* Calls the
* @p create_boundary_right_hand_side
* function, see above, with
- * @p{mapping=MappingQ1@<dim@>()}.
+ * <tt>mapping=MappingQ1@<dim@>()</tt>.
*/
template <int dim>
static void create_boundary_right_hand_side (const DoFHandler<dim> &dof,
* Calls the other
* @p interpolate_boundary_values
* function, see above, with
- * @p{mapping=MappingQ1@<dim@>()}.
+ * <tt>mapping=MappingQ1@<dim@>()</tt>.
*/
template <int dim>
static void interpolate_boundary_values (const DoFHandler<dim> &dof,
* Calls the other
* @p interpolate_boundary_values
* function, see above, with
- * @p{mapping=MappingQ1@<dim@>()}.
+ * <tt>mapping=MappingQ1@<dim@>()</tt>.
*/
template <int dim>
static void interpolate_boundary_values (const DoFHandler<dim> &dof,
/**
* Calls the @p project_boundary_values
* function, see above, with
- * @p{mapping=MappingQ1@<dim@>()}.
+ * <tt>mapping=MappingQ1@<dim@>()</tt>.
*/
template <int dim>
static void project_boundary_values (const DoFHandler<dim> &dof,
/**
* Calls the @p integrate_difference
* function, see above, with
- * @p{mapping=MappingQ1@<dim@>()}.
+ * <tt>mapping=MappingQ1@<dim@>()</tt>.
*/
template <int dim, class InVector, class OutVector>
static void integrate_difference (const DoFHandler<dim> &dof,
/**
* Calls the @p compute_mean_value
* function, see above, with
- * @p{mapping=MappingQ1@<dim@>()}.
+ * <tt>mapping=MappingQ1@<dim@>()</tt>.
*/
template <int dim, class InVector>
static double compute_mean_value (const DoFHandler<dim> &dof,
/**
* Constructor. Initialize the
* number of entries in each
- * block @p i as @p{n[i]}. The
+ * block @p i as <tt>n[i]</tt>. The
* number of blocks will be the
* size of the vector
*/
* of blocks will be adjusted to
* the size of @p n and the size
* of block @p i is set to
- * @p{n[i]}.
+ * <tt>n[i]</tt>.
*/
inline void reinit (const std::vector<unsigned int> &n);
* Block matrix composed of different single matrices.
*
* 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}.
+ * block matrix with block entries of the form <tt>M_{jk</tt> = s_{jk}A_i}.
* 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
- * location @p{(i,j)} several times will add the corresponding
+ * location <tt>(i,j)</tt> 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>}. SparseMatrix is a possible entry
+ * <tt>BlockVector<VECTOR></tt>. SparseMatrix is a possible entry
* type.
*
* @author Guido Kanschat, 2000, 2001
unsigned int n () const;
/**
- * Set the element @p{(i,j)} to
+ * Set the element <tt>(i,j)</tt> to
* @p value. Throws an error if
* the entry does not
* exist. Still, it is allowed to
/**
* Add @p value to the element
- * @p{(i,j)}. Throws an error if
+ * <tt>(i,j)</tt>. Throws an error if
* the entry does not
* exist. Still, it is allowed to
* store zero values in
* 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
- * @p{block(row,col)} function.
+ * <tt>block(row,col)</tt> function.
*
* Attention: this object is not automatically notified if the size of
* one of its subobjects' size is changed. After you initialize the
* sizes of the subobjects, you will therefore have to call the
- * @p{collect_sizes()} function of this class! Note that, of course, all
+ * <tt>collect_sizes()</tt> function of this class! Note that, of course, all
* sub-matrices in a (block-)row have to have the same number of rows, and
* that all sub-matrices in a (block-)column have to have the same number of
* columns.
* bad happens.
*
* This function simply finds out
- * to which block @p{(i,j)} belongs
+ * to which block <tt>(i,j)</tt> belongs
* and then relays to that block.
*/
void add (const unsigned int i, const unsigned int j);
{
// if you get an error here, are
// you sure you called
- // @p{collect_sizes()} before?
+ // <tt>collect_sizes()</tt> before?
const std::pair<unsigned int,unsigned int>
row_index = row_indices.global_to_local (i),
col_index = column_indices.global_to_local (j);
{
// if you get an error here, are
// you sure you called
- // @p{collect_sizes()} before?
+ // <tt>collect_sizes()</tt> before?
const std::pair<unsigned int,unsigned int>
row_index = row_indices.global_to_local (i),
col_index = column_indices.global_to_local (j);
* if yo want to use the STL data types
* on classes like this, e.g. to write
* such statements like
- * @p{v.push_back (CompressedSparsityPattern());},
+ * <tt>v.push_back (CompressedSparsityPattern());</tt>,
* with @p v a vector of @p CompressedSparsityPattern
* objects.
*
* and which can be used to plot the
* sparsity pattern in a graphical
* way. The format consists of pairs
- * @p{i j} of nonzero elements, each
+ * <tt>i j</tt> of nonzero elements, each
* representing one entry of this
* matrix, one per line of the output
* file. Indices are counted from
* way as matrices are displayed, we
* print the negative of the column
* index, which means that the
- * @p{(0,0)} element is in the top left
+ * <tt>(0,0)</tt> element is in the top left
* rather than in the bottom left
* corner.
*
* 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=}.
+ * provide access to indivual elements through <tt>operator()</tt>,
+ * assignment through <tt>operator=</tt>.
*
*
* @sect3{Thread-safety}
* @p std::vector of
* IndexValuePair objects,
* but also a
- * @p{std::map<unsigned,value_type>}.
+ * <tt>std::map<unsigned,value_type></tt>.
*
* It is an error if the argument
* contains an entry for a degree
* assumed that the list of
* constraints is sorted. If the
* input argument is a
- * @p{std::map<unsigned,value_type>},
+ * <tt>std::map<unsigned,value_type></tt>,
* this is automatically the
* case.
*
/**
* Compute the residual of an
- * equation @p{Mx=b}, where the
+ * equation <tt>Mx=b</tt>, where the
* residual is defined to be
- * @p{r=b-Mx} with @p x
+ * <tt>r=b-Mx</tt> with @p x
* typically being an approximate
* of the true solution of the
* equation. Write the residual
* size of the matrix, for which
* we assume that the matrix type
* offers member functions
- * @p{m()} and @p{n()}, which
+ * <tt>m()</tt> and <tt>n()</tt>, which
* return the number of rows and
* columns, respectively.
*/
* for which no specialization of
* this function was declared
* above. This will call
- * @p{operator()} on the matrix.
+ * <tt>operator()</tt> on the matrix.
*/
template <class Matrix>
static double get_element (const Matrix &matrix,
/**
* Get the value of the matrix at
- * gridpoint @p{(i,j)}. Depending
+ * gridpoint <tt>(i,j)</tt>. Depending
* on the given flags, this can
* mean different things, for
* example if only absolute
* does not transmit this information.
*
* This function is therefore exactly
- * equivalent to the @p{el()} function.
+ * equivalent to the <tt>el()</tt> function.
*/
PetscScalar operator () (const unsigned int i,
const unsigned int j) const;
* whether we should tell PETSc that
* the matrix is going to be symmetric
* (as indicated by the call
- * @p{MatSetOption(mat,MAT_SYMMETRIC)}. Note
+ * <tt>MatSetOption(mat,MAT_SYMMETRIC)</tt>. Note
* that the PETSc documentation states
* that one cannot form an ILU
* decomposition of a matrix for which
* whether we should tell PETSc that
* the matrix is going to be symmetric
* (as indicated by the call
- * @p{MatSetOption(mat,MAT_SYMMETRIC)}. Note
+ * <tt>MatSetOption(mat,MAT_SYMMETRIC)</tt>. Note
* that the PETSc documentation states
* that one cannot form an ILU
* decomposition of a matrix for which
*
* The constructor is made explicit
* to avoid accidents like this:
- * @p{v=0;}. Presumably, the user
+ * <tt>v=0;</tt>. Presumably, the user
* wants to set every element of the
* vector to zero, but instead, what
* happens is this call:
- * @p{v=Vector<number>(0);}, i.e. the
+ * <tt>v=Vector<number>(0);</tt>, i.e. the
* vector is replaced by one of
* length zero.
*/
* whether we should tell PETSc that
* the matrix is going to be symmetric
* (as indicated by the call
- * @p{MatSetOption(mat,MAT_SYMMETRIC)}. Note
+ * <tt>MatSetOption(mat,MAT_SYMMETRIC)</tt>. Note
* that the PETSc documentation states
* that one cannot form an ILU
* decomposition of a matrix for which
* whether we should tell PETSc that
* the matrix is going to be symmetric
* (as indicated by the call
- * @p{MatSetOption(mat,MAT_SYMMETRIC)}. Note
+ * <tt>MatSetOption(mat,MAT_SYMMETRIC)</tt>. Note
* that the PETSc documentation states
* that one cannot form an ILU
* decomposition of a matrix for which
*
* The constructor is made explicit to
* avoid accidents like this:
- * @p{v=0;}. Presumably, the user wants
+ * <tt>v=0;</tt>. Presumably, the user wants
* to set every element of the vector to
* zero, but instead, what happens is
- * this call: @p{v=Vector<number>(0);},
+ * this call: <tt>v=Vector<number>(0);</tt>,
* i.e. the vector is replaced by one of
* length zero.
*/
/**
* Declare some of the standard types
* used in all containers. These types
- * parallel those in the @p{C++}
- * standard libraries @p{vector<...>}
+ * parallel those in the <tt>C++</tt>
+ * standard libraries <tt>vector<...></tt>
* class.
*/
typedef PetscScalar value_type;
/**
* Set all entries to zero. Equivalent
- * to @p{v = 0}, but more obvious and
+ * to <tt>v = 0</tt>, but more obvious and
* faster. Note that this function
* does not change the size of the
* vector, unlike the STL's
- * @p{vector<>::clear} function.
+ * <tt>vector<>::clear</tt> function.
*/
void clear ();
/**
* Simple vector addition, equal to the
- * @p{operator +=}.
+ * <tt>operator +=</tt>.
*/
void add (const VectorBase &V);
/**
* Simple addition of a multiple of a
- * vector, i.e. @p{*this += a*V}.
+ * vector, i.e. <tt>*this += a*V</tt>.
*/
void add (const PetscScalar a, const VectorBase &V);
/**
* Multiple addition of scaled vectors,
- * i.e. @p{*this += a*V+b*W}.
+ * i.e. <tt>*this += a*V+b*W</tt>.
*/
void add (const PetscScalar a, const VectorBase &V,
const PetscScalar b, const VectorBase &W);
/**
* Scaling and simple vector addition,
* i.e.
- * @p{*this = s*(*this)+V}.
+ * <tt>*this = s*(*this)+V</tt>.
*/
void sadd (const PetscScalar s,
const VectorBase &V);
/**
* Scaling and simple addition, i.e.
- * @p{*this = s*(*this)+a*V}.
+ * <tt>*this = s*(*this)+a*V</tt>.
*/
void sadd (const PetscScalar s,
const PetscScalar a,
/**
* Scaling and multiple addition.
- * @p{*this = s*(*this)+a*V + b*W + c*X}.
+ * <tt>*this = s*(*this)+a*V + b*W + c*X</tt>.
*/
void sadd (const PetscScalar s,
const PetscScalar a,
void scale (const VectorBase &scaling_factors);
/**
- * Assignment @p{*this = a*V}.
+ * Assignment <tt>*this = a*V</tt>.
*/
void equ (const PetscScalar a, const VectorBase &V);
/**
- * Assignment @p{*this = a*V + b*W}.
+ * Assignment <tt>*this = a*V + b*W</tt>.
*/
void equ (const PetscScalar a, const VectorBase &V,
const PetscScalar b, const VectorBase &W);
/**
* Compute the elementwise ratio of the
* two given vectors, that is let
- * @p{this[i] = a[i]/b[i]}. This is
+ * <tt>this[i] = a[i]/b[i]</tt>. This is
* useful for example if you want to
* compute the cellwise ratio of true to
* estimated error.
* This vector is appropriately
* scaled to hold the result.
*
- * If any of the @p{b[i]} is
+ * If any of the <tt>b[i]</tt> is
* zero, the result is
* undefined. No attempt is made
* to catch such situations.
* the @p swap function of all C++
* standard containers. Also,
* there is a global function
- * @p{swap(u,v)} that simply calls
- * @p{u.swap(v)}, again in analogy
+ * <tt>swap(u,v)</tt> that simply calls
+ * <tt>u.swap(v)</tt>, again in analogy
* to standard functions.
*/
void swap (VectorBase &v);
* Constructor. The pointer in the
* argument is stored in this
* class. As usual, the lifetime of
- * @p{*M} must be longer than the
+ * <tt>*M</tt> must be longer than the
* one of the @p PointerMatrix.
*
* If @p M is zero, no matrix is stored.
/**
* Base class for @p PreconditionBlockJacobi,
* @p PreconditionBlockSOR, ... This class assumes the
- * @p{SparseMatrix<number>} consisting of invertible blocks of
+ * <tt>SparseMatrix<number></tt> consisting of invertible blocks of
* @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
* The first template parameter denotes the type of number
* representation in the sparse matrix, the second denotes the type of
* number representation in which the inverted diagonal block matrices
- * are stored within this class by @p{invert_diagblocks()}. If you
+ * are stored within this class by <tt>invert_diagblocks()</tt>. If you
* don't want to use the block inversion as an exact solver, but
* rather as a preconditioner, you may probably want to store the
* inverted blocks with less accuracy than the original matrix; for
- * example, @p{number==double, inverse_type=float} might be a viable
+ * example, <tt>number==double, inverse_type=float</tt> might be a viable
* choice.
*
*
* It is not allowed to call this
* function twice (will produce
* an error) before a call of
- * @p{clear(...)} because at the
+ * <tt>clear(...)</tt> because at the
* second time there already
* exist the inverse matrices.
*
* Storage of the inverse
* matrices of the diagonal
* blocks matrices as
- * @p{FullMatrix<inverse_type>}
+ * <tt>FullMatrix<inverse_type></tt>
* matrices. Using
- * @p{inverse_type=float} saves
+ * <tt>inverse_type=float</tt> saves
* memory in comparison with
- * @p{inverse_type=double}.
+ * <tt>inverse_type=double</tt>.
*/
std::vector<FullMatrix<inverse_type> > var_inverse;
*/
bool operator == (const const_iterator&) const;
/**
- * Inverse of @p{==}.
+ * Inverse of <tt>==</tt>.
*/
bool operator != (const const_iterator&) const;
* the name of the preconditioning and the damping parameter
* @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
+ * by the matrix-builtin precondition functions. Each time, the <tt>operator()</tt> function
* is called, this preselected preconditioner, this matrix and
* this @p omega is used
* for the preconditioning. This class is designed for being used as
* Takes the matrix that is needed
* for preconditionings that involves a
* matrix. e.g. for @p precondition_jacobi,
- * @p{~_sor}, @p{~_ssor}.
+ * <tt>~_sor</tt>, <tt>~_ssor</tt>.
*/
void use_matrix(const Matrix &M);
* @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.
+ * <tt>swap(VECTOR &a, VECTOR &b)</tt> 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
* 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
+ * each solver class the <tt>struct AdditionalData</tt> 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
* empty and calling the constructor may be done without giving the additional
* 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
- * file if @p{AdditionalData::log_coefficients = true}, the matrix
+ * file if <tt>AdditionalData::log_coefficients = true</tt>, the matrix
* @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}}.
+ * elements <tt>1/alpha_0</tt>, <tt>1/alpha_1 + beta_0/alpha_0</tt>, ...,
+ * <tt>1/alpha_{m-1</tt>+beta_{m-2}/alpha_{m-2}} and off-diagonal elements
+ * <tt>sqrt(beta_0)/alpha_0</tt>, ..., <tt>sqrt(beta_{m-2</tt>)/alpha_{m-2}}.
* The eigenvalues of this matrix can be computed by postprocessing.
*
* This version of CG is taken from Braess: "Finite Elements". It
* Control class for iterative solvers.
*
* Used by iterative methods to determine whether the iteration should
- * be continued. To this respect, the virtual function @p{check()} is
+ * be continued. To this respect, the virtual function <tt>check()</tt> is
* called in each iteration with the current iteration step and the
* value indicating convergence (usually the residual).
*
* @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
+ * <tt>check()</tt> can be replaced in derived classes to allow for more
* sophisticated tests.
*
*
*
* The possible values of State are
* <ul>
- * <li> @p{iterate = 0}: continue the iteration.
+ * <li> <tt>iterate = 0</tt>: continue the iteration.
* <li> @p success: the goal is reached, the iterative method can terminate
* successfully.
* <li> @p failure: the iterative method should stop because convergence
* scripts checks for this and
* sets the flag @p HAVE_ISNAN
* in the file
- * @p{Make.global_options} if
+ * <tt>Make.global_options</tt> if
* this function was found.
*
- * @p{check()} additionally
+ * <tt>check()</tt> additionally
* preserves @p step and
* @p check_value. These
* values are accessible by
- * @p{last_value()} and
- * @p{last_step()}.
+ * <tt>last_value()</tt> and
+ * <tt>last_step()</tt>.
*
* Derived classes may overload
* this function, e.g. to log the
* Enables the failure
* check. Solving is stopped with
* @p ReturnState @p failure if
- * @p{residual>failure_residual} with
- * @p{failure_residual:=rel_failure_residual*first_residual}.
+ * <tt>residual>failure_residual</tt> with
+ * <tt>failure_residual:=rel_failure_residual*first_residual</tt>.
*/
void set_failure_criterion (const double rel_failure_residual);
* of an iteration. This function
* calls the one in the base
* class, but sets the tolerance
- * to @p{reduction * initial value}
+ * to <tt>reduction * initial value</tt>
* upon the first iteration.
*/
virtual State check (const unsigned int step,
* computed by the GMRes method but need to be computed in addition. This
* (especially for the left preconditioned GMRes) might lead to a significant
* loss in the solver performance. Therefore, the user should set
- * @p{use_default_residual=false} only for debugging/testing purposes.
+ * <tt>use_default_residual=false</tt> only for debugging/testing purposes.
*
* For the requirements on matrices and vectors in order to work with
* this class, see the documentation of the Solver base class.
* Krylov space method inside the preconditioner.
*
* FGMRES needs two vectors in each iteration steps yielding a total
- * of @p{2*AdditionalData::max_basis_size+1} auxiliary vectors.
+ * of <tt>2*AdditionalData::max_basis_size+1</tt> auxiliary vectors.
*
* Caveat: documentation of this class is not up to date. There are
* also a few parameters of GMRES we would like to introduce here.
* The algorithm is taken from the Master thesis of Astrid Batterman
* with some changes.
* The full text can be found at
- * @p{http://scholar.lib.vt.edu/theses/public/etd-12164379662151/etd-title.html}
+ * <tt>http://scholar.lib.vt.edu/theses/public/etd-12164379662151/etd-title.html</tt>
*
* @author Thomas Richter, 2000
*/
/**
* Prefix increment. This
* always returns a valid
- * entry or @p{end()}.
+ * entry or <tt>end()</tt>.
*/
const_iterator& operator++ ();
/**
* Postfix increment. This
* always returns a valid
- * entry or @p{end()}.
+ * entry or <tt>end()</tt>.
*/
const_iterator& operator++ (int);
*/
bool operator == (const const_iterator&) const;
/**
- * Inverse of @p{==}.
+ * Inverse of <tt>==</tt>.
*/
bool operator != (const const_iterator&) const;
unsigned int n () const;
/**
- * Set the element @p{(i,j)} to
+ * Set the element <tt>(i,j)</tt> to
* @p value. Allocates the entry,
* if it does not exist and
* @p value is non-zero.
/**
* Add @p value to the element
- * @p{(i,j)}. Allocates the entry
+ * <tt>(i,j)</tt>. Allocates the entry
* if it does not exist. Filters
* out zeroes automatically.
*/
* cheaper. Since this operation
* is notheless not for free, we
* do not make it available
- * through @p{operator =}, since
+ * through <tt>operator =</tt>, since
* this may lead to unwanted
* usage, e.g. in copy arguments
* to functions, which should
* cited function is that the
* objects which the inner
* iterator points to need to be
- * of type @p{std::pair<unsigned int, value},
+ * of type <tt>std::pair<unsigned int, value</tt>,
* where @p value
* needs to be convertible to the
* element type of this class, as
* error if the matrix is not square.
*
* This function is considerably
- * faster than the @p{operator()},
+ * faster than the <tt>operator()</tt>,
* since for square matrices, the
* diagonal entry is always the
* first to be stored in each row
* @p B has a @p const_iterator
* traversing all matrix entries
* and that @p A has a function
- * @p{el(i,j)} for access to a
+ * <tt>el(i,j)</tt> for access to a
* specific entry.
*/
template <class MATRIXA, class MATRIXB>
* STL-like iterator with the
* first entry of row @p r. If
* this row is empty, the result
- * is @p{end(r)}, which does NOT
+ * is <tt>end(r)</tt>, which does NOT
* point into row @p r..
*/
const_iterator begin (const unsigned int r) const;
/**
* Final iterator of row
* @p r. The result may be
- * different from @p{end()}!
+ * different from <tt>end()</tt>!
*/
const_iterator end (const unsigned int r) const;
/**
* Print the matrix to the given
* stream, using the format
- * @p{(line,col) value}, i.e. one
+ * <tt>(line,col) value</tt>, i.e. one
* nonzero entry of the matrix
* per line.
*/
* Version of @p vmult which only
* performs its actions on the
* region defined by
- * @p{[begin_row,end_row)}. This
+ * <tt>[begin_row,end_row)</tt>. This
* function is called by @p vmult
* in the case of enabled
* multithreading.
* @p matrix_norm_square which
* only performs its actions on
* the region defined by
- * @p{[begin_row,end_row)}. This
+ * <tt>[begin_row,end_row)</tt>. This
* function is called by
* @p matrix_norm_square in the
* case of enabled
* @p matrix_scalar_product which
* only performs its actions on
* the region defined by
- * @p{[begin_row,end_row)}. This
+ * <tt>[begin_row,end_row)</tt>. This
* function is called by
* @p matrix_scalar_product in the
* case of enabled
* 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
- * 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
+ * the element <tt>(i,j)</tt> is a nonzero entry in the sparse matrix under
+ * consideration. The elements <tt>(j,i)</tt> are not considered. We now pick all
* matrix entries from rows and columns out of the set of degrees of freedom
* just described out of the global matrix and put it into a local matrix,
* which is subsequently inverted. This system may be of different size for
* multithreaded mode. By
* default, this variable is set
* to the value of
- * @p{multithread_info.n_default_threads}.
+ * <tt>multithread_info.n_default_threads</tt>.
*/
SparseVanka(const SparseMatrix<number> &M,
const std::vector<bool> &selected,
* degrees of freedom. This is
* then equivalent to calling the
* function with a
- * @p{vector<bool>(n_dofs,true)}.
+ * <tt>vector<bool>(n_dofs,true)</tt>.
*
* The @p vmult of this class
* of course calls this function
/**
* Compute the inverses at
* positions in the range
- * @p{[begin,end)}. In
+ * <tt>[begin,end)</tt>. In
* non-multithreaded mode,
- * @p{compute_inverses()} calls
+ * <tt>compute_inverses()</tt> calls
* this function with the whole
* range, but in multithreaded
* mode, several copies of this
* 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
+ * <tt>x.f()</tt>, where @p x is an
* object of the base class, and
* @p f one of it's non-public
* member functions).
* want to set the number of blocks equal to the number of processors
* you have.
*
- * Note that the parallelization is done if @p{deal.II} was configured
+ * Note that the parallelization is done if <tt>deal.II</tt> was configured
* for multithread use and that the number of threads which is spawned
* equals the number of blocks. This is reasonable since you will not
* want to set the number of blocks unnecessarily large, since, as
* 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 <tt>[0,N)</tt>, where @p N is the number of
* degrees of freedom of the system of equations.
*
* <ul>
* <li> @p index_intervals:
- * Here, we chose the blocks to be intervals @p{[a_i,a_{i+1})},
+ * Here, we chose the blocks to be intervals <tt>[a_i,a_{i+1</tt>)},
* i.e. consecutive degrees of freedom are usually also within the
* same block. This is a reasonable strategy, if the degrees of
* freedom have, for example, be re-numbered using the
* 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
+ * @p SparseBlockVanka with <tt>n_blocks==1</tt>), the following numbers of
* iterations is needed to solver the linear system in each nonlinear
* step:
* @verbatim
* In this field, we precompute
* for each block which degrees
* of freedom belong to it. Thus,
- * if @p{dof_masks[i][j]==true},
+ * if <tt>dof_masks[i][j]==true</tt>,
* 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
+ * <tt>dof_masks[l][j]</tt> may be
+ * @p true for <tt>l!=i</tt>. This
* computation is done in the
* constructor, to avoid
* recomputing each time the
// now we know that block @p i
// wants to write to DoF @p j
// as often as
- // @p{access_count[i][j]}
+ // <tt>access_count[i][j]</tt>
// times. Let @p j be allotted
// to the block which
// accesses it most often.
* about that. In particular do
* not take over ownership of any
* files that @p v might own (as,
- * for example, @p{C++}'s
+ * for example, <tt>C++</tt>'s
* @p auto_ptr objects would do).
*/
SwappableVector (const SwappableVector &v);
/**
* Declare standard types used in all
* containers. These types parallel
- * those in the @p{C++} standard libraries
- * @p{vector<...>} class.
+ * those in the <tt>C++</tt> standard libraries
+ * <tt>vector<...></tt> class.
*/
typedef Number value_type;
typedef value_type *pointer;
* The constructor is made
* explicit to avoid accidents
* like this:
- * @p{v=0;}. Presumably, the user
+ * <tt>v=0;</tt>. Presumably, the user
* wants to set every element of
* the vector to zero, but
* instead, what happens is this
/**
* Set all entries to zero. Equivalent to
- * @p{v = 0}, but more obvious and
+ * <tt>v = 0</tt>, but more obvious and
* faster. Note that this function does
* not change the size of the vector,
- * unlike the STL's @p{vector<>::clear}
+ * unlike the STL's <tt>vector<>::clear</tt>
* function.
*/
void clear ();
* vector remains unchanged if possible,
* to make things faster; this may waste
* some memory, so keep this in mind.
- * However, if @p{N==0} all memory is
+ * However, if <tt>N==0</tt> all memory is
* freed, i.e. if you want to resize the
* vector and release the memory not
* needed, you have to first call
- * @p{reinit(0)} and then
- * @p{reinit(N)}. This cited behaviour is
+ * <tt>reinit(0)</tt> and then
+ * <tt>reinit(N)</tt>. This cited behaviour is
* analogous to that of the STL
* containers.
*
*
* The elements of @p V are not copied,
* i.e. this function is the same as
- * calling @p{reinit (V.size(), fast)}.
+ * calling <tt>reinit (V.size(), fast)</tt>.
*/
template <typename Number2>
void reinit (const Vector<Number2> &V,
* the @p swap function of all C++
* standard containers. Also,
* there is a global function
- * @p{swap(u,v)} that simply calls
- * @p{u.swap(v)}, again in analogy
+ * <tt>swap(u,v)</tt> that simply calls
+ * <tt>u.swap(v)</tt>, again in analogy
* to standard functions.
*/
void swap (Vector<Number> &v);
/**
* Make the @p Vector class a bit like the
- * @p{vector<>} class of the C++ standard
+ * <tt>vector<></tt> class of the C++ standard
* library by returning iterators to
* the start and end of the elements of this
* vector.
/**
* Simple vector addition, equal to the
- * @p{operator +=}.
+ * <tt>operator +=</tt>.
*/
void add (const Vector<Number> &V);
/**
* Simple addition of a multiple of a
- * vector, i.e. @p{*this += a*V}.
+ * vector, i.e. <tt>*this += a*V</tt>.
*/
void add (const Number a, const Vector<Number> &V);
/**
* Multiple addition of scaled vectors,
- * i.e. @p{*this += a*V+b*W}.
+ * i.e. <tt>*this += a*V+b*W</tt>.
*/
void add (const Number a, const Vector<Number> &V,
const Number b, const Vector<Number> &W);
/**
* Scaling and simple vector addition,
* i.e.
- * @p{*this = s*(*this)+V}.
+ * <tt>*this = s*(*this)+V</tt>.
*/
void sadd (const Number s,
const Vector<Number> &V);
/**
* Scaling and simple addition, i.e.
- * @p{*this = s*(*this)+a*V}.
+ * <tt>*this = s*(*this)+a*V</tt>.
*/
void sadd (const Number s,
const Number a,
/**
* Scaling and multiple addition.
- * @p{*this = s*(*this)+a*V + b*W + c*X}.
+ * <tt>*this = s*(*this)+a*V + b*W + c*X</tt>.
*/
void sadd (const Number s,
const Number a,
* This function is deprecated
* and will be removed in a
* future version. Use
- * @p{operator *=} and
- * @p{operator /=} instead.
+ * <tt>operator *=</tt> and
+ * <tt>operator /=</tt> instead.
*/
void scale (const Number factor);
void scale (const Vector<Number2> &scaling_factors);
/**
- * Assignment @p{*this = a*V}.
+ * Assignment <tt>*this = a*V</tt>.
*/
template <typename Number2>
void equ (const Number a, const Vector<Number2>& V);
/**
- * Assignment @p{*this = a*V + b*W}.
+ * Assignment <tt>*this = a*V + b*W</tt>.
*/
void equ (const Number a, const Vector<Number>& V,
const Number b, const Vector<Number>& W);
/**
* Compute the elementwise ratio of the
* two given vectors, that is let
- * @p{this[i] = a[i]/b[i]}. This is
+ * <tt>this[i] = a[i]/b[i]</tt>. This is
* useful for example if you want to
* compute the cellwise ratio of true to
* estimated error.
* This vector is appropriately
* scaled to hold the result.
*
- * If any of the @p{b[i]} is
+ * If any of the <tt>b[i]</tt> is
* zero, the result is
* undefined. No attempt is made
* to catch such situations.
* Dimension. Actual number of
* components contained in the
* vector. Get this number by
- * calling @p{size()}.
+ * calling <tt>size()</tt>.
*/
unsigned int dim;
projects / dealii-svn.git / commitdiff