// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
*
* @sect3{Information for all DoFLevel classes}
*
- * The DoFLevel<tt><N></tt> classes
+ * The <tt>DoFLevel<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<tt>::make_hanging_node_constraints ()</tt>
+ * constraint matrix returned by DoFHandler::make_hanging_node_constraints()
* is then
* to be understood as a block matrix.
*
* The storage format of the degrees of freedom indices (short: DoF
* indices) is somewhat like a mirror of the data structures of the
* triangulation classes. There is a hierarchy of
- * DoFLevel<tt><dim></tt> classes for the different dimensions which
+ * DoFLevel<dim> classes for the different dimensions which
* have objects named @p line_dofs, @p quad_dofs and so on, in which
* the indices of DoFs located on lines and quads, respectively, are
* stored. The indices are stored levelwise. The layout in these
* arrays is as follows: if for a selected finite element (use
- * DoFHandler<tt>::distribute_dofs()</tt> to select a finite element)
+ * DoFHandler::distribute_dofs() to select a finite element)
* the number of DoFs on each line (without those in the vertices) is
* @p N, then the length of the @p line_dofs array is @p N times
* the number of lines on this level. The DoF indices for the @p ith
* of hanging nodes. They have
* to be taken care of by a call
* to
- * ConstraintMatrix<tt>::condense()</tt>
+ * ConstraintMatrix::condense()
* afterwards.
*
* Remember using
- * SparsityPattern<tt>::compress()</tt>
+ * SparsityPattern::compress()
* after generating the pattern.
*
* The actual type of the
* nodes. The sparsity pattern
* is not compressed, since if
* you want to call
- * ConstraintMatrix<tt>::condense(1)</tt>
+ * ConstraintMatrix::condense()
* afterwards, new entries have
* to be added. However, if you
* don't want to call
- * ConstraintMatrix<tt>::condense(1)</tt>,
+ * ConstraintMatrix::condense(),
* you have to compress the
* matrix yourself, using
- * SparsityPattern<tt>::compress()</tt>.
+ * SparsityPattern::compress()
*
* The actual type of the
* sparsity pattern may be
* 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<tt><dim>::create_triangulation</tt> function.
+ * Triangulation::create_triangulation() function.
*
* @author Wolfgang Bangerth, 2000, Michael Anderson 2003
*/
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* 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<tt><dim>::clear ()</tt> resets the underlying triangulation to a
+ * Triangulation::clear() resets the underlying triangulation to a
* virgin state, but does not affect the stored refinement flags needed for
* later reconstruction and does also not touch the coarse grid which is
- * used withing <tt>restore()</tt>.
+ * used within restore().
*
* @author Wolfgang Bangerth, 1999
*/
/**
* Structure which is passed to the
- * Triangulation<tt><dim>::create_triangulation</tt> function. It
+ * <tt>Triangulation<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<tt><dim>::create_triangulation</tt>
+ * Structure to be passed to the Triangulation<dim>::create_triangulation
* function to describe boundary information.
*
* This structure is the same for all dimensions, since we use an input
* 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<tt><dim>::read_*</tt> functions. The appropriate function to be
- * called is <tt>Triangulation<dim>::create_triangulation ()</tt>.
+ * GridIn<dim>::read_* functions. The appropriate function to be
+ * called is create_triangulation().
*
* Creating the hierarchical information needed for this
* library from cells storing only vertex information can be
* @p cylinder function of GridGenerator. It should be used for
* the hull of the cylinder only (boundary indicator 0).
*
- * This class is derived from StraightBoundary rather than from
- * Boundary, which would seem natural, since this way we can use the
- * StraightBoundary<tt><dim>::in_between(neighbors)</tt> function.
+ * This class is derived from StraightBoundary rather than from
+ * Boundary, which would seem natural, since this way we can use the
+ * StraightBoundary::in_between() function.
*
- * @author Guido Kanschat, 2001
+ * @author Guido Kanschat, 2001
*/
template <int dim>
class CylinderBoundary : public StraightBoundary<dim>
*
* This class is derived from StraightBoundary rather than from
* Boundary, which would seem natural, since this way we can use the
- * StraightBoundary<tt><dim>::in_between(neighbors)</tt> function.
+ * StraightBoundary::in_between() function.
*
* @author Wolfgang Bangerth, 1998, Ralf Hartmann, 2001
*/
* stored in this list. A line is
* called active if it has no
* children. The function
- * TriaIterator<tt>::active()</tt>
+ * TriaAccessor::has_children()
* tests for this.
*/
std::vector<int> children;
* already been processed.
*
* You can clear all used flags using
- * Triangulation<tt>::clear_user_flags()</tt>.
+ * Triangulation::clear_user_flags().
*/
std::vector<bool> user_flags;
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* generate output for. The usual
* way would, of course, be to
* use an object of type
- * DoFHandler<tt><dim>::fec_iterator</tt>,
+ * <tt>DoFHandler<dim>::face_iterator</tt>,
* but since we have to describe
* faces to objects of type
* FEValues, we can only
* 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<tt><dim>::refine_*</tt> functions. This
+ * can be used to feed the <tt>Triangulation<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.
* 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<tt><dim>::make_sparsity_pattern</tt>
+ * You can do this by calling the DoFTools::make_sparsity_pattern()
* function.
*
* Furthermore it is assumed that no relevant data is in the matrix. All
* 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<tt>::distribute_dofs(...)</tt> will change at least some of the
+ * DoFHandler::distribute_dofs() will change at least some of the
* DoF indices. Hence we need to store the DoF indices of all active cells
* before the refinement. The @p user_pointer of each active cell
* 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 <tt>prepare_for_pure_refinement()</tt>.
+ * done by prepare_for_pure_refinement().
*
* 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)
* <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<tt>::create_*</tt> functions which take a right hand side do,
+ * <tt>MatrixCreator::create_*</tt> functions which take a right hand side do,
* but without assembling a matrix.
*
* <li> Creation of boundary right hand side vectors: The
*
* 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<tt><double>::l1_norm</tt> function. For the global <i>L<sup>2</sup></i>
+ * <tt>Vector<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<tt><double>::l2_norm</tt>. These two operations
+ * <tt>Vector<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<tt><double>::linfty_norm</tt> function.
+ * using the <tt>Vector<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.