* One of the uses of DerivativeForm is to apply it as a transformation. This
* is what this function does. If @p T is DerivativeForm<1,dim,1> it computes
* $DF * T$, if @p T is DerivativeForm<1,dim,rank> it computes $T*DF^{t}$.
+ *
* @relates DerivativeForm
* @author Sebastian Pauletti, 2011
*/
/**
* Similar to previous apply_transformation. It computes $T*DF^{t}$.
+ *
* @relates DerivativeForm
* @author Sebastian Pauletti, 2011
*/
/**
* Similar to previous apply_transformation. It computes $DF2*DF1^{t}$
+ *
* @relates DerivativeForm
* @author Sebastian Pauletti, 2011
*/
/**
* Transpose of a rectangular DerivativeForm DF, mostly for compatibility
- * reasons. @relates DerivativeForm
+ * reasons.
+ *
+ * @relates DerivativeForm
* @author Sebastian Pauletti, 2011
*/
template <int dim, int spacedim>
* subject to change. Rather create new exception classes using the
* <tt>DeclException</tt> macro family.
*
- * See the @ref Exceptions module for more details on this class and what can
+ * See the
+ * @ref Exceptions
+ * module for more details on this class and what can
* be done with classes derived from it.
*
* @ingroup Exceptions
* VectorTools::integrate_difference, where it allows to integrate only one or
* a few vector components, rather than the entire vector-valued solution. In
* other words, it acts as a component mask with a single component selected
- * (see the @ref GlossComponentMask "the glossary entry on component masks").
+ * (see the
+ * @ref GlossComponentMask "the glossary entry on component masks"
+ * ).
* See the step-20 tutorial program for a detailed explanation and a use case.
*
* @ingroup functions
* places in application programs where you need this information actually,
* but a few places in the library make use of this. Note that in 2d, the
* result is always @p true. More information on the topic can be found in
- * this @ref GlossFaceOrientation "glossary" article.
+ * this
+ * @ref GlossFaceOrientation "glossary"
+ * article.
*
* In order to allow all kinds of meshes in 3d, including
* <em>Moebius</em>-loops, a face might even be rotated looking from one cell,
* This information is available as the <tt>line_orientation</tt> flag for
* cells and faces in 3d. Again, this is something that should be internal to
* the library and application program will probably never have to bother
- * about it. For more information on this see also @ref GlossFaceOrientation
- * "this glossary entry" .
+ * about it. For more information on this see also
+ * @ref GlossFaceOrientation "this glossary entry".
*
*
* <h4>Children</h4>
*
* @note Instantiations for this template are provided for dimensions 1,2,3,4,
* and there is a specialization for dim=0 (see the section on
- * @ref Instantiations in the manual).
+ * @ref Instantiations
+ * in the manual).
*
* @ingroup grid geomprimitives aniso
* @author Wolfgang Bangerth, 1998, Ralf Hartmann, 2005, Tobias Leicht, 2007
* defaults to <tt>true</tt>, <tt>face_flip</tt> and <tt>face_rotation</tt>
* default to <tt>false</tt> (standard orientation) and has no effect in 2d.
* The concept of face orientations is explained in this
- * @ref GlossFaceOrientation "glossary" entry.
+ * @ref GlossFaceOrientation "glossary"
+ * entry.
*
* In the case of anisotropically refined cells and faces, the @p
* RefinementCase of the face, <tt>face_ref_case</tt>, might have an
* the standard and non-standard orientation. <tt>face_orientation</tt>
* defaults to <tt>true</tt>, <tt>face_flip</tt> and <tt>face_rotation</tt>
* default to <tt>false</tt> (standard orientation). In 2d only
- * <tt>face_flip</tt> is considered. See this @ref GlossFaceOrientation
- * "glossary" article for more information.
+ * <tt>face_flip</tt> is considered. See this
+ * @ref GlossFaceOrientation "glossary"
+ * article for more information.
*
* As the children of a cell are ordered according to the vertices of the
* cell, this call is passed down to the child_cell_on_face() function.
* tangential to the quad mapped into three-dimensional space.
*
* This function is used in order to determine how distorted a cell is (see
- * the entry on @ref GlossDistorted "distorted cells" in the glossary).
+ * the entry on
+ * @ref GlossDistorted "distorted cells"
+ * in the glossary).
*/
template <int spacedim>
static void
* least in 3d, actual faces of cells in a triangulation can also have the
* opposite orientation, depending on a flag that one can query from the
* cell it belongs to. For more information, see the
- * @ref GlossFaceOrientation "glossary" entry on face orientation.
+ * @ref GlossFaceOrientation "glossary"
+ * entry on face orientation.
*/
static const int unit_normal_orientation[faces_per_cell];
* color.
*
* @note The algorithm used in this function is described in a paper by
- * Turcksin, Kronbichler and Bangerth, see @ref workstream_paper .
+ * Turcksin, Kronbichler and Bangerth, see
+ * @ref workstream_paper.
*
* @param[in] begin The first element of a range of iterators for which a
* coloring is sought.
* class are a subset.
*
* The data structures used in this class along with a rationale can be found
- * in the @ref distributed_paper "Distributed Computing paper".
+ * in the
+ * @ref distributed_paper "Distributed Computing paper".
*
* @author Wolfgang Bangerth, 2009
*/
* DoFHandler can return ranges of cell iterators using an object of the
* current type from functions such as Triangulation::cells() and that such an
* object can then be used in a range-based for loop as supported by C++11,
- * see also @ref CPP11 "C++11 standard".
+ * see also
+ * @ref CPP11 "C++11 standard".
*
* For example, such a loop could look like this if the goal is to set the
* user flag on every active cell:
* multithreaded programs. At the moment this is just the number of CPUs. If
* deal.II is compiled with multithreading support, some functions will use
* multiple threads for their action. Currently the library supports both
- * thread-based and task-based parallelism. @ref threads describes the
+ * thread-based and task-based parallelism.
+ * @ref threads
+ * describes the
* different uses of each. The default number of threads used for task-based
* parallel methods is selected automatically by the Threading Building Blocks
- * library. See @ref threads for more information on this. Thread-based
+ * library. See
+ * @ref threads
+ * for more information on this. Thread-based
* parallel methods need to explicitly created threads and may want to use a
* number of threads that is related to the number of CPUs in your system.
* This can be queried using the variable <code> multithread_info.n_cpus;
private:
/**
- * Value of the lower bound. A number that satisfies the @ref match
+ * Value of the lower bound. A number that satisfies the
+ * @ref match
* operation of this class must be equal to this value or larger, if the
* bounds of the interval for a valid range.
*/
const int lower_bound;
/**
- * Value of the upper bound. A number that satisfies the @ref match
+ * Value of the upper bound. A number that satisfies the
+ * @ref match
* operation of this class must be equal to this value or less, if the
* bounds of the interval for a valid range.
*/
private:
/**
- * Value of the lower bound. A number that satisfies the @ref match
+ * Value of the lower bound. A number that satisfies the
+ * @ref match
* operation of this class must be equal to this value or larger, if the
* bounds of the interval for a valid range.
*/
const double lower_bound;
/**
- * Value of the upper bound. A number that satisfies the @ref match
+ * Value of the upper bound. A number that satisfies the
+ * @ref match
* operation of this class must be equal to this value or less, if the
* bounds of the interval for a valid range.
*/
/**
* Test for the string being one of a sequence of values given like a
* regular expression. For example, if the string given to the constructor
- * is <tt>"red|blue|black"</tt>, then the @ref match function returns
+ * is <tt>"red|blue|black"</tt>, then the
+ * @ref match
+ * function returns
* <tt>true</tt> exactly if the string is either "red" or "blue" or "black".
* Spaces around the pipe signs do not matter and are eliminated.
*/
* Input may be sorted into subsection trees in order to give the input a
* logical structure, and input files may include other files.
*
- * The ParameterHandler class is discussed in detail in the @ref step_19
- * "step-19" example program, and is used in more realistic situations in
+ * The ParameterHandler class is discussed in detail in the
+ * @ref step_19 "step-19"
+ * example program, and is used in more realistic situations in
* step-29, step-33 and step-34.
*
* <h3>Declaring entries</h3>
* <tt>cell->face_orientation(face)</tt>), so we have to project quadrature
* formula onto faces and subfaces in two orientations. (Refer to the
* documentation of the Triangulation class for a description of the
- * orientation of the different faces, as well as to @ref GlossFaceOrientation
- * "the glossary entry on face orientation" for more information on this.) The
+ * orientation of the different faces, as well as to
+ * @ref GlossFaceOrientation "the glossary entry on face orientation"
+ * for more information on this.) The
* DataSetDescriptor member class is used to identify where each dataset
* starts.
*
* N is the constructor parameter of QGauss.
*
* @note Instantiations for this template are provided for dimensions 0, 1, 2,
- * and 3 (see the section on @ref Instantiations).
+ * and 3 (see the section on
+ * @ref Instantiations
+ * ).
*
* @author Wolfgang Bangerth, Guido Kanschat, 1998, 1999, 2000, 2005, 2009
*/
/**
* The type used to denote subdomain_ids of cells.
*
- * See the @ref GlossSubdomainId "glossary" for more information.
+ * See the
+ * @ref GlossSubdomainId "glossary"
+ * for more information.
*
* There is a special value, numbers::invalid_subdomain_id that is used to
* indicate an invalid value of this type.
*
* The data type always indicates an unsigned integer type.
*
- * See the @ref GlobalDoFIndex page for guidance on when this type should or
+ * See the
+ * @ref GlobalDoFIndex
+ * page for guidance on when this type should or
* should not be used.
*/
// TODO: we should check that unsigned long long int
* boundary indicator for faces that are in the interior of the domain and
* therefore not part of any addressable boundary component.
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
typedef unsigned char boundary_id;
* There is a special value, numbers::flat_manifold_id that is used to
* indicate the standard cartesian manifold.
*
- * @see @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
+ * @see
+ * @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
*/
typedef unsigned int manifold_id;
* We assume that all valid boundary_ids lie in the range [0,
* invalid_boundary_id).
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
const types::boundary_id invalid_boundary_id = static_cast<types::boundary_id>(-1);
* faces that lie in the interior of the domain. You should never try to
* assign this boundary indicator to anything in user code.
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
const types::boundary_id internal_face_boundary_id = static_cast<types::boundary_id>(-1);
* We assume that all valid manifold_ids lie in the range [0,
* invalid_maifold_id).
*
- * @see @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
+ * @see
+ * @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
*/
const types::manifold_id invalid_manifold_id = static_cast<types::manifold_id>(-1);
/**
* A manifold_id we reserve for the default flat Cartesian manifold.
*
- * @see @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
+ * @see
+ * @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
*/
const types::manifold_id flat_manifold_id = static_cast<types::manifold_id>(-1);
* valid id but is used, for example, for default arguments to indicate a
* subdomain id that is not to be used.
*
- * See the @ref GlossSubdomainId "glossary" for more information.
+ * See the
+ * @ref GlossSubdomainId "glossary"
+ * for more information.
*/
const types::subdomain_id invalid_subdomain_id = static_cast<types::subdomain_id>(-1);
* that is kept distributed on many processors. Such cells are called
* "artificial".
*
- * See the glossary entries on @ref GlossSubdomainId "subdomain ids" and
- * @ref GlossArtificialCell "artificial cells" as well as the
- * @ref distributed module for more information.
+ * See the glossary entries on
+ * @ref GlossSubdomainId "subdomain ids"
+ * and
+ * @ref GlossArtificialCell "artificial cells"
+ * as well as the
+ * @ref distributed
+ * module for more information.
*/
const types::subdomain_id artificial_subdomain_id = static_cast<types::subdomain_id>(-2);
}
* uses the Intel Threading Building Blocks (TBB) to load balance the
* individual subranges onto the available threads. For a lengthy discussion
* of the rationale of this class, see the
- * @ref threads "Parallel computing with multiple processors" module. It is
+ * @ref threads "Parallel computing with multiple processors"
+ * module. It is
* used in the tutorial first in step-9, and again in step-13, step-14,
* step-32 and others.
*
* A namespace for the implementation of details of the WorkStream pattern
* and function. This namespace holds classes that deal with the second
* implementation described in the paper by Turcksin, Kronbichler and
- * Bangerth (see @ref workstream_paper).
+ * Bangerth (see
+ * @ref workstream_paper
+ * ).
*
* Even though this implementation is slower than the third implementation
* discussed in that paper, we need to keep it around for two reasons: (i)
* A namespace for the implementation of details of the WorkStream pattern
* and function. This namespace holds classes that deal with the third
* implementation described in the paper by Turcksin, Kronbichler and
- * Bangerth (see @ref workstream_paper).
+ * Bangerth (see
+ * @ref workstream_paper
+ * ).
*/
namespace Implementation3
{
* This is one of two main functions of the WorkStream concept, doing work
* as described in the introduction to this namespace. It corresponds to
* implementation 3 of the paper by Turcksin, Kronbichler and Bangerth, see
- * @ref workstream_paper . As such, it takes not a range of iterators
+ * @ref workstream_paper.
+ * As such, it takes not a range of iterators
* described by a begin and end iterator, but a "colored" graph of iterators
* where each color represents cells for which writing the cell
* contributions into the global object does not conflict (in other words,
* This is one of two main functions of the WorkStream concept, doing work
* as described in the introduction to this namespace. It corresponds to
* implementation 2 of the paper by Turcksin, Kronbichler and Bangerth (see
- * @ref workstream_paper).
+ * @ref workstream_paper
+ * ).
*
* This function that can be used for worker and copier objects that are
* either pointers to non-member functions or objects that allow to be
* This is a variant of one of the two main functions of the WorkStream
* concept, doing work as described in the introduction to this namespace.
* It corresponds to implementation 2 of the paper by Turcksin, Kronbichler
- * and Bangerth (see @ref workstream_paper).
+ * and Bangerth (see
+ * @ref workstream_paper
+ * ).
*
* This is the function that can be used for worker and copier functions
* that are member functions of a class. If the copier is an empty function,
* dealii::Triangulation class but there are a number of difficult
* algorithms under the hood that ensure we always have a load-balanced,
* fully distributed mesh. Use of this class is explained in step-40,
- * step-32, the @ref distributed documentation module, as well as the
- * @ref distributed_paper . See there for more information. This class
- * satisfies the requirements outlined in @ref GlossMeshAsAContainer
- * "Meshes as containers".
+ * step-32, the
+ * @ref distributed
+ * documentation module, as well as the
+ * @ref distributed_paper.
+ * See there for more information. This class
+ * satisfies the requirements outlined in
+ * @ref GlossMeshAsAContainer "Meshes as containers".
*
* @note This class does not support anisotropic refinement, because it
* relies on the p4est library that does not support this. Attempts to
* mesh that we want to store here from what we have stored before
* therefore may involve several cycles of refining and coarsening the
* locally stored set of cells until we have finally gotten from the
- * previous to the next triangulation. (This process is described in more
- * detail in the @ref distributed_paper.) Unfortunately, in this process,
+ * previous to the next triangulation. This process is described in more
+ * detail in the
+ * @ref distributed_paper.
+ * Unfortunately, in this process,
* some information can get lost relating to flags that are set by user
* code and that are inherited from mother to child cell but that are not
* moved along with a cell if that cell is migrated from one processor to
/**
* A typedef that is used to to identify
- * @ref GlossActive "active cell iterators". The concept of iterators
+ * @ref GlossActive "active cell iterators".
+ * The concept of iterators
* is discussed at length in the
* @ref Iterators "iterators documentation module".
*
* As a consequence of the remark above, the result of this function is
* always smaller or equal to the result of the function with the same
* name in the ::Triangulation base class, which includes the active
- * ghost and artificial cells (see also @ref GlossArtificialCell and
+ * ghost and artificial cells (see also
+ * @ref GlossArtificialCell
+ * and
* @ref GlossGhostCell).
*/
unsigned int n_locally_owned_active_cells () const;
* 2:1 relationship between cells, this may mean that there are hanging
* nodes between cells that are not locally owned or ghost cells (i.e.,
* between ghost cells and artificial cells, or between artificial and
- * artificial cells; see @ref GlossArtificialCell "the glossary"). One
+ * artificial cells; see
+ * @ref GlossArtificialCell "the glossary"
+ * ). One
* is not typically interested in this case, so the function returns
* whether there are hanging nodes between any two cells of the "global"
* mesh, i.e., the union of locally owned cells on all processors.
* A class that gives access to the degrees of freedom stored in a DoFHandler,
* MGSoDHandler, or hp::DoFHandler object. Accessors are used to, access the
* data that pertains to edges, faces, and cells of a triangulation. The
- * concept is explained in more detail in connection to @ref Iterators.
+ * concept is explained in more detail in connection to
+ * @ref Iterators.
*
* This class follows mainly the route laid out by the accessor library
* declared in the triangulation library (TriaAccessor). It enables the user
* this object in the standard ordering defined by the finite element (i.e.,
* dofs on vertex 0, dofs on vertex 1, etc, dofs on line 0, dofs on line 1,
* etc, dofs on quad 0, etc.) This function is only available on
- * <i>active</i> objects (see @ref GlossActive "this glossary entry").
+ * <i>active</i> objects (see
+ * @ref GlossActive "this glossary entry"
+ * ).
*
* The cells needs to be an active cell (and not artificial in a parallel
* distributed computation).
*/
DeclException0 (ExcMatrixDoesNotMatch);
/**
- * A function has been called for a cell which should be active, but is
- * refined. @ref GlossActive
+ * A function has been called for a cell which should be
+ * @ref GlossActive "active"
+ * , but is refined.
*
* @ingroup Exceptions
*/
* this object in the standard ordering defined by the finite element (i.e.,
* dofs on vertex 0, dofs on vertex 1, etc, dofs on line 0, dofs on line 1,
* etc, dofs on quad 0, etc.) This function is only available on
- * <i>active</i> objects (see @ref GlossActive "this glossary entry").
+ * <i>active</i> objects (see
+ * @ref GlossActive "this glossary entry"
+ * ).
*
* The cells needs to be an active cell (and not artificial in a parallel
* distributed computation).
*/
DeclException0 (ExcMatrixDoesNotMatch);
/**
- * A function has been called for a cell which should be active, but is
- * refined. @ref GlossActive
+ * A function has been called for a cell which should be
+ * @ref GlossActive "active"
+ * , but is refined.
*
* @ingroup Exceptions
*/
* this object in the standard ordering defined by the finite element (i.e.,
* dofs on vertex 0, dofs on vertex 1, etc, dofs on line 0, dofs on line 1,
* etc, dofs on quad 0, etc.) This function is only available on
- * <i>active</i> objects (see @ref GlossActive "this glossary entry").
+ * <i>active</i> objects (see
+ * @ref GlossActive "this glossary entry"
+ * ).
*
* @param[out] dof_indices The vector into which the indices will be
* written. It has to have the right size (namely,
/**
* Manage the distribution and numbering of the degrees of freedom for non-
* multigrid algorithms. This class satisfies the requirements outlined in
- * @ref GlossMeshAsAContainer "Meshes as containers". It is first used in the
+ * @ref GlossMeshAsAContainer "Meshes as containers".
+ * It is first used in the
* step-2 tutorial program.
*
* For each vertex, line, quad, etc, this class stores a list of the indices
* i.e. the class that represents triangulations that entirely reside on a
* single processor. However, it can also be of type
* parallel::distributed::Triangulation (see, for example, step-32, step-40
- * and in particular the @ref distributed module) in which case the DoFHandler
+ * and in particular the
+ * @ref distributed
+ * module) in which case the DoFHandler
* object will proceed to only manage degrees of freedom on locally owned and
* ghost cells. This process is entirely transparent to the used.
*
*
* The current typedef identifies cells in a DoFHandler object. Some of
* these cells may in fact be active (see
- * @ref GlossActive "active cell iterators") in which case they can in
+ * @ref GlossActive "active cell iterators"
+ * ) in which case they can in
* fact be asked for the degrees of freedom that live on them. On the
* other hand, if the cell is not active, any such query will result in
* an error. Note that this is what distinguishes this typedef from the
* use an intermediate compressed sparsity pattern that only allocates
* memory on demand. Refer to the step-2 and step-11 example programs on how
* to do this. The problem is also discussed in the documentation of the
- * module on @ref Sparsity.
+ * module on
+ * @ref Sparsity.
*/
unsigned int max_couplings_between_dofs () const;
*
* @note The same applies to this function as to max_couplings_per_dofs() as
* regards the performance of this function. Think about one of the dynamic
- * sparsity pattern classes instead (see @ref Sparsity).
+ * sparsity pattern classes instead (see
+ * @ref Sparsity
+ * ).
*/
unsigned int max_couplings_between_boundary_dofs () const;
/**
* Return an iterator range that contains all active cells that make up this
* DoFHandler. Such a range is useful to initialize range-based for loops as
- * supported by C++11, see also @ref CPP11 "C++11 standard".
+ * supported by C++11, see also
+ * @ref CPP11 "C++11 standard".
*
* Range-based for loops are useful in that they require much less code than
* traditional loops (see <a href="http://en.wikipedia.org/wiki/C%2B%2B11
* the global number of degrees of freedom, accumulated over all processors.
*
* In either case, included in the returned number are those DoFs which are
- * constrained by hanging nodes, see @ref constraints.
+ * constrained by hanging nodes, see
+ * @ref constraints.
*/
types::global_dof_index n_dofs () const;
* Access to an object informing of the block structure of the dof handler.
*
* If an FESystem is used in distribute_dofs(), degrees of freedom naturally
- * split into several @ref GlossBlock "blocks". For each base element as
+ * split into several
+ * @ref GlossBlock "blocks".
+ * For each base element as
* many blocks appear as its multiplicity.
*
* At the end of distribute_dofs(), the number of degrees of freedom in each
*
* The types have the same meaning as those declared in
* internal::Triangulation::Iterators<1,spacedim>, only the treatment of
- * templates is a little more complicated. See the @ref Iterators module
+ * templates is a little more complicated. See the
+ * @ref Iterators
+ * module
* for more information.
*
* @author Wolfgang Bangerth, Oliver Kayser-Herold, Guido Kanschat, 1998,
*
* The types have the same meaning as those declared in
* internal::Triangulation::Iterators<2,spacedim>, only the treatment of
- * templates is a little more complicated. See the @ref Iterators module
- * for more information.
+ * templates is a little more complicated. See the
+ * @ref Iterators
+ * module for more information.
*
* @author Wolfgang Bangerth, Oliver Kayser-Herold, Guido Kanschat, 1998,
* 2003, 2008, 2010
*
* The types have the same meaning as those declared in
* internal::Triangulation::Iterators<3,spacedim>, only the treatment of
- * templates is a little more complicated. See the @ref Iterators module
- * for more information.
+ * templates is a little more complicated. See the
+ * @ref Iterators
+ * module for more information.
*
* @author Wolfgang Bangerth, Oliver Kayser-Herold, Guido Kanschat, 1998,
* 2003, 2008, 2010
* The component_wise() function allows not only to honor enumeration based on
* vector components, but also allows to group together vector components into
* "blocks" using a defaulted argument to the various
- * DoFRenumber::component_wise() functions (see @ref GlossComponent vs
- * @ref GlossBlock for a description of the difference). The blocks designated
+ * DoFRenumber::component_wise() functions (see
+ * @ref GlossComponent
+ * vs
+ * @ref GlossBlock
+ * for a description of the difference). The blocks designated
* through this argument may, but do not have to be, equal to the blocks that
* the finite element reports. For example, a typical Stokes element would be
* @code
*
* This function only succeeds if each of the elements in the
* hp::FECollection attached to the hp::DoFHandler argument has exactly the
- * same number of blocks (see @ref GlossBlock "the glossary" for more
+ * same number of blocks (see
+ * @ref GlossBlock "the glossary"
+ * for more
* information). Note that this is not always given: while the
* hp::FECollection class ensures that all of its elements have the same
* number of vector components, they need not have the same number of
* into account at the time of creating the sparsity pattern. For this, pass
* the ConstraintMatrix object as the third argument to the current
* function. No call to ConstraintMatrix::condense() is then necessary. This
- * process is explained in @ref step_27 "step-27".
+ * process is explained in
+ * @ref step_27 "step-27"
+.
*
* In case the constraints are already taken care of in this function, it is
* possible to neglect off-diagonal entries in the sparsity pattern. When
* The object into which these are inserted is later used to condense the
* global system matrix and right hand side, and to extend the solution
* vectors from the true degrees of freedom also to the constraint nodes.
- * This function is explained in detail in the @ref step_6 "step-6" tutorial
+ * This function is explained in detail in the
+ * @ref step_6 "step-6"
+ * tutorial
* program and is used in almost all following programs as well.
*
* This function does not clear the constraint matrix object before use, in
* (dofs the entry is constrained to, inhomogeneities) is kept and nothing
* happens.
*
- * The flags in the @p component_mask (see @ref GlossComponentMask) denote
+ * The flags in the @p component_mask (see
+ * @ref GlossComponentMask
+ * ) denote
* which components of the finite element space shall be constrained with
* periodic boundary conditions. If it is left as specified by the default
* value all components are constrained. If it is different from the default
* parallel::distributed::Triangulation::add_periodicity has to be called
* before.
*
- * @see @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions"
+ * @see
+ * @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions"
* for further information.
*
* @author Daniel Arndt, Matthias Maier, 2013, 2014
* happens.
*
* The flags in the last parameter, @p component_mask (see
- * @ref GlossComponentMask) denote which components of the finite element space
+ * @ref GlossComponentMask
+ * ) denote which components of the finite element space
* shall be constrained with periodic boundary conditions. If it is left as
* specified by the default value all components are constrained. If it is
* different from the default value, it is assumed that the number of
* feeds the output to above make_periodicity_constraints() variant. If you
* need more functionality use GridTools::collect_periodic_faces() directly.
*
- * @see @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions"
+ * @see
+ * @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions"
* for further information.
*
* @author Matthias Maier, 2012
/**
* This compatibility version of make_periodicity_constraints only works on
- * grids with cells in @ref GlossFaceOrientation "standard orientation".
+ * grids with cells in
+ * @ref GlossFaceOrientation "standard orientation".
*
* Instead of defining a 'first' and 'second' boundary with the help of two
* boundary_indicators this function defines a 'left' boundary as all faces
* feeds the output to above make_periodicity_constraints() variant. If you
* need more functionality use GridTools::collect_periodic_faces() directly.
*
- * @see @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions"
+ * @see
+ * @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions"
* for further information.
*/
template<typename DH>
* (which holds, for example, for FE_Nedelec or FE_RaviartThomas elements),
* then shape functions cannot be associated with a single vector component.
* In this case, if <em>one</em> shape vector component of this element is
- * flagged in @p component_mask (see @ref GlossComponentMask), then this is
+ * flagged in @p component_mask (see
+ * @ref GlossComponentMask
+ * ), then this is
* equivalent to selecting <em>all</em> vector components corresponding to
* this non-primitive base element.
*
/**
* This function is the equivalent to the DoFTools::extract_dofs() functions
* above except that the selection of which degrees of freedom to extract is
- * not done based on components (see @ref GlossComponent) but instead based
- * on whether they are part of a particular block (see @ref GlossBlock).
- * Consequently, the second argument is not a ComponentMask but a BlockMask
+ * not done based on components (see
+ * @ref GlossComponent
+ * ) but instead based
+ * on whether they are part of a particular block (see
+ * @ref GlossBlock
+ * ). Consequently, the second argument is not a ComponentMask but a BlockMask
* object.
*
* @param dof_handler The DoFHandler object from which to extract degrees of
* freedom
* @param block_mask The block mask that describes which blocks to consider
- * (see @ref GlossBlockMask)
+ * (see
+ * @ref GlossBlockMask
+ * )
* @param selected_dofs A vector of length DoFHandler::n_dofs() in which
* those entries are true that correspond to the selected blocks.
*/
* freedom are located that shall be extracted. If it is an empty list, then
* all boundary indicators are accepted.
*
- * The size of @p component_mask (see @ref GlossComponentMask) shall equal
+ * The size of @p component_mask (see
+ * @ref GlossComponentMask
+ * ) shall equal
* the number of components in the finite element used by @p dof. The size
* of @p selected_dofs shall equal <tt>dof_handler.n_dofs()</tt>. Previous
* contents of this array or overwritten.
* @param dof_handler The object that describes which degrees of freedom
* live on which cell
* @param component_mask A mask denoting the vector components of the finite
- * element that should be considered (see also @ref GlossComponentMask).
+ * element that should be considered (see also
+ * @ref GlossComponentMask
+ * ).
* @param selected_dofs The IndexSet object that is returned and that will
* contain the indices of degrees of freedom that are located on the
* boundary (and correspond to the selected vector components and boundary
* empty list, then the function only considers boundary faces with the
* boundary indicators listed in this argument.
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template <class DH>
void
* parallel::distributed::Triangulation, then the @p selected_dofs index set
* will contain only those degrees of freedom on the boundary that belong to
* the locally relevant set (see
- * @ref GlossLocallyRelevantDof "locally relevant DoFs").
+ * @ref GlossLocallyRelevantDof "locally relevant DoFs"
+ * ).
*
* @param dof_handler The object that describes which degrees of freedom
* live on which cell
* @param component_mask A mask denoting the vector components of the finite
- * element that should be considered (see also @ref GlossComponentMask).
+ * element that should be considered (see also
+ * @ref GlossComponentMask
+ * ).
* @param selected_dofs The IndexSet object that is returned and that will
* contain the indices of degrees of freedom that are located on the
* boundary (and correspond to the selected vector components and boundary
* empty list, then the function only considers boundary faces with the
* boundary indicators listed in this argument.
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template <class DH>
void
* the FiniteElement::has_support_on_face function says that it is nonzero
* on any face on one of the selected boundary parts.
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template <class DH>
void
/**
* Extract a vector that represents the constant modes of the DoFHandler for
* the components chosen by <tt>component_mask</tt> (see
- * @ref GlossComponentMask).
+ * @ref GlossComponentMask
+ * ).
* The constant modes on a discretization are the null
* space of a Laplace operator on the selected components with Neumann
* boundary conditions applied. The null space is a necessary ingredient for
* space (or rather, the constant modes) is provided by the finite element
* underlying the given DoFHandler and for most elements, the null space
* will consist of as many vectors as there are true arguments in
- * <tt>component_mask</tt> (see @ref GlossComponentMask), each of which will
+ * <tt>component_mask</tt> (see
+ * @ref GlossComponentMask
+ * ), each of which will
* be one in one vector component and zero in all others. However, the
* representation of the constant function for e.g. FE_DGP is different (the
* first component on each element one, all other components zero), and some
* indices that live on all locally owned cells (including on the interface
* to ghost cells). However, it does not contain the DoF indices that are
* exclusively defined on ghost or artificial cells (see
- * @ref GlossArtificialCell "the glossary").
+ * @ref GlossArtificialCell "the glossary"
+ * ).
*
* The degrees of freedom identified by this function equal those obtained
* from the dof_indices_with_subdomain_association() function when called
* DoFHandler objects built on parallel::distributed::Triangulation this set
* is the union of DoFHandler::locally_owned_dofs() and the DoF indices on
* all ghost cells. In essence, it is the DoF indices on all cells that are
- * not artificial (see @ref GlossArtificialCell "the glossary").
+ * not artificial (see
+ * @ref GlossArtificialCell "the glossary"
+ * ).
*/
template <class DH>
void
/**
* Count the degrees of freedom in each block. This function is similar to
* count_dofs_per_component(), with the difference that the counting is done
- * by blocks. See @ref GlossBlock "blocks" in the glossary for details.
+ * by blocks. See
+ * @ref GlossBlock "blocks"
+ * in the glossary for details.
* Again the vectors are assumed to have the correct size before calling
* this function. If this is not the case, an assertion is thrown.
*
*
* See the general doc of this class for more information.
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template <class DH>
void
/**
* Return a list of support points (see this
- * @ref GlossSupport "glossary entry") for all the degrees of freedom
+ * @ref GlossSupport "glossary entry"
+ * ) for all the degrees of freedom
* handled by this DoF handler object. This function, of course, only
* works if the finite element object used by the DoF handler object
* actually provides support points, i.e. no edge elements or the like.
/**
* This function is a version of the above map_dofs_to_support_points
* function that doesn't simply return a vector of support points (see this
- * @ref GlossSupport "glossary entry") with one entry for each global degree
+ * @ref GlossSupport "glossary entry"
+ * ) with one entry for each global degree
* of freedom, but instead a map that maps from the DoFs index to its
* location. The point of this function is that it is also usable in cases
* where the DoFHandler is based on a parallel::distributed::Triangulation
* were known. As a consequence, this function constructs a map from those
* DoFs for which we can know the locations (namely, those DoFs that are
* locally relevant (see
- * @ref GlossLocallyRelevantDof "locally relevant DoFs") to their
- * locations.
+ * @ref GlossLocallyRelevantDof "locally relevant DoFs"
+ * ) to their locations.
*
* For non-distributed triangulations, the map returned as @p support_points
* is of course dense, i.e., every DoF is to be found in it.
* object consists of constraints on degrees of freedom that are not located
* on the boundary treated here. If there are previously existing
* constraints for degrees of freedom located on the boundary, then this
- * would constitute a conflict. See the @ref constraints module for handling
+ * would constitute a conflict. See the
+ * @ref constraints
+ * module for handling
* the case where there are conflicting constraints on individual degrees of
* freedom.
* @param component_mask An optional component mask that restricts the
* functionality of this function to a subset of an FESystem. For
- * non-@ref GlossPrimitive "primitive" shape functions, any degree of freedom
+ * non-
+ * @ref GlossPrimitive "primitive"
+ * shape functions, any degree of freedom
* is affected that belongs to a shape function where at least one of its
* nonzero components is affected by the component mask (see
- * @ref GlossComponentMask). If this argument is omitted, all components
+ * @ref GlossComponentMask
+ * ). If this argument is omitted, all components
* of the finite element with degrees of freedom at the boundary will be
* considered.
*
* @ingroup constraints
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template <int dim, int spacedim, template <int, int> class DH>
void
/**
* This class represents a mask that can be used to select individual vector
* blocks of a finite element (see also
- * @ref GlossBlockMask "this glossary entry"). It will typically have as
+ * @ref GlossBlockMask "this glossary entry"
+ * ). It will typically have as
* many elements as the finite element has blocks, and one can use
* <code>operator[]</code> to query whether a particular block has been
* selected.
* These objects can either be created by hand, or, simpler, by asking the
* finite element to generate a block mask from certain selected blocks using
* code such as this where we create a mask that only denotes the velocity
- * block of a Stokes element (see @ref vector_valued):
+ * block of a Stokes element (see
+ * @ref vector_valued
+ * ):
* @code
* FESystem<dim> stokes_fe (FESystem<dim>(FE_Q<dim>(2), dim), 1, // Q2 element for the velocities
* FE_Q<dim>(1), 1); // Q1 element for the pressure
/**
* This class represents a mask that can be used to select individual vector
* components of a finite element (see also
- * @ref GlossComponentMask "this glossary entry"). It will typically have
+ * @ref GlossComponentMask "this glossary entry"
+ * ). It will typically have
* as many elements as the finite element has vector components, and one
* can use <code>operator[]</code> to query whether a particular component
* has been selected.
* created by hand, or, simpler, by asking the finite element to generate a
* component mask from certain selected components using code such as this
* where we create a mask that only denotes the velocity components of a
- * Stokes element (see @ref vector_valued):
+ * Stokes element (see
+ * @ref vector_valued
+ * ):
* @code
* FESystem<dim> stokes_fe (FE_Q<dim>(2), dim, // Q2 element for the velocities
* FE_Q<dim>(1), 1); // Q1 element for the pressure
* <h3>Components and blocks</h3>
*
* For vector valued elements shape functions may have nonzero entries in one
- * or several @ref GlossComponent "components" of the vector valued function.
- * If the element is @ref GlossPrimitive "primitive", there is indeed a single
+ * or several
+ * @ref GlossComponent "components"
+ * of the vector valued function.
+ * If the element is
+ * @ref GlossPrimitive "primitive"
+ * , there is indeed a single
* component with a nonzero entry for each shape function. This component can
* be determined by system_to_component_index(), the number of components is
* FiniteElementData::n_components().
*
- * Furthermore, you may want to split your linear system into @ref GlossBlock
- * "blocks" for the use in BlockVector, BlockSparseMatrix, BlockMatrixArray
+ * Furthermore, you may want to split your linear system into
+ * @ref GlossBlock "blocks"
+ * for the use in BlockVector, BlockSparseMatrix, BlockMatrixArray
* and so on. If you use non-primitive elements, you cannot determine the
* block number by system_to_component_index(). Instead, you can use
* system_to_block_index(), which will automatically take care of the
* <h3>Support points</h3>
*
* Since a FiniteElement does not have information on the actual grid cell, it
- * can only provide @ref GlossSupport "support points" on the unit cell.
+ * can only provide
+ * @ref GlossSupport "support points"
+ * on the unit cell.
* Support points on the actual grid cell must be computed by mapping these
* points. The class used for this kind of operation is FEValues. In most
* cases, code of the following type will serve to provide the mapped support
*
* First, already the basis of the shape function space may be difficult to
* implement for arbitrary order and dimension. On the other hand, if the
- * @ref GlossNodes "node values" are given, then the duality relation
+ * @ref GlossNodes "node values"
+ * are given, then the duality relation
* between node functionals and basis functions defines the basis. As a
* result, the shape function space may be defined with arbitrary "raw"
* basis functions, such that the actual finite element basis is computed
* neither dominates, or if either could dominate.
*
* For a definition of domination, see FiniteElementBase::Domination and in
- * particular the @ref hp_paper "hp paper".
+ * particular the
+ * @ref hp_paper "hp paper".
*/
virtual
FiniteElementDomination::Domination
* #system_to_base_table field and the system_to_base_index() function.
*
* The use of this function is explained extensively in the step-8 and
- * @ref step_20 "step-20" tutorial programs as well as in the
+ * @ref step_20 "step-20"
+ * tutorial programs as well as in the
* @ref vector_valued module.
*/
std::pair<unsigned int, unsigned int>
* @param face The number of the face this degree of freedom lives on. This
* number must be between zero and GeometryInfo::faces_per_cell.
* @param face_orientation One part of the description of the orientation of
- * the face. See @ref GlossFaceOrientation .
+ * the face. See
+ * @ref GlossFaceOrientation.
* @param face_flip One part of the description of the orientation of the
- * face. See @ref GlossFaceOrientation .
+ * face. See
+ * @ref GlossFaceOrientation.
* @param face_rotation One part of the description of the orientation of
- * the face. See @ref GlossFaceOrientation . @return The index of this
- * degree of freedom within the set of degrees of freedom on the entire
- * cell. The returned value will be between zero and dofs_per_cell.
+ * the face. See
+ * @ref GlossFaceOrientation.
+ * @return The index of this degree of freedom within the set of degrees of
+ * freedom on the entire cell. The returned value will be between zero and
+ * dofs_per_cell.
*
* @note This function exists in this class because that is where it was
* first implemented. However, it can't really work in the most general case
* Only for those spaces that couple the components, for example to make a
* shape function divergence free, will there be more than one @p true
* entry. Elements for which this is true are called non-primitive (see
- * @ref GlossPrimitive).
+ * @ref GlossPrimitive
+ * ).
*/
const ComponentMask &
get_nonzero_components (const unsigned int i) const;
* Return a component mask with as many elements as this object has vector
* components and of which exactly the one component is true that
* corresponds to the given argument. See
- * @ref GlossComponentMask "the glossary" for more information.
+ * @ref GlossComponentMask "the glossary"
+ * for more information.
*
* @param scalar An object that represents a single scalar vector component
* of this finite element. @return A component mask that is false in all
* Return a component mask with as many elements as this object has vector
* components and of which exactly the <code>dim</code> components are true
* that correspond to the given argument. See
- * @ref GlossComponentMask "the glossary" for more information.
+ * @ref GlossComponentMask "the glossary"
+ * for more information.
*
* @param vector An object that represents dim vector components of this
* finite element. @return A component mask that is false in all components
* Return a component mask with as many elements as this object has vector
* components and of which exactly the <code>dim*(dim+1)/2</code> components
* are true that correspond to the given argument. See
- * @ref GlossComponentMask "the glossary" for more information.
+ * @ref GlossComponentMask "the glossary"
+ * for more information.
*
* @param sym_tensor An object that represents dim*(dim+1)/2 components of
* this finite element that are jointly to be interpreted as forming a
component_mask (const FEValuesExtractors::SymmetricTensor<2> &sym_tensor) const;
/**
- * Given a block mask (see @ref GlossBlockMask "this glossary entry"),
+ * Given a block mask (see
+ * @ref GlossBlockMask "this glossary entry"
+ * ),
* produce a component mask (see
- * @ref GlossComponentMask "this glossary entry") that represents the
+ * @ref GlossComponentMask "this glossary entry"
+ * ) that represents the
* components that correspond to the blocks selected in the input
* argument. This is essentially a conversion operator from BlockMask to
* ComponentMask.
/**
* Return a block mask with as many elements as this object has blocks and
* of which exactly the one component is true that corresponds to the given
- * argument. See @ref GlossBlockMask "the glossary" for more information.
+ * argument. See
+ * @ref GlossBlockMask "the glossary"
+ * for more information.
*
* @note This function will only succeed if the scalar referenced by the
* argument encompasses a complete block. In other words, if, for example,
* Return a component mask with as many elements as this object has vector
* components and of which exactly the <code>dim</code> components are true
* that correspond to the given argument. See
- * @ref GlossBlockMask "the glossary" for more information.
+ * @ref GlossBlockMask "the glossary"
+ * for more information.
*
* @note The same caveat applies as to the version of the function above:
* The extractor object passed as argument must be so that it corresponds to
/**
* Return a component mask with as many elements as this object has vector
* components and of which exactly the <code>dim*(dim+1)/2</code> components
- * are true that correspond to the given argument. See @ref GlossBlockMask
- * "the glossary" for more information.
+ * are true that correspond to the given argument. See
+ * @ref GlossBlockMask "the glossary"
+ * for more information.
*
* @note The same caveat applies as to the version of the function above:
* The extractor object passed as argument must be so that it corresponds to
/**
* Given a component mask (see
- * @ref GlossComponentMask "this glossary entry"), produce a block mask
- * (see @ref GlossBlockMask "this glossary entry") that represents the
+ * @ref GlossComponentMask "this glossary entry"
+ * ), produce a block mask
+ * (see
+ * @ref GlossBlockMask "this glossary entry"
+ * ) that represents the
* blocks that correspond to the components selected in the input
* argument. This is essentially a conversion operator from ComponentMask
* to BlockMask.
*
* <h3>Interpolation</h3>
*
- * The @ref GlossInterpolation "interpolation" operators associated with the
+ * The
+ * @ref GlossInterpolation "interpolation"
+ * operators associated with the
* RT element are constructed such that interpolation and computing the
* divergence are commuting operations. We require this from interpolating
* arbitrary functions as well as the #restriction matrices. It can be
*
* <h4>Node values on edges/faces</h4>
*
- * On edges or faces, the @ref GlossNodes "node values" are the moments of the
+ * On edges or faces, the
+ * @ref GlossNodes "node values"
+ * are the moments of the
* normal component of the interpolated function with respect to the traces of
* the RT polynomials. Since the normal trace of the RT space of degree
* <i>k</i> on an edge/face is the space <i>Q<sub>k</sub></i>, the moments are
* This enum is used in the FiniteElement::compare_for_face_domination()
* function that is used in the context of hp finite element methods when
* determining what to do at faces where two different finite elements meet
- * (see the @ref hp_paper "hp paper" for a more detailed description of the
+ * (see the
+ * @ref hp_paper "hp paper"
+ * for a more detailed description of the
* following). In that case, the degrees of freedom of one side need to be
* constrained to those on the other side. The determination which side is
* which is based on the outcome of a comparison for mutual domination: the
* function.
*
* Note that there are situations where neither side dominates. The
- * @ref hp_paper "hp paper" lists two case, with the simpler one being
+ * @ref hp_paper "hp paper"
+ * lists two case, with the simpler one being
* that a $Q_2\times Q_1$ vector-valued element (i.e. a
* <code>FESystem(FE_Q(2),1,FE_Q(1),1)</code>) meets a $Q_1\times Q_2$
* element: here, for each of the two vector-components, we can define a
* which is an element that has no degrees of freedom in a subdomain. It
* could also be used by discontinuous elements, for example.
*
- * More details on domination can be found in the @ref hp_paper "hp paper".
+ * More details on domination can be found in the
+ * @ref hp_paper "hp paper".
*/
enum Domination
{
unsigned int n_dofs_per_object () const;
/**
- * Number of components. See @ref GlossComponent "the glossary" for more
- * information.
+ * Number of components. See
+ * @ref GlossComponent "the glossary"
+ * for more information.
*/
unsigned int n_components () const;
/**
- * Number of blocks. See @ref GlossBlock "the glossary" for more
- * information.
+ * Number of blocks. See
+ * @ref GlossBlock "the glossary"
+ * for more information.
*/
unsigned int n_blocks () const;
/**
* Set the primitivity of the element. This is usually done by the
- * constructor of a derived class. See @ref GlossPrimitive "primitive" for
- * details.
+ * constructor of a derived class. See
+ * @ref GlossPrimitive "primitive"
+ * for details.
*/
void set_primitivity(const bool value);
* neither dominates, or if either could dominate.
*
* For a definition of domination, see FiniteElementBase::Domination and in
- * particular the @ref hp_paper "hp paper".
+ * particular the
+ * @ref hp_paper "hp paper".
*/
virtual
FiniteElementDomination::Domination
* neither dominates, or if either could dominate.
*
* For a definition of domination, see FiniteElementBase::Domination and in
- * particular the @ref hp_paper "hp paper".
+ * particular the
+ * @ref hp_paper "hp paper".
*/
virtual
FiniteElementDomination::Domination
* neither dominates, or if either could dominate.
*
* For a definition of domination, see FiniteElementBase::Domination and in
- * particular the @ref hp_paper "hp paper".
+ * particular the
+ * @ref hp_paper "hp paper".
*/
virtual
FiniteElementDomination::Domination
* neither dominates, or if either could dominate.
*
* For a definition of domination, see FiniteElementBase::Domination and in
- * particular the @ref hp_paper "hp paper".
+ * particular the
+ * @ref hp_paper "hp paper".
*/
virtual
FiniteElementDomination::Domination
* neither dominates, or if either could dominate.
*
* For a definition of domination, see FiniteElementBase::Domination and in
- * particular the @ref hp_paper "hp paper".
+ * particular the
+ * @ref hp_paper "hp paper".
*/
virtual
FiniteElementDomination::Domination
* neither dominates, or if either could dominate.
*
* For a definition of domination, see FiniteElementBase::Domination and in
- * particular the @ref hp_paper "hp paper".
+ * particular the
+ * @ref hp_paper "hp paper".
*/
virtual
FiniteElementDomination::Domination
* neither dominates, or if either could dominate.
*
* For a definition of domination, see FiniteElementBase::Domination and in
- * particular the @ref hp_paper "hp paper".
+ * particular the
+ * @ref hp_paper "hp paper".
*/
virtual
FiniteElementDomination::Domination
*
* <h3>Interpolation</h3>
*
- * The @ref GlossInterpolation "interpolation" operators associated with the
+ * The
+ * @ref GlossInterpolation "interpolation"
+ * operators associated with the
* Nédélec element are constructed such that interpolation and
* computing the curl are commuting operations on rectangular mesh cells. We
* require this from interpolating arbitrary functions as well as the
*
* <h4>Node values</h4>
*
- * The @ref GlossNodes "node values" for an element of degree <i>k</i> on the
+ * The
+ * @ref GlossNodes "node values"
+ * for an element of degree <i>k</i> on the
* reference cell are:
* <ol>
* <li> On edges: the moments of the tangential component with respect to
* neither dominates, or if either could dominate.
*
* For a definition of domination, see FiniteElementBase::Domination and in
- * particular the @ref hp_paper "hp paper".
+ * particular the
+ * @ref hp_paper "hp paper".
*
* In the current case, this element is always assumed to dominate, unless
* it is also of type FE_Nothing(). In that situation, either element can
* @param face The number of the face this degree of freedom lives on. This
* number must be between zero and GeometryInfo::faces_per_cell.
* @param face_orientation One part of the description of the orientation of
- * the face. See @ref GlossFaceOrientation .
+ * the face. See
+ * @ref GlossFaceOrientation.
* @param face_flip One part of the description of the orientation of the
- * face. See @ref GlossFaceOrientation .
+ * face. See
+ * @ref GlossFaceOrientation.
* @param face_rotation One part of the description of the orientation of
- * the face. See @ref GlossFaceOrientation . @return The index of this
+ * the face. See
+ * @ref GlossFaceOrientation.
+ * @return The index of this
* degree of freedom within the set of degrees of freedom on the entire
* cell. The returned value will be between zero and dofs_per_cell.
*/
* neither dominates, or if either could dominate.
*
* For a definition of domination, see FiniteElementBase::Domination and in
- * particular the @ref hp_paper "hp paper".
+ * particular the
+ * @ref hp_paper "hp paper".
*/
virtual
FiniteElementDomination::Domination
* neither dominates, or if either could dominate.
*
* For a definition of domination, see FiniteElementBase::Domination and in
- * particular the @ref hp_paper "hp paper".
+ * particular the
+ * @ref hp_paper "hp paper".
*/
virtual
FiniteElementDomination::Domination
* neither dominates, or if either could dominate.
*
* For a definition of domination, see FiniteElementBase::Domination and in
- * particular the @ref hp_paper "hp paper".
+ * particular the
+ * @ref hp_paper "hp paper".
*/
virtual
FiniteElementDomination::Domination
*
* <h3>Interpolation</h3>
*
- * The @ref GlossInterpolation "interpolation" operators associated with the
+ * The
+ * @ref GlossInterpolation "interpolation"
+ * operators associated with the
* RT element are constructed such that interpolation and computing the
* divergence are commuting operations. We require this from interpolating
* arbitrary functions as well as the #restriction matrices. It can be
*
* <h4>Node values on edges/faces</h4>
*
- * On edges or faces, the @ref GlossNodes "node values" are the moments of the
+ * On edges or faces, the
+ * @ref GlossNodes "node values"
+ * are the moments of the
* normal component of the interpolated function with respect to the traces of
* the RT polynomials. Since the normal trace of the RT space of degree
* <i>k</i> on an edge/face is the space <i>Q<sub>k</sub></i>, the moments are
* that are possibly of different type. The result is then a vector-valued
* finite element. %Vector valued elements are discussed in a number of
* tutorial programs, for example step-8, step-20, step-21, and in particular
- * in the @ref vector_valued module.
+ * in the
+ * @ref vector_valued
+ * module.
*
* <h3>FESystem, components and blocks</h3>
*
* partial differential equation, the finite element side looks a bit
* different Since not only FESystem, but also vector-valued elements like
* FE_RaviartThomas, have several components. The concept needed here is a
- * @ref GlossBlock "block". Each block encompasses the set of degrees of
+ * @ref GlossBlock "block".
+ * Each block encompasses the set of degrees of
* freedom associated with a single base element of an FESystem, where base
* elements with multiplicities count multiple times. These blocks are usually
* addressed using the information in DoFHandler::block_info(). The number of
* @param face The number of the face this degree of freedom lives on. This
* number must be between zero and GeometryInfo::faces_per_cell.
* @param face_orientation One part of the description of the orientation of
- * the face. See @ref GlossFaceOrientation .
+ * the face. See
+ * @ref GlossFaceOrientation.
* @param face_flip One part of the description of the orientation of the
- * face. See @ref GlossFaceOrientation .
+ * face. See
+ * @ref GlossFaceOrientation.
* @param face_rotation One part of the description of the orientation of
- * the face. See @ref GlossFaceOrientation . @return The index of this
- * degree of freedom within the set of degrees of freedom on the entire
- * cell. The returned value will be between zero and dofs_per_cell.
+ * the face. See
+ * @ref GlossFaceOrientation.
+ * @return The index of this degree of freedom within the set of degrees of
+ * freedom on the entire cell. The returned value will be between zero and
+ * dofs_per_cell.
*/
virtual
unsigned int face_to_cell_index (const unsigned int face_dof_index,
* neither dominates, or if either could dominate.
*
* For a definition of domination, see FiniteElementBase::Domination and in
- * particular the @ref hp_paper "hp paper".
+ * particular the
+ * @ref hp_paper "hp paper".
*/
virtual
FiniteElementDomination::Domination
*
* Note also that this table exists once for each space dimension. If you
* have a program that works with finite elements in different space
- * dimensions (for example, @ref step_4 "step-4" does something like this),
+ * dimensions (for example,
+ * @ref step_4 "step-4"
+ * does something like this),
* then you should call this function for each space dimension for which you
* want your finite element added to the map.
*/
DeclException0 (ExcInvalidFE);
/**
- * The finite element must be @ref GlossPrimitive "primitive".
+ * The finite element must be
+ * @ref GlossPrimitive "primitive".
*
* @ingroup Exceptions
*/
* flags.
*
* The mechanism by which all this is accomplished is also discussed on the
- * page on @ref UpdateFlagsEssay.
+ * page on
+ * @ref UpdateFlagsEssay.
*/
enum UpdateFlags
{
* order tensor components consisting of <code>(dim*dim + dim)/2</code>
* elements
*
- * See the description of the @ref vector_valued module for examples how to
+ * See the description of the
+ * @ref vector_valued
+ * module for examples how to
* use the features of this namespace.
*
* @ingroup feaccess vector_valued
/**
* A class representing a view to a single scalar component of a possibly
* vector-valued finite element. Views are discussed in the
- * @ref vector_valued module.
+ * @ref vector_valued
+ * module.
*
* You get an object of this type if you apply a FEValuesExtractors::Scalar
* to an FEValues, FEFaceValues or FESubfaceValues object.
/**
* A class representing a view to a set of <code>spacedim</code> components
* forming a vector part of a vector-valued finite element. Views are
- * discussed in the @ref vector_valued module.
+ * discussed in the
+ * @ref vector_valued
+ * module.
*
* Note that in the current context, a vector is meant in the sense physics
* uses it: it has <code>spacedim</code> components that behave in specific
/**
* A class representing a view to a set of <code>(dim*dim + dim)/2</code>
* components forming a symmetric second-order tensor from a vector-valued
- * finite element. Views are discussed in the @ref vector_valued module.
+ * finite element. Views are discussed in the
+ * @ref vector_valued
+ * module.
*
* This class allows to query the value and divergence of (components of)
* shape functions and solutions representing symmetric tensors. The
/**
* A class representing a view to a set of <code>dim*dim</code> components
* forming a second-order tensor from a vector-valued finite element. Views
- * are discussed in the @ref vector_valued module.
+ * are discussed in the
+ * @ref vector_valued
+ * module.
*
* This class allows to query the value and divergence of (components of)
* shape functions and solutions representing tensors. The divergence of a
* Create a view of the current FEValues object that represents a particular
* scalar component of the possibly vector-valued finite element. The
* concept of views is explained in the documentation of the namespace
- * FEValuesViews and in particular in the @ref vector_valued module.
+ * FEValuesViews and in particular in the
+ * @ref vector_valued
+ * module.
*/
const FEValuesViews::Scalar<dim,spacedim> &
operator[] (const FEValuesExtractors::Scalar &scalar) const;
* Create a view of the current FEValues object that represents a set of
* <code>dim</code> scalar components (i.e. a vector) of the vector-valued
* finite element. The concept of views is explained in the documentation of
- * the namespace FEValuesViews and in particular in the @ref vector_valued
+ * the namespace FEValuesViews and in particular in the
+ * @ref vector_valued
* module.
*/
const FEValuesViews::Vector<dim,spacedim> &
* <code>(dim*dim + dim)/2</code> scalar components (i.e. a symmetric 2nd
* order tensor) of the vector-valued finite element. The concept of views
* is explained in the documentation of the namespace FEValuesViews and in
- * particular in the @ref vector_valued module.
+ * particular in the
+ * @ref vector_valued
+ * module.
*/
const FEValuesViews::SymmetricTensor<2,dim,spacedim> &
operator[] (const FEValuesExtractors::SymmetricTensor<2> &tensor) const;
* <code>(dim*dim)</code> scalar components (i.e. a 2nd order tensor) of the
* vector-valued finite element. The concept of views is explained in the
* documentation of the namespace FEValuesViews and in particular in the
- * @ref vector_valued module.
+ * @ref vector_valued
+ * module.
*/
const FEValuesViews::Tensor<2,dim,spacedim> &
operator[] (const FEValuesExtractors::Tensor<2> &tensor) const;
/**
* Boundary form of the transformation of the cell at the <tt>i</tt>th
- * quadrature point. See @ref GlossBoundaryForm .
+ * quadrature point. See
+ * @ref GlossBoundaryForm.
*
* @dealiiRequiresUpdateFlags{update_boundary_forms}
*/
* <code>dim</code> elements, and second order symmetric tensors consisting of
* <code>(dim*dim + dim)/2</code> components
*
- * See the description of the @ref vector_valued module for examples how to
+ * See the description of the
+ * @ref vector_valued
+ * module for examples how to
* use the features of this namespace.
*
* @ingroup feaccess vector_valued
* result of applying an object of this type to an FEValues, FEFaceValues or
* FESubfaceValues object is of type FEValuesViews::Scalar. The concept of
* extractors is defined in the documentation of the namespace
- * FEValuesExtractors and in the @ref vector_valued module.
+ * FEValuesExtractors and in the
+ * @ref vector_valued
+ * module.
*
* @ingroup feaccess vector_valued
*/
* object is of type FEValuesViews::Vector.
*
* The concept of extractors is defined in the documentation of the
- * namespace FEValuesExtractors and in the @ref vector_valued module.
+ * namespace FEValuesExtractors and in the
+ * @ref vector_valued
+ * module.
*
* Note that in the current context, a vector is meant in the sense physics
* uses it: it has <code>spacedim</code> components that behave in specific
* type FEValuesViews::SymmetricTensor.
*
* The concept of extractors is defined in the documentation of the
- * namespace FEValuesExtractors and in the @ref vector_valued module.
+ * namespace FEValuesExtractors and in the
+ * @ref vector_valued module.
*
* @ingroup feaccess vector_valued
*
* FEValuesViews::Tensor.
*
* The concept of extractors is defined in the documentation of the
- * namespace FEValuesExtractors and in the @ref vector_valued module.
+ * namespace FEValuesExtractors and in the
+ * @ref vector_valued module.
*
* @ingroup feaccess vector_valued
*
* fields not asked for by FEValues, but computed for efficiency reasons
* will be notified here.
*
- * See @ref UpdateFlagsEssay.
+ * See
+ * @ref UpdateFlagsEssay.
*/
virtual UpdateFlags update_once (const UpdateFlags) const = 0;
* The same as update_once(), but for the flags to be updated for each grid
* cell.
*
- * See @ref UpdateFlagsEssay.
+ * See
+ * @ref UpdateFlagsEssay.
*/
virtual UpdateFlags update_each (const UpdateFlags) const = 0;
/**
* Performs the same as @p fill_fe_values on a face. Additionally, @p
- * boundary_form (see @ref GlossBoundaryForm) and @p normal_vectors can be
+ * boundary_form (see
+ * @ref GlossBoundaryForm
+ * ) and @p normal_vectors can be
* computed on surfaces. Since the boundary form already contains the
* determinant of the Jacobian of the transformation, it is sometimes more
* economic to use the boundary form instead of the product of the unit
*
* Some of these functions receive a flag @p colorize. If this is set, parts
* of the boundary receive different boundary indicators (
- * @ref GlossBoundaryIndicator), allowing them to be distinguished for the
+ * @ref GlossBoundaryIndicator
+ * ), allowing them to be distinguished for the
* purpose of attaching geometry objects and evaluating different boundary
* conditions.
*
*
*
* @tparam Container A type that satisfies the requirements of a mesh
- * container (see @ref GlossMeshAsAContainer). The map that is returned will
+ * container (see
+ * @ref GlossMeshAsAContainer
+ * ). The map that is returned will
* be between cell iterators pointing into the container describing the
* surface mesh and face iterators of the volume mesh container. If the
* Container argument is DoFHandler of hp::DoFHandler, then the function
* cells it creates as part of the coarse mesh are distorted or not (where
* distortion here means that the Jacobian of the mapping from the reference
* cell to the real cell has a non-positive determinant, i.e. the cell is
- * pinched or twisted; see the entry on @ref GlossDistorted "distorted cells"
+ * pinched or twisted; see the entry on
+ * @ref GlossDistorted "distorted cells"
* in the glossary). If it finds any such cells, it throws an exception. This
* exception is not caught in the grid reader functions of the current class,
* and so will propagate through to the function that called it. There, you
/**
* Should lines with a set @p user_flag be drawn in a different color
- * (red)? See @ref GlossUserFlags for information about user flags.
+ * (red)? See
+ * @ref GlossUserFlags
+ * for information about user flags.
*/
bool color_lines_on_user_flag;
* located closest to a given point.
*
* @param container A variable of a type that satisfies the requirements of
- * a mesh container (see @ref GlossMeshAsAContainer).
+ * a mesh container (see
+ * @ref GlossMeshAsAContainer
+ * ).
* @param p The point for which we want to find the closest vertex. @return
* The index of the closest vertex found.
*
* vertex of a cell or be a hanging node located on a face or an edge of it.
*
* @param container A variable of a type that satisfies the requirements of
- * a mesh container (see @ref GlossMeshAsAContainer).
+ * a mesh container (see
+ * @ref GlossMeshAsAContainer
+ * ).
* @param vertex_index The index of the vertex for which we try to find
* adjacent cells. @return A vector of cells that lie adjacent to the given
* vertex.
* additional computational cost.
*
* @param container A variable of a type that satisfies the requirements of
- * a mesh container (see @ref GlossMeshAsAContainer).
+ * a mesh container (see
+ * @ref GlossMeshAsAContainer
+ * ).
* @param p The point for which we want to find the surrounding cell.
* @return An iterator into the mesh container that points to the
* surrounding cell.
* changed using a call of the kind
* <code>cell-@>face(1)-@>set_boundary_indicator(42);</code>.
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*
*
* <h3>History of a triangulation</h3>
* field can be accessed as all other data using iterators. Normally, this
* user flag is used if an algorithm walks over all cells and needs
* information whether another cell, e.g. a neighbor, has already been
- * processed. See @ref GlossUserFlags "the glossary for more information".
+ * processed. See
+ * @ref GlossUserFlags "the glossary for more information".
*
* There is another set of user data, which can be either an <tt>unsigned
* int</tt> or a <tt>void *</tt>, for each line, quad, etc. You can access
* these through the functions listed under <tt>User data</tt> in the accessor
- * classes. Again, see @ref GlossUserData "the glossary for more information".
+ * classes. Again, see
+ * @ref GlossUserData "the glossary for more information".
*
* The value of these user indices or pointers is @p NULL by default. Note
* that the pointers are not inherited to children upon refinement. Still,
* cell. Therefore if your new boundary vertex is too near the center of the
* old quadrilateral or hexahedron, the distance to the midpoint vertex will
* become too small, thus generating distorted cells. This issue is discussed
- * extensively in @ref GlossDistorted "distorted cells".
+ * extensively in
+ * @ref GlossDistorted "distorted cells".
*
*
* <h3>Getting notice when a triangulation changes</h3>
/**
* A typedef that is used to to identify
- * @ref GlossActive "active cell iterators". The concept of iterators is
+ * @ref GlossActive "active cell iterators".
+ * The concept of iterators is
* discussed at length in the
* @ref Iterators "iterators documentation module".
*
* A structure that is used as an exception object by the
* create_triangulation() function to indicate which cells among the coarse
* mesh cells are inverted or severely distorted (see the entry on
- * @ref GlossDistorted "distorted cells" in the glossary).
+ * @ref GlossDistorted "distorted cells"
+ * in the glossary).
*
* Objects of this kind are thrown by the create_triangulation() and
* execute_coarsening_and_refinement() functions, and they can be caught in
* @param check_for_distorted_cells Determines whether the triangulation
* should check whether any of the cells that are created by
* create_triangulation() or execute_coarsening_and_refinement() are
- * distorted (see @ref GlossDistorted "distorted cells"). If set, these two
+ * distorted (see
+ * @ref GlossDistorted "distorted cells"
+ * ). If set, these two
* functions may throw an exception if they encounter distorted cells.
*/
Triangulation (const MeshSmoothing smooth_grid = none,
*
* @ingroup boundary
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
void set_boundary (const types::manifold_id number,
const Boundary<dim,spacedim> &boundary_object);
*
* @ingroup boundary
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
void set_boundary (const types::manifold_id number);
*
* @ingroup manifold
*
- * @see @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
+ * @see
+ * @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
*/
void set_manifold (const types::manifold_id number,
const Manifold<dim,spacedim> &manifold_object);
*
* @ingroup manifold
*
- * @see @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
+ * @see
+ * @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
*/
void set_manifold (const types::manifold_id number);
*
* @ingroup boundary
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
const Boundary<dim,spacedim> &get_boundary (const types::manifold_id number) const;
*
* @ingroup manifold
*
- * @see @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
+ * @see
+ * @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
*/
const Manifold<dim,spacedim> &get_manifold (const types::manifold_id number) const;
*
* @ingroup boundary
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
std::vector<types::boundary_id> get_boundary_indicators() const;
*
* @ingroup manifold
*
- * @see @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
+ * @see
+ * @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
*/
std::vector<types::manifold_id> get_manifold_ids() const;
* If the <code>check_for_distorted_cells</code> flag was specified upon
* creation of this object, at the very end of its operation, the current
* function walks over all cells and verifies that none of the cells is
- * deformed (see the entry on @ref GlossDistorted "distorted cells" in the
+ * deformed (see the entry on
+ * @ref GlossDistorted "distorted cells"
+ * in the
* glossary), where we call a cell deformed if the determinant of the
* Jacobian of the mapping from reference cell to real cell is negative at
* least at one of the vertices (this computation is done using the
/**
* Revert or flip the direction_flags of a dim<spacedim triangulation, see
- * @ref GlossDirectionFlag .
+ * @ref GlossDirectionFlag.
*
* This function throws an exception if dim equals spacedim.
*/
*/
/**
- * Clear all user flags. See also @ref GlossUserFlags .
+ * Clear all user flags. See also
+ * @ref GlossUserFlags.
*/
void clear_user_flags ();
/**
* Save all user flags. See the general documentation for this class and the
* documentation for the @p save_refine_flags for more details. See also
- * @ref GlossUserFlags .
+ * @ref GlossUserFlags.
*/
void save_user_flags (std::ostream &out) const;
/**
* Same as above, but store the flags to a bitvector rather than to a file.
- * The output vector is resized if necessary. See also @ref GlossUserFlags .
+ * The output vector is resized if necessary. See also
+ * @ref GlossUserFlags.
*/
void save_user_flags (std::vector<bool> &v) const;
/**
* Read the information stored by @p save_user_flags. See also
- * @ref GlossUserFlags .
+ * @ref GlossUserFlags.
*/
void load_user_flags (std::istream &in);
/**
* Read the information stored by @p save_user_flags. See also
- * @ref GlossUserFlags .
+ * @ref GlossUserFlags.
*/
void load_user_flags (const std::vector<bool> &v);
/**
- * Clear all user flags on lines. See also @ref GlossUserFlags .
+ * Clear all user flags on lines. See also
+ * @ref GlossUserFlags.
*/
void clear_user_flags_line ();
/**
- * Save the user flags on lines. See also @ref GlossUserFlags .
+ * Save the user flags on lines. See also
+ * @ref GlossUserFlags.
*/
void save_user_flags_line (std::ostream &out) const;
/**
* Same as above, but store the flags to a bitvector rather than to a file.
- * The output vector is resized if necessary. See also @ref GlossUserFlags .
+ * The output vector is resized if necessary. See also
+ * @ref GlossUserFlags.
*/
void save_user_flags_line (std::vector<bool> &v) const;
/**
- * Load the user flags located on lines. See also @ref GlossUserFlags .
+ * Load the user flags located on lines. See also
+ * @ref GlossUserFlags.
*/
void load_user_flags_line (std::istream &in);
/**
- * Load the user flags located on lines. See also @ref GlossUserFlags .
+ * Load the user flags located on lines. See also
+ * @ref GlossUserFlags.
*/
void load_user_flags_line (const std::vector<bool> &v);
/**
- * Clear all user flags on quads. See also @ref GlossUserFlags .
+ * Clear all user flags on quads. See also
+ * @ref GlossUserFlags.
*/
void clear_user_flags_quad ();
/**
- * Save the user flags on quads. See also @ref GlossUserFlags .
+ * Save the user flags on quads. See also
+ * @ref GlossUserFlags.
*/
void save_user_flags_quad (std::ostream &out) const;
/**
* Same as above, but store the flags to a bitvector rather than to a file.
- * The output vector is resized if necessary. See also @ref GlossUserFlags .
+ * The output vector is resized if necessary. See also
+ * @ref GlossUserFlags.
*/
void save_user_flags_quad (std::vector<bool> &v) const;
/**
- * Load the user flags located on quads. See also @ref GlossUserFlags .
+ * Load the user flags located on quads. See also
+ * @ref GlossUserFlags.
*/
void load_user_flags_quad (std::istream &in);
/**
- * Load the user flags located on quads. See also @ref GlossUserFlags .
+ * Load the user flags located on quads. See also
+ * @ref GlossUserFlags.
*/
void load_user_flags_quad (const std::vector<bool> &v);
/**
- * Clear all user flags on quads. See also @ref GlossUserFlags .
+ * Clear all user flags on quads. See also
+ * @ref GlossUserFlags.
*/
void clear_user_flags_hex ();
/**
- * Save the user flags on hexs. See also @ref GlossUserFlags .
+ * Save the user flags on hexs. See also
+ * @ref GlossUserFlags.
*/
void save_user_flags_hex (std::ostream &out) const;
/**
* Same as above, but store the flags to a bitvector rather than to a file.
- * The output vector is resized if necessary. See also @ref GlossUserFlags .
+ * The output vector is resized if necessary. See also
+ * @ref GlossUserFlags.
*/
void save_user_flags_hex (std::vector<bool> &v) const;
/**
- * Load the user flags located on hexs. See also @ref GlossUserFlags .
+ * Load the user flags located on hexs. See also
+ * @ref GlossUserFlags.
*/
void load_user_flags_hex (std::istream &in);
/**
- * Load the user flags located on hexs. See also @ref GlossUserFlags .
+ * Load the user flags located on hexs. See also
+ * @ref GlossUserFlags.
*/
void load_user_flags_hex (const std::vector<bool> &v);
/**
* Clear all user pointers and indices and allow the use of both for next
- * access. See also @ref GlossUserData .
+ * access. See also
+ * @ref GlossUserData.
*/
void clear_user_data ();
/**
* @deprecated User clear_user_data() instead.
*
- * Clear all user pointers. See also @ref GlossUserData .
+ * Clear all user pointers. See also
+ * @ref GlossUserData.
*/
void clear_user_pointers () DEAL_II_DEPRECATED;
/**
* Save all user indices. The output vector is resized if necessary. See
- * also @ref GlossUserData .
+ * also
+ * @ref GlossUserData.
*/
void save_user_indices (std::vector<unsigned int> &v) const;
/**
* Read the information stored by save_user_indices(). See also
- * @ref GlossUserData .
+ * @ref GlossUserData.
*/
void load_user_indices (const std::vector<unsigned int> &v);
/**
* Save all user pointers. The output vector is resized if necessary. See
- * also @ref GlossUserData .
+ * also
+ * @ref GlossUserData.
*/
void save_user_pointers (std::vector<void *> &v) const;
/**
* Read the information stored by save_user_pointers(). See also
- * @ref GlossUserData .
+ * @ref GlossUserData.
*/
void load_user_pointers (const std::vector<void *> &v);
/**
* Save the user indices on lines. The output vector is resized if
- * necessary. See also @ref GlossUserData .
+ * necessary. See also
+ * @ref GlossUserData.
*/
void save_user_indices_line (std::vector<unsigned int> &v) const;
/**
- * Load the user indices located on lines. See also @ref GlossUserData .
+ * Load the user indices located on lines. See also
+ * @ref GlossUserData.
*/
void load_user_indices_line (const std::vector<unsigned int> &v);
/**
* Save the user indices on quads. The output vector is resized if
- * necessary. See also @ref GlossUserData .
+ * necessary. See also
+ * @ref GlossUserData.
*/
void save_user_indices_quad (std::vector<unsigned int> &v) const;
/**
- * Load the user indices located on quads. See also @ref GlossUserData .
+ * Load the user indices located on quads. See also
+ * @ref GlossUserData.
*/
void load_user_indices_quad (const std::vector<unsigned int> &v);
/**
* Save the user indices on hexes. The output vector is resized if
- * necessary. See also @ref GlossUserData .
+ * necessary. See also
+ * @ref GlossUserData.
*/
void save_user_indices_hex (std::vector<unsigned int> &v) const;
/**
- * Load the user indices located on hexs. See also @ref GlossUserData .
+ * Load the user indices located on hexs. See also
+ * @ref GlossUserData.
*/
void load_user_indices_hex (const std::vector<unsigned int> &v);
/**
* Save the user indices on lines. The output vector is resized if
- * necessary. See also @ref GlossUserData .
+ * necessary. See also
+ * @ref GlossUserData.
*/
void save_user_pointers_line (std::vector<void *> &v) const;
/**
- * Load the user pointers located on lines. See also @ref GlossUserData .
+ * Load the user pointers located on lines. See also
+ * @ref GlossUserData.
*/
void load_user_pointers_line (const std::vector<void *> &v);
/**
* Save the user pointers on quads. The output vector is resized if
- * necessary. See also @ref GlossUserData .
+ * necessary. See also
+ * @ref GlossUserData.
*/
void save_user_pointers_quad (std::vector<void *> &v) const;
/**
- * Load the user pointers located on quads. See also @ref GlossUserData .
+ * Load the user pointers located on quads. See also
+ * @ref GlossUserData.
*/
void load_user_pointers_quad (const std::vector<void *> &v);
/**
* Save the user pointers on hexes. The output vector is resized if
- * necessary. See also @ref GlossUserData .
+ * necessary. See also
+ * @ref GlossUserData.
*/
void save_user_pointers_hex (std::vector<void *> &v) const;
/**
- * Load the user pointers located on hexs. See also @ref GlossUserData .
+ * Load the user pointers located on hexs. See also
+ * @ref GlossUserData.
*/
void load_user_pointers_hex (const std::vector<void *> &v);
/**
* Return an iterator range that contains all active cells that make up this
* triangulation. Such a range is useful to initialize range-based for loops
- * as supported by C++11, see also @ref CPP11 "C++11 standard".
+ * as supported by C++11, see also
+ * @ref CPP11 "C++11 standard".
*
* Range-based for loops are useful in that they require much less code than
* traditional loops (see <a href="http://en.wikipedia.org/wiki/C%2B%2B11
* <tt>dim=2,3</tt> and the <tt>quad->user_flags</tt> for <tt>dim=3</tt>.
*
* The function returns a list of cells that have produced children that
- * satisfy the criteria of @ref GlossDistorted "distorted cells" if the
+ * satisfy the criteria of
+ * @ref GlossDistorted "distorted cells"
+ * if the
* <code>check_for_distorted_cells</code> flag was specified upon creation
* of this object, at
*/
*/
DeclException0 (ExcCellNotUsed);
/**
- * The cell is not an @ref GlossActive "active" cell, but it already has
+ * The cell is not an
+ * @ref GlossActive "active"
+ * cell, but it already has
* children. Some operations, like setting refinement flags or accessing
* degrees of freedom are only possible on active cells.
*
* (<tt>structdim<dim</tt>).
*
* Some internals of this class are discussed in
- * @ref IteratorAccessorInternals .
+ * @ref IteratorAccessorInternals.
*
* @ingroup grid
* @ingroup Accessors
* assignment, thereby moving the vertex of a cell within the triangulation.
* Of course, doing so requires that you ensure that the new location of the
* vertex remains useful -- for example, avoiding inverted or otherwise
- * distorted (see also @ref GlossDistorted "this glossary entry").
+ * distorted (see also
+ * @ref GlossDistorted "this glossary entry"
+ * ).
*
* @note When a cell is refined, its children inherit the position of the
* vertex positions of those vertices they share with the mother cell (plus
* @note The behavior described above is relevant if you have a
* parallel::distributed::Triangulation object. There, refining a mesh
* always involves a re-partitioning. In other words, vertices of locally
- * owned cells (see @ref GlossLocallyOwnedCell "this glossary entry") that
+ * owned cells (see
+ * @ref GlossLocallyOwnedCell "this glossary entry"
+ * ) that
* you may have moved to a different location on one processor may be moved
* to a different processor upon mesh refinement (even if these particular
* cells were not refined) which will re-create their position based on the
* numbers::internal_face_boundary_id, then this object is in the interior
* of the domain.
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
types::boundary_id boundary_indicator () const;
*
* @ingroup boundary
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
void set_boundary_indicator (const types::boundary_id) const;
*
* @ingroup boundary
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
void set_all_boundary_indicators (const types::boundary_id) const;
* Return a constant reference to the manifold object used for this object.
*
* As explained in
- * @ref boundary "Boundary and manifold description for triangulations",
- * the process involved in finding the appropriate manifold description
+ * @ref boundary "Boundary and manifold description for triangulations"
+ * , the process involved in finding the appropriate manifold description
* involves querying both the manifold or boundary indicators. See there
* for more information.
*/
* If the return value is the special value numbers::flat_manifold_id, then
* this object is associated with a standard Cartesian Manifold Description.
*
- * @see @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
+ * @see
+ * @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
*/
types::manifold_id manifold_id () const;
*
* @ingroup manifold
*
- * @see @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
+ * @see
+ * @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
*/
void set_manifold_id (const types::manifold_id) const;
*
* @ingroup manifold
*
- * @see @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
+ * @see
+ * @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
*/
void set_all_manifold_ids (const types::manifold_id) const;
* @{
*/
/**
- * Read the user flag. See @ref GlossUserFlags for more information.
+ * Read the user flag. See
+ * @ref GlossUserFlags
+ * for more information.
*/
bool user_flag_set () const;
/**
- * Set the user flag. See @ref GlossUserFlags for more information.
+ * Set the user flag. See
+ * @ref GlossUserFlags
+ * for more information.
*/
void set_user_flag () const;
/**
- * Clear the user flag. See @ref GlossUserFlags for more information.
+ * Clear the user flag. See
+ * @ref GlossUserFlags
+ * for more information.
*/
void clear_user_flag () const;
/**
- * Set the user flag for this and all descendants. See @ref GlossUserFlags
+ * Set the user flag for this and all descendants. See
+ * @ref GlossUserFlags
* for more information.
*/
void recursively_set_user_flag () const;
/**
- * Clear the user flag for this and all descendants. See @ref GlossUserFlags
+ * Clear the user flag for this and all descendants. See
+ * @ref GlossUserFlags
* for more information.
*/
void recursively_clear_user_flag () const;
/**
* Reset the user data to zero, independent if pointer or index. See
- * @ref GlossUserData for more information.
+ * @ref GlossUserData
+ * for more information.
*/
void clear_user_data () const;
* you can only use one of them, unless you call
* Triangulation::clear_user_data() in between.
*
- * See @ref GlossUserData for more information.
+ * See
+ * @ref GlossUserData
+ * for more information.
*/
void set_user_pointer (void *p) const;
/**
- * Reset the user pointer to a @p NULL pointer. See @ref GlossUserData for
- * more information.
+ * Reset the user pointer to a @p NULL pointer. See
+ * @ref GlossUserData
+ * for more information.
*/
void clear_user_pointer () const;
* Triangulation::clear_user_data() in between. <tt>A
* *a=static_cast<A*>(cell->user_pointer());</tt>.
*
- * See @ref GlossUserData for more information.
+ * See
+ * @ref GlossUserData
+ * for more information.
*/
void *user_pointer () const;
* you can only use one of them, unless you call
* Triangulation::clear_user_data() in between.
*
- * See @ref GlossUserData for more information.
+ * See
+ * @ref GlossUserData
+ * for more information.
*/
void recursively_set_user_pointer (void *p) const;
/**
* Clear the user pointer of this object and all of its descendants. The
* same holds as said for the recursively_set_user_pointer() function. See
- * @ref GlossUserData for more information.
+ * @ref GlossUserData
+ * for more information.
*/
void recursively_clear_user_pointer () const;
*
* @note User pointers and user indices are mutually exclusive. Therefore,
* you can only use one of them, unless you call
- * Triangulation::clear_user_data() in between. See @ref GlossUserData for
- * more information.
+ * Triangulation::clear_user_data() in between. See
+ * @ref GlossUserData
+ * for more information.
*/
void set_user_index (const unsigned int p) const;
/**
- * Reset the user index to 0. See @ref GlossUserData for more information.
+ * Reset the user index to 0. See
+ * @ref GlossUserData
+ * for more information.
*/
void clear_user_index () const;
* you can only use one of them, unless you call
* Triangulation::clear_user_data() in between.
*
- * See @ref GlossUserData for more information.
+ * See
+ * @ref GlossUserData
+ * for more information.
*/
unsigned int user_index () const;
* you can only use one of them, unless you call
* Triangulation::clear_user_data() in between.
*
- * See @ref GlossUserData for more information.
+ * See
+ * @ref GlossUserData
+ * for more information.
*/
void recursively_set_user_index (const unsigned int p) const;
* Clear the user index of this object and all of its descendants. The same
* holds as said for the recursively_set_user_index() function.
*
- * See @ref GlossUserData for more information.
+ * See
+ * @ref GlossUserData
+ * for more information.
*/
void recursively_clear_user_index () const;
/**
* numbers::internal_face_boundary_id, then this object is in the interior
* of the domain.
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
types::boundary_id boundary_indicator () const;
/**
* Return the manifold indicator of this object.
*
- * @see @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
+ * @see
+ * @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
*/
types::manifold_id manifold_id () const;
*
* @ingroup boundary
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
void
set_boundary_indicator (const types::boundary_id);
*
* @ingroup boundary
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
void
set_all_boundary_indicators (const types::boundary_id);
*
* @ingroup manifold
*
- * @see @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
+ * @see
+ * @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
*/
void
/**
* Return the material id of this cell.
*
- * For a typical use of this function, see the @ref step_28 "step-28"
+ * For a typical use of this function, see the
+ * @ref step_28 "step-28"
* tutorial program.
*
- * See the @ref GlossMaterialId "glossary" for more information.
+ * See the
+ * @ref GlossMaterialId "glossary"
+ * for more information.
*/
types::material_id material_id () const;
/**
* Set the material id of this cell.
*
- * For a typical use of this function, see the @ref step_28 "step-28"
+ * For a typical use of this function, see the
+ * @ref step_28 "step-28"
* tutorial program.
*
- * See the @ref GlossMaterialId "glossary" for more information.
+ * See the
+ * @ref GlossMaterialId "glossary"
+ * for more information.
*/
void set_material_id (const types::material_id new_material_id) const;
* Set the material id of this cell and all its children (and grand-
* children, and so on) to the given value.
*
- * See the @ref GlossMaterialId "glossary" for more information.
+ * See the
+ * @ref GlossMaterialId "glossary"
+ * for more information.
*/
void recursively_set_material_id (const types::material_id new_material_id) const;
/**
/**
* Return the subdomain id of this cell.
*
- * See the @ref GlossSubdomainId "glossary" for more information.
+ * See the
+ * @ref GlossSubdomainId "glossary"
+ * for more information.
*
* @note The subdomain of a cell is a property only defined for active
* cells, i.e., cells that are not further refined. Consequently, you can
/**
* Set the subdomain id of this cell.
*
- * See the @ref GlossSubdomainId "glossary" for more information. This
+ * See the
+ * @ref GlossSubdomainId "glossary"
+ * for more information. This
* function should not be called if you use a
* parallel::distributed::Triangulation object.
*
* and grand children of this cell that are actually active, skipping
* intermediate child cells.
*
- * See the @ref GlossSubdomainId "glossary" for more information. This
+ * See the
+ * @ref GlossSubdomainId "glossary"
+ * for more information. This
* function should not be called if you use a
* parallel::distributed::Triangulation object since there the subdomain id
* is implicitly defined by which processor you're on.
/**
* Return the orientation of this cell.
*
- * For the meaning of this flag, see @ref GlossDirectionFlag .
+ * For the meaning of this flag, see
+ * @ref GlossDirectionFlag.
*/
bool direction_flag () const;
* Test whether the cell has children (this is the criterion for activity of
* a cell).
*
- * See the @ref GlossActive "glossary" for more information.
+ * See the
+ * @ref GlossActive "glossary"
+ * for more information.
*/
bool active () const;
* object of type dealii::Triangulation, but may yield false if the
* triangulation is of type parallel::distributed::Triangulation.
*
- * See the @ref GlossGhostCell "glossary" and the @ref distributed module
+ * See the
+ * @ref GlossGhostCell "glossary"
+ * and the
+ * @ref distributed
+ * module
* for more information.
*
* @post The returned value is equal to <code>!is_ghost() &&
* parallel::distributed::Triangulation. In all other cases, the returned
* value is always false.
*
- * See the @ref GlossGhostCell "glossary" and the @ref distributed module
+ * See the
+ * @ref GlossGhostCell "glossary"
+ * and the
+ * @ref distributed
+ * module
* for more information.
*
* @post The returned value is equal to <code>!is_locally_owned() &&
* parallel::distributed::Triangulation. In all other cases, the returned
* value is always false.
*
- * See the @ref GlossArtificialCell "glossary" and the @ref distributed
+ * See the
+ * @ref GlossArtificialCell "glossary"
+ * and the
+ * @ref distributed
* module for more information.
*
* @post The returned value is equal to <code>!is_ghost() &&
/**
* Set the orientation of this cell.
*
- * For the meaning of this flag, see @ref GlossDirectionFlag .
+ * For the meaning of this flag, see
+ * @ref GlossDirectionFlag.
*/
void set_direction_flag (const bool new_direction_flag) const;
/**
/**
* This class implements some types which differ between the dimensions.
- * These are the declararions for the 1D case only. See the @ref Iterators
+ * These are the declararions for the 1D case only. See the
+ * @ref Iterators
* module for more information.
*
* A @p line_iterator is typdef'd to an iterator operating on the @p lines
/**
* This class implements some types which differ between the dimensions.
- * These are the declararions for the 2D case only. See the @ref Iterators
+ * These are the declararions for the 2D case only. See the
+ * @ref Iterators
* module for more information.
*
* A @p line_iterator is typdef'd to an iterator operating on the @p lines
/**
* This class implements some types which differ between the dimensions.
- * These are the declararions for the 3D case only. See the @ref Iterators
+ * These are the declararions for the 3D case only. See the
+ * @ref Iterators
* module for more information.
*
* For the declarations of the data types, more or less the same holds as
*
* The whole process of working with objects of this type is explained in
* step-27. Many of the algorithms this class implements are described in
- * the @ref hp_paper "hp paper".
+ * the
+ * @ref hp_paper "hp paper".
*
*
* <h3>Active FE indices and their behavior under mesh refinement</h3>
/**
* A typedef that is used to to identify
- * @ref GlossActive "active cell iterators". The concept of iterators
+ * @ref GlossActive "active cell iterators".
+ * The concept of iterators
* is discussed at length in the
* @ref Iterators "iterators documentation module".
*
*
* The current typedef identifies cells in a DoFHandler object. Some of
* these cells may in fact be active (see
- * @ref GlossActive "active cell iterators") in which case they can in
+ * @ref GlossActive "active cell iterators"
+ * ) in which case they can in
* fact be asked for the degrees of freedom that live on them. On the
* other hand, if the cell is not active, any such query will result in
* an error. Note that this is what distinguishes this typedef from the
* As for ::DoFHandler::max_couplings_between_dofs(), the result of this
* function is often not very accurate for 3d and/or high polynomial
* degrees. The consequences are discussed in the documentation of the
- * module on @ref Sparsity.
+ * module on
+ * @ref Sparsity.
*/
unsigned int max_couplings_between_dofs () const;
*
* @note The same applies to this function as to max_couplings_per_dofs()
* as regards the performance of this function. Think about one of the
- * dynamic sparsity pattern classes instead (see @ref Sparsity).
+ * dynamic sparsity pattern classes instead (see
+ * @ref Sparsity).
*/
unsigned int max_couplings_between_boundary_dofs () const;
/**
* Return an iterator range that contains all active cells that make up
* this DoFHandler. Such a range is useful to initialize range-based for
- * loops as supported by C++11, see also @ref CPP11 "C++11 standard".
+ * loops as supported by C++11, see also
+ * @ref CPP11 "C++11 standard".
*
* Range-based for loops are useful in that they require much less code
* than traditional loops (see <a
* processors.
*
* In either case, included in the returned number are those DoFs which
- * are constrained by hanging nodes, see @ref constraints.
+ * are constrained by hanging nodes, see
+ * @ref constraints.
*/
types::global_dof_index n_dofs () const;
* hp::DoFHandler. It is thus to a hp::DoFHandler what a FiniteElement is to
* a ::DoFHandler.
*
- * It implements the concepts stated in the @ref hpcollection module
- * described in the doxygen documentation.
+ * It implements the concepts stated in the
+ * @ref hpcollection
+ * module described in the doxygen documentation.
*
* In addition to offering access to the elements of the collection, this
* class provides access to the maximal number of degrees of freedom per
* collection.
*
* This function calls FiniteElement::n_components. See
- * @ref GlossComponent "the glossary" for more information.
+ * @ref GlossComponent "the glossary"
+ * for more information.
*/
unsigned int n_components () const;
* have the same number of vector components, there is no such guarantees
* for the number of blocks each element is made up of (an element may
* have fewer blocks than vector components; see
- * @ref GlossBlock "the glossary" for more information). For example,
+ * @ref GlossBlock "the glossary"
+ * for more information). For example,
* you may have an FECollection object that stores one copy of an
* FESystem with <code>dim</code> FE_Q objects and one copy of an
* FE_RaviartThomas element. Both have <code>dim</code> vector
component_mask (const FEValuesExtractors::SymmetricTensor<2> &sym_tensor) const;
/**
- * Given a block mask (see @ref GlossBlockMask "this glossary entry"),
+ * Given a block mask (see
+ * @ref GlossBlockMask "this glossary entry"
+ * ),
* produce a component mask (see
- * @ref GlossComponentMask "this glossary entry") that represents the
+ * @ref GlossComponentMask "this glossary entry"
+ * ) that represents the
* components that correspond to the blocks selected in the input
* argument. This is essentially a conversion operator from BlockMask
* to ComponentMask.
/**
* Return a block mask with as many elements as this object has blocks and
* of which exactly the one component is true that corresponds to the
- * given argument. See @ref GlossBlockMask "the glossary" for more
+ * given argument. See
+ * @ref GlossBlockMask "the glossary"
+ * for more
* information.
*
* @note This function will only succeed if the scalar referenced by the
/**
* Return a component mask with as many elements as this object has vector
* components and of which exactly the <code>dim</code> components are
- * true that correspond to the given argument. See @ref GlossBlockMask
- * "the glossary" for more information.
+ * true that correspond to the given argument. See
+ * @ref GlossBlockMask "the glossary"
+ * for more information.
*
* @note This function is the equivalent of
* FiniteElement::component_mask() with the same arguments. It verifies
* Return a component mask with as many elements as this object has vector
* components and of which exactly the <code>dim*(dim+1)/2</code>
* components are true that correspond to the given argument. See
- * @ref GlossBlockMask "the glossary" for more information.
+ * @ref GlossBlockMask "the glossary"
+ * for more information.
*
* @note The same caveat applies as to the version of the function above:
* The extractor object passed as argument must be so that it corresponds
/**
* Given a component mask (see
- * @ref GlossComponentMask "this glossary entry"), produce a block mask
- * (see @ref GlossBlockMask "this glossary entry") that represents the
+ * @ref GlossComponentMask "this glossary entry"
+ * ), produce a block mask
+ * (see
+ * @ref GlossBlockMask "this glossary entry"
+ * ) that represents the
* blocks that correspond to the components selected in the input
* argument. This is essentially a conversion operator from
* ComponentMask to BlockMask.
* This class implements a collection of mapping objects in the same way as
* the hp::FECollection implements a collection of finite element classes.
*
- * It implements the concepts stated in the @ref hpcollection module
+ * It implements the concepts stated in the
+ * @ref hpcollection
+ * module
* described in the doxygen documentation.
*
* Although it is recommended to supply an appropriate mapping for each
* as the hp::FECollection implements a collection of finite element
* classes.
*
- * It implements the concepts stated in the @ref hpcollection module
+ * It implements the concepts stated in the
+ * @ref hpcollection
+ * module
* described in the doxygen documentation.
*
* @ingroup hp hpcollection
* blocks, where you have to translate global row and column indices to local
* ones.
*
- * @ingroup data @see @ref GlossBlockLA "Block (linear algebra)"
+ * @ingroup data
+ * @see
+ * @ref GlossBlockLA "Block (linear algebra)"
* @author Wolfgang Bangerth, Guido Kanschat, 2000, 2007, 2011
*/
class BlockIndices : public Subscriptor
* do things differently depending on whether a template type denotes a
* regular or a block matrix type.
*
- * @see @ref GlossBlockLA "Block (linear algebra)"
+ * @see
+ * @ref GlossBlockLA "Block (linear algebra)"
* @author Wolfgang Bangerth, 2009
*/
template <typename MatrixType>
* One special application is a one by one block matrix, allowing to apply the
* @p vmult of the original matrix (or preconditioner) to a block vector.
*
- * @see @ref GlossBlockLA "Block (linear algebra)"
+ * @see
+ * @ref GlossBlockLA "Block (linear algebra)"
* @author Guido Kanschat, 2000
*/
template <class MATRIX>
*
* @note Instantiations for this template are provided for <tt>@<float@> and
* @<double@></tt>; others can be generated in application programs (see the
- * section on @ref Instantiations in the manual).
+ * section on
+ * @ref Instantiations
+ * in the manual).
*
- * @see @ref GlossBlockLA "Block (linear algebra)"
+ * @see
+ * @ref GlossBlockLA "Block (linear algebra)"
* @author Wolfgang Bangerth, 2000, 2004
*/
template <typename MatrixType>
* Call the compress() function on all the subblocks of the matrix.
*
*
- * See @ref GlossCompress "Compressing distributed objects" for more
- * information.
+ * See
+ * @ref GlossCompress "Compressing distributed objects"
+ * for more information.
*/
void compress (::dealii::VectorOperation::values operation);
* the calls to the individual blocks to the functions implemented in the base
* class. See there also for a description of when this class is useful.
*
- * @see @ref GlossBlockLA "Block (linear algebra)"
+ * @see
+ * @ref GlossBlockLA "Block (linear algebra)"
* @author Wolfgang Bangerth, 2000, 2004
*/
template <typename number>
* functions for the multiplication with BlockVector and access to the
* individual blocks.
*
- * @see @ref GlossBlockLA "Block (linear algebra)"
+ * @see
+ * @ref GlossBlockLA "Block (linear algebra)"
* @author Guido Kanschat, 2002, 2003
*/
template<typename Number>
* @todo Handle optimization of diagonal elements of the underlying
* SparsityPattern correctly.
*
- * @see @ref GlossBlockLA "Block (linear algebra)"
+ * @see
+ * @ref GlossBlockLA "Block (linear algebra)"
* @author Wolfgang Bangerth, 2000, 2001
*/
template <class SparsityPatternBase>
* Print the sparsity of the matrix in a format that <tt>gnuplot</tt>
* understands and which can be used to plot the sparsity pattern in a
* graphical way. This is the same functionality implemented for usual
- * sparsity patterns, see @ref SparsityPattern.
+ * sparsity patterns, see
+ * @ref SparsityPattern.
*/
void print_gnuplot (std::ostream &out) const;
* few additional member functions, but the main interface stems from the base
* class, see there for more information.
*
- * This class is an example of the "static" type of @ref Sparsity.
+ * This class is an example of the "static" type of
+ * @ref Sparsity.
*
* @author Wolfgang Bangerth, 2000, 2001
*/
* information on the interface of this class refer to the base class. The
* individual blocks are based on the CompressedSparsityPattern class.
*
- * This class is an example of the "dynamic" type of @ref Sparsity.
+ * This class is an example of the "dynamic" type of
+ * @ref Sparsity.
*
* <b>Note:</b> There are several, exchangeable variations of this class, see
- * @ref Sparsity, section 'Dynamic block sparsity patterns' for more
+ * @ref Sparsity
+ * , section 'Dynamic block sparsity patterns' for more
* information.
*
* <b>Note:</b> This class used to be called CompressedBlockSparsityPattern.
* CompressedSetSparsityPattern instead of the CompressedSparsityPattern. See
* the documentation of the BlockCompressedSparsityPattern for examples.
*
- * This class is an example of the "dynamic" type of @ref Sparsity.
+ * This class is an example of the "dynamic" type of
+ * @ref Sparsity.
*
- * <b>Note:</b> There are several, exchangeable variations of this class, see
- * @ref Sparsity, section 'Dynamic block sparsity patterns' for more
+ * @note There are several, exchangeable variations of this class, see
+ * @ref Sparsity
+ * , section 'Dynamic block sparsity patterns' for more
* information.
*
* @author Wolfgang Bangerth, 2007
* CompressedSimpleSparsityPattern instead of the CompressedSparsityPattern.
* See the documentation of the BlockCompressedSparsityPattern for examples.
*
- * This class is an example of the "dynamic" type of @ref Sparsity.
+ * This class is an example of the "dynamic" type of
+ * @ref Sparsity.
*
- * <b>Note:</b> There are several, exchangeable variations of this class, see
- * @ref Sparsity, section 'Dynamic block sparsity patterns' for more
+ * @note There are several, exchangeable variations of this class, see
+ * @ref Sparsity
+ * , section 'Dynamic block sparsity patterns' for more
* information.
*
* This class is used in step-22 and step-31.
* TrilinosWrappers::SparsityPattern instead of the dealii::SparsityPattern.
* See the documentation of the BlockSparsityPattern for examples.
*
- * This class is has properties of the "dynamic" type of @ref Sparsity (in the
+ * This class is has properties of the "dynamic" type of
+ * @ref Sparsity
+ * (in the
* sense that it can extend the memory if too little elements were allocated),
* but otherwise is more like the basic deal.II SparsityPattern (in the sense
* that the method compress() needs to be called before the pattern can be
*
* @note Instantiations for this template are provided for <tt>@<float@> and
* @<double@></tt>; others can be generated in application programs (see the
- * section on @ref Instantiations in the manual).
+ * section on
+ * @ref Instantiations
+ * in the manual).
*
- * @see @ref GlossBlockLA "Block (linear algebra)"
+ * @see
+ * @ref GlossBlockLA "Block (linear algebra)"
* @author Wolfgang Bangerth, Guido Kanschat, 1999, 2000, 2001, 2002, 2004
*/
template <typename Number>
* This functionality only needs to be called if using MPI based vectors and
* exists in other objects for compatibility.
*
- * See @ref GlossCompress "Compressing distributed objects" for more
+ * See
+ * @ref GlossCompress "Compressing distributed objects"
+ * for more
* information.
*/
void compress (::dealii::VectorOperation::values operation
* calling collect_sizes(), results may be unpredictable. The debug version
* does not check consistency here for performance reasons!
*
- * @see @ref GlossBlockLA "Block (linear algebra)"
+ * @see
+ * @ref GlossBlockLA "Block (linear algebra)"
* @author Wolfgang Bangerth, Guido Kanschat, 1999, 2000, 2001, 2002, 2004
*/
template <class VectorType>
* This functionality only needs to be called if using MPI based vectors and
* exists in other objects for compatibility.
*
- * See @ref GlossCompress "Compressing distributed objects" for more
- * information.
+ * See
+ * @ref GlossCompress "Compressing distributed objects"
+ * for more information.
*/
void compress (::dealii::VectorOperation::values operation);
*
* @note Instantiations for this template are provided for <tt>@<float@> and
* @<double@></tt>; others can be generated in application programs (see the
- * section on @ref Instantiations in the manual).
+ * section on
+ * @ref Instantiations
+ * in the manual).
*
* @author Wolfgang Bangerth, 2008
*/
*
* Note that while this function can operate on all vectors that offer
* iterator classes, it is only really effective for objects of type
- * @ref Vector. For all classes for which iterating over elements, or random
+ * @ref Vector.
+ * For all classes for which iterating over elements, or random
* member access is expensive, this function is not efficient. In
* particular, if you want to multiply with BlockVector objects, you should
* consider using a BlockChunkSparseMatrix as well.
*
* Note that while this function can operate on all vectors that offer
* iterator classes, it is only really effective for objects of type
- * @ref Vector. For all classes for which iterating over elements, or random
+ * @ref Vector.
+ * For all classes for which iterating over elements, or random
* member access is expensive, this function is not efficient. In
* particular, if you want to multiply with BlockVector objects, you should
* consider using a BlockChunkSparseMatrix as well.
*
* Note that while this function can operate on all vectors that offer
* iterator classes, it is only really effective for objects of type
- * @ref Vector. For all classes for which iterating over elements, or random
+ * @ref Vector.
+ * For all classes for which iterating over elements, or random
* member access is expensive, this function is not efficient. In
* particular, if you want to multiply with BlockVector objects, you should
* consider using a BlockChunkSparseMatrix as well.
*
* Note that while this function can operate on all vectors that offer
* iterator classes, it is only really effective for objects of type
- * @ref Vector. For all classes for which iterating over elements, or random
+ * @ref Vector.
+ * For all classes for which iterating over elements, or random
* member access is expensive, this function is not efficient. In
* particular, if you want to multiply with BlockVector objects, you should
* consider using a BlockChunkSparseMatrix as well.
/**
* Structure representing the sparsity pattern of a sparse matrix. This class
- * is an example of the "static" type of @ref Sparsity. It uses the compressed
+ * is an example of the "static" type of
+ * @ref Sparsity.
+ * It uses the compressed
* row storage (CSR) format to store data.
*
* The use of this class is demonstrated in step-51.
*
* Another viewpoint is that this class does not need up front allocation of a
* certain amount of memory, but grows as necessary. An extensive description
- * of sparsity patterns can be found in the documentation of the @ref Sparsity
+ * of sparsity patterns can be found in the documentation of the
+ * @ref Sparsity
* module.
*
- * This class is an example of the "dynamic" type of @ref Sparsity. It is
- * discussed in the step-27 and @ref step_22 "step-22" tutorial programs.
+ * This class is an example of the "dynamic" type of
+ * @ref Sparsity.
+ * It is discussed in the step-27 and
+ * @ref step_22 "step-22"
+ * tutorial programs.
*
* <h3>Interface</h3>
*
* <h3>Notes</h3>
*
* There are several, exchangeable variations of this class, see
- * @ref Sparsity, section '"Dynamic" or "compressed" sparsity patterns' for more
+ * @ref Sparsity
+ * , section '"Dynamic" or "compressed" sparsity patterns' for more
* information.
*
* This class is a variation of the CompressedSparsityPattern class. Instead
* solution might not be the fastest in all situations, but seems to work much
* better than the CompressedSparsityPattern in the context of hp-adaptivity
* (see for example step-27), or generally when there are many nonzero entries
- * in each row of a matrix (see @ref step_22 "step-22"). On the other hand, a
+ * in each row of a matrix (see
+ * @ref step_22 "step-22"
+ * ). On the other hand, a
* benchmark where nonzero entries were randomly inserted into the sparsity
* pattern revealed that this class is slower by a factor 4-6 in this
* situation. Hence, currently the suggestion is to carefully analyze which of
*
* Another viewpoint is that this class does not need up front allocation of a
* certain amount of memory, but grows as necessary. An extensive description
- * of sparsity patterns can be found in the documentation of the @ref Sparsity
+ * of sparsity patterns can be found in the documentation of the
+ * @ref Sparsity
* module.
*
- * This class is an example of the "dynamic" type of @ref Sparsity.
+ * This class is an example of the "dynamic" type of
+ * @ref Sparsity.
*
* <h3>Interface</h3>
*
* <h3>Notes</h3>
*
* There are several, exchangeable variations of this class, see
- * @ref Sparsity, section '"Dynamic" or "compressed" sparsity patterns' for
+ * @ref Sparsity
+ * , section '"Dynamic" or "compressed" sparsity patterns' for
* more information.
*
* @author Timo Heister, 2008
*
* Another viewpoint is that this class does not need up front allocation of a
* certain amount of memory, but grows as necessary. An extensive description
- * of sparsity patterns can be found in the documentation of the @ref Sparsity
+ * of sparsity patterns can be found in the documentation of the
+ * @ref Sparsity
* module.
*
- * This class is an example of the "dynamic" type of @ref Sparsity.
+ * This class is an example of the "dynamic" type of
+ * @ref Sparsity.
*
* <h3>Interface</h3>
*
* <h3>Notes</h3>
*
* There are several, exchangeable variations of this class, see
- * @ref Sparsity, section '"Dynamic" or "compressed" sparsity patterns' for
+ * @ref Sparsity
+ * , section '"Dynamic" or "compressed" sparsity patterns' for
* more information.
*
* @author Wolfgang Bangerth, 2001
/**
* This class implements dealing with linear (possibly inhomogeneous)
* constraints on degrees of freedom. The concept and origin of such
- * constraints is extensively described in the @ref constraints module. The
+ * constraints is extensively described in the
+ * @ref constraints
+ * module. The
* class is meant to deal with a limited number of constraints relative to the
* total number of degrees of freedom, for example a few per cent up to maybe
* 30 per cent; and with a linear combination of <i>M</i> other degrees of
* <em>not</em> meant to describe full rank linear systems.
*
* The algorithms used in the implementation of this class are described in
- * some detail in the @ref hp_paper "hp paper". There is also a significant
- * amount of documentation on how to use this class in the @ref constraints
+ * some detail in the
+ * @ref hp_paper "hp paper".
+ * There is also a significant
+ * amount of documentation on how to use this class in the
+ * @ref constraints
* module.
*
*
* and sorts the entries.
*
* @note Many of the algorithms this class implements are discussed in the
- * @ref hp_paper . The algorithms are also related to those shown in <i>M. S.
+ * @ref hp_paper.
+ * The algorithms are also related to those shown in <i>M. S.
* Shephard: Linear multipoint constraints applied via transformation as part
* of a direct stiffness assembly process. Int. J. Numer. Meth. Engrg., vol.
* 20 (1984), pp. 2107-2112.</i>, with the difference that the algorithms
* or millions of unknowns are involved and for problems with many nonzero
* elements per row (for example for vector-valued problems or hp finite
* elements). In this case, it is advisable to use the
- * CompressedSetSparsityPattern class instead, see for example @ref step_27
- * "step-27", or to use the CompressedSimpleSparsityPattern class, see for
- * example @ref step_31 "step-31".
+ * CompressedSetSparsityPattern class instead, see for example
+ * @ref step_27 "step-27"
+ * , or to use the CompressedSimpleSparsityPattern class, see for
+ * example
+ * @ref step_31 "step-31".
*/
void condense (CompressedSparsityPattern &sparsity) const;
* nonzero elements per row (for example for vector-valued problems or hp
* finite elements). In this case, it is advisable to use the
* BlockCompressedSetSparsityPattern class instead, see for example
- * @ref step_27 "step-27" and @ref step_31 "step-31".
+ * @ref step_27 "step-27"
+ * and
+ * @ref step_31 "step-31".
*/
void condense (BlockCompressedSparsityPattern &sparsity) const;
* according to the constraints specified by the calling ConstraintMatrix.
* This function can correctly handle inhomogeneous constraints as well. For
* the parameter use_inhomogeneities_for_rhs see the documentation in
- * @ref constraints module.
+ * @ref constraints
+ * module.
*
* @note This function in itself is thread-safe, i.e., it works properly
* also when several threads call it simultaneously. However, the function
* freedom, except that here we don't write into a matrix but only allocate
* sparsity pattern entries.
*
- * As explained in the @ref hp_paper "hp paper" and in step-27, first
+ * As explained in the
+ * @ref hp_paper "hp paper"
+ * and in step-27, first
* allocating a sparsity pattern and later coming back and allocating
* additional entries for those matrix entries that will be written to due
* to the elimination of constrained degrees of freedom (using
*
* @note Instantiations for this template are provided for <tt>@<float@> and
* @<double@></tt>; others can be generated in application programs (see the
- * section on @ref Instantiations in the manual).
+ * section on
+ * @ref Instantiations
+ * in the manual).
*
* @author Guido Kanschat, 2005
*/
*
* @note Instantiations for this template are provided for <tt>@<float@> and
* @<double@></tt>; others can be generated in application programs (see the
- * section on @ref Instantiations in the manual).
+ * section on
+ * @ref Instantiations
+ * in the manual).
*
* @author Guido Kanschat, 2005
*/
*
* @note Instantiations for this template are provided for <tt>@<float@>
* and @<double@></tt>; others can be generated in application programs
- * (see the section on @ref Instantiations in the manual).
+ * (see the section on
+ * @ref Instantiations
+ * in the manual).
*
- * @see @ref GlossBlockLA "Block (linear algebra)"
+ * @see
+ * @ref GlossBlockLA "Block (linear algebra)"
* @author Katharina Kormann, Martin Kronbichler, 2011
*/
template <typename Number>
/**
* This function copies the data that has accumulated in the data buffer
* for ghost indices to the owning processor. For the meaning of the
- * argument @p operation, see the entry on @ref GlossCompress
- * "Compressing distributed vectors and matrices" in the glossary.
+ * argument @p operation, see the entry on
+ * @ref GlossCompress "Compressing distributed vectors and matrices"
+ * in the glossary.
*
* There are two variants for this function. If called with argument @p
* VectorOperation::add adds all the data accumulated in ghost elements
* exception that storage is distributed with MPI.
*
* The vector is designed for the following scheme of parallel
- * partitioning: - The indices held by individual processes (locally owned
+ * partitioning:
+ * - The indices held by individual processes (locally owned
* part) in the MPI parallelization form a contiguous range
- * <code>[my_first_index,my_last_index)</code>. - Ghost indices residing
+ * <code>[my_first_index,my_last_index)</code>.
+ * - Ghost indices residing
* on arbitrary positions of other processors are allowed. It is in
* general more efficient if ghost indices are clustered, since they are
* stored as a set of intervals. The communication pattern of the ghost
* communication of indices. In particular, it stores the communication
* pattern, rather than having to compute it again for every
* communication. (For more information on ghost vectors, see also the
- * @ref GlossGhostedVector "glossary entry on vectors with ghost elements".)
+ * @ref GlossGhostedVector "glossary entry on vectors with ghost elements"
+ * .)
* - Besides the usual global access operator () it is also
* possible to access vector entries in the local index space with the
* function @p local_element(). Locally owned indices are placed first,
* [0, local_size()), and then all ghost indices follow after them
* contiguously, [local_size(), local_size()+n_ghost_entries()).
*
- * Functions related to parallel functionality: - The function
+ * Functions related to parallel functionality:
+ * - The function
* <code>compress()</code> goes through the data associated with ghost
* indices and communicates it to the owner process, which can then add it
* to the correct position. This can be used e.g. after having run an
* @p insert mode of @p compress() does not set the elements included in
* ghost entries but simply discards them, assuming that the owning
* processor has set them to the desired value already. (See also the
- * @ref GlossCompress "glossary entry on compress".) - The
+ * @ref GlossCompress "glossary entry on compress"
+ * .)
+ * - The
* <code>update_ghost_values()</code> function imports the data from the
* owning processor to the ghost indices in order to provide read access
- * to the data associated with ghosts. - It is possible to split the above
+ * to the data associated with ghosts.
+ * - It is possible to split the above
* functions into two phases, where the first initiates the communication
* and the second one finishes it. These functions can be used to overlap
- * communication with computations in other parts of the code. - Of
+ * communication with computations in other parts of the code.
+ * - Of
* course, reduction operations (like norms) make use of collective all-
* to-all MPI communications.
*
* This vector can take two different states with respect to ghost
- * elements: - After creation and whenever zero_out_ghosts() is called (or
+ * elements:
+ * - After creation and whenever zero_out_ghosts() is called (or
* <code>operator = (0.)</code>), the vector does only allow writing into
- * ghost elements but not reading from ghost elements. - After a call to
+ * ghost elements but not reading from ghost elements.
+ * - After a call to
* update_ghost_values(), the vector does not allow writing into ghost
* elements but only reading from them. This is in order to avoid
* undesired ghost data artifacts when calling compress() after modifying
* Vector<Number> argument to create additional vectors with the same
* parallel layout.
*
- * @see @ref GlossGhostedVector "vectors with ghost elements"
+ * @see
+ * @ref GlossGhostedVector "vectors with ghost elements"
*/
Vector (const IndexSet &local_range,
const IndexSet &ghost_indices,
* Vector<Number> argument to create additional vectors with the same
* parallel layout.
*
- * @see @ref GlossGhostedVector "vectors with ghost elements"
+ * @see
+ * @ref GlossGhostedVector "vectors with ghost elements"
*/
void reinit (const IndexSet &local_range,
const IndexSet &ghost_indices,
/**
* This function copies the data that has accumulated in the data buffer
* for ghost indices to the owning processor. For the meaning of the
- * argument @p operation, see the entry on @ref GlossCompress
- * "Compressing distributed vectors and matrices" in the glossary.
+ * argument @p operation, see the entry on
+ * @ref GlossCompress "Compressing distributed vectors and matrices"
+ * in the glossary.
*
* There are two variants for this function. If called with argument @p
* VectorOperation::add adds all the data accumulated in ghost elements
* counting the ghost data more than once. To allow writing to ghost
* elements again, call zero_out_ghosts().
*
- * @see @ref GlossGhostedVector "vectors with ghost elements"
+ * @see
+ * @ref GlossGhostedVector "vectors with ghost elements"
*/
void update_ghost_values () const;
* still possible (to those entries specified as ghosts during
* initialization), not that there are no ghost elements at all.
*
- * @see @ref GlossGhostedVector "vectors with ghost elements"
+ * @see
+ * @ref GlossGhostedVector "vectors with ghost elements"
*/
bool has_ghost_elements() const;
* operations where before only assembly functions were allowed. This
* function must therefore be called once you have assembled the matrix.
*
- * See @ref GlossCompress "Compressing distributed objects" for more
- * information. more information.
+ * See
+ * @ref GlossCompress "Compressing distributed objects"
+ * for more information.
*/
void compress (::dealii::VectorOperation::values operation);
* specify the sizes of the individual blocks, but also the number of
* elements of each of these blocks to be stored on the local process.
*
- * @ingroup Vectors @see @ref GlossBlockLA "Block (linear algebra)"
+ * @ingroup Vectors
+ * @see
+ * @ref GlossBlockLA "Block (linear algebra)"
* @author Wolfgang Bangerth, 2004
*/
class BlockVector : public BlockVectorBase<Vector>
* A class that implements the interface to use the PETSc Jacobi
* preconditioner.
*
- * See the comment in the base class @ref PreconditionerBase for when this
+ * See the comment in the base class
+ * @ref PreconditionerBase
+ * for when this
* preconditioner may or may not work.
*
* @ingroup PETScWrappers
* the matrix for preconditioning. This can be changed, as is explained in
* the relevant section of the PETSc manual, but is not implemented here.
*
- * See the comment in the base class @ref PreconditionerBase for when this
+ * See the comment in the base class
+ * @ref PreconditionerBase
+ * for when this
* preconditioner may or may not work.
*
* @ingroup PETScWrappers
* A class that implements the interface to use the PETSc SOR
* preconditioner.
*
- * See the comment in the base class @ref PreconditionerBase for when this
+ * See the comment in the base class
+ * @ref PreconditionerBase
+ * for when this
* preconditioner may or may not work.
*
* @ingroup PETScWrappers
* A class that implements the interface to use the PETSc SSOR
* preconditioner.
*
- * See the comment in the base class @ref PreconditionerBase for when this
+ * See the comment in the base class
+ * @ref PreconditionerBase
+ * for when this
* preconditioner may or may not work.
*
* @ingroup PETScWrappers
* A class that implements the interface to use the PETSc Eisenstat
* preconditioner.
*
- * See the comment in the base class @ref PreconditionerBase for when this
+ * See the comment in the base class
+ * @ref PreconditionerBase
+ * for when this
* preconditioner may or may not work.
*
* @ingroup PETScWrappers
* A class that implements the interface to use the PETSc Incomplete
* Cholesky preconditioner.
*
- * See the comment in the base class @ref PreconditionerBase for when this
+ * See the comment in the base class
+ * @ref PreconditionerBase
+ * for when this
* preconditioner may or may not work.
*
* @ingroup PETScWrappers
* A class that implements the interface to use the PETSc ILU
* preconditioner.
*
- * See the comment in the base class @ref PreconditionerBase for when this
+ * See the comment in the base class
+ * @ref PreconditionerBase
+ * for when this
* preconditioner may or may not work.
*
* @ingroup PETScWrappers
* The LU decomposition is only implemented for single processor machines.
* It should provide a convenient interface to another direct solver.
*
- * See the comment in the base class @ref PreconditionerBase for when this
+ * See the comment in the base class
+ * @ref PreconditionerBase
+ * for when this
* preconditioner may or may not work.
*
* @ingroup PETScWrappers
* necessary after writing into a vector element-by-element and before
* anything else can be done on it.
*
- * See @ref GlossCompress "Compressing distributed objects" for more
- * information.
+ * See
+ * @ref GlossCompress "Compressing distributed objects"
+ * for more information.
*/
void compress (::dealii::VectorOperation::values operation);
/**
* Return if the vector contains ghost elements.
*
- * @see @ref GlossGhostedVector "vectors with ghost elements"
+ * @see
+ * @ref GlossGhostedVector "vectors with ghost elements"
*/
bool has_ghost_elements() const;
* for example, <tt>number==double, inverse_type=float</tt> might be a viable
* choice.
*
- * @see @ref GlossBlockLA "Block (linear algebra)"
+ * @see
+ * @ref GlossBlockLA "Block (linear algebra)"
* @author Ralf Hartmann, Guido Kanschat
* @date 1999, 2000, 2010
*/
*
* @note Instantiations for this template are provided for <tt>@<float@> and
* @<double@></tt>; others can be generated in application programs (see the
- * section on @ref Instantiations in the manual).
+ * section on
+ * @ref Instantiations
+ * in the manual).
*
* @author Ralf Hartmann, Guido Kanschat, 1999, 2000, 2003
*/
*
* @note Instantiations for this template are provided for <tt>@<float@> and
* @<double@></tt>; others can be generated in application programs (see the
- * section on @ref Instantiations in the manual).
+ * section on
+ * @ref Instantiations
+ * in the manual).
*
* @author Ralf Hartmann, Guido Kanschat, 1999, 2000, 2001, 2002, 2003
*/
*
* @note Instantiations for this template are provided for <tt>@<float@> and
* @<double@></tt>; others can be generated in application programs (see the
- * section on @ref Instantiations in the manual).
+ * section on
+ * @ref Instantiations
+ * in the manual).
*
* @author Ralf Hartmann, Guido Kanschat, 1999, 2000
*/
* schur.postprocess (u, p);
* @endcode
*
- * @see @ref GlossBlockLA "Block (linear algebra)"
+ * @see
+ * @ref GlossBlockLA "Block (linear algebra)"
* @author Guido Kanschat, 2000, 2001, 2002
*/
template <class MA_inverse, class MB, class MDt, class MC>
* @endcode
* as an example on how to do this.
*
- * For further information and explanations on handling the @ref SLEPcWrappers
- * "SLEPcWrappers", see also the @ref PETScWrappers "PETScWrappers", on which
- * they depend.
+ * For further information and explanations on handling the
+ * @ref SLEPcWrappers "SLEPcWrappers"
+ * , see also the
+ * @ref PETScWrappers "PETScWrappers"
+ * , on which they depend.
*
* @ingroup SLEPcWrappers
*
* systems, Ax=b, using the Unsymmetric-pattern MultiFrontal method and direct
* sparse LU factorization. Matrices may have symmetric or unsymmetrix
* sparsity patterns, and may have unsymmetric entries. The use of this class
- * is explained in the @ref step_22 "step-22" and @ref step_29 "step-29"
+ * is explained in the
+ * @ref step_22 "step-22"
+ * and
+ * @ref step_29 "step-29"
* tutorial programs.
*
* This matrix class implements the usual interface of preconditioners, that
* <h3>Usage and state management</h3>
*
* Refer to SparseLUDecomposition documentation for suggested usage and state
- * management. This class is used in the @ref step_22 "step-22" tutorial
- * program.
+ * management. This class is used in the
+ * @ref step_22 "step-22"
+ * tutorial program.
*
* @note Instantiations for this template are provided for <tt>@<float@> and
* @<double@></tt>; others can be generated in application programs (see the
- * section on @ref Instantiations in the manual).
+ * section on
+ * @ref Instantiations
+ * in the manual).
*
* @author Wolfgang Bangerth, 2008, 2009; unified interface: Ralf Hartmann
*/
*
* @note Instantiations for this template are provided for <tt>@<float@> and
* @<double@></tt>; others can be generated in application programs (see the
- * section on @ref Instantiations in the manual).
+ * section on
+ * @ref Instantiations
+ * in the manual).
*
* @ingroup Matrix1
* @author Essentially everyone who has ever worked on deal.II
*
* Note that while this function can operate on all vectors that offer
* iterator classes, it is only really effective for objects of type
- * @ref Vector. For all classes for which iterating over elements, or random
+ * @ref Vector.
+ * For all classes for which iterating over elements, or random
* member access is expensive, this function is not efficient. In
* particular, if you want to multiply with BlockVector objects, you should
* consider using a BlockSparseMatrix as well.
*
* Note that while this function can operate on all vectors that offer
* iterator classes, it is only really effective for objects of type
- * @ref Vector. For all classes for which iterating over elements, or random
+ * @ref Vector.
+ * For all classes for which iterating over elements, or random
* member access is expensive, this function is not efficient. In
* particular, if you want to multiply with BlockVector objects, you should
* consider using a BlockSparseMatrix as well.
*
* Note that while this function can operate on all vectors that offer
* iterator classes, it is only really effective for objects of type
- * @ref Vector. For all classes for which iterating over elements, or random
+ * @ref Vector.
+ * For all classes for which iterating over elements, or random
* member access is expensive, this function is not efficient. In
* particular, if you want to multiply with BlockVector objects, you should
* consider using a BlockSparseMatrix as well.
*
* Note that while this function can operate on all vectors that offer
* iterator classes, it is only really effective for objects of type
- * @ref Vector. For all classes for which iterating over elements, or random
+ * @ref Vector.
+ * For all classes for which iterating over elements, or random
* member access is expensive, this function is not efficient. In
* particular, if you want to multiply with BlockVector objects, you should
* consider using a BlockSparseMatrix as well.
*
* @note Instantiations for this template are provided for <tt>@<float@> and
* @<double@></tt>; others can be generated in application programs (see the
- * section on @ref Instantiations in the manual).
+ * section on
+ * @ref Instantiations
+ * in the manual).
*
* @author Guido Kanschat, Wolfgang Bangerth; 1999, 2000
*/
/**
* Structure representing the sparsity pattern of a sparse matrix. This class
- * is an example of the "static" type of @ref Sparsity. It uses the compressed
+ * is an example of the "static" type of
+ * @ref Sparsity.
+ * It uses the compressed
* row storage (CSR) format to store data.
*
* The elements of a SparsityPattern, corresponding to the places where
* systems, it is rarely set up directly due to the way it stores its
* information. Rather, one typically goes through an intermediate format
* first, see for example the step-2 tutorial program as well as the
- * documentation module @ref Sparsity.
+ * documentation module
+ * @ref Sparsity.
*
* @author Wolfgang Bangerth, Guido Kanschat and others
*/
*
* @note Instantiations for this template are provided for <tt>@<float@> and
* @<double@></tt>; others can be generated in application programs (see the
- * section on @ref Instantiations in the manual).
+ * section on
+ * @ref Instantiations
+ * in the manual).
*
* @author Wolfgang Bangerth, 1999, 2000
*/
* processor, since the Trilinos matrices are inherently parallel.
*
* @ingroup Vectors
- * @ingroup TrilinosWrappers @see @ref GlossBlockLA "Block (linear algebra)"
+ * @ingroup TrilinosWrappers
+ * @see
+ * @ref GlossBlockLA "Block (linear algebra)"
* @author Martin Kronbichler, 2008
*/
class BlockVector : public BlockVectorBase<Vector>
*
* @deprecated
*
- * See @ref GlossCompress "Compressing distributed objects" for more
- * information.
+ * See
+ * @ref GlossCompress "Compressing distributed objects"
+ * for more information.
*/
void compress (const Epetra_CombineMode last_action) DEAL_II_DEPRECATED;
* elements of each of these blocks to be stored on the local process.
*
* @ingroup Vectors
- * @ingroup TrilinosWrappers @see
+ * @ingroup TrilinosWrappers
+ * @see
* @ref GlossBlockLA "Block (linear algebra)"
* @author Martin Kronbichler, Wolfgang Bangerth, 2008, 2009
*/
*
* @deprecated
*
- * See @ref GlossCompress "Compressing distributed objects" for more
- * information.
+ * See
+ * @ref GlossCompress "Compressing distributed objects"
+ * for more information.
*/
void compress (const Epetra_CombineMode last_action) DEAL_II_DEPRECATED;
/**
* Returns if this Vector contains ghost elements.
*
- * @see @ref GlossGhostedVector "vectors with ghost elements"
+ * @see
+ * @ref GlossGhostedVector "vectors with ghost elements"
*/
bool has_ghost_elements() const;
* vector products. This is a collective operation, i.e., it needs to be
* run on all processors when used in %parallel.
*
- * See @ref GlossCompress "Compressing distributed objects" for more
- * information.
+ * See
+ * @ref GlossCompress "Compressing distributed objects"
+ * for more information.
*/
void compress (::dealii::VectorOperation::values operation);
* above.
*
* What we call a 'ghosted' vector (see
- * @ref GlossGhostedVector "vectors with ghost elements") is simply a
+ * @ref GlossGhostedVector "vectors with ghost elements"
+ * ) is simply a
* view of the parallel vector where the element distributions overlap.
* The 'ghosted' Trilinos vector in itself has no idea of which entries
* are ghosted and which are locally owned. In fact, a ghosted vector
* or may not have ghost elements. See the general documentation of this
* class for more information.
*
- * @see @ref GlossGhostedVector "vectors with ghost elements"
+ * @see
+ * @ref GlossGhostedVector "vectors with ghost elements"
*/
explicit Vector (const Epetra_Map ¶llel_partitioning);
* or may not have ghost elements. See the general documentation of this
* class for more information.
*
- * @see @ref GlossGhostedVector "vectors with ghost elements"
+ * @see
+ * @ref GlossGhostedVector "vectors with ghost elements"
*/
Vector (const Epetra_Map ¶llel_partitioning,
const VectorBase &v);
* or may not have ghost elements. See the general documentation of this
* class for more information.
*
- * @see @ref GlossGhostedVector "vectors with ghost elements"
+ * @see
+ * @ref GlossGhostedVector "vectors with ghost elements"
*/
template <typename number>
void reinit (const Epetra_Map ¶llel_partitioner,
* or may not have ghost elements. See the general documentation of this
* class for more information.
*
- * @see @ref GlossGhostedVector "vectors with ghost elements"
+ * @see
+ * @ref GlossGhostedVector "vectors with ghost elements"
*/
void reinit (const Epetra_Map ¶llel_partitioning,
const bool fast = false);
* or may not have ghost elements. See the general documentation of this
* class for more information.
*
- * @see @ref GlossGhostedVector "vectors with ghost elements"
+ * @see
+ * @ref GlossGhostedVector "vectors with ghost elements"
*/
template <typename Number>
Vector (const Epetra_Map ¶llel_partitioning,
* or may not have ghost elements. See the general documentation of this
* class for more information.
*
- * @see @ref GlossGhostedVector "vectors with ghost elements"
+ * @see
+ * @ref GlossGhostedVector "vectors with ghost elements"
*/
explicit Vector (const IndexSet ¶llel_partitioning,
const MPI_Comm &communicator = MPI_COMM_WORLD);
* have ghost elements. See the general documentation of this class for
* more information.
*
- * @see @ref GlossGhostedVector "vectors with ghost elements"
+ * @see
+ * @ref GlossGhostedVector "vectors with ghost elements"
*/
Vector (const IndexSet &local,
const IndexSet &ghost,
* or may not have ghost elements. See the general documentation of this
* class for more information.
*
- * @see @ref GlossGhostedVector "vectors with ghost elements"
+ * @see
+ * @ref GlossGhostedVector "vectors with ghost elements"
*/
Vector (const IndexSet ¶llel_partitioning,
const VectorBase &v,
* or may not have ghost elements. See the general documentation of this
* class for more information.
*
- * @see @ref GlossGhostedVector "vectors with ghost elements"
+ * @see
+ * @ref GlossGhostedVector "vectors with ghost elements"
*/
template <typename Number>
Vector (const IndexSet ¶llel_partitioning,
* or may not have ghost elements. See the general documentation of this
* class for more information.
*
- * @see @ref GlossGhostedVector "vectors with ghost elements"
+ * @see
+ * @ref GlossGhostedVector "vectors with ghost elements"
*/
void reinit (const IndexSet ¶llel_partitioning,
const MPI_Comm &communicator = MPI_COMM_WORLD,
* or may not have ghost elements. See the general documentation of this
* class for more information.
*
- * @see @ref GlossGhostedVector "vectors with ghost elements"
+ * @see
+ * @ref GlossGhostedVector "vectors with ghost elements"
*/
void reinit (const IndexSet &locally_owned_entries,
const IndexSet &ghost_entries,
* argument is ignored if the vector has been added or written to since
* the last time compress() was called.
*
- * See @ref GlossCompress "Compressing distributed objects" for more
- * information.
+ * See
+ * @ref GlossCompress "Compressing distributed objects"
+ * for more information.
*/
void compress (::dealii::VectorOperation::values operation);
* Return if the vector contains ghost elements. This answer is true if
* there are ghost elements on at least one process.
*
- * @see @ref GlossGhostedVector "vectors with ghost elements"
+ * @see
+ * @ref GlossGhostedVector "vectors with ghost elements"
*/
bool has_ghost_elements() const;
* It is used in the various compress() functions. They also exist in serial
* codes for compatibility and are empty there.
*
- * See @ref GlossCompress "Compressing distributed objects" for more
- * information.
+ * See
+ * @ref GlossCompress "Compressing distributed objects"
+ * for more information.
*/
struct VectorOperation
{
* @<double@>, @<long double@>, @<std::complex@<float@>@>,
* @<std::complex@<double@>@>, @<std::complex@<long double@>@></tt>; others
* can be generated in application programs (see the section on
- * @ref Instantiations in the manual).
+ * @ref Instantiations
+ * in the manual).
*
* @author Guido Kanschat, Franz-Theo Suttmeier, Wolfgang Bangerth
*/
*
* In the block model, each of the blocks of the local vectors corresponds
* to the restriction of a single block of the system to this cell
- * (@ref GlossBlock). Thus, the size of this local block is the number of
+ * (
+ * @ref GlossBlock
+ * ). Thus, the size of this local block is the number of
* degrees of freedom of the corresponding base element of the FESystem.
*
* @todo Comprehensive model currently not implemented.
* operate on all components of the solution.
*
* @note For the following, it is important to realize the difference between
- * a solution @ref GlossComponent "component" and a solution @ref GlossBlock
- * "block". The distinction only applies if vector valued elements are used,
+ * a solution
+ * @ref GlossComponent "component"
+ * and a solution
+ * @ref GlossBlock "block".
+ * The distinction only applies if vector valued elements are used,
* but is quite important then. This is reflected in the fact that it is not
* possible right now to use transfer classes based on MGTransferComponentBase
* for genuine vector valued elements, but descendants of MGTransferBlockBase
/**
- * Iterators for MGDofHandler in one dimension. See the @ref Iterators
+ * Iterators for MGDofHandler in one dimension. See the
+ * @ref Iterators
* module for more information.
*/
template <int spacedim>
/**
- * Iterators for MGDofHandler in two dimensions. See the @ref Iterators
+ * Iterators for MGDofHandler in two dimensions. See the
+ * @ref Iterators
* module for more information.
*/
template <int spacedim>
/**
- * Iterators for MGDofHandler in three dimensions. See the @ref Iterators
+ * Iterators for MGDofHandler in three dimensions. See the
+ * @ref Iterators
* module for more information.
*/
template <int spacedim>
/**
* Make a sparsity pattern including fluxes of discontinuous Galerkin
- * methods. @ref make_sparsity_pattern @ref DoFTools
+ * methods.
+ * @see
+ * @ref make_sparsity_pattern
+ * and
+ * @ref DoFTools
*/
template <int dim, class SparsityPattern, int spacedim>
void
/**
* Return the first cell which we want output for. The default
- * implementation returns the first @ref GlossActive "active cell", but you
+ * implementation returns the first
+ * @ref GlossActive "active cell"
+ * , but you
* might want to return other cells in a derived class.
*/
virtual cell_iterator first_cell ();
* You might give a list of components you want to evaluate, in case the
* finite element used by the DoFHandler object is vector-valued. You then
* have to set those entries to true in the bit-vector @p component_mask
- * (see @ref GlossComponentMask) for which the respective component is to be
+ * (see
+ * @ref GlossComponentMask
+ * ) for which the respective component is to be
* used in the error estimator. The default is to use all components, which
* is done by either providing a bit-vector with all-set entries, or an
* empty bit-vector.
* and evaluating the solution at a particular point, not every processor
* will own the cell at which the solution is evaluated. Rather, it may be
* that the cell in which this point is found is in fact a ghost or
- * artificial cell (see @ref GlossArtificialCell and @ref GlossGhostCell).
+ * artificial cell (see
+ * @ref GlossArtificialCell
+ * and
+ * @ref GlossGhostCell
+ * ).
* If the cell is artificial, we have no access to the solution there and
* functions that evaluate the solution at such a point will trigger an
* exception of type FEFieldFunction::ExcPointNotAvailableHere. The same
* @note When using this function on a
* parallel::distributed::Triangulation you may get an exception when
* trying to evaluate the solution at a point that does not lie in a
- * locally owned cell (see @ref GlossLocallyOwnedCell). See the section in
+ * locally owned cell (see
+ * @ref GlossLocallyOwnedCell
+ * ). See the section in
* the general documentation of this class for more information.
*/
virtual void vector_value (const Point<dim> &p,
* @note When using this function on a
* parallel::distributed::Triangulation you may get an exception when
* trying to evaluate the solution at a point that does not lie in a
- * locally owned cell (see @ref GlossLocallyOwnedCell). See the section in
+ * locally owned cell (see
+ * @ref GlossLocallyOwnedCell
+ * ). See the section in
* the general documentation of this class for more information.
*/
virtual double value (const Point< dim > &p,
* @note When using this function on a
* parallel::distributed::Triangulation you may get an exception when
* trying to evaluate the solution at a point that does not lie in a
- * locally owned cell (see @ref GlossLocallyOwnedCell). See the section in
+ * locally owned cell (see
+ * @ref GlossLocallyOwnedCell
+ * ). See the section in
* the general documentation of this class for more information.
*/
virtual void value_list (const std::vector<Point< dim > > &points,
* @note When using this function on a
* parallel::distributed::Triangulation you may get an exception when
* trying to evaluate the solution at a point that does not lie in a
- * locally owned cell (see @ref GlossLocallyOwnedCell). See the section in
+ * locally owned cell (see
+ * @ref GlossLocallyOwnedCell
+ * ). See the section in
* the general documentation of this class for more information.
*/
virtual void vector_value_list (const std::vector<Point< dim > > &points,
* @note When using this function on a
* parallel::distributed::Triangulation you may get an exception when
* trying to evaluate the solution at a point that does not lie in a
- * locally owned cell (see @ref GlossLocallyOwnedCell). See the section in
+ * locally owned cell (see
+ * @ref GlossLocallyOwnedCell
+ * ). See the section in
* the general documentation of this class for more information.
*/
virtual void
* @note When using this function on a
* parallel::distributed::Triangulation you may get an exception when
* trying to evaluate the solution at a point that does not lie in a
- * locally owned cell (see @ref GlossLocallyOwnedCell). See the section in
+ * locally owned cell (see
+ * @ref GlossLocallyOwnedCell
+ * ). See the section in
* the general documentation of this class for more information.
*/
virtual Tensor<1,dim> gradient(const Point< dim > &p,
* @note When using this function on a
* parallel::distributed::Triangulation you may get an exception when
* trying to evaluate the solution at a point that does not lie in a
- * locally owned cell (see @ref GlossLocallyOwnedCell). See the section in
+ * locally owned cell (see
+ * @ref GlossLocallyOwnedCell
+ * ). See the section in
* the general documentation of this class for more information.
*/
virtual void
* @note When using this function on a
* parallel::distributed::Triangulation you may get an exception when
* trying to evaluate the solution at a point that does not lie in a
- * locally owned cell (see @ref GlossLocallyOwnedCell). See the section in
+ * locally owned cell (see
+ * @ref GlossLocallyOwnedCell
+ * ). See the section in
* the general documentation of this class for more information.
*/
virtual void
* @note When using this function on a
* parallel::distributed::Triangulation you may get an exception when
* trying to evaluate the solution at a point that does not lie in a
- * locally owned cell (see @ref GlossLocallyOwnedCell). See the section in
+ * locally owned cell (see
+ * @ref GlossLocallyOwnedCell
+ * ). See the section in
* the general documentation of this class for more information.
*/
virtual double
* @note When using this function on a
* parallel::distributed::Triangulation you may get an exception when
* trying to evaluate the solution at a point that does not lie in a
- * locally owned cell (see @ref GlossLocallyOwnedCell). See the section in
+ * locally owned cell (see
+ * @ref GlossLocallyOwnedCell
+ * ). See the section in
* the general documentation of this class for more information.
*/
virtual void
* @note When using this function on a
* parallel::distributed::Triangulation you may get an exception when
* trying to evaluate the solution at a point that does not lie in a
- * locally owned cell (see @ref GlossLocallyOwnedCell). See the section in
+ * locally owned cell (see
+ * @ref GlossLocallyOwnedCell
+ * ). See the section in
* the general documentation of this class for more information.
*/
virtual void
* @note When using this function on a
* parallel::distributed::Triangulation you may get an exception when
* trying to evaluate the solution at a point that does not lie in a
- * locally owned cell (see @ref GlossLocallyOwnedCell). See the section in
+ * locally owned cell (see
+ * @ref GlossLocallyOwnedCell
+ * ). See the section in
* the general documentation of this class for more information.
*/
virtual void
* <ol>
* <li>Firstly, the @p evaluate_field version that does not take a @p
* DataPostprocessor object selects the nearest support point (see
- * @ref GlossSupport "this entry in the glossary") to a given point to extract
+ * @ref GlossSupport "this entry in the glossary"
+ * ) to a given point to extract
* data from. This makes the code that needs to be run at each time step
* very
* short, since looping over the mesh to extract the needed dof_index can be
* done just once at the start. However, this method is not suitable for
* FiniteElement objects that do not assign dofs to actual mesh locations
- * (i.e. FEs without @ref GlossSupport "support points") or if adaptive mesh
+ * (i.e. FEs without
+ * @ref GlossSupport "support points"
+ * ) or if adaptive mesh
* refinement is used. The reason for the latter restriction is that the
* location of the closest support point to a given point may change upon mesh
* refinement. The class will throw an exception if any change to the
* </ol>
*
* When recording a new mnemonic name, the user must supply a component_mask
- * (see @ref GlossComponentMask "this glossary entry") to indicate the
- * @ref GlossComponent "(vector) components" to be extracted from the given
+ * (see
+ * @ref GlossComponentMask "this glossary entry"
+ * ) to indicate the
+ * @ref GlossComponent "(vector) components"
+ * to be extracted from the given
* input. If the user simply wants to extract all the components, the mask
* need not be explicitly supplied to the @p add_field_name method and the
* default value of the parameter is sufficient. If the @p evaluate_field
* @note Instantiations for this template are provided for some vector types,
* in particular <code>Vector<float>, Vector<double>,
* BlockVector<float>, BlockVector<double></code>; others can be
- * generated in application code (see the section on @ref Instantiations in
+ * generated in application code (see the section on
+ * @ref Instantiations
+ * in
* the manual).
*
* @ingroup numerics
* first interpolate() function in the series. It interpolations a set of
* functions onto the finite element space given by the DoFHandler argument
* where the determination which function to use is made based on the
- * material id (see @ref GlossMaterialId) of each cell.
+ * material id (see
+ * @ref GlossMaterialId
+ * ) of each cell.
*
* @param mapping - The mapping to use to determine the location of
* support points at which the functions are to be evaluated.
* it is assumed that the number of entries equals the number of components
* in the boundary functions and the finite element, and those components in
* the given boundary function will be used for which the respective flag
- * was set in the component mask. See also @ref GlossComponentMask. As an
+ * was set in the component mask. See also
+ * @ref GlossComponentMask.
+ * As an
* example, assume that you are solving the Stokes equations in 2d, with
* variables $(u,v,p)$ and that you only want to interpolate boundary values
* for the pressure, then the component mask should correspond to
* previous function, in particular about the use of the component mask and
* the requires size of the function object.
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template <class DH>
void
* previous function, in particular about the use of the component mask and
* the requires size of the function object.
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template <class DH>
void
* are not set in the second operation on degrees of freedom that are
* already constrained. This makes sure that the discretization remains
* conforming as is needed. See the discussion on conflicting constraints in
- * the module on @ref constraints .
+ * the module on
+ * @ref constraints.
*
* The parameter @p boundary_component corresponds to the number @p
* boundary_indicator of the face.
* it is assumed that the number of entries equals the number of components
* in the boundary functions and the finite element, and those components in
* the given boundary function will be used for which the respective flag
- * was set in the component mask. See also @ref GlossComponentMask. As an
+ * was set in the component mask. See also
+ * @ref GlossComponentMask.
+ * As an
* example, assume that you are solving the Stokes equations in 2d, with
* variables $(u,v,p)$ and that you only want to interpolate boundary values
* for the pressure, then the component mask should correspond to
*
* @ingroup constraints
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template <class DH>
void
*
* @ingroup constraints
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template <class DH>
void
* numbering of degrees of freedom.
* @param boundary_functions A map from boundary indicators to pointers to
* functions that describe the desired values on those parts of the boundary
- * marked with this boundary indicator (see @ref GlossBoundaryIndicator
- * "Boundary indicator"). The projection happens on only those parts of the
+ * marked with this boundary indicator (see
+ * @ref GlossBoundaryIndicator "Boundary indicator"
+ * ). The projection happens on only those parts of the
* boundary whose indicators are represented in this map.
* @param q The face quadrature used in the integration necessary to compute
* the mass matrix and right hand side of the projection.
* are not set in the second operation on degrees of freedom that are
* already constrained. This makes sure that the discretization remains
* conforming as is needed. See the discussion on conflicting constraints in
- * the module on @ref constraints .
+ * the module on
+ * @ref constraints.
*
* If @p component_mapping is empty, it is assumed that the number of
* components of @p boundary_function matches that of the finite element
* the Dirichlet conditions should be set first, and then completed by
* hanging node constraints, in order to make sure that the discretization
* remains consistent. See the discussion on conflicting constraints in the
- * module on @ref constraints .
+ * module on
+ * @ref constraints.
*
* This function is explicitly written to use with the FE_Nedelec elements.
* Thus it throws an exception, if it is called with other finite elements.
*
* @ingroup constraints
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template <int dim>
void project_boundary_values_curl_conforming (const DoFHandler<dim> &dof_handler,
*
* @ingroup constraints
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template <int dim>
void project_boundary_values_curl_conforming (const hp::DoFHandler<dim> &dof_handler,
* the Dirichlet conditions should be set first, and then completed by
* hanging node constraints, in order to make sure that the discretization
* remains consistent. See the discussion on conflicting constraints in the
- * module on @ref constraints .
+ * module on
+ * @ref constraints.
*
* The argument @p first_vector_component denotes the first vector component
* in the finite element that corresponds to the vector function $\vec{u}$
*
* @ingroup constraints
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template<int dim>
void project_boundary_values_div_conforming (const DoFHandler<dim> &dof_handler,
*
* @ingroup constraints
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template<int dim>
void project_boundary_values_div_conforming (const hp::DoFHandler<dim> &dof_handler,
* are not set in the second operation on degrees of freedom that are
* already constrained. This makes sure that the discretization remains
* conforming as is needed. See the discussion on conflicting constraints in
- * the module on @ref constraints .
+ * the module on
+ * @ref constraints.
*
*
* <h4>Computing constraints in 2d</h4>
*
* @ingroup constraints
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template <int dim, template <int, int> class DH, int spacedim>
void
*
* @ingroup constraints
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template <int dim, template <int, int> class DH, int spacedim>
void
*
* @ingroup constraints
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template <int dim, template <int, int> class DH, int spacedim>
void
*
* @ingroup constraints
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template <int dim, template <int, int> class DH, int spacedim>
void
*
* See the general documentation of this class for further information.
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template <int dim, int spacedim>
void create_boundary_right_hand_side (const Mapping<dim,spacedim> &mapping,
* Calls the create_boundary_right_hand_side() function, see above, with
* <tt>mapping=MappingQ1@<dim@>()</tt>.
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template <int dim, int spacedim>
void create_boundary_right_hand_side (const DoFHandler<dim,spacedim> &dof,
/**
* Same as the set of functions above, but for hp objects.
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template <int dim, int spacedim>
void create_boundary_right_hand_side (const hp::MappingCollection<dim,spacedim> &mapping,
* single Q1 mapping as collection. This function therefore will only work
* if the only active fe index in use is zero.
*
- * @see @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
+ * @see
+ * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template <int dim, int spacedim>
void create_boundary_right_hand_side (const hp::DoFHandler<dim,spacedim> &dof,
* the vector elements $d_K$ for an output vector with as many cells as
* there are active cells of the triangulation object of the current
* processor. However, not all active cells are in fact locally owned: some
- * may be ghost or artificial cells (see @ref GlossGhostCell "here" and
- * @ref GlossArtificialCell "here"). The vector computed will, in the case of
+ * may be ghost or artificial cells (see
+ * @ref GlossGhostCell "here"
+ * and
+ * @ref GlossArtificialCell "here"
+ * ). The vector computed will, in the case of
* a distributed triangulation, contain zeros for cells that are not locally
* owned. As a consequence, in order to compute the <i>global</i> $L_2$
* error (for example), the errors from different processors need to be
* function using a Q1-mapping for cells.
*
* This function is used in the "Possibilities for extensions" part of the
- * results section of @ref step_3 "step-3".
+ * results section of
+ * @ref step_3 "step-3".
*
* @note If the cell in which the point is found is not locally owned, an
* exception of type VectorTools::ExcPointNotAvailableHere is thrown.
* argument is used to denote which components of the solution vector
* correspond to the pressure, and avoid touching all other components of
* the vector, such as the velocity components. (Note, however, that the
- * mask is not a @ref GlossComponentMask operating on the vector components
+ * mask is not a
+ * @ref GlossComponentMask
+ * operating on the vector components
* of the finite element the solution vector @p v may be associated with;
* rather, it is a mask on the entire vector, without reference to what the
* vector elements mean.)
* numerically using the quadrature formula given as third argument.
*
* This function is used in the "Possibilities for extensions" part of the
- * results section of @ref step_3 "step-3".
+ * results section of
+ * @ref step_3 "step-3".
*
* @note The function is most often used when solving a problem whose
* solution is only defined up to a constant, for example a pure Neumann
projects / dealii.git / commitdiff