/**
* 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.
/**
* 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
+ * @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
/**
* Given a block mask (see
- * @ref GlossBlockMask "this glossary entry"), produce a component 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
/**
* Given a component mask (see
- * @ref GlossComponentMask "this glossary entry"), produce a block 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.
* 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
- * 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
- * line "Mesh.MshFileVersion = 1" to the input file.
+ * 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 line
+ * "Mesh.MshFileVersion = 1" to the input file.
*
* <li> <tt>Gmsh 2.0 mesh</tt> format: this is a variant of the above format.
* The read_msh() function automatically determines whether an input file is
* 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
+ * @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>
* parallel::distributed::Triangulation object. There, refining a mesh
* always involves a re-partitioning. In other words, vertices of locally
* owned cells (see
- * @ref GlossLocallyOwnedCell "this glossary entry") that you may have
- * moved to a different location on one processor may be moved to a
- * different processor upon mesh refinement (even if these particular cells
- * were not refined) which will re-create their position based on the
- * position of the coarse cells they previously had, not based on the
- * position these vertices had on the processor that previously owned them.
- * In other words, in parallel computations, you will probably have to move
- * nodes explicitly after every mesh refinement because vertex positions may
- * or may not be preserved across the re-partitioning that accompanies mesh
- * refinement.
+ * @ref GlossLocallyOwnedCell "this glossary entry") that you may have moved
+ * to a different location on one processor may be moved to a different
+ * processor upon mesh refinement (even if these particular cells were not
+ * refined) which will re-create their position based on the position of the
+ * coarse cells they previously had, not based on the position these
+ * vertices had on the processor that previously owned them. In other words,
+ * in parallel computations, you will probably have to move nodes explicitly
+ * after every mesh refinement because vertex positions may or may not be
+ * preserved across the re-partitioning that accompanies mesh refinement.
*/
Point<spacedim> &vertex (const unsigned int i) const;
* 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
+ * @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
* @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
projects / dealii.git / commitdiff