* <tt>DeclException</tt> macro family.
*
* See the
- * @ref Exceptions module for more details on this class and what can be done
- * with classes derived from it.
+ * @ref Exceptions
+ * module for more details on this class and what can be done with classes
+ * derived from it.
*
* @ingroup Exceptions
* @author Wolfgang Bangerth, 1997, 1998, Matthias Maier, 2013
* 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
- * step-20 tutorial program for a detailed explanation and a use case.
+ * @ref GlossComponentMask "the glossary entry on component masks").
+ * See the step-20 tutorial program for a detailed explanation and a use case.
*
* @ingroup functions
* @author Guido Kanschat, 2000, Wolfgang Bangerth 2006
* 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.
+ * @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,
*
* @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
* 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.
+ * @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.
*
* This function is used in order to determine how distorted a cell is (see
* the entry on
- * @ref GlossDistorted "distorted cells" in the glossary).
+ * @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];
* 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 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 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; </code> of a global
- * variable <code>multithread_info</code> of this class that, or using <code>
+ * @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 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; </code> of a global variable
+ * <code>multithread_info</code> of this class that, or using <code>
* multithread_info.n_threads(); </code>
*
* @ingroup threads
*
* For a discussion of the kind of problems to which this function is
* applicable, see the
- * @ref threads "Parallel computing with multiple processors" module.
+ * @ref threads "Parallel computing with multiple processors"
+ * module.
*/
template <typename InputIterator,
typename OutputIterator,
*
* For a discussion of the kind of problems to which this function is
* applicable, see the
- * @ref threads "Parallel computing with multiple processors" module.
+ * @ref threads "Parallel computing with multiple processors"
+ * module.
*/
template <typename InputIterator1,
typename InputIterator2,
*
* For a discussion of the kind of problems to which this function is
* applicable, see the
- * @ref threads "Parallel computing with multiple processors" module.
+ * @ref threads "Parallel computing with multiple processors"
+ * module.
*/
template <typename InputIterator1,
typename InputIterator2,
*
* For a discussion of the kind of problems to which this function is
* applicable, see also the
- * @ref threads "Parallel computing with multiple processors" module.
+ * @ref threads "Parallel computing with multiple processors"
+ * module.
*/
template <typename RangeType, typename Function>
void apply_to_subranges (const RangeType &begin,
*
* For a discussion of the kind of problems to which this function is
* applicable, see also the
- * @ref threads "Parallel computing with multiple processors" module.
+ * @ref threads "Parallel computing with multiple processors"
+ * module.
*/
template <typename ResultType, typename RangeType, typename Function>
ResultType accumulate_from_subranges (const Function &f,
private:
/**
* 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.
+ * @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 operation of this class must be equal to this value or less,
- * if the bounds of the interval for a valid range.
+ * @ref match
+ * operation of this class must be equal to this value or less, if the
+ * bounds of the interval for a valid range.
*/
const int upper_bound;
private:
/**
* 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.
+ * @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 operation of this class must be equal to this value or less,
- * if the bounds of the interval for a valid range.
+ * @ref match
+ * operation of this class must be equal to this value or less, if the
+ * bounds of the interval for a valid range.
*/
const double upper_bound;
* 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 <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.
+ * @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.
*/
class Selection : public PatternBase
{
* 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 step-29, step-33 and step-34.
+ * @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>
*
* 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 DataSetDescriptor member class is used to
- * identify where each dataset starts.
+ * @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.
*
* @author Wolfgang Bangerth, Guido Kanschat, 1998, 1999, 2003, 2005
*/
* The type used to denote subdomain_ids of cells.
*
* See the
- * @ref GlossSubdomainId "glossary" for more information.
+ * @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 should
- * not be used.
+ * @ref GlobalDoFIndex
+ * page for guidance on when this type should or should not be used.
*/
// TODO: we should check that unsigned long long int
// has the same size as uint64_t
* subdomain id that is not to be used.
*
* See the
- * @ref GlossSubdomainId "glossary" for more information.
+ * @ref GlossSubdomainId "glossary"
+ * for more information.
*/
const types::subdomain_id invalid_subdomain_id = static_cast<types::subdomain_id>(-1);
* "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.
+ * @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
- * used in the tutorial first in step-9, and again in step-13, step-14,
- * step-32 and others.
+ * @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.
*
* The class is built on the following premise: One frequently has some work
* that needs to be done on a sequence of objects; a prototypical example is
* 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
- * 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,
- * these cells are not neighbors). Each "color" is represented by
- * std::vectors of cells. The first argument to this function, a set of sets
- * of cells (which are represent as a vector of vectors, for efficiency), is
- * typically constructed by calling GraphColoring::make_graph_coloring().
- * See there for more information.
+ * @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, these cells are not neighbors). Each
+ * "color" is represented by std::vectors of cells. The first argument to
+ * this function, a set of sets of cells (which are represent as a vector of
+ * vectors, for efficiency), is typically constructed by calling
+ * GraphColoring::make_graph_coloring(). See there for more information.
*
* 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
* 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 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
* 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, 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
- * another.
+ * @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 another.
*
* An example are boundary indicators. Assume, for example, that you start
* with a single cell that is refined once globally, yielding four
/**
* A typedef that is used to to identify
- * @ref GlossActive "active cell iterators". The concept of iterators is
- * discussed at length in the
+ * @ref GlossActive "active cell iterators".
+ * The concept of iterators is discussed at length in the
* @ref Iterators "iterators documentation module".
*
* The current typedef identifies active cells in a triangulation. You
* 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
+ * @ref GlossArtificialCell
+ * and
* @ref GlossGhostCell).
*/
unsigned int n_locally_owned_active_cells () const;
* 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 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.
+ * @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.
*/
virtual
bool has_hanging_nodes() const;
DeclException0 (ExcMatrixDoesNotMatch);
/**
* A function has been called for a cell which should be
- * @ref GlossActive "active", but is refined.
+ * @ref GlossActive "active",
+ * but is refined.
*
* @ingroup Exceptions
*/
DeclException0 (ExcMatrixDoesNotMatch);
/**
* A function has been called for a cell which should be
- * @ref GlossActive "active", but is refined.
+ * @ref GlossActive "active",
+ * but is refined.
*
* @ingroup Exceptions
*/
/**
* 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
- * step-2 tutorial program.
+ * @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
* of degrees of freedom living on this object. These indices refer to the
* 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 object will proceed
- * to only manage degrees of freedom on locally owned and ghost cells. This
- * process is entirely transparent to the used.
+ * @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.
*
*
* <h3>User defined renumbering schemes</h3>
/**
* A typedef that is used to to identify
- * @ref GlossActive "active cell iterators". The concept of iterators is
- * discussed at length in the
+ * @ref GlossActive "active cell iterators".
+ * The concept of iterators is discussed at length in the
* @ref Iterators "iterators documentation module".
*
* The current typedef identifies active cells in a DoFHandler object. While
*
* 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 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 level_cell_iterator
- * typedef.
+ * @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 level_cell_iterator typedef.
*
* While the actual data type of the typedef is hidden behind a few layers
* of (unfortunately necessary) indirections, it is in essence
*
* If an FESystem is used in distribute_dofs(), degrees of freedom naturally
* split into several
- * @ref GlossBlock "blocks". For each base element as many blocks appear as
- * its multiplicity.
+ * @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
* block is counted, and stored in a BlockInfo object, which can be accessed
* 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 for more information.
+ * @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<2,spacedim>, only the treatment of
* templates is a little more complicated. See the
- * @ref Iterators module for more information.
+ * @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.
+ * @ref Iterators
+ * module for more information.
*
* @author Wolfgang Bangerth, Oliver Kayser-Herold, Guido Kanschat, 1998,
* 2003, 2008, 2010
* 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
- * 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
+ * @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
* FESystem<dim> stokes_fe (FE_Q<dim>(2), dim, // dim velocities
* FE_Q<dim>(1), 1); // one pressure
* 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 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 blocks. At the same time, this function here
- * needs to match individual blocks across elements and therefore requires
- * that elements have the same number of blocks and that subsequent blocks
- * in one element have the same meaning as in another element.
+ * @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
+ * blocks. At the same time, this function here needs to match individual
+ * blocks across elements and therefore requires that elements have the same
+ * number of blocks and that subsequent blocks in one element have the same
+ * meaning as in another element.
*/
template <int dim>
void
* 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 program and is used in almost all following
- * programs as well.
+ * @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
* order to allow adding constraints from different sources to the same
* happens.
*
* 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 value, it is assumed that the number of
- * entries equals the number of components of the finite element. This can
- * be used to enforce periodicity in only one variable in a system of
- * equations.
+ * @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 entries equals the number
+ * of components of the finite element. This can be used to enforce
+ * periodicity in only one variable in a system of equations.
*
* @p face_orientation, @p face_flip and @p face_rotation describe an
* orientation that should be applied to @p face_1 prior to matching and
* before.
*
* @see
- * @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions" for further information.
+ * @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 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
- * 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.
+ * @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 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.
*
* @note: This function is a convenience wrapper. It internally calls
* GridTools::collect_periodic_faces() with the supplied paramaters and
* need more functionality use GridTools::collect_periodic_faces() directly.
*
* @see
- * @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions" for further information.
+ * @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions"
+ * for further information.
*
* @author Matthias Maier, 2012
*/
* need more functionality use GridTools::collect_periodic_faces() directly.
*
* @see
- * @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions" for further information.
+ * @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions"
+ * for further information.
*/
template<typename DH>
void
* 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 equivalent to selecting
- * <em>all</em> vector components corresponding to this non-primitive base
- * element.
+ * @ref GlossComponentMask),
+ * then this is equivalent to selecting <em>all</em> vector components
+ * corresponding to this non-primitive base element.
*
* @note If the @p blocks argument is true,
*/
* 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 object.
+ * @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
* all boundary indicators are accepted.
*
* 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
+ * @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.
*
/**
* Extract a vector that represents the constant modes of the DoFHandler for
* the components chosen by <tt>component_mask</tt> (see
- * @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
- * obtaining a good AMG preconditioner when using the class
+ * @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 obtaining a good
+ * AMG preconditioner when using the class
* TrilinosWrappers::PreconditionAMG. Since the ML AMG package only works
* on algebraic properties of the respective matrix, it has no chance to
* detect whether the matrix comes from a scalar or a vector valued problem.
* 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 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 scalar elements
- * may even have two constant modes (FE_Q_DG0). Therefore, we store this
- * object in a vector of vectors, where the outer vector contains the
- * collection of the actual constant modes on the DoFHandler. Each inner
- * vector has as many components as there are (locally owned) degrees of
- * freedom in the selected components. Note that any matrix associated with
- * this null space must have been constructed using the same
- * <tt>component_mask</tt> argument, since the numbering of DoFs is done
- * relative to the selected dofs, not to all dofs.
+ * @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 scalar elements may even have two constant modes
+ * (FE_Q_DG0). Therefore, we store this object in a vector of vectors, where
+ * the outer vector contains the collection of the actual constant modes on
+ * the DoFHandler. Each inner vector has as many components as there are
+ * (locally owned) degrees of freedom in the selected components. Note that
+ * any matrix associated with this null space must have been constructed
+ * using the same <tt>component_mask</tt> argument, since the numbering of
+ * DoFs is done relative to the selected dofs, not to all dofs.
*
* The main reason for this program is the use of the null space with the
* AMG preconditioner.
* 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. Again the vectors
- * are assumed to have the correct size before calling this function. If
- * this is not the case, an assertion is thrown.
+ * @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.
*
* This function is used in the step-22, step-31, and step-32 tutorial
* programs.
/**
* Return a list of support points (see this
- * @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. Otherwise, an
- * exception is thrown.
+ * @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. Otherwise, an exception is thrown.
*
* @pre The given array must have a length of as many elements as there are
* degrees of freedom.
/**
* 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
- * 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
- * object. In such cases, each processor will not be able to determine the
- * support point location of all DoFs, and worse no processor may be able to
- * hold a vector that would contain the locations of all DoFs even if they
- * 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 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 object. In such cases, each
+ * processor will not be able to determine the support point location of all
+ * DoFs, and worse no processor may be able to hold a vector that would
+ * contain the locations of all DoFs even if they 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.
*
* 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.
* 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 the case where there are conflicting
- * constraints on individual degrees of freedom.
+ * @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 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 of
- * the finite element with degrees of freedom at the boundary will be
- * considered.
+ * @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 of the finite element with
+ * degrees of freedom at the boundary will be considered.
*
* @ingroup constraints
*
/**
* This class declares a local typedef that denotes a mapping between a
* boundary indicator (see
- * @ref GlossBoundaryIndicator) that is used to describe what kind of boundary
- * condition holds on a particular piece of the boundary, and the function
- * describing the actual function that provides the boundary values on this
- * part of the boundary. This type is required in many functions in the
- * library where, for example, we need to know about the functions
- * $h_i(\mathbf x)$ used in boundary conditions @f{align*} \mathbf n \cdot
- * \nabla u = h_i \qquad \qquad \text{on}\ \Gamma_i\subset\partial\Omega. @f}
- * An example is the function KellyErrorEstimator::estimate() that allows us
- * to provide a set of functions $h_i$ for all those boundary indicators $i$
- * for which the boundary condition is supposed to be of Neumann type. Of
- * course, the same kind of principle can be applied to cases where we care
- * about Dirichlet values, where one needs to provide a map from boundary
- * indicator $i$ to Dirichlet function $h_i$ if the boundary conditions are
- * given as @f{align*} u = h_i \qquad \qquad \text{on}\
- * \Gamma_i\subset\partial\Omega. @f} This is, for example, the case for the
- * VectorTools::interpolate() functions.
+ * @ref GlossBoundaryIndicator)
+ * that is used to describe what kind of boundary condition holds on a
+ * particular piece of the boundary, and the function describing the actual
+ * function that provides the boundary values on this part of the boundary.
+ * This type is required in many functions in the library where, for example,
+ * we need to know about the functions $h_i(\mathbf x)$ used in boundary
+ * conditions @f{align*} \mathbf n \cdot \nabla u = h_i \qquad \qquad
+ * \text{on}\ \Gamma_i\subset\partial\Omega. @f} An example is the function
+ * KellyErrorEstimator::estimate() that allows us to provide a set of
+ * functions $h_i$ for all those boundary indicators $i$ for which the
+ * boundary condition is supposed to be of Neumann type. Of course, the same
+ * kind of principle can be applied to cases where we care about Dirichlet
+ * values, where one needs to provide a map from boundary indicator $i$ to
+ * Dirichlet function $h_i$ if the boundary conditions are given as @f{align*}
+ * u = h_i \qquad \qquad \text{on}\ \Gamma_i\subset\partial\Omega. @f} This
+ * is, for example, the case for the VectorTools::interpolate() functions.
*
* Tutorial programs step-6, step-7 and step-8 show examples of how to use
* function arguments of this type in situations where we actually have an
/**
* 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 many
- * elements as the finite element has blocks, and one can use
- * <code>operator[]</code> to query whether a particular block has been
- * selected.
+ * @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.
*
* The semantics of this class are the same as the related ComponentMask
* class, i.e., a default constructed mask represents all possible blocks. See
/**
* 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 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.
+ * @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.
*
* Objects of this kind are used in many places where one wants to restrict
* operations to a certain subset of components, e.g. in
*
* 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 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().
+ * @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 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
- * additional components occupied by vector valued elements. The number of
- * generated blocks can be determined by FiniteElementData::n_blocks().
+ * @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 additional components occupied by
+ * vector valued elements. The number of generated blocks can be determined by
+ * FiniteElementData::n_blocks().
*
* If you decide to operate by base element and multiplicity, the function
* first_block_of_base() will be helpful.
*
* Since a FiniteElement does not have information on the actual grid cell, it
* 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 points.
+ * @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 points.
*
* @code
* Quadrature<dim> dummy_quadrature (fe.get_unit_support_points());
*
* 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 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 from linear
- * combinations of them. The coefficients of these combinations are determined
- * by the duality of node values.
+ * @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 from linear combinations of them. The
+ * coefficients of these combinations are determined by the duality of node
+ * values.
*
* Using this matrix allows the construction of the basis of shape functions
* in two steps.
* #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 vector_valued module.
+ * @ref step_20 "step-20"
+ * tutorial programs as well as in the
+ * @ref vector_valued
+ * module.
*/
std::pair<unsigned int, unsigned int>
system_to_component_index (const unsigned int index) 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 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 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
/**
* Given a block mask (see
- * @ref GlossBlockMask "this glossary entry"), produce a component mask (see
- * @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.
+ * @ref GlossBlockMask "this glossary entry"),
+ * produce a component mask (see
+ * @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.
*
* @param block_mask The mask that selects individual blocks of the finite
* element
* 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.
+ * @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.
+ * @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 blocks
- * that correspond to the components selected in the input argument. This is
- * essentially a conversion operator from ComponentMask to BlockMask.
+ * @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.
*
* @note This function will only succeed if the components referenced by the
* argument encompasses complete blocks. In other words, if, for example,
* Return a support point vector for generalized interpolation.
*
* See the
- * @ref GlossGeneralizedSupport "glossary entry on generalized points" for more information.
+ * @ref GlossGeneralizedSupport "glossary entry on generalized points"
+ * for more information.
*/
const std::vector<Point<dim> > &
get_generalized_support_points () const;
* get_unit_support_points() or get_generalized_support_points().
*
* See the
- * @ref GlossGeneralizedSupport "glossary entry on generalized support points" for more information.
+ * @ref GlossGeneralizedSupport "glossary entry on generalized support points"
+ * for more information.
*/
bool has_generalized_support_points () const;
* <h3>Interpolation</h3>
*
* 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
- * achieved by two interpolation schemes, the simplified one in
- * FE_RaviartThomasNodal and the original one here:
+ * @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 achieved by two interpolation schemes,
+ * the simplified one in FE_RaviartThomasNodal and the original one here:
*
* <h4>Node values on edges/faces</h4>
*
* 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 taken with respect to
- * this space.
+ * @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 taken with respect to this space.
*
* <h4>Interior node values</h4>
*
* and #interior_weights). Called from the constructor.
*
* See the
- * @ref GlossGeneralizedSupport "glossary entry on generalized support points" for more information.
+ * @ref GlossGeneralizedSupport "glossary entry on generalized support points"
+ * for more information.
*/
void initialize_support_points (const unsigned int rt_degree);
* 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
- * 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
- * dominated side is constrained to the dominating one.
+ * @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 dominated side is constrained
+ * to the dominating one.
*
* A similar situation happens in 3d, where we have to consider different
* elements meeting at only an edge, not an entire face. Such comparisons
* function.
*
* Note that there are situations where neither side dominates. The
- * @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
- * domination relationship, but it is different for the two components.
+ * @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 domination relationship, but it is different for the two
+ * components.
*
* It is clear that the concept of domination doesn't matter for
* discontinuous elements. However, discontinuous elements may be part of
/**
* Number of components. See
- * @ref GlossComponent "the glossary" for more information.
+ * @ref GlossComponent "the glossary"
+ * for more information.
*/
unsigned int n_components () const;
/**
* Number of blocks. See
- * @ref GlossBlock "the glossary" for more information.
+ * @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.
+ * @ref GlossPrimitive "primitive"
+ * for details.
*/
void set_primitivity(const bool value);
* Initialize the FiniteElement<dim>::generalized_support_points and
* FiniteElement<dim>::generalized_face_support_points fields. Called from
* the constructor. See the
- * @ref GlossGeneralizedSupport "glossary entry on generalized support points" for more information.
+ * @ref GlossGeneralizedSupport "glossary entry on generalized support points"
+ * for more information.
*/
void initialize_support_points (const unsigned int rt_degree);
/**
* constructor.
*
* See the
- * @ref GlossGeneralizedSupport "glossary entry on generalized support points" for more information.
+ * @ref GlossGeneralizedSupport "glossary entry on generalized support points"
+ * for more information.
*/
void initialize_support_points (const unsigned int degree);
* <h3>Interpolation</h3>
*
* 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
- * #restriction matrices.
+ * @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 #restriction matrices.
*
* <h4>Node values</h4>
*
* The
- * @ref GlossNodes "node values" for an element of degree <i>k</i> on the
- * reference cell are:
+ * @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
* polynomials of degree <i>k</i>.
* #generalized_face_support_points when computing the integration.
*
* See the
- * @ref GlossGeneralizedSupport "glossary entry on generalized support points" for more information.
+ * @ref GlossGeneralizedSupport "glossary entry on generalized support points"
+ * for more information.
*/
Table<2, double> boundary_weights;
* <h3>Interpolation</h3>
*
* 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
- * achieved by two interpolation schemes, the simplified one in
- * FE_RaviartThomasNodal and the original one here:
+ * @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 achieved by two interpolation schemes,
+ * the simplified one in FE_RaviartThomasNodal and the original one here:
*
* <h4>Node values on edges/faces</h4>
*
* 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 taken with respect to
- * this space.
+ * @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 taken with respect to this space.
*
* <h4>Interior node values</h4>
*
* point and one column for each degree of freedom on the face.
*
* See the
- * @ref GlossGeneralizedSupport "glossary entry on generalized support points" for more information.
+ * @ref GlossGeneralizedSupport "glossary entry on generalized support points"
+ * for more information.
*/
Table<2, double> boundary_weights;
/**
* the constructor.
*
* See the
- * @ref GlossGeneralizedSupport "glossary entry on generalized support points" for more information.
+ * @ref GlossGeneralizedSupport "glossary entry on generalized support points"
+ * for more information.
*/
void initialize_support_points (const unsigned int rt_degree);
};
* 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.
+ * @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
- * 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
- * blocks of a FESystem object is simply the sum of all multiplicities of base
- * elements and is given by n_blocks().
+ * @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 blocks of a FESystem
+ * object is simply the sum of all multiplicities of base elements and is
+ * given by n_blocks().
*
* For example, the FESystem for the Taylor-Hood element for the three-
* dimensional Stokes problem can be built using the code
* 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), then you should call this
- * function for each space dimension for which you want your finite element
- * added to the map.
+ * @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.
*/
template <int dim, int spacedim>
void add_fe_name (const std::string &name,
* elements
*
* See the description of the
- * @ref vector_valued module for examples how to use the features of this
- * namespace.
+ * @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.
+ * @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.
+ * @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.
+ * @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
* 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.
+ * @ref vector_valued
+ * module.
*/
const FEValuesViews::Scalar<dim,spacedim> &
operator[] (const FEValuesExtractors::Scalar &scalar) const;
* <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 module.
+ * @ref vector_valued
+ * module.
*/
const FEValuesViews::Vector<dim,spacedim> &
operator[] (const FEValuesExtractors::Vector &vector) const;
* 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::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;
* <code>(dim*dim + dim)/2</code> components
*
* See the description of the
- * @ref vector_valued module for examples how to use the features of this
- * namespace.
+ * @ref vector_valued
+ * module for examples how to use the features of this namespace.
*
* @ingroup feaccess vector_valued
*/
* 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.
+ * @ref vector_valued
+ * module.
*
* @ingroup feaccess vector_valued
*/
*
* The concept of extractors is defined in the documentation of the
* namespace FEValuesExtractors and in the
- * @ref vector_valued module.
+ * @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
*
* The concept of extractors is defined in the documentation of the
* namespace FEValuesExtractors and in the
- * @ref vector_valued module.
+ * @ref vector_valued
+ * module.
*
* @ingroup feaccess vector_valued
*
*
* The concept of extractors is defined in the documentation of the
* namespace FEValuesExtractors and in the
- * @ref vector_valued module.
+ * @ref vector_valued
+ * module.
*
* @ingroup feaccess vector_valued
*
/**
* Performs the same as @p fill_fe_values on a face. Additionally, @p
* 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 normal and the
- * transformed quadrature weight.
+ * @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 normal and the transformed quadrature
+ * weight.
*/
virtual void
fill_fe_face_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
/**
* Filter that evaluates to true if either the iterator points to an object
* for which the user flag is set or an iterator past the end. See
- * @ref GlossUserFlags for information about user flags.
+ * @ref GlossUserFlags
+ * for information about user flags.
*
* @ingroup Iterators
*/
* @ref GlossLocallyOwnedCell "locally owned cell".
*
* This class is used in step-32, in connection with the methods of the
- * @ref distributed module.
+ * @ref distributed
+ * module.
*
* @ingroup Iterators
*/
*
* 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
- * purpose of attaching geometry objects and evaluating different boundary
- * conditions.
+ * @ref GlossBoundaryIndicator),
+ * allowing them to be distinguished for the purpose of attaching geometry
+ * objects and evaluating different boundary conditions.
*
* This namespace also provides a function
* GridGenerator::laplace_transformation that smoothly transforms a domain
*
* @tparam Container A type that satisfies the requirements of a mesh
* 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 will re-build
- * the triangulation underlying the second argument and return a map between
- * appropriate iterators into the Container arguments. However, the function
- * will not actually distribute degrees of freedom on this newly created
- * surface mesh.
+ * @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 will re-build the triangulation
+ * underlying the second argument and return a map between appropriate
+ * iterators into the Container arguments. However, the function will not
+ * actually distribute degrees of freedom on this newly created surface
+ * mesh.
*
* @note The algorithm outlined above assumes that all faces on higher
* refinement levels always have exactly the same boundary indicator as
* 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" 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 can catch and ignore the
- * exception if you are certain that there is no harm in dealing with such
- * cells. If you were not aware that your mesh had such cells, your results
- * will likely be of dubious quality at best if you ignore the exception.
+ * @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
+ * can catch and ignore the exception if you are certain that there is no harm
+ * in dealing with such cells. If you were not aware that your mesh had such
+ * cells, your results will likely be of dubious quality at best if you ignore
+ * the exception.
*
*
* @ingroup grid
/**
* Should lines with a set @p user_flag be drawn in a different color
* (red)? See
- * @ref GlossUserFlags for information about user flags.
+ * @ref GlossUserFlags
+ * for information about user flags.
*/
bool color_lines_on_user_flag;
* @note When applied to a triangulation or DoF handler object based on a
* parallel::distributed::Triangulation object, the cell returned may in
* fact be a ghost or artificial cell (see
- * @ref GlossArtificialCell and
- * @ref GlossGhostCell). If so, many of the operations one may want to do on
- * this cell (e.g., evaluating the solution) may not be possible and you
- * will have to decide what to do in that case.
+ * @ref GlossArtificialCell
+ * and
+ * @ref GlossGhostCell).
+ * If so, many of the operations one may want to do on this cell (e.g.,
+ * evaluating the solution) may not be possible and you will have to decide
+ * what to do in that case.
*/
template <int dim, template <int,int> class Container, int spacedim>
#ifndef _MSC_VER
* @note When applied to a triangulation or DoF handler object based on a
* parallel::distributed::Triangulation object, the cell returned may in
* fact be a ghost or artificial cell (see
- * @ref GlossArtificialCell and
- * @ref GlossGhostCell). If so, many of the operations one may want to do on
- * this cell (e.g., evaluating the solution) may not be possible and you
- * will have to decide what to do in that case.
+ * @ref GlossArtificialCell
+ * and
+ * @ref GlossGhostCell).
+ * If so, many of the operations one may want to do on this cell (e.g.,
+ * evaluating the solution) may not be possible and you will have to decide
+ * what to do in that case.
*/
template <int dim, template<int, int> class Container, int spacedim>
#ifndef _MSC_VER
* @note When applied to a triangulation or DoF handler object based on a
* parallel::distributed::Triangulation object, the cell returned may in
* fact be a ghost or artificial cell (see
- * @ref GlossArtificialCell and
- * @ref GlossGhostCell). If so, many of the operations one may want to do on
- * this cell (e.g., evaluating the solution) may not be possible and you
- * will have to decide what to do in that case.
+ * @ref GlossArtificialCell
+ * and
+ * @ref GlossGhostCell).
+ * If so, many of the operations one may want to do on this cell (e.g.,
+ * evaluating the solution) may not be possible and you will have to decide
+ * what to do in that case.
*/
template <int dim, int spacedim>
std::pair<typename hp::DoFHandler<dim, spacedim>::active_cell_iterator, Point<dim> >
* For a triangulation, return a mask that represents which of its vertices
* are "owned" by the current process in the same way as we talk about
* locally owned cells or degrees of freedom (see
- * @ref GlossLocallyOwnedCell and
- * @ref GlossLocallyOwnedDof). For the purpose of this function, we define a
- * locally owned vertex as follows: a vertex is owned by that processor with
- * the smallest subdomain id (which equals the MPI rank of that processor)
- * among all owners of cells adjacent to this vertex. In other words,
- * vertices that are in the interior of a partition of the triangulation are
- * owned by the owner of this partition; for vertices that lie on the
- * boundary between two or more partitions, the owner is the processor with
- * the least subdomain_id among all adjacent subdomains.
+ * @ref GlossLocallyOwnedCell
+ * and
+ * @ref GlossLocallyOwnedDof).
+ * For the purpose of this function, we define a locally owned vertex as
+ * follows: a vertex is owned by that processor with the smallest subdomain
+ * id (which equals the MPI rank of that processor) among all owners of
+ * cells adjacent to this vertex. In other words, vertices that are in the
+ * interior of a partition of the triangulation are owned by the owner of
+ * this partition; for vertices that lie on the boundary between two or more
+ * partitions, the owner is the processor with the least subdomain_id among
+ * all adjacent subdomains.
*
* For sequential triangulations (as opposed to, for example,
* parallel::distributed::Triangulation), every user vertex is of course
* a subset of the input argument.
*
* For a definition of the concept of distorted cells, see the
- * @ref GlossDistorted "glossary entry". The first argument passed to the
- * current function is typically the exception thrown by the
- * Triangulation::execute_coarsening_and_refinement function.
+ * @ref GlossDistorted "glossary entry".
+ * The first argument passed to the current function is typically the
+ * exception thrown by the Triangulation::execute_coarsening_and_refinement
+ * function.
*/
template <int dim, int spacedim>
typename Triangulation<dim,spacedim>::DistortedCellList
*
* @tparam Container A type that satisfies the requirements of a mesh
* container (see
- * @ref GlossMeshAsAContainer). In C++, the compiler can not determine the
- * type of <code>Container</code> from the function call. You need to
- * specify it as an explicit template argument following the function name.
+ * @ref GlossMeshAsAContainer).
+ * In C++, the compiler can not determine the type of <code>Container</code>
+ * from the function call. You need to specify it as an explicit template
+ * argument following the function name.
* @param[in] cell An iterator pointing to a cell of the mesh container.
* @return A list of active cells that form the patch around the given cell
*
*
* and any combination of that... More information on the topic can be found
* in the
- * @ref GlossFaceOrientation "glossary" article.
+ * @ref GlossFaceOrientation "glossary"
+ * article.
*
* @author Matthias Maier, 2012
*/
/**
* A typedef that is used to to identify
- * @ref GlossActive "active cell iterators". The concept of iterators is
- * discussed at length in the
+ * @ref GlossActive "active cell iterators".
+ * The concept of iterators is discussed at length in the
* @ref Iterators "iterators documentation module".
*
* The current typedef identifies active cells in a triangulation. The
* 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
* 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 functions may
- * throw an exception if they encounter distorted cells.
+ * @ref GlossDistorted "distorted cells").
+ * If set, these two functions may throw an exception if they encounter
+ * distorted cells.
*/
Triangulation (const MeshSmoothing smooth_grid = none,
const bool check_for_distorted_cells = false);
* 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 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
+ * @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
* GeometryInfo::jacobian_determinants_at_vertices function). If there are
* deformed cells, this function throws an exception of kind
* DistortedCellList. Since this happens after all data structures have been
*
* The function returns a list of cells that have produced children that
* 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
+ * @ref GlossDistorted "distorted cells"
+ * if the <code>check_for_distorted_cells</code> flag was specified upon
+ * creation of this object, at
*/
DistortedCellList execute_refinement ();
DeclException0 (ExcCellNotUsed);
/**
* 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.
+ * @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.
*
* @ingroup Exceptions
*/
* 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 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 position of the
- * coarse cells they previously had, not based on the position these
- * vertices had on the processor that previously owned them. In other words,
- * in parallel computations, you will probably have to move nodes explicitly
- * after every mesh refinement because vertex positions may or may not be
- * preserved across the re-partitioning that accompanies mesh refinement.
+ * @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 position of the coarse cells they previously had, not based
+ * on the position these vertices had on the processor that previously owned
+ * them. In other words, in parallel computations, you will probably have to
+ * move nodes explicitly after every mesh refinement because vertex
+ * positions may or may not be preserved across the re-partitioning that
+ * accompanies mesh refinement.
*/
Point<spacedim> &vertex (const unsigned int i) const;
*/
/**
* Read the user flag. See
- * @ref GlossUserFlags for more information.
+ * @ref GlossUserFlags
+ * for more information.
*/
bool user_flag_set () const;
/**
* Set the user flag. See
- * @ref GlossUserFlags for more information.
+ * @ref GlossUserFlags
+ * for more information.
*/
void set_user_flag () const;
/**
* Clear the user flag. See
- * @ref GlossUserFlags for more information.
+ * @ref GlossUserFlags
+ * for more information.
*/
void clear_user_flag () const;
/**
* Set the user flag for this and all descendants. See
- * @ref GlossUserFlags for more information.
+ * @ref GlossUserFlags
+ * for more information.
*/
void recursively_set_user_flag () const;
/**
* Clear the user flag for this and all descendants. See
- * @ref GlossUserFlags for more information.
+ * @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;
* Triangulation::clear_user_data() in between.
*
* See
- * @ref GlossUserData for more information.
+ * @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.
+ * @ref GlossUserData
+ * for more information.
*/
void clear_user_pointer () const;
* *a=static_cast<A*>(cell->user_pointer());</tt>.
*
* See
- * @ref GlossUserData for more information.
+ * @ref GlossUserData
+ * for more information.
*/
void *user_pointer () const;
* Triangulation::clear_user_data() in between.
*
* See
- * @ref GlossUserData for more information.
+ * @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.
+ * @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.
+ * @ref GlossUserData
+ * for more information.
*/
void clear_user_index () const;
* Triangulation::clear_user_data() in between.
*
* See
- * @ref GlossUserData for more information.
+ * @ref GlossUserData
+ * for more information.
*/
unsigned int user_index () const;
* Triangulation::clear_user_data() in between.
*
* See
- * @ref GlossUserData for more information.
+ * @ref GlossUserData
+ * for more information.
*/
void recursively_set_user_index (const unsigned int p) const;
* holds as said for the recursively_set_user_index() function.
*
* See
- * @ref GlossUserData for more information.
+ * @ref GlossUserData
+ * for more information.
*/
void recursively_clear_user_index () const;
/**
* Return the material id of this cell.
*
* For a typical use of this function, see the
- * @ref step_28 "step-28" tutorial program.
+ * @ref step_28 "step-28"
+ * tutorial program.
*
* See the
- * @ref GlossMaterialId "glossary" for more information.
+ * @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" tutorial program.
+ * @ref step_28 "step-28"
+ * tutorial program.
*
* See the
- * @ref GlossMaterialId "glossary" for more information.
+ * @ref GlossMaterialId "glossary"
+ * for more information.
*/
void set_material_id (const types::material_id new_material_id) const;
* children, and so on) to the given value.
*
* See the
- * @ref GlossMaterialId "glossary" for more information.
+ * @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.
+ * @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 function
- * should not be called if you use a parallel::distributed::Triangulation
- * object.
+ * @ref GlossSubdomainId "glossary"
+ * for more information. This function should not be called if you use a
+ * parallel::distributed::Triangulation object.
*
* @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
* intermediate child cells.
*
* 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.
+ * @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.
*/
void recursively_set_subdomain_id (const types::subdomain_id new_subdomain_id) const;
/**
* a cell).
*
* See the
- * @ref GlossActive "glossary" for more information.
+ * @ref GlossActive "glossary"
+ * for more information.
*/
bool active () const;
* triangulation is of type parallel::distributed::Triangulation.
*
* See the
- * @ref GlossGhostCell "glossary" and the
- * @ref distributed module for more information.
+ * @ref GlossGhostCell "glossary"
+ * and the
+ * @ref distributed
+ * module for more information.
*
* @post The returned value is equal to <code>!is_ghost() &&
* !is_artificial()</code>.
* value is always false.
*
* See the
- * @ref GlossGhostCell "glossary" and the
- * @ref distributed module for more information.
+ * @ref GlossGhostCell "glossary"
+ * and the
+ * @ref distributed
+ * module for more information.
*
* @post The returned value is equal to <code>!is_locally_owned() &&
* !is_artificial()</code>.
* value is always false.
*
* See the
- * @ref GlossArtificialCell "glossary" and the
- * @ref distributed module for more information.
+ * @ref GlossArtificialCell "glossary"
+ * and the
+ * @ref distributed
+ * module for more information.
*
* @post The returned value is equal to <code>!is_ghost() &&
* !is_locally_owned()</code>.
/**
* This class implements some types which differ between the dimensions.
* These are the declararions for the 1D case only. See the
- * @ref Iterators module for more information.
+ * @ref Iterators
+ * module for more information.
*
* A @p line_iterator is typdef'd to an iterator operating on the @p lines
* member variable of a <tt>Triangulation<1></tt> object. An @p
/**
* This class implements some types which differ between the dimensions.
* These are the declararions for the 2D case only. See the
- * @ref Iterators module for more information.
+ * @ref Iterators
+ * module for more information.
*
* A @p line_iterator is typdef'd to an iterator operating on the @p lines
* member variable of a <tt>Triangulation<2></tt> object. An @p
/**
* This class implements some types which differ between the dimensions.
* These are the declararions for the 3D case only. See the
- * @ref Iterators module for more information.
+ * @ref Iterators
+ * module for more information.
*
* For the declarations of the data types, more or less the same holds as
* for lower dimensions (see <tt>Iterators<[12]></tt>). The dimension
/**
* A typedef that is used to to identify
- * @ref GlossActive "active cell iterators". The concept of iterators is
- * discussed at length in the
+ * @ref GlossActive "active cell iterators".
+ * The concept of iterators is discussed at length in the
* @ref Iterators "iterators documentation module".
*
* The current typedef identifies active cells in a hp::DoFHandler object.
*
* 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
- * 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
- * level_cell_iterator typedef.
+ * @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 level_cell_iterator typedef.
*
* While the actual data type of the typedef is hidden behind a few layers
* of (unfortunately necessary) indirections, it is in essence
* a ::DoFHandler.
*
* It implements the concepts stated in the
- * @ref hpcollection module described in the doxygen documentation.
+ * @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, 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 components but while the
- * former has <code>dim</code> blocks the latter has only one.
- * Consequently, this function will throw an assertion if the number of
- * blocks is not the same for all elements. If they are the same, this
- * function returns the result of FiniteElement::n_blocks().
+ * @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 components but while the former has <code>dim</code> blocks the
+ * latter has only one. Consequently, this function will throw an
+ * assertion if the number of blocks is not the same for all elements. If
+ * they are the same, this function returns the result of
+ * FiniteElement::n_blocks().
*/
unsigned int n_blocks () const;
/**
* Given a block mask (see
- * @ref GlossBlockMask "this glossary entry" ), produce a component mask
- * (see
- * @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.
+ * @ref GlossBlockMask "this glossary entry"
+ * ), produce a component mask (see
+ * @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.
*
* @note This function is the equivalent of
* FiniteElement::component_mask() with the same arguments. It verifies
* 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.
+ * @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 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 blocks
- * that correspond to the components selected in the input argument. This
- * is essentially a conversion operator from ComponentMask to BlockMask.
+ * @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.
*
* @note This function will only succeed if the components referenced by
* the argument encompasses complete blocks. In other words, if, for
* the hp::FECollection implements a collection of finite element classes.
*
* It implements the concepts stated in the
- * @ref hpcollection module described in the doxygen documentation.
+ * @ref hpcollection
+ * module described in the doxygen documentation.
*
* Although it is recommended to supply an appropriate mapping for each
* finite element kind used in a hp-computation, the MappingCollection class
* classes.
*
* It implements the concepts stated in the
- * @ref hpcollection module described in the doxygen documentation.
+ * @ref hpcollection
+ * module described in the doxygen documentation.
*
* @ingroup hp hpcollection
*
* @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).
+ * @ref Instantiations
+ * in the manual).
*
* @see
* @ref GlossBlockLA "Block (linear algebra)"
*
*
* See
- * @ref GlossCompress "Compressing distributed objects" for more
- * information.
+ * @ref GlossCompress "Compressing distributed objects"
+ * for more information.
*/
void compress (::dealii::VectorOperation::values operation);
* @ref Sparsity.
*
* <b>Note:</b> There are several, exchangeable variations of this class, see
- * @ref Sparsity, section 'Dynamic block sparsity patterns' for more
- * information.
+ * @ref Sparsity,
+ * section 'Dynamic block sparsity patterns' for more information.
*
* <b>Note:</b> This class used to be called CompressedBlockSparsityPattern.
* However, since it's a block wrapper around the CompressedSparsityPattern
* @ref Sparsity.
*
* @note There are several, exchangeable variations of this class, see
- * @ref Sparsity, section 'Dynamic block sparsity patterns' for more
- * information.
+ * @ref Sparsity,
+ * section 'Dynamic block sparsity patterns' for more information.
*
* @author Wolfgang Bangerth, 2007
*/
* @ref Sparsity.
*
* @note There are several, exchangeable variations of this class, see
- * @ref Sparsity, section 'Dynamic block sparsity patterns' for more
- * information.
+ * @ref Sparsity,
+ * section 'Dynamic block sparsity patterns' for more information.
*
* This class is used in step-22 and step-31.
*
* See the documentation of the BlockSparsityPattern for examples.
*
* 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 used).
+ * @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 used).
*
* This class is used in step-32.
*
* @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).
+ * @ref Instantiations
+ * in the manual).
*
* @see
* @ref GlossBlockLA "Block (linear algebra)"
* exists in other objects for compatibility.
*
* See
- * @ref GlossCompress "Compressing distributed objects" for more
- * information.
+ * @ref GlossCompress "Compressing distributed objects"
+ * for more information.
*/
void compress (::dealii::VectorOperation::values operation
=::dealii::VectorOperation::unknown);
* exists in other objects for compatibility.
*
* See
- * @ref GlossCompress "Compressing distributed objects" for more
- * information.
+ * @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).
+ * @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
- * 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.
+ * @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.
*
* Source and destination must not be the same vector.
*/
*
* 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
- * 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.
+ * @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.
*
* Source and destination must not be the same vector.
*/
*
* 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
- * 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.
+ * @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.
*
* Source and destination must not be the same vector.
*/
*
* 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
- * 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.
+ * @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.
*
* Source and destination must not be the same vector.
*/
/**
* 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 row storage (CSR) format to store
- * data.
+ * @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 module.
+ * @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.
+ * @ref Sparsity.
+ * It is discussed in the step-27 and
+ * @ref step_22 "step-22"
+ * tutorial programs.
*
* <h3>Interface</h3>
*
*
* There are several, exchangeable variations of this class, see
* @ref Sparsity,
- * section '"Dynamic" or "compressed" sparsity patterns' for
- * more information.
+ * section '"Dynamic" or "compressed" sparsity patterns' for more information.
*
* This class is a variation of the CompressedSparsityPattern class. Instead
* of using sorted vectors together with a caching algorithm for storing the
* 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 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 the CompressedSparsityPattern
- * classes works best in a certain setting. An algorithm which performs
- * equally well in all situations still has to be found.
+ * @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 the CompressedSparsityPattern classes works best in a
+ * certain setting. An algorithm which performs equally well in all situations
+ * still has to be found.
*
*
* @author Oliver Kayser-Herold, 2007
* 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 module.
+ * @ref Sparsity
+ * module.
*
* This class is an example of the "dynamic" type of
* @ref Sparsity.
*
* There are several, exchangeable variations of this class, see
* @ref Sparsity,
- * section '"Dynamic" or "compressed" sparsity patterns' for
- * more information.
+ * 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 module.
+ * @ref Sparsity
+ * module.
*
* This class is an example of the "dynamic" type of
* @ref Sparsity.
*
* There are several, exchangeable variations of this class, see
* @ref Sparsity,
- * section '"Dynamic" or "compressed" sparsity patterns' for
- * more information.
+ * 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 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 freedom where <i>M</i> is also
- * relatively small (no larger than at most around the average number of
- * entries per row of a linear system). It is <em>not</em> meant to describe
- * full rank linear systems.
+ * @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 freedom where <i>M</i> is also relatively small (no larger
+ * than at most around the average number of entries per row of a linear
+ * system). It is <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 module.
+ * @ref hp_paper "hp paper".
+ * There is also a significant amount of documentation on how to use this
+ * class in the
+ * @ref constraints
+ * module.
*
*
* <h3>Description of constraints</h3>
* 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.
- * 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
- * shown there completely eliminated constrained degrees of freedom, whereas
- * we usually keep them as part of the linear system.
+ * @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 shown there
+ * completely eliminated constrained degrees of freedom, whereas we usually
+ * keep them as part of the linear system.
*
* @ingroup dofs
* @ingroup constraints
* 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_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_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
* sparsity pattern entries.
*
* 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 ConstraintMatrix::condense() ), can
- * be a very expensive procedure. It is cheaper to allocate these entries
- * right away without having to do a second pass over the sparsity pattern
- * object. This function does exactly that.
+ * @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 ConstraintMatrix::condense() ), can be a very expensive procedure.
+ * It is cheaper to allocate these entries right away without having to do a
+ * second pass over the sparsity pattern object. This function does exactly
+ * that.
*
* Because the function only allocates entries in a sparsity pattern, all it
* needs to know are the degrees of freedom that couple to each other.
* @<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, 1993-2004
*/
* @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).
+ * @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).
+ * @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).
+ * @ref Instantiations
+ * in the manual).
*
* @see
* @ref GlossBlockLA "Block (linear algebra)"
* 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.
+ * @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
* @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
- * <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
- * 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
- * course, reduction operations (like norms) make use of collective all-
- * to-all MPI communications.
+ * @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 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 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
* 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.
+ * @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
* function, for much the same reason as is documented with the
* BlockSparsityPattern class.
*
- * @ingroup Matrix1
- * @see
+ * @ingroup Matrix1 @see
* @ref GlossBlockLA "Block (linear algebra)"
* @author Wolfgang Bangerth, 2004
*/
* function must therefore be called once you have assembled the matrix.
*
* See
- * @ref GlossCompress "Compressing distributed objects" for more
- * information.
+ * @ref GlossCompress "Compressing distributed objects"
+ * for more information.
*/
void compress (::dealii::VectorOperation::values operation);
* collect_sizes() function, for much the same reason as is documented
* with the BlockSparsityPattern class.
*
- * @ingroup Matrix1
- * @see
+ * @ingroup Matrix1 @see
* @ref GlossBlockLA "Block (linear algebra)"
* @author Wolfgang Bangerth, 2004
*/
* preconditioner.
*
* See the comment in the base class
- * @ref PreconditionerBase for when this preconditioner may or may not work.
+ * @ref PreconditionerBase
+ * for when this preconditioner may or may not work.
*
* @ingroup PETScWrappers
* @author Wolfgang Bangerth, Timo Heister, 2004, 2011
* the relevant section of the PETSc manual, but is not implemented here.
*
* See the comment in the base class
- * @ref PreconditionerBase for when this preconditioner may or may not work.
+ * @ref PreconditionerBase
+ * for when this preconditioner may or may not work.
*
* @ingroup PETScWrappers
* @author Wolfgang Bangerth, Timo Heister, 2004, 2011
* preconditioner.
*
* See the comment in the base class
- * @ref PreconditionerBase for when this preconditioner may or may not work.
+ * @ref PreconditionerBase
+ * for when this preconditioner may or may not work.
*
* @ingroup PETScWrappers
* @author Wolfgang Bangerth, Timo Heister, 2004, 2011
* preconditioner.
*
* See the comment in the base class
- * @ref PreconditionerBase for when this preconditioner may or may not work.
+ * @ref PreconditionerBase
+ * for when this preconditioner may or may not work.
*
* @ingroup PETScWrappers
* @author Wolfgang Bangerth, Timo Heister, 2004, 2011
* preconditioner.
*
* See the comment in the base class
- * @ref PreconditionerBase for when this preconditioner may or may not work.
+ * @ref PreconditionerBase
+ * for when this preconditioner may or may not work.
*
* @ingroup PETScWrappers
* @author Wolfgang Bangerth, Timo Heister, 2004, 2011
* Cholesky preconditioner.
*
* See the comment in the base class
- * @ref PreconditionerBase for when this preconditioner may or may not work.
+ * @ref PreconditionerBase
+ * for when this preconditioner may or may not work.
*
* @ingroup PETScWrappers
* @author Wolfgang Bangerth, Timo Heister, 2004, 2011
* preconditioner.
*
* See the comment in the base class
- * @ref PreconditionerBase for when this preconditioner may or may not work.
+ * @ref PreconditionerBase
+ * for when this preconditioner may or may not work.
*
* @ingroup PETScWrappers
* @author Wolfgang Bangerth, Timo Heister, 2004, 2011
* It should provide a convenient interface to another direct solver.
*
* See the comment in the base class
- * @ref PreconditionerBase for when this preconditioner may or may not work.
+ * @ref PreconditionerBase
+ * for when this preconditioner may or may not work.
*
* @ingroup PETScWrappers
* @author Oliver Kayser-Herold, 2004
* anything else can be done on it.
*
* See
- * @ref GlossCompress "Compressing distributed objects" for more
- * information.
+ * @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).
+ * @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).
+ * @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).
+ * @ref Instantiations
+ * in the manual).
*
* @author Ralf Hartmann, Guido Kanschat, 1999, 2000
*/
* 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" tutorial programs.
+ * @ref step_22 "step-22"
+ * and
+ * @ref step_29 "step-29"
+ * tutorial programs.
*
* This matrix class implements the usual interface of preconditioners, that
* is a function initialize(const SparseMatrix<double>&matrix,const
*
* Refer to SparseLUDecomposition documentation for suggested usage and state
* management. This class is used in the
- * @ref step_22 "step-22" tutorial program.
+ * @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).
+ * @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).
+ * @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
- * 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.
+ * @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.
*
* Source and destination must not be the same vector.
*
*
* 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
- * 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.
+ * @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.
*
* Source and destination must not be the same vector.
*/
*
* 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
- * 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.
+ * @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.
*
* Source and destination must not be the same vector.
*
*
* 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
- * 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.
+ * @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.
*
* Source and destination must not be the same vector.
*/
* @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).
+ * @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 row storage (CSR) format to store
- * data.
+ * @ref Sparsity.
+ * It uses the compressed row storage (CSR) format to store data.
*
* The elements of a SparsityPattern, corresponding to the places where
* SparseMatrix objects can store nonzero entries, are stored row-by-row.
* @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).
+ * @ref Instantiations
+ * in the manual).
*
* @author Wolfgang Bangerth, 1999, 2000
*/
* function, for much the same reason as is documented with the
* BlockSparsityPattern class.
*
- * @ingroup Matrix1
- * @see
+ * @ingroup Matrix1 @see
* @ref GlossBlockLA "Block (linear algebra)"
* @author Martin Kronbichler, Wolfgang Bangerth, 2008
*/
* @deprecated
*
* See
- * @ref GlossCompress "Compressing distributed objects" for more
- * information.
+ * @ref GlossCompress "Compressing distributed objects"
+ * for more information.
*/
void compress (const Epetra_CombineMode last_action) DEAL_II_DEPRECATED;
* @deprecated
*
* See
- * @ref GlossCompress "Compressing distributed objects" for more
- * information.
+ * @ref GlossCompress "Compressing distributed objects"
+ * for more information.
*/
void compress (const Epetra_CombineMode last_action) DEAL_II_DEPRECATED;
* run on all processors when used in %parallel.
*
* See
- * @ref GlossCompress "Compressing distributed objects" for more
- * information.
+ * @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
- * 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 may
- * not even store all of the elements a non- ghosted vector would store on
- * the current processor. Consequently, for Trilinos vectors, there is no
- * notion of an 'owner' of vector elements in the way we have it in the
- * the non-ghost case view.
+ * @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 may not even store all of the elements a non- ghosted
+ * vector would store on the current processor. Consequently, for
+ * Trilinos vectors, there is no notion of an 'owner' of vector elements
+ * in the way we have it in the the non-ghost case view.
*
* This explains why we do not allow writing into ghosted vectors on the
* Trilinos side: Who would be responsible for taking care of the
* the last time compress() was called.
*
* See
- * @ref GlossCompress "Compressing distributed objects" for more
- * information.
+ * @ref GlossCompress "Compressing distributed objects"
+ * for more information.
*/
void compress (::dealii::VectorOperation::values operation);
* codes for compatibility and are empty there.
*
* See
- * @ref GlossCompress "Compressing distributed objects" for more information.
+ * @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
*/
* @<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 Luca Heltai, 2009
*/
*
* 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
- * degrees of freedom of the corresponding base element of the FESystem.
+ * @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.
*
*
* @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, 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 would have to be applied. In the following text, we
- * will use the term <em>block</em>, but remark that it might refer to
- * components as well.
+ * @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
+ * would have to be applied. In the following text, we will use the term
+ * <em>block</em>, but remark that it might refer to components as well.
*
* @todo update the following documentation, since it does not reflect the
* latest changes in structure.
/**
* Iterators for MGDofHandler in one dimension. See the
- * @ref Iterators module for more information.
+ * @ref Iterators
+ * module for more information.
*/
template <int spacedim>
class Iterators<1,spacedim>
/**
* Iterators for MGDofHandler in two dimensions. See the
- * @ref Iterators module for more information.
+ * @ref Iterators
+ * module for more information.
*/
template <int spacedim>
class Iterators<2,spacedim>
/**
* Iterators for MGDofHandler in three dimensions. See the
- * @ref Iterators module for more information.
+ * @ref Iterators
+ * module for more information.
*/
template <int spacedim>
class Iterators<3,spacedim>
/**
* Make a sparsity pattern including fluxes of discontinuous Galerkin
* methods. @see
- * @ref make_sparsity_pattern and
+ * @ref make_sparsity_pattern
+ * and
* @ref DoFTools
*/
template <int dim, class SparsityPattern, int spacedim>
*
* This is the base class for MGTransfer objects for systems of equations
* where multigrid is applied only to one ore some blocks, where a
- * @ref GlossBlock comprises all degrees of freedom generated by one base
- * element.
+ * @ref GlossBlock
+ * comprises all degrees of freedom generated by one base element.
*
* @author Guido Kanschat, 2001-2003
*/
* independent scalar field, or whether some of them together form logically a
* vector-field (see the
* DataComponentInterpretation::DataComponentInterpretation enum, and the
- * @ref step_22 "step-22" tutorial program).
+ * @ref step_22 "step-22"
+ * tutorial program).
*
* It should be noted that this class does not copy the vector given to it
* through the add_data_vector() functions, for memory consumption reasons. It
/**
* Return the first cell which we want output for. The default
* implementation returns the first
- * @ref GlossActive "active cell", but you might want to return other cells
- * in a derived class.
+ * @ref GlossActive "active cell",
+ * but you might want to return other cells in a derived class.
*/
virtual cell_iterator first_cell ();
* guaranteed as long as @p first_cell is also used from the default
* implementation. Overloading only one of the two functions might not be a
* good idea.
- */
+ */
virtual cell_iterator next_cell (const cell_iterator &cell);
/**
* 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
- * 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.
+ * @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.
*
* The @p subdomain_id parameter indicates whether we shall compute
* indicators for all cells (in case its value is the default,
* 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). 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 kind of exception
- * will also be produced if the cell is a ghost cell: On such cells, one
- * could in principle evaluate the solution, but it becomes easier if we do
- * not allow to do so because then there is exactly one processor in a
- * parallel distributed computation that can indeed evaluate the solution.
- * Consequently, it is clear which processor is responsible for producing
- * output if the point evaluation is done as a postprocessing step.
+ * @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
+ * kind of exception will also be produced if the cell is a ghost cell: On
+ * such cells, one could in principle evaluate the solution, but it becomes
+ * easier if we do not allow to do so because then there is exactly one
+ * processor in a parallel distributed computation that can indeed evaluate
+ * the solution. Consequently, it is clear which processor is responsible
+ * for producing output if the point evaluation is done as a postprocessing
+ * step.
*
* To deal with this situation, you will want to use code as follows when,
* for example, evaluating the solution at the origin (here using a parallel
* 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 the general
- * documentation of this class for more information.
+ * @ref GlossLocallyOwnedCell).
+ * See the section in the general documentation of this class for more
+ * information.
*/
virtual void vector_value (const Point<dim> &p,
Vector<double> &values) const;
* 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 the general
- * documentation of this class for more information.
+ * @ref GlossLocallyOwnedCell).
+ * See the section in the general documentation of this class for more
+ * information.
*/
virtual double value (const Point< dim > &p,
const unsigned int component = 0) const;
* 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 the general
- * documentation of this class for more information.
+ * @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,
std::vector< double > &values,
* 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 the general
- * documentation of this class for more information.
+ * @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,
std::vector< Vector<double> > &values) const;
* 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 the general
- * documentation of this class for more information.
+ * @ref GlossLocallyOwnedCell).
+ * See the section in the general documentation of this class for more
+ * information.
*/
virtual void
vector_gradient (const Point< dim > &p,
* 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 the general
- * documentation of this class for more information.
+ * @ref GlossLocallyOwnedCell).
+ * See the section in the general documentation of this class for more
+ * information.
*/
virtual Tensor<1,dim> gradient(const Point< dim > &p,
const unsigned int component = 0)const;
* 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 the general
- * documentation of this class for more information.
+ * @ref GlossLocallyOwnedCell).
+ * See the section in the general documentation of this class for more
+ * information.
*/
virtual void
vector_gradient_list (const std::vector< Point< dim > > &p,
* 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 the general
- * documentation of this class for more information.
+ * @ref GlossLocallyOwnedCell).
+ * See the section in the general documentation of this class for more
+ * information.
*/
virtual void
gradient_list (const std::vector< Point< dim > > &p,
* 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 the general
- * documentation of this class for more information.
+ * @ref GlossLocallyOwnedCell).
+ * See the section in the general documentation of this class for more
+ * information.
*/
virtual double
laplacian (const Point<dim> &p,
* 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 the general
- * documentation of this class for more information.
+ * @ref GlossLocallyOwnedCell).
+ * See the section in the general documentation of this class for more
+ * information.
*/
virtual void
vector_laplacian (const Point<dim> &p,
* 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 the general
- * documentation of this class for more information.
+ * @ref GlossLocallyOwnedCell).
+ * See the section in the general documentation of this class for more
+ * information.
*/
virtual void
laplacian_list (const std::vector<Point<dim> > &points,
* 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 the general
- * documentation of this class for more information.
+ * @ref GlossLocallyOwnedCell).
+ * See the section in the general documentation of this class for more
+ * information.
*/
virtual void
vector_laplacian_list (const std::vector<Point<dim> > &points,
* <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 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 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 triangulation is made
- * (Although the nearest support point could be re- computed upon mesh
- * refinement, the location of the support point will most likely change
- * slightly, making the interpretation of the data difficult, hence this is
- * not implemented currently.)
+ * @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 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 triangulation is made (Although the nearest support point
+ * could be re- computed upon mesh refinement, the location of the support
+ * point will most likely change slightly, making the interpretation of the
+ * data difficult, hence this is not implemented currently.)
*
* <li> Secondly, @p evaluate_field_at_requested_location calls @p
* VectorTools::point_value to compute values at the specific point requested.
*
* 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
- * 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 with
- * a @p DataPostprocessor object is used, the component_mask is interpreted as
- * the mask of the @p DataPostprocessor return vector. The size of this mask
- * can be different to that of the FE space, but must be provided when the @p
- * add_field_name method is called. One variant of the @p add_field_name
- * method allows an unsigned int input to construct a suitable mask, if all
- * values from the @p DataPostprocessor are desired.
+ * @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 with a @p DataPostprocessor object is used, the
+ * component_mask is interpreted as the mask of the @p DataPostprocessor
+ * return vector. The size of this mask can be different to that of the FE
+ * space, but must be provided when the @p add_field_name method is called.
+ * One variant of the @p add_field_name method allows an unsigned int input to
+ * construct a suitable mask, if all values from the @p DataPostprocessor are
+ * desired.
*
* The class automatically generates names for the data stored based on the
* mnemonics supplied. The methods @p add_component_names and @p
* 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 the manual).
+ * @ref Instantiations
+ * in the manual).
*
* @ingroup numerics
* @author Wolfgang Bangerth, Ralf Hartmann, Guido Kanschat, 1998, 1999, 2000,
* 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.
+ * @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.
* 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 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 <code>(true,true,false)</code>.
+ * @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
+ * <code>(true,true,false)</code>.
*
* @note Whether a component mask has been specified or not, the number of
* components of the functions in @p function_map must match that of the
* 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 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 <code>(true,true,false)</code>.
+ * @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
+ * <code>(true,true,false)</code>.
*
* @note Whether a component mask has been specified or not, the number of
* components of the functions in @p function_map must match that of the
* @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 boundary whose indicators are represented in
- * this map.
+ * @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.
* @param boundary_values The result of this function. It is a map
* 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 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 combined, but this is simple because every processor only computes
- * contributions for those cells of the global triangulation it locally owns
- * (and these sets are, by definition, mutually disjoint). Consequently, the
- * following piece of code computes the global $L_2$ error across multiple
- * processors sharing a parallel::distribute::Triangulation:
+ * @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 combined, but this is simple because
+ * every processor only computes contributions for those cells of the global
+ * triangulation it locally owns (and these sets are, by definition,
+ * mutually disjoint). Consequently, the following piece of code computes
+ * the global $L_2$ error across multiple processors sharing a
+ * parallel::distribute::Triangulation:
* @code
* Vector<double> local_errors (tria.n_active_cells());
* VectorTools::integrate_difference (mapping, dof,
* 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 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.)
+ * @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.)
*
* The boolean mask @p p_select has an empty vector as default value, which
* will be interpreted as selecting all vector elements, hence, subtracting
projects / dealii.git / commitdiff