/**
* This class provides dimension independent information to all topological
- * structures that make up the unit, or @ref GlossReferenceCell "reference
- * cell".
+ * structures that make up the unit, or
+ * @ref GlossReferenceCell "reference cell".
*
* It is the one central point in the library where information about the
* numbering of vertices, lines, or faces of the reference cell is collected.
*
*
* @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).
+ * and there is a specialization for dim=0 (see the section on
+ * @ref Instantiations in the manual).
*
* @ingroup grid geomprimitives aniso
* @author Wolfgang Bangerth, 1998, Ralf Hartmann, 2005, Tobias Leicht, 2007
* the standard and non-standard orientation. <tt>face_orientation</tt>
* defaults to <tt>true</tt>, <tt>face_flip</tt> and <tt>face_rotation</tt>
* default to <tt>false</tt> (standard orientation) and has no effect in 2d.
- * The concept of face orientations is explained in this @ref
- * GlossFaceOrientation "glossary" entry.
+ * The concept of face orientations is explained in this
+ * @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
* Note that this is only the <em>standard orientation</em> of faces. At
* 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.
+ * cell it belongs to. For more information, see the
+ * @ref GlossFaceOrientation "glossary" entry on face orientation.
*/
static const int unit_normal_orientation[faces_per_cell];
* balanced.
*
* For a discussion of the kind of problems to which this function is
- * applicable, see the @ref threads "Parallel computing with multiple
- * processors" module.
+ * applicable, see the
+ * @ref threads "Parallel computing with multiple processors" module.
*/
template <typename InputIterator,
typename OutputIterator,
* balanced.
*
* For a discussion of the kind of problems to which this function is
- * applicable, see the @ref threads "Parallel computing with multiple
- * processors" module.
+ * applicable, see the
+ * @ref threads "Parallel computing with multiple processors" module.
*/
template <typename InputIterator1,
typename InputIterator2,
* balanced.
*
* For a discussion of the kind of problems to which this function is
- * applicable, see the @ref threads "Parallel computing with multiple
- * processors" module.
+ * applicable, see the
+ * @ref threads "Parallel computing with multiple processors" module.
*/
template <typename InputIterator1,
typename InputIterator2,
* scheduling subranges to CPU resources than on doing actual work.
*
* For a discussion of the kind of problems to which this function is
- * applicable, see also the @ref threads "Parallel computing with multiple
- * processors" module.
+ * applicable, see also the
+ * @ref threads "Parallel computing with multiple processors" module.
*/
template <typename RangeType, typename Function>
void apply_to_subranges (const RangeType &begin,
* differ on the order of round-off.
*
* For a discussion of the kind of problems to which this function is
- * applicable, see also the @ref threads "Parallel computing with multiple
- * processors" module.
+ * applicable, see also the
+ * @ref threads "Parallel computing with multiple processors" module.
*/
template <typename ResultType, typename RangeType, typename Function>
ResultType accumulate_from_subranges (const Function &f,
* "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 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);
}
* each of which operates on a subset of the given range of objects. The class
* uses the Intel Threading Building Blocks (TBB) to load balance the
* individual subranges onto the available threads. For a lengthy discussion
- * of the rationale of this class, see the @ref threads "Parallel computing
- * with multiple processors" module. It is used in the tutorial first in
- * step-9, and again in step-13, step-14, step-32 and others.
+ * of the rationale of this class, see the
+ * @ref threads "Parallel computing with multiple processors" module. It is
+ * used in the tutorial first in step-9, and again in step-13, step-14,
+ * step-32 and others.
*
* The class is built on the following premise: One frequently has some work
* that needs to be done on a sequence of objects; a prototypical example is
* dealii::Triangulation class but there are a number of difficult
* algorithms under the hood that ensure we always have a load-balanced,
* fully distributed mesh. Use of this class is explained in step-40,
- * step-32, the @ref distributed documentation module, as well as the @ref
- * distributed_paper . See there for more information. This class
+ * step-32, the @ref distributed documentation module, as well as the
+ * @ref distributed_paper . See there for more information. This class
* satisfies the requirements outlined in @ref GlossMeshAsAContainer
* "Meshes as containers".
*
public:
/**
* A typedef that is used to to identify cell iterators. The concept of
- * iterators is discussed at length in the @ref Iterators "iterators
- * documentation module".
+ * iterators is discussed at length in the
+ * @ref Iterators "iterators documentation module".
*
* The current typedef identifies cells in a triangulation. You can find
* the exact type it refers to in the base class's own typedef, but it
typedef typename dealii::Triangulation<dim,spacedim>::cell_iterator cell_iterator;
/**
- * A typedef that is used to to identify @ref GlossActive "active cell
- * iterators". The concept of iterators is discussed at length in the
+ * A typedef that is used to to identify
+ * @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
typedef typename ActiveSelector::active_hex_iterator active_hex_iterator;
/**
- * A typedef that is used to to identify @ref GlossActive "active cell
- * iterators". The concept of iterators is discussed at length in the @ref
- * Iterators "iterators documentation module".
+ * A typedef that is used to to identify
+ * @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 actual data type of the typedef is hidden behind a few layers of
/**
* A typedef that is used to to identify cell iterators. The concept of
- * iterators is discussed at length in the @ref Iterators "iterators
- * documentation module".
+ * iterators is discussed at length in the
+ * @ref Iterators "iterators documentation module".
*
* The current typedef identifies cells in a DoFHandler object. Some of
- * these cells may in fact be active (see @ref GlossActive "active cell
- * iterators") in which case they can in 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.
+ * 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.
*
* While the actual data type of the typedef is hidden behind a few layers
* of (unfortunately necessary) indirections, it is in essence
// ---------------------------------------------------------------------
//
-// Copyright (C) 2003 - 2013 by the deal.II authors
+// Copyright (C) 2003 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
* The component_wise() function allows not only to honor enumeration based on
* vector components, but also allows to group together vector components into
* "blocks" using a defaulted argument to the various
- * DoFRenumber::component_wise() functions (see @ref GlossComponent vs @ref
- * GlossBlock for a description of the difference). The blocks designated
+ * DoFRenumber::component_wise() functions (see @ref GlossComponent vs
+ * @ref GlossBlock for a description of the difference). The blocks designated
* through this argument may, but do not have to be, equal to the blocks that
* the finite element reports. For example, a typical Stokes element would be
* @code
* first_vector_components is empty the matrix is interpreted as an
* 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".
+ * Detailed information can be found in the see
+ * @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions".
*
* @todo: Reference to soon be written example step and glossary article.
*
* parallel::distributed::Triangulation::add_periodicity has to be called
* before.
*
- * @see @ref GlossPeriodicConstraints "Glossary entry on periodic boundary
- * conditions" for further information.
+ * @see @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions"
+ * for further information.
*
* @author Daniel Arndt, Matthias Maier, 2013, 2014
*/
* (dofs the entry is constrained to, inhomogeneities) is kept and nothing
* happens.
*
- * The flags in the last parameter, @p component_mask (see @ref
- * GlossComponentMask) denote which components of the finite element space
+ * 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
* feeds the output to above make_periodicity_constraints() variant. If you
* need more functionality use GridTools::collect_periodic_faces() directly.
*
- * @see @ref GlossPeriodicConstraints "Glossary entry on periodic boundary
- * conditions" for further information.
+ * @see @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions"
+ * for further information.
*
* @author Matthias Maier, 2012
*/
* face index <code>2*dimension+1</code> and boundary indicator @p b_id.
*
* @note This version of make_periodicity_constraints will not work on
- * meshes with cells not in @ref GlossFaceOrientation "standard
- * orientation".
+ * meshes with cells not in
+ * @ref GlossFaceOrientation "standard orientation".
*
* @note: This function is a convenience wrapper. It internally calls
* GridTools::collect_periodic_faces() with the supplied paramaters and
* feeds the output to above make_periodicity_constraints() variant. If you
* need more functionality use GridTools::collect_periodic_faces() directly.
*
- * @see @ref GlossPeriodicConstraints "Glossary entry on periodic boundary
- * conditions" for further information.
+ * @see @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions"
+ * for further information.
*/
template<typename DH>
void
* $u(0,y)=u(1,y+1)$.
*
* @note This version of make_periodicity_constraints will not work on
- * meshes with cells not in @ref GlossFaceOrientation "standard
- * orientation".
+ * meshes with cells not in
+ * @ref GlossFaceOrientation "standard orientation".
*
* @deprecated This function is deprecated. Use
* GridTools::collect_periodic_faces in conjunction with
* @note If the DoFHandler object is indeed defined on a
* 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").
+ * the locally relevant set (see
+ * @ref GlossLocallyRelevantDof "locally relevant DoFs").
*
* @param dof_handler The object that describes which degrees of freedom
* live on which cell
/**
* 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
+ * the components chosen by <tt>component_mask</tt> (see
+ * @ref GlossComponentMask).
+ * The constant modes on a discretization are the null
* space of a Laplace operator on the selected components with Neumann
* boundary conditions applied. The null space is a necessary ingredient for
* obtaining a good AMG preconditioner when using the class
* is a superset of DoFHandler::locally_owned_dofs() and contains all DoF
* 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").
+ * exclusively defined on ghost or artificial cells (see
+ * @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
std::vector<types::global_dof_index> &mapping);
/**
- * 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.
+ * 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.
*
* @pre The given array must have a length of as many elements as there are
* degrees of freedom.
* hold a vector that would contain the locations of all DoFs even if they
* were known. As a consequence, this function constructs a map from those
* DoFs for which we can know the locations (namely, those DoFs that are
- * locally relevant (see @ref GlossLocallyRelevantDof "locally relevant
- * DoFs") to their locations.
+ * locally relevant (see
+ * @ref GlossLocallyRelevantDof "locally relevant DoFs") to their
+ * locations.
*
* For non-distributed triangulations, the map returned as @p support_points
* is of course dense, i.e., every DoF is to be found in it.
* the case where there are conflicting constraints on individual degrees of
* freedom.
* @param component_mask An optional component mask that restricts the
- * functionality of this function to a subset of an FESystem. For non-@ref
- * GlossPrimitive "primitive" shape functions, any degree of freedom is
- * affected that belongs to a shape function where at least one of its
- * nonzero components is affected by the component mask (see @ref
- * GlossComponentMask). If this argument is omitted, all components of the
- * finite element with degrees of freedom at the boundary will be
+ * functionality of this function to a subset of an FESystem. For
+ * non-@ref GlossPrimitive "primitive" shape functions, any degree of freedom
+ * is affected that belongs to a shape function where at least one of its
+ * nonzero components is affected by the component mask (see
+ * @ref GlossComponentMask). If this argument is omitted, all components
+ * of the finite element with degrees of freedom at the boundary will be
* considered.
*
* @ingroup constraints
// ---------------------------------------------------------------------
//
-// Copyright (C) 2009 - 2013 by the deal.II authors
+// Copyright (C) 2009 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
/**
* This class represents a mask that can be used to select individual vector
- * blocks of a finite element (see also @ref GlossBlockMask "this glossary
- * entry"). It will typically have as many elements as the finite element has
- * blocks, and one can use <code>operator[]</code> to query whether a
- * particular block has been selected.
+ * blocks of a finite element (see also
+ * @ref GlossBlockMask "this glossary entry"). It will typically have as
+ * many elements as the finite element has blocks, and one can use
+ * <code>operator[]</code> to query whether a particular block has been
+ * selected.
*
* The semantics of this class are the same as the related ComponentMask
* class, i.e., a default constructed mask represents all possible blocks. See
// ---------------------------------------------------------------------
//
-// Copyright (C) 2009 - 2013 by the deal.II authors
+// Copyright (C) 2009 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
/**
* 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.
+ * 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.
*
* Objects of this kind are used in many places where one wants to restrict
* operations to a certain subset of components, e.g. in
* <h5>Computing the correct basis from "raw" basis functions</h5>
*
* 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.
+ * 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.
*
* Using this matrix allows the construction of the basis of shape functions
* in two steps.
* The function computing the matrix <i>M</i> for you is
* FETools::compute_node_matrix(). It relies on the existence of
* #generalized_support_points and implementation of interpolate() with
- * VectorSlice argument. See the @ref GlossGeneralizedSupport "glossary entry
- * on generalized support points" for more information.
+ * VectorSlice argument. See the
+ * @ref GlossGeneralizedSupport "glossary entry on generalized support points"
+ * for more information.
*
* The piece of code in the constructor of a finite element responsible for
* this looks like
* than one vector-component). For this information, refer to the
* #system_to_base_table field and the system_to_base_index() function.
*
- * The use of this function is explained extensively in the step-8 and @ref
- * step_20 "step-20" tutorial programs as well as in the @ref vector_valued
- * module.
+ * The use of this function is explained extensively in the step-8 and
+ * @ref step_20 "step-20" tutorial programs as well as in the
+ * @ref vector_valued module.
*/
std::pair<unsigned int, unsigned int>
system_to_component_index (const unsigned int index) const;
/**
* Return a component mask with as many elements as this object has vector
* components and of which exactly the one component is true that
- * corresponds to the given argument. See @ref GlossComponentMask "the
- * glossary" for more information.
+ * corresponds to the given argument. See
+ * @ref GlossComponentMask "the glossary" for more information.
*
* @param scalar An object that represents a single scalar vector component
* of this finite element. @return A component mask that is false in all
/**
* Return a component mask with as many elements as this object has vector
* components and of which exactly the <code>dim</code> components are true
- * that correspond to the given argument. See @ref GlossComponentMask "the
- * glossary" for more information.
+ * that correspond to the given argument. See
+ * @ref GlossComponentMask "the glossary" for more information.
*
* @param vector An object that represents dim vector components of this
* finite element. @return A component mask that is false in all components
/**
* Return a component mask with as many elements as this object has vector
* components and of which exactly the <code>dim*(dim+1)/2</code> components
- * are true that correspond to the given argument. See @ref
- * GlossComponentMask "the glossary" for more information.
+ * are true that correspond to the given argument. See
+ * @ref GlossComponentMask "the glossary" for more information.
*
* @param sym_tensor An object that represents dim*(dim+1)/2 components of
* this finite element that are jointly to be interpreted as forming a
/**
* Given a block mask (see @ref GlossBlockMask "this glossary entry"),
- * produce a component mask (see @ref GlossComponentMask "this glossary
- * entry") that represents the components that correspond to the blocks
- * selected in the input argument. This is essentially a conversion operator
- * from BlockMask to ComponentMask.
+ * produce a component mask (see
+ * @ref GlossComponentMask "this glossary entry") that represents the
+ * components that correspond to the blocks selected in the input
+ * argument. This is essentially a conversion operator from BlockMask to
+ * ComponentMask.
*
* @param block_mask The mask that selects individual blocks of the finite
* element @return A mask that selects those components corresponding to the
/**
* Return a component mask with as many elements as this object has vector
* components and of which exactly the <code>dim</code> components are true
- * that correspond to the given argument. See @ref GlossBlockMask "the
- * glossary" for more information.
+ * that correspond to the given argument. See
+ * @ref GlossBlockMask "the glossary" for more information.
*
* @note The same caveat applies as to the version of the function above:
* The extractor object passed as argument must be so that it corresponds to
block_mask (const FEValuesExtractors::SymmetricTensor<2> &sym_tensor) const;
/**
- * Given a component mask (see @ref GlossComponentMask "this glossary
- * entry"), produce a block mask (see @ref GlossBlockMask "this glossary
- * entry") that represents the blocks that correspond to the components
- * selected in the input argument. This is essentially a conversion operator
- * from ComponentMask to BlockMask.
+ * Given a component mask (see
+ * @ref GlossComponentMask "this glossary entry"), produce a block mask
+ * (see @ref GlossBlockMask "this glossary entry") that represents the
+ * blocks that correspond to the components selected in the input
+ * argument. This is essentially a conversion operator from ComponentMask
+ * to BlockMask.
*
* @note This function will only succeed if the components referenced by the
* argument encompasses complete blocks. In other words, if, for example,
/**
* Return a support point vector for generalized interpolation.
*
- * See the @ref GlossGeneralizedSupport "glossary entry on generalized
- * support points" for more information.
+ * See the
+ * @ref GlossGeneralizedSupport "glossary entry on generalized support points"
+ * for more information.
*/
const std::vector<Point<dim> > &
get_generalized_support_points () const;
* Returns <tt>true</tt> if the class provides nonempty vectors either from
* get_unit_support_points() or get_generalized_support_points().
*
- * See the @ref GlossGeneralizedSupport "glossary entry on generalized
- * support points" for more information.
+ * See the
+ * @ref GlossGeneralizedSupport "glossary entry on generalized support points"
+ * for more information.
*/
bool has_generalized_support_points () const;
* points such that this quadrature can be performed with sufficient accuracy.
* The points needed are those of QGauss<sub>k+1</sub> on each face as well as
* QGauss<sub>k</sub> in the interior of the cell (or none for
- * RT<sub>0</sub>). See the @ref GlossGeneralizedSupport "glossary entry on
- * generalized support points" for more information.
+ * RT<sub>0</sub>). See the
+ * @ref GlossGeneralizedSupport "glossary entry on generalized support points"
+ * for more information.
*
*
* @author Oliver Kayser-Herold, 2006, based on previous work by Guido
* class and fill the tables with interpolation weights (#boundary_weights
* and #interior_weights). Called from the constructor.
*
- * See the @ref GlossGeneralizedSupport "glossary entry on generalized
- * support points" for more information.
+ * See the
+ * @ref GlossGeneralizedSupport "glossary entry on generalized support points"
+ * for more information.
*/
void initialize_support_points (const unsigned int rt_degree);
// ---------------------------------------------------------------------
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
* are then implemented in the FiniteElement::compare_for_line_domination()
* 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
+ * Note that there are situations where neither side dominates. The
+ * @ref hp_paper "hp paper" lists two case, with the simpler one being
+ * that a $Q_2\times Q_1$ vector-valued element (i.e. a
* <code>FESystem(FE_Q(2),1,FE_Q(1),1)</code>) meets a $Q_1\times Q_2$
* element: here, for each of the two vector-components, we can define a
* domination relationship, but it is different for the two components.
// ---------------------------------------------------------------------
//
-// Copyright (C) 2003 - 2013 by the deal.II authors
+// Copyright (C) 2003 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
/**
* 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.
+ * the constructor. See the
+ * @ref GlossGeneralizedSupport "glossary entry on generalized support points"
+ * for more information.
*/
void initialize_support_points (const unsigned int rt_degree);
/**
* class and fill the tables with @p interior_weights. Called from the
* constructor.
*
- * See the @ref GlossGeneralizedSupport "glossary entry on generalized
- * support points" for more information.
+ * See the
+ * @ref GlossGeneralizedSupport "glossary entry on generalized support points"
+ * for more information.
*/
void initialize_support_points (const unsigned int degree);
* These are the factors multiplied to a function in the
* #generalized_face_support_points when computing the integration.
*
- * See the @ref GlossGeneralizedSupport "glossary entry on generalized
- * support points" for more information.
+ * See the
+ * @ref GlossGeneralizedSupport "glossary entry on generalized support points"
+ * for more information.
*/
Table<2, double> boundary_weights;
* organized such that there is one row for each generalized face support
* 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.
+ * See the
+ * @ref GlossGeneralizedSupport "glossary entry on generalized support points"
+ * for more information.
*/
Table<2, double> boundary_weights;
/**
* FiniteElement<dim>::generalized_face_support_points fields. Called from
* the constructor.
*
- * See the @ref GlossGeneralizedSupport "glossary entry on generalized
- * support points" for more information.
+ * See the
+ * @ref GlossGeneralizedSupport "glossary entry on generalized support points"
+ * for more information.
*/
void initialize_support_points (const unsigned int rt_degree);
};
* covered in step-8 has $d$ components in $d$ space dimensions. In general,
* the number of components of a FESystem element is the accumulated number of
* components of all base elements times their multiplicities. A bit more on
- * components is also given in the @ref GlossComponent "glossary entry on
- * components".
+ * components is also given in the
+ * @ref GlossComponent "glossary entry on components".
*
* While the concept of components is important from the viewpoint of a
* partial differential equation, the finite element side looks a bit
{
/**
* 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.
+ * vector-valued finite element. Views are discussed in the
+ * @ref vector_valued module.
*
* You get an object of this type if you apply a FEValuesExtractors::Scalar
* to an FEValues, FEFaceValues or FESubfaceValues object.
* @note All data fields are public, but this is not critical, because access
* to this object is private in FEValues.
*
- * The purpose of this class is discussed on the page on @ref
- * UpdateFlagsEssay.
+ * The purpose of this class is discussed on the page on
+ * @ref UpdateFlagsEssay.
*
* @ingroup feaccess
* @author Guido Kanschat
// ---------------------------------------------------------------------
//
-// Copyright (C) 2002 - 2013 by the deal.II authors
+// Copyright (C) 2002 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
/**
* Filter that evaluates to true if either the iterator points to an object
- * for which the user flag is set or an iterator past the end. See @ref
- * GlossUserFlags for information about user flags.
+ * for which the user flag is set or an iterator past the end. See
+ * @ref GlossUserFlags for information about user flags.
*
* @ingroup Iterators
*/
/**
* Filter for iterators that evaluates to true if a cell is owned by the
- * current processor, i.e., if it is a @ref GlossLocallyOwnedCell "locally
- * owned cell".
+ * current processor, i.e., if it is a
+ * @ref GlossLocallyOwnedCell "locally owned cell".
*
- * This class is used in step-32, in connection with the methods of the @ref
- * distributed module.
+ * This class is used in step-32, in connection with the methods of the
+ * @ref distributed module.
*
* @ingroup Iterators
*/
* triangulations for some basic geometries.
*
* Some of these functions receive a flag @p colorize. If this is set, parts
- * of the boundary receive different boundary indicators (@ref
- * GlossBoundaryIndicator), allowing them to be distinguished for the purpose
- * of attaching geometry objects and evaluating different boundary conditions.
+ * of the boundary receive different boundary indicators (
+ * @ref GlossBoundaryIndicator), allowing them to be distinguished for the
+ * purpose of attaching geometry objects and evaluating different boundary
+ * conditions.
*
* This namespace also provides a function
* GridGenerator::laplace_transformation that smoothly transforms a domain
* appropriate manifold descriptions to the geometry created by this
* function. In the current context, this would involve the
* SphericalManifold class. An example of how this works and what it leads
- * to is shown in the documentation of the @ref manifold "documentation
- * module on manifolds".
+ * to is shown in the documentation of the
+ * @ref manifold "documentation module on manifolds".
*
* @note This function is declared to exist for triangulations of all space
* dimensions, but throws an error if called in 1d.
*
* @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.
+ * 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.
*/
template <int dim, template <int,int> class Container, int spacedim>
#ifndef _MSC_VER
*
* @note When applied to a triangulation or DoF handler object based on a
* parallel::distributed::Triangulation object, the cell returned may in
- * fact be a ghost or artificial cell (see @ref GlossArtificialCell and @ref
- * GlossGhostCell). If so, many of the operations one may want to do on this
- * cell (e.g., evaluating the solution) may not be possible and you will
- * have to decide what to do in that case.
+ * 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.
*/
template <int dim, template<int, int> class Container, int spacedim>
#ifndef _MSC_VER
*
* @note When applied to a triangulation or DoF handler object based on a
* parallel::distributed::Triangulation object, the cell returned may in
- * fact be a ghost or artificial cell (see @ref GlossArtificialCell and @ref
- * GlossGhostCell). If so, many of the operations one may want to do on this
- * cell (e.g., evaluating the solution) may not be possible and you will
- * have to decide what to do in that case.
+ * 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.
*/
template <int dim, int spacedim>
std::pair<typename hp::DoFHandler<dim, spacedim>::active_cell_iterator, Point<dim> >
* couldn't be fixed up for whatever reason. The returned list is therefore
* a subset of the input argument.
*
- * For a definition of the concept of distorted cells, see the @ref
- * GlossDistorted "glossary entry". The first argument passed to the current
- * function is typically the exception thrown by the
+ * For a definition of the concept of distorted cells, see the
+ * @ref GlossDistorted "glossary entry". The first argument passed to the
+ * current function is typically the exception thrown by the
* Triangulation::execute_coarsening_and_refinement function.
*/
template <int dim, int spacedim>
* FESystem. If @p first_vector_components is empty the matrix is
* 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".
+ * the glossary
+ * @ref GlossPeriodicConstraints "glossary entry on periodic boundary conditions".
*/
FullMatrix<double> matrix;
* DoFs of the second face. If @p first_vector_components is non empty the
* 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".
+ * more details see make_periodicity_constraints() and the glossary
+ * @ref GlossPeriodicConstraints "glossary entry on periodic boundary conditions".
*
* @tparam Container A type that satisfies the requirements of a mesh
* container (see @ref GlossMeshAsAContainer).
* DoFs of the second face. If @p first_vector_components is non empty the
* 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".
+ * more details see make_periodicity_constraints() and the glossary
+ * @ref GlossPeriodicConstraints "glossary entry on periodic boundary conditions".
*
* @tparam Container A type that satisfies the requirements of a mesh
* container (see @ref GlossMeshAsAContainer).
*
* @note This version of collect_periodic_face_pairs() will not work on
- * meshes with cells not in @ref GlossFaceOrientation "standard
- * orientation".
+ * meshes with cells not in
+ * @ref GlossFaceOrientation "standard orientation".
*
* @author Daniel Arndt, Matthias Maier, 2013, 2014
*/
* dependent of the dimension and there only exist specialized versions for
* distinct dimensions.
*
- * This class satisfies the requirements outlined in @ref
- * GlossMeshAsAContainer "Meshes as containers".
+ * This class satisfies the requirements outlined in
+ * @ref GlossMeshAsAContainer "Meshes as containers".
*
*
* <h3>Structure and iterators</h3>
/**
* A typedef that is used to to identify cell iterators. The concept of
- * iterators is discussed at length in the @ref Iterators "iterators
- * documentation module".
+ * iterators is discussed at length in the
+ * @ref Iterators "iterators documentation module".
*
* The current typedef identifies cells in a triangulation. The TriaIterator
* class works like a pointer that when you dereference it yields an object
typedef TriaIterator <CellAccessor<dim,spacedim> > cell_iterator;
/**
- * A typedef that is used to to identify @ref GlossActive "active cell
- * iterators". The concept of iterators is discussed at length in the @ref
- * Iterators "iterators documentation module".
+ * A typedef that is used to to identify
+ * @ref GlossActive "active cell iterators". The concept of iterators is
+ * discussed at length in the
+ * @ref Iterators "iterators documentation module".
*
* The current typedef identifies active cells in a triangulation. The
* TriaActiveIterator class works like a pointer to active objects that when
/**
* 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).
+ * mesh cells are inverted or severely distorted (see the entry on
+ * @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
*
* @note If the boundary description is sufficiently irregular, it can
* happen that some of the children produced by mesh refinement are
- * distorted (see the extensive discussion on @ref GlossDistorted "distorted
- * cells").
+ * distorted (see the extensive discussion on
+ * @ref GlossDistorted "distorted cells").
*
* @note This function is <tt>virtual</tt> to allow derived classes to
* insert hooks, such as saving refinement flags and the like (see e.g. the
void save_user_flags (std::vector<bool> &v) const;
/**
- * Read the information stored by @p save_user_flags. See also @ref
- * GlossUserFlags .
+ * Read the information stored by @p save_user_flags. See also
+ * @ref GlossUserFlags .
*/
void load_user_flags (std::istream &in);
/**
- * Read the information stored by @p save_user_flags. See also @ref
- * GlossUserFlags .
+ * Read the information stored by @p save_user_flags. See also
+ * @ref GlossUserFlags .
*/
void load_user_flags (const std::vector<bool> &v);
void save_user_indices (std::vector<unsigned int> &v) const;
/**
- * Read the information stored by save_user_indices(). See also @ref
- * GlossUserData .
+ * Read the information stored by save_user_indices(). See also
+ * @ref GlossUserData .
*/
void load_user_indices (const std::vector<unsigned int> &v);
void save_user_pointers (std::vector<void *> &v) const;
/**
- * Read the information stored by save_user_pointers(). See also @ref
- * GlossUserData .
+ * Read the information stored by save_user_pointers(). See also
+ * @ref GlossUserData .
*/
void load_user_pointers (const std::vector<void *> &v);
* level or the container with all objects of this dimension
* (<tt>structdim<dim</tt>).
*
- * Some internals of this class are discussed in @ref
- * IteratorAccessorInternals .
+ * Some internals of this class are discussed in
+ * @ref IteratorAccessorInternals .
*
* @ingroup grid
* @ingroup Accessors
/**
* 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.
+ * 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.
*/
const Manifold<dim,spacedim> &get_manifold () const;
void recursively_clear_user_flag () const;
/**
- * Reset the user data to zero, independent if pointer or index. See @ref
- * GlossUserData for more information.
+ * Reset the user data to zero, independent if pointer or index. See
+ * @ref GlossUserData for more information.
*/
void clear_user_data () const;
// ---------------------------------------------------------------------
//
-// Copyright (C) 1998 - 2013 by the deal.II authors
+// Copyright (C) 1998 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
/**
* One bool per cell to indicate the direction of the normal true: use
- * orientation from vertex false: revert the orientation. See @ref
- * GlossDirectionFlag .
+ * orientation from vertex false: revert the orientation. See
+ * @ref GlossDirectionFlag .
*
* This is only used for codim==1 meshes.
*/
/**
* Manage the distribution and numbering of the degrees of freedom for hp-
- * FEM algorithms. This class satisfies the requirements outlined in @ref
- * GlossMeshAsAContainer "Meshes as containers".
+ * FEM algorithms. This class satisfies the requirements outlined in
+ * @ref GlossMeshAsAContainer "Meshes as containers".
*
* The purpose of this class is to allow for an enumeration of degrees of
* freedom in the same way as the ::DoFHandler class, but it allows to use a
typedef typename ActiveSelector::active_hex_iterator active_hex_iterator;
/**
- * A typedef that is used to to identify @ref GlossActive "active cell
- * iterators". The concept of iterators is discussed at length in the @ref
- * Iterators "iterators documentation module".
+ * A typedef that is used to to identify
+ * @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.
* While the actual data type of the typedef is hidden behind a few layers
/**
* A typedef that is used to to identify cell iterators. The concept of
- * iterators is discussed at length in the @ref Iterators "iterators
- * documentation module".
+ * iterators is discussed at length in the
+ * @ref Iterators "iterators documentation module".
*
* The current typedef identifies cells in a DoFHandler object. Some of
- * these cells may in fact be active (see @ref GlossActive "active cell
- * iterators") in which case they can in 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.
+ * 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.
*
* While the actual data type of the typedef is hidden behind a few layers
* of (unfortunately necessary) indirections, it is in essence
// ---------------------------------------------------------------------
//
-// Copyright (C) 2003 - 2013 by the deal.II authors
+// Copyright (C) 2003 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
* collection. This number must be the same for all elements in the
* collection.
*
- * This function calls FiniteElement::n_components. See @ref
- * GlossComponent "the glossary" for more information.
+ * This function calls FiniteElement::n_components. See
+ * @ref GlossComponent "the glossary" for more information.
*/
unsigned int n_components () const;
* collection. While this class ensures that all elements stored in it
* 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().
+ * 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().
*/
unsigned int n_blocks () const;
/**
* Given a block mask (see @ref GlossBlockMask "this glossary entry"),
- * produce a component mask (see @ref GlossComponentMask "this glossary
- * entry") that represents the components that correspond to the blocks
- * selected in the input argument. This is essentially a conversion
- * operator from BlockMask to ComponentMask.
+ * produce a component mask (see
+ * @ref GlossComponentMask "this glossary entry") that represents the
+ * components that correspond to the blocks selected in the input
+ * argument. This is essentially a conversion operator from BlockMask
+ * to ComponentMask.
*
* @note This function is the equivalent of
* FiniteElement::component_mask() with the same arguments. It verifies
/**
* Return a 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.
+ * components are true that correspond to the given argument. See
+ * @ref GlossBlockMask "the glossary" for more information.
*
* @note The same caveat applies as to the version of the function above:
* The extractor object passed as argument must be so that it corresponds
block_mask (const FEValuesExtractors::SymmetricTensor<2> &sym_tensor) const;
/**
- * Given a component mask (see @ref GlossComponentMask "this glossary
- * entry"), produce a block mask (see @ref GlossBlockMask "this glossary
- * entry") that represents the blocks that correspond to the components
- * selected in the input argument. This is essentially a conversion
- * operator from ComponentMask to BlockMask.
+ * Given a component mask (see
+ * @ref GlossComponentMask "this glossary entry"), produce a block mask
+ * (see @ref GlossBlockMask "this glossary entry") that represents the
+ * blocks that correspond to the components selected in the input
+ * argument. This is essentially a conversion operator from
+ * ComponentMask to BlockMask.
*
* @note This function will only succeed if the components referenced by
* the argument encompasses complete blocks. In other words, if, for
// ---------------------------------------------------------------------
//
-// Copyright (C) 2008 - 2013 by the deal.II authors
+// Copyright (C) 2008 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
* this matrix.
*
* 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
+ * iterator classes, it is only really effective for objects of type
+ * @ref Vector. For all classes for which iterating over elements, or random
* member access is expensive, this function is not efficient. In
* particular, if you want to multiply with BlockVector objects, you should
* consider using a BlockChunkSparseMatrix as well.
* takes the transposed matrix.
*
* 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
+ * iterator classes, it is only really effective for objects of type
+ * @ref Vector. For all classes for which iterating over elements, or random
* member access is expensive, this function is not efficient. In
* particular, if you want to multiply with BlockVector objects, you should
* consider using a BlockChunkSparseMatrix as well.
* <i>M</i> being this matrix.
*
* 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
+ * iterator classes, it is only really effective for objects of type
+ * @ref Vector. For all classes for which iterating over elements, or random
* member access is expensive, this function is not efficient. In
* particular, if you want to multiply with BlockVector objects, you should
* consider using a BlockChunkSparseMatrix as well.
* as vmult_add() but takes the transposed matrix.
*
* 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
+ * iterator classes, it is only really effective for objects of type
+ * @ref Vector. For all classes for which iterating over elements, or random
* member access is expensive, this function is not efficient. In
* particular, if you want to multiply with BlockVector objects, you should
* consider using a BlockChunkSparseMatrix as well.
// ---------------------------------------------------------------------
//
-// Copyright (C) 2001 - 2013 by the deal.II authors
+// Copyright (C) 2001 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
*
* <h3>Notes</h3>
*
- * There are several, exchangeable variations of this class, see @ref
- * Sparsity, section '"Dynamic" or "compressed" sparsity patterns' for more
+ * There are several, exchangeable variations of this class, see
+ * @ref Sparsity, section '"Dynamic" or "compressed" sparsity patterns' for more
* information.
*
* This class is a variation of the CompressedSparsityPattern class. Instead
// ---------------------------------------------------------------------
//
-// Copyright (C) 2001 - 2013 by the deal.II authors
+// Copyright (C) 2001 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
*
* <h3>Notes</h3>
*
- * There are several, exchangeable variations of this class, see @ref
- * Sparsity, section '"Dynamic" or "compressed" sparsity patterns' for more
- * information.
+ * There are several, exchangeable variations of this class, see
+ * @ref Sparsity, section '"Dynamic" or "compressed" sparsity patterns' for
+ * more information.
*
* @author Timo Heister, 2008
*/
// ---------------------------------------------------------------------
//
-// Copyright (C) 2001 - 2013 by the deal.II authors
+// Copyright (C) 2001 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
template <typename number> class SparseMatrix;
-//TODO[WB]: Unify implementation with the CompressedSetSparsityPattern since really all that's different is the Line structure in the two classes. We should have a templatized base class that simply gets the particular Line structure from a derived class.
+// TODO[WB]: Unify implementation with the CompressedSetSparsityPattern
+// since really all that's different is the Line structure in the two
+// classes. We should have a templatized base class that simply gets the
+// particular Line structure from a derived class.
/*! @addtogroup Sparsity
*@{
*
* <h3>Notes</h3>
*
- * There are several, exchangeable variations of this class, see @ref
- * Sparsity, section '"Dynamic" or "compressed" sparsity patterns' for more
- * information.
+ * There are several, exchangeable variations of this class, see
+ * @ref Sparsity, section '"Dynamic" or "compressed" sparsity patterns' for
+ * more information.
*
* @author Wolfgang Bangerth, 2001
*/
* thousand or millions of unknowns are involved and for problems with many
* nonzero elements per row (for example for vector-valued problems or hp
* finite elements). In this case, it is advisable to use the
- * BlockCompressedSetSparsityPattern class instead, see for example @ref
- * step_27 "step-27" and @ref step_31 "step-31".
+ * BlockCompressedSetSparsityPattern class instead, see for example
+ * @ref step_27 "step-27" and @ref step_31 "step-31".
*/
void condense (BlockCompressedSparsityPattern &sparsity) const;
* This function simultaneously writes elements into matrix and vector,
* 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.
+ * the parameter use_inhomogeneities_for_rhs see the documentation in
+ * @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
* @note Instantiations for this template are provided for <tt>@<float@>,
* @<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).
+ * can be generated in application programs (see the section on
+ * @ref Instantiations in the manual).
*
* @author Guido Kanschat, Franz-Theo Suttmeier, Wolfgang Bangerth, 1993-2004
*/
* communication of indices. In particular, it stores the communication
* pattern, rather than having to compute it again for every
* communication. (For more information on ghost vectors, see also the
- * @ref GlossGhostedVector "glossary entry on vectors with ghost
- * elements".) - Besides the usual global access operator () it is also
+ * @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
* assembly routine involving ghosts that fill this vector. Note that the
* @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
+ * processor has set them to the desired value already. (See also the
+ * @ref GlossCompress "glossary entry on compress".) - The
* <code>update_ghost_values()</code> function imports the data from the
* owning processor to the ghost indices in order to provide read access
* to the data associated with ghosts. - It is possible to split the above
* this matrix.
*
* 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
+ * iterator classes, it is only really effective for objects of type
+ * @ref Vector. For all classes for which iterating over elements, or random
* member access is expensive, this function is not efficient. In
* particular, if you want to multiply with BlockVector objects, you should
* consider using a BlockSparseMatrix as well.
* takes the transposed matrix.
*
* 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
+ * iterator classes, it is only really effective for objects of type
+ * @ref Vector. For all classes for which iterating over elements, or random
* member access is expensive, this function is not efficient. In
* particular, if you want to multiply with BlockVector objects, you should
* consider using a BlockSparseMatrix as well.
* <i>M</i> being this matrix.
*
* 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
+ * iterator classes, it is only really effective for objects of type
+ * @ref Vector. For all classes for which iterating over elements, or random
* member access is expensive, this function is not efficient. In
* particular, if you want to multiply with BlockVector objects, you should
* consider using a BlockSparseMatrix as well.
* as vmult_add() but takes the transposed matrix.
*
* 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
+ * iterator classes, it is only really effective for objects of type
+ * @ref Vector. For all classes for which iterating over elements, or random
* member access is expensive, this function is not efficient. In
* particular, if you want to multiply with BlockVector objects, you should
* consider using a BlockSparseMatrix as well.
* elements of each of these blocks to be stored on the local process.
*
* @ingroup Vectors
- * @ingroup TrilinosWrappers @see @ref GlossBlockLA "Block (linear
- * algebra)"
+ * @ingroup TrilinosWrappers @see
+ * @ref GlossBlockLA "Block (linear algebra)"
* @author Martin Kronbichler, Wolfgang Bangerth, 2008, 2009
*/
class BlockVector : public BlockVectorBase<Vector>
* this vector element the next time you call compress(), as described
* above.
*
- * What we call a 'ghosted' vector (see @ref GlossGhostedVector "vectors
- * with ghost elements") is simply a view of the parallel vector where the
- * element distributions overlap. The 'ghosted' Trilinos vector in itself
- * has no idea of which entries are ghosted and which are locally owned.
- * In fact, a ghosted vector may not even store all of the elements a non-
- * ghosted vector would store on the current processor. Consequently, for
- * Trilinos vectors, there is no notion of an 'owner' of vector elements
- * in the way we have it in the the non-ghost case view.
+ * What we call a 'ghosted' vector (see
+ * @ref GlossGhostedVector "vectors with ghost elements") is simply a
+ * view of the parallel vector where the element distributions overlap.
+ * The 'ghosted' Trilinos vector in itself has no idea of which entries
+ * are ghosted and which are locally owned. In fact, a ghosted vector
+ * may not even store all of the elements a non- ghosted vector would
+ * store on the current processor. Consequently, for Trilinos vectors,
+ * there is no notion of an 'owner' of vector elements in the way we
+ * have it in the the non-ghost case view.
*
* This explains why we do not allow writing into ghosted vectors on the
* Trilinos side: Who would be responsible for taking care of the
* @note Instantiations for this template are provided for <tt>@<float@>,
* @<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).
+ * can be generated in application programs (see the section on
+ * @ref Instantiations in the manual).
*
* @author Guido Kanschat, Franz-Theo Suttmeier, Wolfgang Bangerth
*/
// ---------------------------------------------------------------------
//
-// Copyright (C) 2009 - 2013 by the deal.II authors
+// Copyright (C) 2009 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
* @note Instantiations for this template are provided for <tt>@<float@>,
* @<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).
+ * can be generated in application programs (see the section on
+ * @ref Instantiations in the manual).
*
* @author Luca Heltai, 2009
*/
// ---------------------------------------------------------------------
//
-// Copyright (C) 2010 - 2013 by the deal.II authors
+// Copyright (C) 2010 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
* 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.
// ---------------------------------------------------------------------
//
-// Copyright (C) 2001 - 2013 by the deal.II authors
+// Copyright (C) 2001 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
* Implementation of matrix generation for MGTransferBlock.
*
* 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.
+ * where multigrid is applied only to one ore some blocks, where a
+ * @ref GlossBlock comprises all degrees of freedom generated by one base element.
*
* @author Guido Kanschat, 2001-2003
*/
// ---------------------------------------------------------------------
//
-// Copyright (C) 1999 - 2013 by the deal.II authors
+// Copyright (C) 1999 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
* interpreted, i.e. whether each component of the data is logically an
* independent scalar field, or whether some of them together form logically a
* vector-field (see the
- * DataComponentInterpretation::DataComponentInterpretation enum, and the @ref
- * step_22 "step-22" tutorial program).
+ * DataComponentInterpretation::DataComponentInterpretation enum, and the
+ * @ref step_22 "step-22" tutorial program).
*
* It should be noted that this class does not copy the vector given to it
* through the add_data_vector() functions, for memory consumption reasons. It
// ---------------------------------------------------------------------
//
-// Copyright (C) 2009 - 2013 by the deal.II authors
+// Copyright (C) 2009 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
* weaknesses making each suitable for different contexts:
* <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
+ * 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
* </ol>
*
* When recording a new mnemonic name, the user must supply a component_mask
- * (see @ref GlossComponentMask "this glossary entry") to indicate the @ref
- * GlossComponent "(vector) components" to be extracted from the given 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.
+ * (see @ref GlossComponentMask "this glossary entry") to indicate the
+ * @ref GlossComponent "(vector) components" to be extracted from the given
+ * input. If the user simply wants to extract all the components, the mask
+ * need not be explicitly supplied to the @p add_field_name method and the
+ * default value of the parameter is sufficient. If the @p evaluate_field
+ * with a @p DataPostprocessor object is used, the component_mask is
+ * interpreted as the mask of the @p DataPostprocessor return vector. The
+ * size of this mask can be different to that of the FE space, but must be
+ * provided when the @p add_field_name method is called. One variant of the
+ * @p add_field_name method allows an unsigned int input to construct a
+ * suitable mask, if all values from the @p DataPostprocessor are desired.
*
* The class automatically generates names for the data stored based on the
* mnemonics supplied. The methods @p add_component_names and @p
* the vector elements $d_K$ for an output vector with as many cells as
* there are active cells of the triangulation object of the current
* processor. However, not all active cells are in fact locally owned: some
- * may be ghost or artificial cells (see @ref GlossGhostCell "here" and @ref
- * GlossArtificialCell "here"). The vector computed will, in the case of a
- * distributed triangulation, contain zeros for cells that are not locally
+ * 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
projects / dealii.git / commitdiff