/**
* Define some types for the DoF handling in one dimension.
*
- * The types have the same meaning as those declared in @ref{TriaDimensionInfo<2>}.
+ * The types have the same meaning as those declared in TriaDimensionInfo<2>.
*
* @author Wolfgang Bangerth, 1998
*/
/**
* Define some types for the DoF handling in two dimensions.
*
- * The types have the same meaning as those declared in @ref{TriaDimensionInfo<2>}.
+ * The types have the same meaning as those declared in TriaDimensionInfo<2>.
*
* @author Wolfgang Bangerth, 1998
*/
/**
* Define some types for the DoF handling in two dimensions.
*
- * The types have the same meaning as those declared in @ref{TriaDimensionInfo<3>}.
+ * The types have the same meaning as those declared in TriaDimensionInfo<3>.
*
* @author Wolfgang Bangerth, 1998
*/
/**
* Store the indices of the degrees of freedom which are located on
- * quads. See @ref{DoFLevel<1>} for more information.
+ * quads. See DoFLevel<1> for more information.
*
* @author Wolfgang Bangerth, 1998
*/
/**
* Store the indices of the degrees of freedom which are located on
- * hexhedra. See @ref{DoFLevel<1>} for more information.
+ * hexhedra. See DoFLevel<1> for more information.
*
* @author Wolfgang Bangerth, 1998
*/
const UpdateFlags update_flags);
/**
- * Constructor. Uses @ref{MappingQ1}
+ * Constructor. Uses MappingQ1
* implicitly.
*/
FEValues (const FiniteElement<dim> &fe,
const UpdateFlags update_flags);
/**
- * Constructor. Uses @ref{MappingQ1}
+ * Constructor. Uses MappingQ1
* implicitly.
*/
FEFaceValues (const FiniteElement<dim>& fe,
const UpdateFlags update_flags);
/**
- * Constructor. Uses @ref{MappingQ1}
+ * Constructor. Uses MappingQ1
* implicitly.
*/
FESubfaceValues (const FiniteElement<dim>& fe,
* further information.
*
* Example: refer to the same
- * function in @ref{MappingQ1}.
+ * function in MappingQ1.
*/
virtual UpdateFlags update_once (const UpdateFlags) const = 0;
* Cache class used to store the number of used and active elements
* (lines or quads etc) within the levels of a triangulation. This
* specialization stores the numbers of quads. Due to the inheritance
- * from the base class @ref{TriaNumberCache<1>}, the numbers of lines
+ * from the base class TriaNumberCache<1>, the numbers of lines
* are also within this class.
*
* In the old days, whenever one wanted to access one of these
* Cache class used to store the number of used and active elements
* (lines or quads etc) within the levels of a triangulation. This
* specialization stores the numbers of hexes. Due to the inheritance
- * from the base class @ref{TriaNumberCache<2>}, the numbers of lines
+ * from the base class TriaNumberCache<2>, the numbers of lines
* and quads are also within this class.
*
* In the old days, whenever one wanted to access one of these
* <li> Face 4: children 3, 2, 6, 7;
* <li> Face 5: children 0, 4, 7, 3.
* </ul>
- * You can get these numbers using the @ref{GeometryInfo<3>}@p ::child_cell_on_face
+ * You can get these numbers using the GeometryInfo<3>@p ::child_cell_on_face
* function. Each child is adjacent to the vertex with the same number.
*
* Note that, again, the above list only holds for faces in their
/**
* Store all information which belongs to one level of the multilevel hierarchy.
*
- * In @ref{TriangulationLevel<0>} all data is stored which is not
+ * In TriangulationLevel<0> all data is stored which is not
* dependent on the dimension, e.g. a field to store the
* refinement flag for the cells (what a cell actually is
* is declared elsewhere), etc. Actually, it is only cell-based
* between the number of new quads and
* the number of new lines, etc.). Also
* don't forget to call the
- * @ref{TriangulationLevel<0>}@p ::reserve_space
+ * TriangulationLevel<0>@p ::reserve_space
* function.
*/
void reserve_space (const unsigned int new_lines);
* information about the children of these lines and quads.
*
* The vector of lines and their children is derived from
- * @ref{TriangulationLevel<1>}.
+ * TriangulationLevel<1>.
*
* @author Wolfgang Bangerth, 1998
*/
* level.
*
* It is fully analogous to the
- * @ref{TriangulationLevel<1>::LinesData} structure inherited from
+ * TriangulationLevel<1>::LinesData structure inherited from
* Triangulation<tt><1></tt>.
*/
struct QuadsData
std::vector<Quad> quads;
/**
* Same as for the
- * @ref{TriangulationLevel<1>::LinesData}@p ::chilren
+ * TriangulationLevel<1>::LinesData@p ::chilren
* array, but since there
* are four children, the
* index points to the first
/**
* Same as for
- * @ref{TriangulationLevel<1>::LinesData}@p ::used.
+ * TriangulationLevel<1>::LinesData@p ::used.
*/
std::vector<bool> used;
/**
* Same as for
- * @ref{TriangulationLevel<1>::LinesData}@p ::used.
+ * TriangulationLevel<1>::LinesData@p ::used.
*/
std::vector<bool> user_flags;
* Triangulation class) or in the opposite direction.
*
* The vectors of lines and quads and their children are derived from
- * @ref{TriangulationLevel<2>}.
+ * TriangulationLevel<2>.
*
* @author Wolfgang Bangerth, 1998, 2003
*/
* level.
*
* It is fully analogous to the
- * @ref{TriangulationLevel<1>::LinesData}
+ * TriangulationLevel<1>::LinesData
* structure inherited from
- * @ref{Triangulation<1>}.
+ * Triangulation<1>.
*/
struct HexesData
{
/**
* Same as for the
- * @ref{TriangulationLevel<1>::LinesData}@p ::chilren
+ * TriangulationLevel<1>::LinesData@p ::chilren
* array, but since there
* are four children, the
* index points to the first
/**
* Same as for
- * @ref{TriangulationLevel<1>::LinesData}@p ::used.
+ * TriangulationLevel<1>::LinesData@p ::used.
*/
std::vector<bool> used;
/**
* Same as for
- * @ref{TriangulationLevel<1>::LinesData}@p ::used.
+ * TriangulationLevel<1>::LinesData@p ::used.
*/
std::vector<bool> user_flags;
* the values of the finite element field at the centers of the cells
* are taken. It might therefore only be useful to use this class for
* discontinuous, piecewise constant elements (i.e. using the
- * @ref{FEDG_Q0} class), since all other finite elements can approximate
+ * FEDG_Q0 class), since all other finite elements can approximate
* gradients themselves.
*
*
* square of the jumps) of each cell and take the square root.
*
* The integration is done using a quadrature formula on the face.
- * For linear trial functions (@ref{FEQ1}), the @ref{QGauss2} or even the
+ * For linear trial functions (FEQ1), the QGauss2 or even the
* QMidpoint rule will suffice. For higher order elements, it is
* necessary to utilize higher order quadrature formulae as well.
*
*
* There exist two versions of each function. One with a Mapping
* argument and one without. If a code uses a mapping different from
- * @ref{MappingQ1} the functions <em>with</em> mapping argument should
- * be used. Code that uses only @ref{MappingQ1} may also use the
+ * MappingQ1 the functions <em>with</em> mapping argument should
+ * be used. Code that uses only MappingQ1 may also use the
* functions <em>without</em> Mapping argument. Each of these
- * latter functions create a @ref{MappingQ1} object and just call the
+ * latter functions create a MappingQ1 object and just call the
* respective functions with that object as mapping argument. The
* functions without Mapping argument still exist to ensure
* backward compatibility. Nevertheless it is advised to change the
* the functions that take this @p Mapping object as argument. This
* gives the possibility to easily extend the user codes to work also
* on mappings of higher degree, this just by exchanging
- * @ref{MappingQ1} by, for example, a MappingQ or another
+ * MappingQ1 by, for example, a MappingQ or another
* Mapping object of interest.
*
* All functions take a sparse matrix object to hold the matrix to be