* The value of this variable is written into the output file according to
* the instructions provided in
* http://www.visitusers.org/index.php?title=Time_and_Cycle_in_VTK_files
- * unless it is at its default value of
- * std::numeric_limits<unsigned int>::min().
+ * unless it is at its default value of std::numeric_limits<unsigned
+ * int>::min().
*/
unsigned int cycle;
* <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
* @param p The point at which the function is to be evaluated.
* @param component The vector component. Since this function is scalar,
* only zero is a valid argument here.
- * @return The interpolated value at
- * this point. If the point lies outside the set of coordinates, the
- * function is extended by a constant.
+ * @return The interpolated value at this point. If the point lies outside
+ * the set of coordinates, the function is extended by a constant.
*/
virtual
double
* Constructor
* @param interval_endpoints The left and right end points of the
* (uniformly subdivided) intervals in each of the coordinate directions.
- * @param n_subintervals The number of subintervals in
- * each coordinate direction. A value of one for a coordinate means that
- * the interval is considered as one subinterval consisting of the entire
- * range. A value of two means that there are two subintervals each with
- * one half of the range, etc.
+ * @param n_subintervals The number of subintervals in each coordinate
+ * direction. A value of one for a coordinate means that the interval is
+ * considered as one subinterval consisting of the entire range. A value
+ * of two means that there are two subintervals each with one half of the
+ * range, etc.
* @param data_values A dim-dimensional table of data at each of the mesh
* points defined by the coordinate arrays above. Note that the Table
* class has a number of conversion constructors that allow converting
* @param p The point at which the function is to be evaluated.
* @param component The vector component. Since this function is scalar,
* only zero is a valid argument here.
- * @return The interpolated value at
- * this point. If the point lies outside the set of coordinates, the
- * function is extended by a constant.
+ * @return The interpolated value at this point. If the point lies outside
+ * the set of coordinates, the function is extended by a constant.
*/
virtual
double
* 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];
* is not computed.
* @param indices1 A set of indices, assumed sorted.
* @param indices2 A set of indices, assumed sorted.
- * @return Whether the
- * two sets of indices do have a nonempty intersection.
+ * @return Whether the two sets of indices do have a nonempty
+ * intersection.
*/
inline
bool
* @param[in] get_conflict_indices A user defined function object
* returning a set of indicators that are descriptive of what represents a
* conflict. See above for a more thorough discussion.
- * @return A set of
- * sets of iterators (where sets are represented by std::vector for
- * efficiency). Each element of the outermost set corresponds to the
- * iterators pointing to objects that are in the same partition (i.e., the
- * same zone).
+ * @return A set of sets of iterators (where sets are represented by
+ * std::vector for efficiency). Each element of the outermost set
+ * corresponds to the iterators pointing to objects that are in the same
+ * partition (i.e., the same zone).
*
* @author Martin Kronbichler, Bruno Turcksin
*/
* different cells may be to the same matrix entries if the cells share
* degrees of freedom and, consequently, can not happen at the same time
* unless we want to risk a race condition (see
- * http://en.wikipedia.org/wiki/Race_condition ). Thus, we call these two
+ * http://en.wikipedia.org/wiki/Race_condition). Thus, we call these two
* cells in conflict, and we can only allow operations in parallel from
* cells that do not conflict. In other words, two cells are in conflict if
* the set of matrix entries (for example characterized by the rows) have a
* @param[in] get_conflict_indices A user defined function object returning
* a set of indicators that are descriptive of what represents a conflict.
* See above for a more thorough discussion.
- * @return A set of sets of
- * iterators (where sets are represented by std::vector for efficiency).
- * Each element of the outermost set corresponds to the iterators pointing
- * to objects that are in the same partition (have the same color) and
- * consequently do not conflict. The elements of different sets may
- * conflict.
+ * @return A set of sets of iterators (where sets are represented by
+ * std::vector for efficiency). Each element of the outermost set
+ * corresponds to the iterators pointing to objects that are in the same
+ * partition (have the same color) and consequently do not conflict. The
+ * elements of different sets may conflict.
*
* @author Martin Kronbichler, Bruno Turcksin
*/
/**
* Dereferencing operator.
- * @return The iterator within the collection
- * currently pointed to.
+ * @return The iterator within the collection currently pointed to.
*/
BaseIterator operator* () const;
/**
* Dereferencing operator.
- * @return The iterator within the collection
- * currently pointed to.
+ * @return The iterator within the collection currently pointed to.
*/
const BaseIterator *operator-> () const;
/**
* Comparison operator
* @param i_o_i Another iterator over iterators.
- * @return Returns whether
- * the current iterator points to a different object than the iterator
- * represented by the argument.
+ * @return Returns whether the current iterator points to a different
+ * object than the iterator represented by the argument.
*/
bool operator != (const IteratorOverIterators &i_o_i);
* 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> multithread_info.n_threads(); </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
* @author Thomas Richter, Wolfgang Bangerth, 2000
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>
*
*
* @image html parameter_handler.png
*
- * Once parameters have been read in, the contents of
- * the <code>value</code> "files" may be different while the other files
- * remain untouched.
+ * Once parameters have been read in, the contents of the <code>value</code>
+ * "files" may be different while the other files remain untouched.
*
* Using the ParameterHandler::print_parameters() function with
* ParameterHandler::XML as second argument, we can get a complete
*
* <dl> <dt> 1D <dd> <i> x<sup>0</sup>, x<sup>1</sup>,...,x<sup>n</sup></i>
* <dt> 2D: <dd> <i> x<sup>0</sup>y<sup>0</sup>,
- * x<sup>1</sup>y<sup>0</sup>,...,
- * x<sup>n</sup>y<sup>0</sup>,
+ * x<sup>1</sup>y<sup>0</sup>,..., x<sup>n</sup>y<sup>0</sup>,
* <br>
* x<sup>0</sup>y<sup>1</sup>, x<sup>1</sup>y<sup>1</sup>,...,
* x<sup>n-1</sup>y<sup>1</sup>,
* <br>
- * x<sup>0</sup>y<sup>2</sup>,...
- * x<sup>n-2</sup>y<sup>2</sup>,
+ * x<sup>0</sup>y<sup>2</sup>,... x<sup>n-2</sup>y<sup>2</sup>,
* <br>
* ...
* <br>
- * x<sup>0</sup>y<sup>n-1</sup>,
- * x<sup>1</sup>y<sup>n-1</sup>,
+ * x<sup>0</sup>y<sup>n-1</sup>, x<sup>1</sup>y<sup>n-1</sup>,
* <br>
* x<sup>0</sup>y<sup>n</sup> </i> <dt> 3D: <dd> <i>
* x<sup>0</sup>y<sup>0</sup>z<sup>0</sup>,...,
* 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
*/
*
* @note Instantiations for this template are provided for dimensions 0, 1, 2,
* and 3 (see the section on
- * @ref Instantiations
- * ).
+ * @ref Instantiations).
*
* @author Wolfgang Bangerth, Guido Kanschat, 1998, 1999, 2000, 2005, 2009
*/
* The type used to denote subdomain_ids of cells.
*
* See the
- * @ref GlossSubdomainId "glossary"
- * for more information.
+ * @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);
}
* template parameters: dim (the topological dimension of the object) and
* spacedim (the dimension of the embedding Euclidean space). Since in all
* deal.II classes, by default spacedim is equal to dimension, the above
- * string is usually contracted to "<dim>", instead of "<dim,spacedim>". This
- * function returns a string containing "dim" if dim is equal to spacedim,
- * otherwhise it returns "dim,spacedim".
+ * string is usually contracted to "<dim>", instead of "<dim,spacedim>".
+ * This function returns a string containing "dim" if dim is equal to
+ * spacedim, otherwhise it returns "dim,spacedim".
*/
std::string dim_string(const int dim, const int spacedim);
* uses the Intel Threading Building Blocks (TBB) to load balance the
* individual subranges onto the available threads. For a lengthy discussion
* of the rationale of this class, see the
- * @ref threads "Parallel computing with multiple processors"
- * module. It is
+ * @ref threads "Parallel computing with multiple processors" module. It is
* used in the tutorial first in step-9, and again in step-13, step-14,
* step-32 and others.
*
* and function. This namespace holds classes that deal with the second
* implementation described in the paper by Turcksin, Kronbichler and
* Bangerth (see
- * @ref workstream_paper
- * ).
+ * @ref workstream_paper).
*
* Even though this implementation is slower than the third implementation
* discussed in that paper, we need to keep it around for two reasons: (i)
* and function. This namespace holds classes that deal with the third
* implementation described in the paper by Turcksin, Kronbichler and
* Bangerth (see
- * @ref workstream_paper
- * ).
+ * @ref workstream_paper).
*/
namespace Implementation3
{
* This is one of two main functions of the WorkStream concept, doing work
* as described in the introduction to this namespace. It corresponds to
* implementation 3 of the paper by Turcksin, Kronbichler and Bangerth, see
- * @ref workstream_paper.
- * As such, it takes not a range of iterators
+ * @ref workstream_paper. As such, it takes not a range of iterators
* described by a begin and end iterator, but a "colored" graph of iterators
* where each color represents cells for which writing the cell
* contributions into the global object does not conflict (in other words,
* This is one of two main functions of the WorkStream concept, doing work
* as described in the introduction to this namespace. It corresponds to
* implementation 2 of the paper by Turcksin, Kronbichler and Bangerth (see
- * @ref workstream_paper
- * ).
+ * @ref workstream_paper).
*
* This function that can be used for worker and copier objects that are
* either pointers to non-member functions or objects that allow to be
* concept, doing work as described in the introduction to this namespace.
* It corresponds to implementation 2 of the paper by Turcksin, Kronbichler
* and Bangerth (see
- * @ref workstream_paper
- * ).
+ * @ref workstream_paper).
*
* This is the function that can be used for worker and copier functions
* that are member functions of a class. If the copier is an empty function,
/**
* A structure whose explicit specializations contain typedefs to the
* relevant p4est_* and p8est_* types. Using this structure, for example
- * by saying <tt>types<dim>::connectivity</tt> we can write code in
- * a dimension independent way, either referring to p4est_connectivity_t
- * or p8est_connectivity_t, depending on template argument.
+ * by saying <tt>types<dim>::connectivity</tt> we can write code in a
+ * dimension independent way, either referring to p4est_connectivity_t or
+ * p8est_connectivity_t, depending on template argument.
*/
template <int> struct types;
* 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
+ * @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".
*
* 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
+ * @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
/**
* 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;
* dofs on vertex 0, dofs on vertex 1, etc, dofs on line 0, dofs on line 1,
* etc, dofs on quad 0, etc.) This function is only available on
* <i>active</i> objects (see
- * @ref GlossActive "this glossary entry"
- * ).
+ * @ref GlossActive "this glossary entry").
*
* The cells needs to be an active cell (and not artificial in a parallel
* distributed computation).
DeclException0 (ExcMatrixDoesNotMatch);
/**
* A function has been called for a cell which should be
- * @ref GlossActive "active"
- * , but is refined.
+ * @ref GlossActive "active" , but is refined.
*
* @ingroup Exceptions
*/
* dofs on vertex 0, dofs on vertex 1, etc, dofs on line 0, dofs on line 1,
* etc, dofs on quad 0, etc.) This function is only available on
* <i>active</i> objects (see
- * @ref GlossActive "this glossary entry"
- * ).
+ * @ref GlossActive "this glossary entry").
*
* The cells needs to be an active cell (and not artificial in a parallel
* distributed computation).
DeclException0 (ExcMatrixDoesNotMatch);
/**
* A function has been called for a cell which should be
- * @ref GlossActive "active"
- * , but is refined.
+ * @ref GlossActive "active" , but is refined.
*
* @ingroup Exceptions
*/
* dofs on vertex 0, dofs on vertex 1, etc, dofs on line 0, dofs on line 1,
* etc, dofs on quad 0, etc.) This function is only available on
* <i>active</i> objects (see
- * @ref GlossActive "this glossary entry"
- * ).
+ * @ref GlossActive "this glossary entry").
*
* @param[out] dof_indices The vector into which the indices will be
* written. It has to have the right size (namely,
/**
* Manage the distribution and numbering of the degrees of freedom for non-
* multigrid algorithms. This class satisfies the requirements outlined in
- * @ref GlossMeshAsAContainer "Meshes as containers".
- * It is first used in the
+ * @ref GlossMeshAsAContainer "Meshes as containers". It is first used in the
* step-2 tutorial program.
*
* For each vertex, line, quad, etc, this class stores a list of the indices
* 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
* @note The same applies to this function as to max_couplings_per_dofs() as
* regards the performance of this function. Think about one of the dynamic
* sparsity pattern classes instead (see
- * @ref Sparsity
- * ).
+ * @ref Sparsity).
*/
unsigned int max_couplings_between_boundary_dofs () const;
*
* @param[in] level A given level in the refinement hierarchy of this
* triangulation.
- * @return The half open range
- * <code>[this->begin_active(level), this->end(level))</code>
+ * @return The half open range <code>[this->begin_active(level),
+ * this->end(level))</code>
*
* @pre level must be less than this->n_levels().
*
*
* 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
+ * @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
* ordering than with another one, then this means that the actual solver is
* actually several times faster.
*
- * <table> <tr>
- * <td>
+ * <table> <tr> <td>
* @image html "reorder_sparsity_step_31_original.png"
- * </td>
- * <td>
+ * </td> <td>
* @image html "reorder_sparsity_step_31_random.png"
- * </td>
- * <td>
+ * </td> <td>
* @image html "reorder_sparsity_step_31_deal_cmk.png"
- * </td>
- * </tr> <tr> <td>
- * Enumeration as produced by deal.II's DoFHandler::distribute_dofs function
- * and no further reordering apart from the component-wise one.
+ * </td> </tr> <tr> <td> Enumeration as produced by deal.II's
+ * DoFHandler::distribute_dofs function and no further reordering apart from
+ * the component-wise one.
*
* With this renumbering, we needed an average of 92.2 iterations for the
* testcase outlined above, and a runtime of 7min53s. </td> <td> Random
*
* <tr> <td>
* @image html "reorder_sparsity_step_31_boost_cmk.png"
- * </td>
- * <td>
+ * </td> <td>
* @image html "reorder_sparsity_step_31_boost_king.png"
- * </td>
- * <td>
+ * </td> <td>
* @image html "reorder_sparsity_step_31_boost_md.png"
- * </td>
- * </tr> <tr> <td> Cuthill-
- * McKee enumeration as produced by calling the BOOST implementation of the
- * algorithm provided by DoFRenumbering::boost::Cuthill_McKee after
- * DoFHandler::distribute_dofs.
+ * </td> </tr> <tr> <td> Cuthill- McKee enumeration as produced by calling the
+ * BOOST implementation of the algorithm provided by
+ * DoFRenumbering::boost::Cuthill_McKee after DoFHandler::distribute_dofs.
*
* With this renumbering, we needed an average of 51.7 iterations for the
* testcase outlined above, and a runtime of 5min52s. </td> <td> King
*
* <tr> <td>
* @image html "reorder_sparsity_step_31_downstream.png"
- * </td> <td>
- * </td> <td> </td> </tr> <tr> <td> Downstream enumeration using
+ * </td> <td> </td> <td> </td> </tr> <tr> <td> Downstream enumeration using
* DoFRenumbering::downstream using a direction that points diagonally through
* the domain.
*
* 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
* variables couple in which equation. For example, if wanted to solve the
* Stokes equations,
*
- * @f{align*} -\Delta \mathbf u + \nabla p &= 0,\\ \text{div}\ u
- * &= 0 @f}
+ * @f{align*} -\Delta \mathbf u + \nabla p &= 0,\\ \text{div}\ u &= 0 @f}
*
* in two space dimensions, using stable Q2/Q1 mixed elements (using the
* FESystem class), then you don't want all degrees of freedom to couple in
* the ConstraintMatrix object as the third argument to the current
* function. No call to ConstraintMatrix::condense() is then necessary. This
* process is explained in
- * @ref step_27 "step-27"
-.
+ * @ref step_27 "step-27".
*
* In case the constraints are already taken care of in this function, it is
* possible to neglect off-diagonal entries in the sparsity pattern. When
* 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
* interpolation matrix with size no_face_dofs $\times$ no_face_dofs.
*
* Detailed information can be found in the see
- * @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions".
+ * @ref GlossPeriodicConstraints "Glossary entry on periodic boundary
+ * conditions".
*
* @todo: Reference to soon be written example step and glossary article.
*
* 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
+ * @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.
* 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
* @param block_mask The block mask that describes which blocks to consider
* (see
- * @ref GlossBlockMask
- * )
+ * @ref GlossBlockMask)
* @param selected_dofs A vector of length DoFHandler::n_dofs() in which
* those entries are true that correspond to the selected blocks.
*/
* 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 <tt>dof_handler.n_dofs()</tt>. Previous
- * contents of this array or overwritten.
+ * @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.
*
* Using the usual convention, if a shape function is non-zero in more than
* one component (i.e. it is non-primitive), then the element in the
* live on which cell
* @param component_mask A mask denoting the vector components of the finite
* element that should be considered (see also
- * @ref GlossComponentMask
- * ).
+ * @ref GlossComponentMask).
* @param selected_dofs The IndexSet object that is returned and that will
* contain the indices of degrees of freedom that are located on the
* boundary (and correspond to the selected vector components and boundary
* parallel::distributed::Triangulation, then the @p selected_dofs index set
* will contain only those degrees of freedom on the boundary that belong to
* the locally relevant set (see
- * @ref GlossLocallyRelevantDof "locally relevant DoFs"
- * ).
+ * @ref GlossLocallyRelevantDof "locally relevant DoFs").
*
* @param dof_handler The object that describes which degrees of freedom
* live on which cell
* @param component_mask A mask denoting the vector components of the finite
* element that should be considered (see also
- * @ref GlossComponentMask
- * ).
+ * @ref GlossComponentMask).
* @param selected_dofs The IndexSet object that is returned and that will
* contain the indices of degrees of freedom that are located on the
* boundary (and correspond to the selected vector components and boundary
/**
* 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
+ * @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
* 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
+ * @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.
*
* indices that live on all locally owned cells (including on the interface
* to ghost cells). However, it does not contain the DoF indices that are
* exclusively defined on ghost or artificial cells (see
- * @ref GlossArtificialCell "the glossary"
- * ).
+ * @ref GlossArtificialCell "the glossary").
*
* The degrees of freedom identified by this function equal those obtained
* from the dof_indices_with_subdomain_association() function when called
* is the union of DoFHandler::locally_owned_dofs() and the DoF indices on
* all ghost cells. In essence, it is the DoF indices on all cells that are
* not artificial (see
- * @ref GlossArtificialCell "the glossary"
- * ).
+ * @ref GlossArtificialCell "the glossary").
*/
template <class DH>
void
* Count the degrees of freedom in each block. This function is similar to
* count_dofs_per_component(), with the difference that the counting is done
* by blocks. See
- * @ref GlossBlock "blocks"
- * in the glossary for details.
- * 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
+ * @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
* were known. As a consequence, this function constructs a map from those
* DoFs for which we can know the locations (namely, those DoFs that are
* locally relevant (see
- * @ref GlossLocallyRelevantDof "locally relevant DoFs"
- * ) to their locations.
+ * @ref GlossLocallyRelevantDof "locally relevant DoFs") to their
+ * locations.
*
* For non-distributed triangulations, the map returned as @p support_points
* is of course dense, i.e., every DoF is to be found in it.
* 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
+ * 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
+ * @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
+ * @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.
*
* finite element to generate a block mask from certain selected blocks using
* code such as this where we create a mask that only denotes the velocity
* block of a Stokes element (see
- * @ref vector_valued
- * ):
+ * @ref vector_valued):
* @code
* FESystem<dim> stokes_fe (FESystem<dim>(FE_Q<dim>(2), dim), 1, // Q2 element for the velocities
* FE_Q<dim>(1), 1); // Q1 element for the pressure
/**
* This class represents a mask that can be used to select individual vector
* components of a finite element (see also
- * @ref GlossComponentMask "this glossary entry"
- * ). It will typically have
- * 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
* component mask from certain selected components using code such as this
* where we create a mask that only denotes the velocity components of a
* Stokes element (see
- * @ref vector_valued
- * ):
+ * @ref vector_valued):
* @code
* FESystem<dim> stokes_fe (FE_Q<dim>(2), dim, // Q2 element for the velocities
* FE_Q<dim>(1), 1); // Q1 element for the pressure
*
* 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
+ * @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
+ * @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().
*
*
* 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 step_20 "step-20" tutorial programs as well as in the
* @ref vector_valued module.
*/
std::pair<unsigned int, unsigned int>
* Only for those spaces that couple the components, for example to make a
* shape function divergence free, will there be more than one @p true
* entry. Elements for which this is true are called non-primitive (see
- * @ref GlossPrimitive
- * ).
+ * @ref GlossPrimitive).
*/
const ComponentMask &
get_nonzero_components (const unsigned int i) const;
* Return a component mask with as many elements as this object has vector
* components and of which exactly the one component is true that
* corresponds to the given argument. See
- * @ref GlossComponentMask "the glossary"
- * for more information.
+ * @ref GlossComponentMask "the glossary" for more information.
*
* @param scalar An object that represents a single scalar vector component
* of this finite element.
- * @return A component mask that is false in all
- * components except for the one that corresponds to the argument.
+ * @return A component mask that is false in all components except for the
+ * one that corresponds to the argument.
*/
ComponentMask
component_mask (const FEValuesExtractors::Scalar &scalar) const;
* Return a component mask with as many elements as this object has vector
* components and of which exactly the <code>dim</code> components are true
* that correspond to the given argument. See
- * @ref GlossComponentMask "the glossary"
- * for more information.
+ * @ref GlossComponentMask "the glossary" for more information.
*
* @param vector An object that represents dim vector components of this
* finite element.
- * @return A component mask that is false in all components
- * except for the ones that corresponds to the argument.
+ * @return A component mask that is false in all components except for the
+ * ones that corresponds to the argument.
*/
ComponentMask
component_mask (const FEValuesExtractors::Vector &vector) const;
* 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
* symmetric tensor.
- * @return A component mask that is false in all
- * components except for the ones that corresponds to the argument.
+ * @return A component mask that is false in all components except for the
+ * ones that corresponds to the argument.
*/
ComponentMask
component_mask (const FEValuesExtractors::SymmetricTensor<2> &sym_tensor) 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
+ * @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
* 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,
*
* @param scalar An object that represents a single scalar vector component
* of this finite element.
- * @return A component mask that is false in all
- * components except for the one that corresponds to the argument.
+ * @return A component mask that is false in all components except for the
+ * one that corresponds to the argument.
*/
BlockMask
block_mask (const FEValuesExtractors::Scalar &scalar) const;
* 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
*
* @param vector An object that represents dim vector components of this
* finite element.
- * @return A component mask that is false in all components
- * except for the ones that corresponds to the argument.
+ * @return A component mask that is false in all components except for the
+ * ones that corresponds to the argument.
*/
BlockMask
block_mask (const FEValuesExtractors::Vector &vector) const;
* 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
* @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
* symmetric tensor.
- * @return A component mask that is false in all
- * components except for the ones that corresponds to the argument.
+ * @return A component mask that is false in all components except for the
+ * ones that corresponds to the argument.
*/
BlockMask
block_mask (const FEValuesExtractors::SymmetricTensor<2> &sym_tensor) const;
/**
* Given a component mask (see
- * @ref GlossComponentMask "this glossary entry"
- * ), produce a block mask
+ * @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 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,
*
* @param component_mask The mask that selects individual components of the
* finite element
- * @return A mask that selects those blocks corresponding to
- * the selected blocks of the input argument.
+ * @return A mask that selects those blocks corresponding to the selected
+ * blocks of the input argument.
*/
BlockMask
block_mask (const ComponentMask &component_mask) const;
* Return a support point vector for generalized interpolation.
*
* See the
- * @ref GlossGeneralizedSupport "glossary entry on generalized support points"
- * for more information.
+ * @ref GlossGeneralizedSupport "glossary entry on generalized support
+ * 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
+ * @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
* <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
+ * @ref hp_paper "hp paper" for a more detailed description of the
* following). In that case, the degrees of freedom of one side need to be
* constrained to those on the other side. The determination which side is
* which is based on the outcome of a comparison for mutual domination: the
* function.
*
* Note that there are situations where neither side dominates. The
- * @ref hp_paper "hp paper"
- * lists two case, with the simpler one being
- * that a $Q_2\times Q_1$ vector-valued element (i.e. a
+ * @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.
* <li> <i>L<sup>2</sup></i> indicates that the element is discontinuous.
* Since discontinuous elements have no topological couplings between grid
* cells and code may actually depend on this property, <i>L<sup>2</sup></i>
- * conformity is handled in a special way in the sense
- * that it is <b>not</b> implied by any higher conformity.
+ * conformity is handled in a special way in the sense that it is <b>not</b>
+ * implied by any higher conformity.
* </ol>
*
* In order to test if a finite element conforms to a certain space, use
/**
* 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
+ * @ref GlossInterpolation "interpolation" operators associated with the
* Nédélec element are constructed such that interpolation and
* computing the curl are commuting operations on rectangular mesh cells. We
* require this from interpolating arbitrary functions as well as the
* <h4>Node values</h4>
*
* The
- * @ref GlossNodes "node values"
- * for an element of degree <i>k</i> on the
+ * @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
* #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;
* @param face_rotation One part of the description of the orientation of
* the face. See
* @ref GlossFaceOrientation.
- * @return The index of this
- * degree of freedom within the set of degrees of freedom on the entire
- * cell. The returned value will be between zero and dofs_per_cell.
+ * @return The index of this degree of freedom within the set of degrees of
+ * freedom on the entire cell. The returned value will be between zero and
+ * dofs_per_cell.
*/
virtual
unsigned int face_to_cell_index (const unsigned int face_dof_index,
* <h3>Interpolation</h3>
*
* The
- * @ref GlossInterpolation "interpolation"
- * operators associated with the
- * RT element are constructed such that interpolation and computing 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
* <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
+ * @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
* 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 class is as follows: first, call the functions @p update_once and @p
* update_each with the update flags you need. This includes the flags needed
* by the FiniteElement. Then call <tt>get_*_data</tt> and with the or'd
- * results. This will initialize and return some internal data structures.
- * On the first cell, call <tt>fill_fe_*_values</tt> with the result of @p
+ * results. This will initialize and return some internal data structures. On
+ * the first cell, call <tt>fill_fe_*_values</tt> with the result of @p
* update_once. Finally, on each cell, use <tt>fill_fe_*_values</tt> with the
* result of @p update_each to compute values for a special cell.
*
* Jacobians of spacedim-vector valued differentiable functions are
* transformed this way.
* </ul>
- * @note It would have been more reasonable to make this transform a
+ * @note It would have been more reasonable to make this transform a
* template function with the rank in <code>DerivativeForm@<1, dim,
* rank@></code>. Unfortunately C++ does not allow templatized virtual
* functions. This is why we identify <code>DerivativeForm@<1, dim,
* J^{-1}(\mathbf{\hat x}).
* @f]
* </ul>
- * @todo The formulas for mapping_covariant_gradient(),
+ * @todo The formulas for mapping_covariant_gradient(),
* mapping_contravariant_gradient() and mapping_piola_gradient() are only
* true as stated for linear mappings. If, for example, the mapping is
* bilinear then there is a missing term associated with the derivative of
/**
* 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,
* <li> Solve the equation A x_hat + b = p for x_hat
* <li> This x_hat is the initial solution used for the Newton Method.
* </ul>
- * @note if dim<spacedim we first project p onto the plane. @note if dim==1
+ * @note if dim<spacedim we first project p onto the plane. @note if dim==1
* (for any spacedim) the initial guess is the exact solution and no Newton
* iteration is needed. Some details about how we compute the least square
* plane. We look for a spacedim x (dim + 1) matrix X such that X * M = Y
*
* Some of these functions receive a flag @p colorize. If this is set, parts
* of the boundary receive different boundary indicators (
- * @ref GlossBoundaryIndicator
- * ), allowing them to be distinguished for the
+ * @ref GlossBoundaryIndicator), allowing them to be distinguished for the
* purpose of attaching geometry objects and evaluating different boundary
* conditions.
*
const bool colorize = false);
/**
- * A subdivided parallelepiped. The first corner point is the origin. The
- * @p dim adjacent points are vectors describing the edges of the
+ * A subdivided parallelepiped. The first corner point is the origin. The @p
+ * dim adjacent points are vectors describing the edges of the
* parallelepiped with respect to the origin. Additional points are sums of
* these dim vectors. The variable @p n_subdivisions designates the number
- * of subdivisions in each of the @p dim directions. Colorizing is
- * done according to hyper_rectangle().
+ * of subdivisions in each of the @p dim directions. Colorizing is done
+ * according to hyper_rectangle().
*
* @note The triangulation needs to be void upon calling this function.
*/
/**
* A subdivided parallelepiped, ie. the same as above, but where the number
- * of subdivisions in each of the @p dim directions may vary.
- * Colorizing is done according to hyper_rectangle().
+ * of subdivisions in each of the @p dim directions may vary. Colorizing is
+ * done according to hyper_rectangle().
*
* @note The triangulation needs to be void upon calling this function.
*/
const double radius = 1.);
/**
- * This class produces a half hyper-ball around @p center, which
- * contains four elements in 2d and 6 in 3d. The cut plane is perpendicular
- * to the <i>x</i>-axis.
+ * This class produces a half hyper-ball around @p center, which contains
+ * four elements in 2d and 6 in 3d. The cut plane is perpendicular to the
+ * <i>x</i>-axis.
*
* The boundary indicators for the final triangulation are 0 for the curved
* boundary and 1 for the cut plane.
*
* @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
* fairly simple to extend it.
*
* <li> <tt>Gmsh 1.0 mesh</tt> format: this format is used by the @p GMSH mesh
- * generator (see http://www.geuz.org/gmsh/ ). The documentation in the @p
+ * generator (see http://www.geuz.org/gmsh/). The documentation in the @p
* GMSH manual explains how to generate meshes compatible with the deal.II
* library (i.e. quads rather than triangles). In order to use this format,
* Gmsh has to output the file in the old format 1.0. This is done adding the
* 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
/**
* Read grid data from an msh file, either version 1 or version 2 of that
- * file format. The GMSH formats are documented at http://www.geuz.org/gmsh/ .
+ * file format. The GMSH formats are documented at http://www.geuz.org/gmsh/
+ * .
*
* @note The input function of deal.II does not distinguish between newline
* and other whitespace. Therefore, deal.II will be able to read files in a
/**
* 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;
* side_hop(&qnum, &lsn) has qnum being the quadnumber of a quad in the
* triangulation, and a local side number. side_hop then sets qnum to
* the quadnumber across the other side of the side, and sets lsn so
- * that quads[qnum].sides[lsn] is the same before and after the call.
- * if there is no other quad on the other side of the current quad, then
+ * that quads[qnum].sides[lsn] is the same before and after the call. If
+ * there is no other quad on the other side of the current quad, then
* side_hop returns false.
*/
bool side_hop (unsigned int &qnum,
* should be used when describing whether cells are bounded by straight or
* curved faces. The default is to use a $Q_1$ mapping, which corresponds to
* straight lines bounding the cells.
- * @return The dim-dimensional measure of
- * the domain described by the triangulation, as discussed above.
+ * @return The dim-dimensional measure of the domain described by the
+ * triangulation, as discussed above.
*/
template <int dim, int spacedim>
double volume (const Triangulation<dim,spacedim> &tria,
*
* @param container A variable of a type that satisfies the requirements of
* a mesh container (see
- * @ref GlossMeshAsAContainer
- * ).
+ * @ref GlossMeshAsAContainer).
* @param p The point for which we want to find the closest vertex.
* @return The index of the closest vertex found.
*
*
* @param container A variable of a type that satisfies the requirements of
* a mesh container (see
- * @ref GlossMeshAsAContainer
- * ).
+ * @ref GlossMeshAsAContainer).
* @param vertex_index The index of the vertex for which we try to find
* adjacent cells.
- * @return A vector of cells that lie adjacent to the given
- * vertex.
+ * @return A vector of cells that lie adjacent to the given vertex.
*
* @note If the point requested does not lie in any of the cells of the mesh
* given, then this function throws an exception of type
*
* @param container A variable of a type that satisfies the requirements of
* a mesh container (see
- * @ref GlossMeshAsAContainer
- * ).
+ * @ref GlossMeshAsAContainer).
* @param p The point for which we want to find the surrounding cell.
* @return An iterator into the mesh container that points to the
* surrounding cell.
* @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
* inside a given cell.
* @param container A variable of a type that satisfies the requirements of
* a mesh container (see
- * @ref GlossMeshAsAContainer
- * ).
+ * @ref GlossMeshAsAContainer).
* @param p The point for which we want to find the surrounding cell.
* @return An pair of an iterator into the mesh container that points to the
* surrounding cell, and of the coordinates of that point inside the cell in
* @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
* 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 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
*
* @param triangulation The triangulation of which the function evaluates
* which vertices are locally owned.
- * @return The subset of vertices, as
- * described above. The length of the returned array equals
- * Triangulation.n_vertices() and may, consequently, be larger than
- * Triangulation::n_used_vertices().
+ * @return The subset of vertices, as described above. The length of the
+ * returned array equals Triangulation.n_vertices() and may, consequently,
+ * be larger than Triangulation::n_used_vertices().
*/
template <int dim, int spacedim>
std::vector<bool>
*
* @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
*
* interpreted as an interpolation matrix with size no_face_dofs $\times$
* no_face_dofs. For more details see make_periodicity_constraints() and
* the glossary
- * @ref GlossPeriodicConstraints "glossary entry on periodic boundary conditions".
+ * @ref GlossPeriodicConstraints "glossary entry on periodic boundary
+ * conditions".
*/
FullMatrix<double> matrix;
* between its vertices can be achieved via an orthogonal equality relation.
*
* Hereby, two vertices <tt>v_1</tt> and <tt>v_2</tt> are considered equal,
- * if $M\cdot v_1 + offset - v_2$ is parallel to the unit vector in
- * unit direction @p direction. If the parameter @p matrix is a reference to
- * a spacedim x spacedim matrix, $M$ is set to @p matrix, otherwise $M$ is
- * the identity matrix.
+ * if $M\cdot v_1 + offset - v_2$ is parallel to the unit vector in unit
+ * direction @p direction. If the parameter @p matrix is a reference to a
+ * spacedim x spacedim matrix, $M$ is set to @p matrix, otherwise $M$ is the
+ * identity matrix.
*
* If the matching was successful, the _relative_ orientation of @p face1
* with respect to @p face2 is returned in the bitset @p orientation, where
* matrix is interpreted as a rotation matrix that is applied to all vector
* valued blocks listed in @p first_vector_components of the FESystem. For
* more details see make_periodicity_constraints() and the glossary
- * @ref GlossPeriodicConstraints "glossary entry on periodic boundary conditions".
+ * @ref GlossPeriodicConstraints "glossary entry on periodic boundary
+ * conditions".
*
* @tparam Container A type that satisfies the requirements of a mesh
* container (see
* matrix is interpreted as a rotation matrix that is applied to all vector
* valued blocks listet in @p first_vector_components of the FESystem. For
* more details see make_periodicity_constraints() and the glossary
- * @ref GlossPeriodicConstraints "glossary entry on periodic boundary conditions".
+ * @ref GlossPeriodicConstraints "glossary entry on periodic boundary
+ * conditions".
*
* @tparam Container A type that satisfies the requirements of a mesh
* container (see
* \subset R^{\text{chartdim}} \f] (the pull_back() function).
*
* The get_new_point() function of the ChartManifold class is implemented by
- * calling the pull_back() method for all <tt>surrounding_points</tt>, computing their
- * weighted average in the chartdim Euclidean space, and calling the
- * push_forward() method with the resulting point, i.e., \f[ p^{\text{new}} =
- * F(\sum_i w_i F^{-1}(p_i)). \f]
+ * calling the pull_back() method for all <tt>surrounding_points</tt>,
+ * computing their weighted average in the chartdim Euclidean space, and
+ * calling the push_forward() method with the resulting point, i.e., \f[
+ * p^{\text{new}} = F(\sum_i w_i F^{-1}(p_i)). \f]
*
* Derived classes are required to implement the push_forward() and the
* pull_back() methods. All other functions required by mappings will then be
* provided by this class.
*
- * The dimension arguments @p chartdim, @p dim and @p spacedim must satisfy the
- * following relationships:
+ * The dimension arguments @p chartdim, @p dim and @p spacedim must satisfy
+ * the following relationships:
* @code
* dim <= spacedim
* chartdim <= spacedim
* @endcode
- * However, there is no a priori relationship between @p dim and @p chartdim. For
- * example, if you want to describe a mapping for an edge (a 1d object) in a
- * 2d triangulation embedded in 3d space, you could do so by parameterizing it
- * via a line
+ * However, there is no a priori relationship between @p dim and @p chartdim.
+ * For example, if you want to describe a mapping for an edge (a 1d object) in
+ * a 2d triangulation embedded in 3d space, you could do so by parameterizing
+ * it via a line
* @f[
* F: [0,1] \rightarrow {\mathbb R}^3
* @f]
- * in which case @p chartdim is 1. On the other hand, there is no reason why one
- * can't describe this as a mapping
+ * in which case @p chartdim is 1. On the other hand, there is no reason why
+ * one can't describe this as a mapping
* @f[
* F: {\mathbb R}^3 \rightarrow {\mathbb R}^3
* @f]
* space and then back again. Finally, given that we are dealing with a 2d
* triangulation in 3d, one will often have a mapping from, say, the 2d unit
* square or unit disk to the domain in 3d space, and the edge in question may
- * simply be the mapped edge of the unit domain in 2d space. In this case,
- * @p chartdim is 2.
+ * simply be the mapped edge of the unit domain in 2d space. In this case, @p
+ * chartdim is 2.
*
* @ingroup manifold
*
/**
* Expressions constructor. Takes the expressions of the push_forward
- * function of spacedim components, and of the pull_back function of
- * @p chartdim components. See the documentation of the base class
+ * function of spacedim components, and of the pull_back function of @p
+ * chartdim components. See the documentation of the base class
* ChartManifold for the meaning of the optional @p periodicity argument.
*
* The strings should be the readable by the default constructor of the
/**
* Given a point in the @p chartdim coordinate system, uses the
- * push_forward_function to compute the push_forward of points in @p chartdim
- * space dimensions to @p spacedim space dimensions.
+ * push_forward_function to compute the push_forward of points in @p
+ * chartdim space dimensions to @p spacedim space dimensions.
*/
virtual Point<spacedim>
push_forward(const Point<chartdim> &chart_point) const;
/**
* Given a point in the spacedim coordinate system, uses the
- * pull_back_function to compute the pull_back of points in @p spacedim space
- * dimensions to @p chartdim space dimensions.
+ * pull_back_function to compute the pull_back of points in @p spacedim
+ * space dimensions to @p chartdim space dimensions.
*/
virtual Point<chartdim>
pull_back(const Point<spacedim> &space_point) const;
/**
* A typedef that is used to to identify
- * @ref GlossActive "active cell iterators".
- * The concept of iterators is
+ * @ref GlossActive "active cell iterators". The concept of iterators is
* discussed at length in the
* @ref Iterators "iterators documentation module".
*
* A structure that is used as an exception object by the
* create_triangulation() function to indicate which cells among the coarse
* mesh cells are inverted or severely distorted (see the entry on
- * @ref GlossDistorted "distorted cells"
- * in the glossary).
+ * @ref GlossDistorted "distorted cells" in the glossary).
*
* Objects of this kind are thrown by the create_triangulation() and
* execute_coarsening_and_refinement() functions, and they can be caught in
* 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
*
* @param[in] level A given level in the refinement hierarchy of this
* triangulation.
- * @return The half open range
- * <code>[this->begin_active(level), this->end(level))</code>
+ * @return The half open range <code>[this->begin_active(level),
+ * this->end(level))</code>
*
* @pre level must be less than this->n_levels().
*
*
* The function returns a list of cells that have produced children that
* satisfy the criteria of
- * @ref GlossDistorted "distorted cells"
- * if the
+ * @ref GlossDistorted "distorted cells" if the
* <code>check_for_distorted_cells</code> flag was specified upon creation
* of this object, at
*/
DeclException0 (ExcCellNotUsed);
/**
* The cell is not an
- * @ref GlossActive "active"
- * cell, but it already has
- * 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
*/
* Of course, doing so requires that you ensure that the new location of the
* vertex remains useful -- for example, avoiding inverted or otherwise
* distorted (see also
- * @ref GlossDistorted "this glossary entry"
- * ).
+ * @ref GlossDistorted "this glossary entry").
*
* @note When a cell is refined, its children inherit the position of the
* vertex positions of those vertices they share with the mother cell (plus
* 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
+ * @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
* Return a constant reference to the manifold object used for this object.
*
* As explained in
- * @ref boundary "Boundary and manifold description for triangulations"
- * , the process involved in finding the appropriate manifold description
- * involves querying both the manifold or boundary indicators. See there
- * for more information.
+ * @ref boundary "Boundary and manifold description for triangulations" ,
+ * the process involved in finding the appropriate manifold description
+ * involves querying both the manifold or boundary indicators. See there for
+ * more information.
*/
const Manifold<dim,spacedim> &get_manifold () 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;
/**
/**
* Returns a point belonging to the Manifold<dim,spacedim> where this object
- * lives, given its parametric coordinates on the reference @p structdim cell.
- * This function queries the underlying manifold object, and can be used to
- * obtain the exact geometrical location of arbitrary points on this object.
+ * lives, given its parametric coordinates on the reference @p structdim
+ * cell. This function queries the underlying manifold object, and can be
+ * used to obtain the exact geometrical location of arbitrary points on this
+ * object.
*
* Notice that the argument @p coordinates are the coordinates on the
- * <em>reference cell</em>, given in reference coordinates. In other
- * words, the argument provides a weighting between the different vertices.
- * For example, for lines, calling this function with argument Point<1>(.5),
- * is equivalent to asking the line for its center.
+ * <em>reference cell</em>, given in reference coordinates. In other words,
+ * the argument provides a weighting between the different vertices. For
+ * example, for lines, calling this function with argument Point<1>(.5), is
+ * equivalent to asking the line for its center.
*/
Point<spacedim> intermediate_point(const Point<structdim> &coordinates) 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
+ * @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
+ * 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
*
* @param[in] level A given level in the refinement hierarchy of this
* triangulation.
- * @return The half open range
- * <code>[this->begin_active(level), this->end(level))</code>
+ * @return The half open range <code>[this->begin_active(level),
+ * this->end(level))</code>
*
* @pre level must be less than this->n_levels().
*
* @param dofs_per_cell The number of DoFs per cell for this cell. This
* is not used for the hp case but necessary to keep the interface the
* same as for the non-hp case.
- * @return A pointer to the first DoF index
- * for the current cell. The next dofs_per_cell indices are for the
- * current cell.
+ * @return A pointer to the first DoF index for the current cell. The
+ * next dofs_per_cell indices are for the current cell.
*/
const types::global_dof_index *
get_cell_cache_start (const unsigned int obj_index,
* 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;
*
* @param scalar An object that represents a single scalar vector
* component of this finite element.
- * @return A component mask that is
- * false in all components except for the one that corresponds to the
- * argument.
+ * @return A component mask that is false in all components except for the
+ * one that corresponds to the argument.
*/
ComponentMask
component_mask (const FEValuesExtractors::Scalar &scalar) const;
*
* @param vector An object that represents dim vector components of this
* finite element.
- * @return A component mask that is false in all
- * components except for the ones that corresponds to the argument.
+ * @return A component mask that is false in all components except for the
+ * ones that corresponds to the argument.
*/
ComponentMask
component_mask (const FEValuesExtractors::Vector &vector) const;
* @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
* symmetric tensor.
- * @return A component mask that is false in all
- * components except for the ones that corresponds to the argument.
+ * @return A component mask that is false in all components except for the
+ * ones that corresponds to the argument.
*/
ComponentMask
component_mask (const FEValuesExtractors::SymmetricTensor<2> &sym_tensor) const;
/**
* Given a block mask (see
- * @ref GlossBlockMask "this glossary entry"
- * ),
- * produce a component mask (see
- * @ref GlossComponentMask "this glossary entry"
- * ) that represents the
+ * @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.
+ * 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
*
* @param block_mask The mask that selects individual blocks of the finite
* element
- * @return A mask that selects those components corresponding to
- * the selected blocks of the input argument.
+ * @return A mask that selects those components corresponding to the
+ * selected blocks of the input argument.
*/
ComponentMask
component_mask (const BlockMask &block_mask) const;
* 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,
*
* @param scalar An object that represents a single scalar vector
* component of this finite element.
- * @return A component mask that is
- * false in all components except for the one that corresponds to the
- * argument.
+ * @return A component mask that is false in all components except for the
+ * one that corresponds to the argument.
*/
BlockMask
block_mask (const FEValuesExtractors::Scalar &scalar) const;
* 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
*
* @param vector An object that represents dim vector components of this
* finite element.
- * @return A component mask that is false in all
- * components except for the ones that corresponds to the argument.
+ * @return A component mask that is false in all components except for the
+ * ones that corresponds to the argument.
*/
BlockMask
block_mask (const FEValuesExtractors::Vector &vector) const;
* 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
* @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
* symmetric tensor.
- * @return A component mask that is false in all
- * components except for the ones that corresponds to the argument.
+ * @return A component mask that is false in all components except for the
+ * ones that corresponds to the argument.
*/
BlockMask
block_mask (const FEValuesExtractors::SymmetricTensor<2> &sym_tensor) const;
/**
* Given a component mask (see
- * @ref GlossComponentMask "this glossary entry"
- * ), produce a block mask
+ * @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 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
*
* @param component_mask The mask that selects individual components of
* the finite element
- * @return A mask that selects those blocks
- * corresponding to the selected blocks of the input argument.
+ * @return A mask that selects those blocks corresponding to the selected
+ * blocks of the input argument.
*/
BlockMask
block_mask (const ComponentMask &component_mask) const;
* 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
*
* blocks, where you have to translate global row and column indices to local
* ones.
*
- * @ingroup data
- * @see
+ * @ingroup data @see
* @ref GlossBlockLA "Block (linear algebra)"
* @author Wolfgang Bangerth, Guido Kanschat, 2000, 2007, 2011
*/
* @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
+ * @ref Sparsity , section 'Dynamic block sparsity patterns' for more
* information.
*
* <b>Note:</b> This class used to be called CompressedBlockSparsityPattern.
* @ref Sparsity.
*
* @note There are several, exchangeable variations of this class, see
- * @ref Sparsity
- * , section 'Dynamic block sparsity patterns' for more
+ * @ref Sparsity , section 'Dynamic block sparsity patterns' for more
* information.
*
* @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
+ * @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
+ * @ref GlossCompress "Compressing distributed objects" for more
* information.
*/
void compress (::dealii::VectorOperation::values operation
* 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
+ * @ref Vector. For all classes for which iterating over elements, or random
* member access is expensive, this function is not efficient. In
* particular, if you want to multiply with BlockVector objects, you should
* consider using a BlockChunkSparseMatrix as well.
*
* Note that while this function can operate on all vectors that offer
* iterator classes, it is only really effective for objects of type
- * @ref Vector.
- * For all classes for which iterating over elements, or random
+ * @ref Vector. For all classes for which iterating over elements, or random
* member access is expensive, this function is not efficient. In
* particular, if you want to multiply with BlockVector objects, you should
* consider using a BlockChunkSparseMatrix as well.
*
* Note that while this function can operate on all vectors that offer
* iterator classes, it is only really effective for objects of type
- * @ref Vector.
- * For all classes for which iterating over elements, or random
+ * @ref Vector. For all classes for which iterating over elements, or random
* member access is expensive, this function is not efficient. In
* particular, if you want to multiply with BlockVector objects, you should
* consider using a BlockChunkSparseMatrix as well.
*
* Note that while this function can operate on all vectors that offer
* iterator classes, it is only really effective for objects of type
- * @ref Vector.
- * For all classes for which iterating over elements, or random
+ * @ref Vector. For all classes for which iterating over elements, or random
* member access is expensive, this function is not efficient. In
* particular, if you want to multiply with BlockVector objects, you should
* consider using a BlockChunkSparseMatrix as well.
/**
* Structure representing the sparsity pattern of a sparse matrix. This class
* is an example of the "static" type of
- * @ref Sparsity.
- * It uses the compressed
- * 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>
*
* <h3>Notes</h3>
*
* There are several, exchangeable variations of this class, see
- * @ref Sparsity
- * , section '"Dynamic" or "compressed" sparsity patterns' for more
- * information.
+ * @ref Sparsity , 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.
* <h3>Notes</h3>
*
* There are several, exchangeable variations of this class, see
- * @ref Sparsity
- * , section '"Dynamic" or "compressed" sparsity patterns' for
+ * @ref Sparsity , section '"Dynamic" or "compressed" sparsity patterns' for
* more information.
*
* @author Timo Heister, 2008
* Another viewpoint is that this class does not need up front allocation of a
* certain amount of memory, but grows as necessary. An extensive description
* of sparsity patterns can be found in the documentation of the
- * @ref Sparsity
- * module.
+ * @ref Sparsity module.
*
* This class is an example of the "dynamic" type of
* @ref Sparsity.
* <h3>Notes</h3>
*
* There are several, exchangeable variations of this class, see
- * @ref Sparsity
- * , section '"Dynamic" or "compressed" sparsity patterns' for
+ * @ref Sparsity , section '"Dynamic" or "compressed" sparsity patterns' for
* more information.
*
* @author Wolfgang Bangerth, 2001
* This class implements dealing with linear (possibly inhomogeneous)
* constraints on degrees of freedom. The concept and origin of such
* constraints is extensively described in the
- * @ref constraints
- * module. The
- * 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.
+ * @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
* 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.
* @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
*/
* type is really only useful in two contexts: preconditioning and
* initializing other matrices.
*
- * <h4>Initialization</h4>
+ * <h4>Initialization</h4>
*
* The main usefulness of this class lies in its ability to initialize other
* matrix, like this:
* @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
* exception that storage is distributed with MPI.
*
* The vector is designed for the following scheme of parallel
- * partitioning:
- * - The indices held by individual processes (locally owned
+ * partitioning: - The indices held by individual processes (locally owned
* part) in the MPI parallelization form a contiguous range
- * <code>[my_first_index,my_last_index)</code>.
- * - Ghost indices residing
+ * <code>[my_first_index,my_last_index)</code>. - Ghost indices residing
* on arbitrary positions of other processors are allowed. It is in
* general more efficient if ghost indices are clustered, since they are
* stored as a set of intervals. The communication pattern of the ghost
* pattern, rather than having to compute it again for every
* communication. (For more information on ghost vectors, see also the
* @ref GlossGhostedVector "glossary entry on vectors with ghost elements"
- * .)
- * - Besides the usual global access operator () it is also
- * possible to access vector entries in the local index space with the
- * function @p local_element(). Locally owned indices are placed first,
- * [0, local_size()), and then all ghost indices follow after them
+ * .) - Besides the usual global access operator () it is also possible to
+ * access vector entries in the local index space with the function @p
+ * local_element(). Locally owned indices are placed first, [0,
+ * local_size()), and then all ghost indices follow after them
* contiguously, [local_size(), local_size()+n_ghost_entries()).
*
- * Functions related to parallel functionality:
- * - The function
+ * Functions related to parallel functionality: - The function
* <code>compress()</code> goes through the data associated with ghost
* indices and communicates it to the owner process, which can then add it
* to the correct position. This can be used e.g. after having run an
* @p insert mode of @p compress() does not set the elements included in
* ghost entries but simply discards them, assuming that the owning
* processor has set them to the desired value already. (See also the
- * @ref GlossCompress "glossary entry on compress"
- * .)
- * - The
+ * @ref GlossCompress "glossary entry on compress" .) - The
* <code>update_ghost_values()</code> function imports the data from the
* owning processor to the ghost indices in order to provide read access
- * to the data associated with ghosts.
- * - It is possible to split the above
+ * to the data associated with ghosts. - It is possible to split the above
* functions into two phases, where the first initiates the communication
* and the second one finishes it. These functions can be used to overlap
- * communication with computations in other parts of the code.
- * - Of
+ * communication with computations in other parts of the code. - Of
* course, reduction operations (like norms) make use of collective all-
* to-all MPI communications.
*
* This vector can take two different states with respect to ghost
- * elements:
- * - After creation and whenever zero_out_ghosts() is called (or
+ * elements: - After creation and whenever zero_out_ghosts() is called (or
* <code>operator = (0.)</code>), the vector does only allow writing into
- * ghost elements but not reading from ghost elements.
- * - After a call to
+ * ghost elements but not reading from ghost elements. - After a call to
* update_ghost_values(), the vector does not allow writing into ghost
* elements but only reading from them. This is in order to avoid
* undesired ghost data artifacts when calling compress() after modifying
* 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 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);
* specify the sizes of the individual blocks, but also the number of
* elements of each of these blocks to be stored on the local process.
*
- * @ingroup Vectors
- * @see
+ * @ingroup Vectors @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
*/
* as an example on how to do this.
*
* For further information and explanations on handling the
- * @ref SLEPcWrappers "SLEPcWrappers"
- * , see also the
- * @ref PETScWrappers "PETScWrappers"
- * , on which they depend.
+ * @ref SLEPcWrappers "SLEPcWrappers" , see also the
+ * @ref PETScWrappers "PETScWrappers" , on which they depend.
*
* @ingroup SLEPcWrappers
*
* @image html "cg-monitor-smoothing-3.png"
* </td> <td>
* @image html "cg-monitor-smoothing-4.png"
- * </td>
- * <td>
+ * </td> <td>
* @image html "cg-monitor-smoothing-5.png"
* </td> </tr> </table>
*
* application is also the use of a Krylov space method inside the
* preconditioner.
*
- * FGMRES needs two vectors in each iteration steps yielding a total of
- * <tt>2 * SolverFGMRESAdditionalData::max_basis_size+1</tt> auxiliary vectors.
+ * FGMRES needs two vectors in each iteration steps yielding a total of <tt>2
+ * * SolverFGMRESAdditionalData::max_basis_size+1</tt> auxiliary vectors.
*
* Caveat: documentation of this class is not up to date. There are also a few
* parameters of GMRES we would like to introduce here.
* 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
+ * @ref Vector. For all classes for which iterating over elements, or random
* member access is expensive, this function is not efficient. In
* particular, if you want to multiply with BlockVector objects, you should
* consider using a BlockSparseMatrix as well.
*
* Note that while this function can operate on all vectors that offer
* iterator classes, it is only really effective for objects of type
- * @ref Vector.
- * For all classes for which iterating over elements, or random
+ * @ref Vector. For all classes for which iterating over elements, or random
* member access is expensive, this function is not efficient. In
* particular, if you want to multiply with BlockVector objects, you should
* consider using a BlockSparseMatrix as well.
*
* Note that while this function can operate on all vectors that offer
* iterator classes, it is only really effective for objects of type
- * @ref Vector.
- * For all classes for which iterating over elements, or random
+ * @ref Vector. For all classes for which iterating over elements, or random
* member access is expensive, this function is not efficient. In
* particular, if you want to multiply with BlockVector objects, you should
* consider using a BlockSparseMatrix as well.
*
* Note that while this function can operate on all vectors that offer
* iterator classes, it is only really effective for objects of type
- * @ref Vector.
- * For all classes for which iterating over elements, or random
+ * @ref Vector. For all classes for which iterating over elements, or random
* member access is expensive, this function is not efficient. In
* particular, if you want to multiply with BlockVector objects, you should
* consider using a BlockSparseMatrix as well.
* @note Instantiations for this template are provided for <tt>@<float@> and
* @<double@></tt>; others can be generated in application programs (see the
* section on
- * @ref Instantiations
- * in the manual).
+ * @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
*/
* processor, since the Trilinos matrices are inherently parallel.
*
* @ingroup Vectors
- * @ingroup TrilinosWrappers
- * @see
+ * @ingroup TrilinosWrappers @see
* @ref GlossBlockLA "Block (linear algebra)"
* @author Martin Kronbichler, 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;
* elements of each of these blocks to be stored on the local process.
*
* @ingroup Vectors
- * @ingroup TrilinosWrappers
- * @see
+ * @ingroup TrilinosWrappers @see
* @ref GlossBlockLA "Block (linear algebra)"
* @author Martin Kronbichler, Wolfgang Bangerth, 2008, 2009
*/
* @deprecated
*
* See
- * @ref GlossCompress "Compressing distributed objects"
- * for more information.
+ * @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
+ * @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.
+ * 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
*/
* range in @p cell_loop runs from zero to n_macro_cells() (exclusive), so
* this is the appropriate size if you want to store arrays of data for all
* cells to be worked on. This number is approximately
- * n_physical_cells()/VectorizedArray<number>::n_array_elements (depending on how
- * many cell chunks that do not get filled up completely).
+ * n_physical_cells()/VectorizedArray<number>::n_array_elements (depending
+ * on how many cell chunks that do not get filled up completely).
*/
unsigned int n_macro_cells () const;
* used locally.
*
* 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
+ * 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.
*
* @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
+ * methods. @see
+ * @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
*/
/**
* 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 ();
* 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
+ * @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.
* 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
+ * @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.
+ * 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
* Return a @p Vector with the indices of selected points flagged with a 1.
* This method is mainly for testing and verifying that the class is working
* correctly. By passing this vector to a DataOut object, the user can
- * verify that the positions returned by @p get_points
- * agree with the positions that @p DataOut interprets from
- * the @p Vector returned. The code snippet below demonstrates how this
- * could be done:
+ * verify that the positions returned by @p get_points agree with the
+ * positions that @p DataOut interprets from the @p Vector returned. The
+ * code snippet below demonstrates how this could be done:
* @code
* // Make a DataOut object and attach the dof_handler
* DataOut<dim> data_out;
* 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
+ * @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
* 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