*
* 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
- * here. If you have previously called distribute_mg_dofs(),
- * the same is done on each level of the multigrid hierarchy. Additionally,
- * the block structure on each cell can be generated in this object by
- * calling initialize_local_block_info().
+ * here. If you have previously called distribute_mg_dofs(), the same is
+ * done on each level of the multigrid hierarchy. Additionally, the block
+ * structure on each cell can be generated in this object by calling
+ * initialize_local_block_info().
*/
const BlockInfo &block_info() const;
const unsigned int version);
/**
- * Declare the classes that store levels and faces of DoFs
- * friends so that they can resize arrays.
+ * Declare the classes that store levels and faces of DoFs friends so
+ * that they can resize arrays.
*/
template <int> friend class DoFLevel;
template <int> friend class DoFFaces;
/**
* This function computes the renumbering vector on each level needed by the
* sort_selected_dofs_back() function. Does not perform the renumbering on
- * the DoFHandler dofs but only computes the renumbering and returns
- * the renumbering vector.
+ * the DoFHandler dofs but only computes the renumbering and returns the
+ * renumbering vector.
*
* @pre The @p selected_dofs array must have as many elements as the @p
* dof_handler has degrees of freedom on the given level.
/**
* Given two mesh containers (i.e. objects of type Triangulation,
- * DoFHandler, or hp::DoFHandler) that are based on the same
- * coarse mesh, this function figures out a set of cells that are matched
- * between the two meshes and where at most one of the meshes is more
- * refined on this cell. In other words, it finds the smallest cells that
- * are common to both meshes, and that together completely cover the domain.
+ * DoFHandler, or hp::DoFHandler) that are based on the same coarse mesh,
+ * this function figures out a set of cells that are matched between the two
+ * meshes and where at most one of the meshes is more refined on this cell.
+ * In other words, it finds the smallest cells that are common to both
+ * meshes, and that together completely cover the domain.
*
* This function is useful, for example, in time-dependent or nonlinear
* application, where one has to integrate a solution defined on one mesh
/**
* The same function as above, but working on arguments of type DoFHandler,
- * or hp::DoFHandler. This function is provided to allow
- * calling have_same_coarse_mesh for all types of containers representing
+ * or hp::DoFHandler. This function is provided to allow calling
+ * have_same_coarse_mesh for all types of containers representing
* triangulations or the classes built on triangulations.
*
* @tparam Container A type that satisfies the requirements of a mesh
/*@{*/
/**
- * Copy boundary ids to manifold ids. The default manifold_id for
- * new Triangulation objects is numbers::invalid_manifold_id. This
- * function copies the boundary_ids of the boundary faces to the
- * manifold_ids of the same faces, allowing the user to change the
- * boundary_ids and use them for boundary conditions regardless of
- * the geometry, which will use manifold_ids to create new
- * points. Only active cells will be iterated over. This is a
- * function you'd typically call when there is only one active level
- * on your Triangulation.
- *
- * The optional parameter @p reset_boundary_ids, indicates wether
- * this function should reset the boundary_ids of the Triangulation
- * to its default value 0 after copying its value to the
- * manifold_id. By default, boundary_ids are left untouched.
+ * Copy boundary ids to manifold ids. The default manifold_id for new
+ * Triangulation objects is numbers::invalid_manifold_id. This function
+ * copies the boundary_ids of the boundary faces to the manifold_ids of the
+ * same faces, allowing the user to change the boundary_ids and use them for
+ * boundary conditions regardless of the geometry, which will use
+ * manifold_ids to create new points. Only active cells will be iterated
+ * over. This is a function you'd typically call when there is only one
+ * active level on your Triangulation.
+ *
+ * The optional parameter @p reset_boundary_ids, indicates wether this
+ * function should reset the boundary_ids of the Triangulation to its
+ * default value 0 after copying its value to the manifold_id. By default,
+ * boundary_ids are left untouched.
*
* @ingroup manifold
* @ingroup boundary
const bool reset_boundary_ids=false);
/**
- * Copy material ids to manifold ids. The default manifold_id for
- * new Triangulation objects is numbers::invalid_manifold_id. When
- * refinements occurs, the Triangulation asks where to locate new
- * points to the underlying manifold.
- *
- * When reading a Triangulation from a supported input format,
- * typical informations that can be stored in a file are boundary
- * conditions for boundary faces (which we store in the boundary_id
- * of the faces), material types for cells (which we store in the
- * material_id of the cells) and in some cases subdomain ids for
- * cells (which we store in the subdomain_id of the cell).
- *
- * If you read one of these grids into a Triangulation, you might
- * still want to use the material_id specified in the input file as
- * a manifold_id description. In this case you can associate a
- * Manifold object to internal cells, and this object will be used
- * by the Triangulation to query Manifold objects for new
- * points. This function iterates over active cells and copies the
- * material_ids to the manifold_ids.
+ * Copy material ids to manifold ids. The default manifold_id for new
+ * Triangulation objects is numbers::invalid_manifold_id. When refinements
+ * occurs, the Triangulation asks where to locate new points to the
+ * underlying manifold.
+ *
+ * When reading a Triangulation from a supported input format, typical
+ * informations that can be stored in a file are boundary conditions for
+ * boundary faces (which we store in the boundary_id of the faces), material
+ * types for cells (which we store in the material_id of the cells) and in
+ * some cases subdomain ids for cells (which we store in the subdomain_id of
+ * the cell).
+ *
+ * If you read one of these grids into a Triangulation, you might still want
+ * to use the material_id specified in the input file as a manifold_id
+ * description. In this case you can associate a Manifold object to internal
+ * cells, and this object will be used by the Triangulation to query
+ * Manifold objects for new points. This function iterates over active cells
+ * and copies the material_ids to the manifold_ids.
*
* The optional parameter @p compute_face_ids, indicates wether this
- * function should also set the manifold_ids of the faces (both for
- * internal faces and for faces on the boundary). If set to true,
- * then each face will get a manifold_id equal to the minimum of the
- * surrounding manifold_ids, ensuring that a unique manifold id is
- * selected for each face of the Triangulation. By default, face
- * manifold_ids are not computed.
+ * function should also set the manifold_ids of the faces (both for internal
+ * faces and for faces on the boundary). If set to true, then each face will
+ * get a manifold_id equal to the minimum of the surrounding manifold_ids,
+ * ensuring that a unique manifold id is selected for each face of the
+ * Triangulation. By default, face manifold_ids are not computed.
*
* @ingroup manifold
*
*
* The implementation of this class is such that not only cell iterators into
* triangulations can be mapped, but also iterators into objects of type
- * DoFHandler or hp::DoFHandler. The extension to other classes
- * offering iterator functions and some minor additional requirements is
- * simple.
+ * DoFHandler or hp::DoFHandler. The extension to other classes offering
+ * iterator functions and some minor additional requirements is simple.
*
* Note that this class could in principle be based on the C++
- * <tt>std::map<Key,Value></tt> data type. Instead, it uses another data format
- * which is more effective both in terms of computing time for access as well
- * as with regard to memory consumpion.
+ * <tt>std::map<Key,Value></tt> data type. Instead, it uses another data
+ * format which is more effective both in terms of computing time for access
+ * as well as with regard to memory consumpion.
*
*
* <h3>Usage</h3>
* but you may write your own version (non-virtual, since we use templates) to
* add functionality.
*
- * The accessors provided by the library consists of two groups,
- * determined by whether they access the data of Triangulation objects or
+ * The accessors provided by the library consists of two groups, determined by
+ * whether they access the data of Triangulation objects or
* DoFHandler/hp::DoFHandler objects. They are derived from TriaAccessor and
* DoFAccessor, respectively. Each group also has specialized accessors for
* cells (as opposed to faces and lines) that offer more functionality such as
* The vector is designed for the following scheme of parallel
* partitioning:
* <ul>
- * <li> The indices held by individual processes
- * (locally owned part) in the MPI parallelization form a contiguous range
+ * <li> 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>.
- * <li> 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 indices is determined when calling the function <code>reinit
- * (locally_owned, ghost_indices, communicator)</code>, and retained until
- * the partitioning is changed. This allows for efficient parallel
- * 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
+ * <li> 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 indices is determined when calling
+ * the function <code>reinit (locally_owned, ghost_indices,
+ * communicator)</code>, and retained until the partitioning is changed.
+ * This allows for efficient parallel 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".
- * <li> 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
+ * <li> 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()).
* </ul>
*
* Functions related to parallel functionality:
* <ul>
- * <li> 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
- * 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
+ * <li> 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 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").
- * <li> 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.
- * <li> 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.
+ * <li> 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.
+ * <li> 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.
* <li> Of course, reduction operations (like norms) make use of
* collective all-to-all MPI communications.
* </ul>
* This vector can take two different states with respect to ghost
* elements:
* <ul>
- * <li> 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.
+ * <li> 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.
* <li> After a call to update_ghost_values(), the vector does not allow
* writing into ghost elements but only reading from them. This is to
* avoid undesired ghost data artifacts when calling compress() after
const MPI_Comm &communicator);
/**
- * Initialize this matrix to have the same structure as @p other. This will not copy
- * the values of the other matrix, but you can use copy_from() for this.
+ * Initialize this matrix to have the same structure as @p other. This
+ * will not copy the values of the other matrix, but you can use
+ * copy_from() for this.
*/
void reinit (const SparseMatrix &other);
*
* This class implements the step() and Tstep() functions expected by
* SolverRelaxation and MGSmootherRelaxation. They perform an additive Schwarz
- * method on the blocks provided in the block list of AdditionalData. Differing
- * from PreconditionBlockJacobi, these blocks may be of varying size, non-
- * contiguous, and overlapping. On the other hand, this class does not
- * implement the preconditioner interface expected by Solver objects.
+ * method on the blocks provided in the block list of AdditionalData.
+ * Differing from PreconditionBlockJacobi, these blocks may be of varying
+ * size, non- contiguous, and overlapping. On the other hand, this class does
+ * not implement the preconditioner interface expected by Solver objects.
*
* @ingroup Preconditioners
* @author Guido Kanschat
*
* This class implements the step() and Tstep() functions expected by
* SolverRelaxation and MGSmootherRelaxation. They perform a multiplicative
- * Schwarz method on the blocks provided in the block list of AdditionalData in
- * symmetric fashion. Differing from PreconditionBlockSSOR, these blocks may
- * be of varying size, non-contiguous, and overlapping. On the other hand,
+ * Schwarz method on the blocks provided in the block list of AdditionalData
+ * in symmetric fashion. Differing from PreconditionBlockSSOR, these blocks
+ * may be of varying size, non-contiguous, and overlapping. On the other hand,
* this class does not implement the preconditioner interface expected by
* Solver objects.
*
* value (@p NaN). Note, however, that this check is only performed if the
* @p isnan function is provided by the operating system, which is not
* always true. The @p configure scripts checks for this and sets the flag
- * @p DEAL_II_HAVE_ISNAN in the include file
- * <tt>deal.II/base/config.h</tt> if this function was found.
+ * @p DEAL_II_HAVE_ISNAN in the include file <tt>deal.II/base/config.h</tt>
+ * if this function was found.
*
* <tt>check()</tt> additionally preserves @p step and @p check_value. These
* values are accessible by <tt>last_value()</tt> and <tt>last_step()</tt>.
void reinit (const SparsityPattern &sparsity_pattern);
/**
- * This function copies the layout of @p sparse_matrix to the
- * calling matrix. The values are not copied, but you can use
- * copy_from() for this.
+ * This function copies the layout of @p sparse_matrix to the calling
+ * matrix. The values are not copied, but you can use copy_from() for
+ * this.
*
* This is a collective operation that needs to be called on all
* processors in order to avoid a dead lock.
/**
* The number of the current face on the current cell.
*
- * This number is numbers::invalid_unsigned_int if the info object
- * was initialized with a cell.
+ * This number is numbers::invalid_unsigned_int if the info object was
+ * initialized with a cell.
*/
unsigned int face_number;
/**
* The number of the current subface on the current face
*
- * This number is numbers::invalid_unsigned_int if the info object
- * was not initialized with a subface.
+ * This number is numbers::invalid_unsigned_int if the info object was not
+ * initialized with a subface.
*/
unsigned int sub_number;
/**
* A memory object to be used for temporary vectors.
*
- * The object is marked as mutable since we will need to use it
- * to allocate temporary vectors also in functions that are
- * const.
+ * The object is marked as mutable since we will need to use it to allocate
+ * temporary vectors also in functions that are const.
*/
mutable GrowingVectorMemory<VECTOR> vector_memory;
{
public:
/**
- * Destructor. This function doesn't actually do anything but
- * is marked as virtual to ensure that data postprocessors can
- * be destroyed through pointers to the base class.
+ * Destructor. This function doesn't actually do anything but is marked as
+ * virtual to ensure that data postprocessors can be destroyed through
+ * pointers to the base class.
*/
virtual ~DataPostprocessor ();
*
* Once the FEFieldFunction knows where the points lie, it creates a
* quadrature formula for those points, and calls
- * FEValues::get_function_values or FEValues::get_function_gradients with the
- * given quadrature points.
+ * FEValues::get_function_values or FEValues::get_function_gradients with
+ * the given quadrature points.
*
* If you only need the quadrature points but not the values of the finite
* element function (you might want this for the adjoint interpolation), you