const bool colorize = false);
/**
- * Initialize the given triangulation with several coarse mesh cells
+ * Initialize the given triangulation with several
+ * @ref GlossCoarseMesh "coarse mesh cells"
* that cover a hyperball, i.e. a circle or a
* ball around @p center with given @p radius.
*
/**
* Produce a grid consisting of concentric shells. The primary difference
- * between this function and GridGenerator::hyper_shell is that this
- * function permits unevenly spaced (in the radial direction) coarse level
- * cells.
+ * between this function and GridGenerator::hyper_shell() is that this
+ * function permits unevenly spaced (in the radial direction)
+ * @ref GlossCoarseMesh "coarse level cells".
*
* The parameters @p center, @p inner_radius, and @p outer_radius behave in
* the same way as the first three arguments to
*
* This function is most often used to compose meshes for more complicated
* geometries if the geometry can be composed of simpler parts for which
- * functions exist to generate coarse meshes. For example, the channel mesh
+ * functions exist to generate
+ * @ref GlossCoarseMesh "coarse meshes". For example, the channel mesh
* used in step-35 could in principle be created using a mesh created by the
* GridGenerator::hyper_cube_with_cylindrical_hole function and several
* rectangles, and merging them using the current function. The rectangles
* This will merge any vertices that are closer than any pair of vertices on
* the input meshes.
*
- * @note The two input triangulations must be coarse meshes that have no
+ * @note The two input triangulations must be
+ * @ref GlossCoarseMesh "coarse meshes", i.e., they can not have any
* refined cells.
*
* @note The function copies the material ids of the cells of the two input
*
* @note This function is intended to create an adaptively refined
* triangulation that contains the <i>most refined cells</i> from two input
- * triangulations that were derived from the <i>same</i> coarse grid by
+ * triangulations that were derived from the <i>same</i>
+ * @ref GlossCoarseMesh "coarse mesh" by
* adaptive refinement. This is an operation sometimes needed when one
* solves for two variables of a coupled problem on separately refined
* meshes on the same domain (for example because these variables have
* needs to have a mesh for the domain that is at least as fine as each of
* the two initial meshes. This function computes such a mesh.
*
- * @note If you want to create a mesh that is the merger of two other coarse
- * meshes, for example in order to compose a mesh for a complicated geometry
+ * @note If you want to create a mesh that is the merger of two other
+ * @ref GlossCoarseMesh "coarse meshes", for example in order to compose
+ * a mesh for a complicated geometry
* from meshes for simpler geometries, then this is not the function for
* you. Instead, consider GridGenerator::merge_triangulations().
*
* Note that numbers::flat_manifold_id (should it be a manifold id of @p
* input) will always be the last entry in the first category.
*
- * @note The 2d input triangulation @p input must be a coarse mesh that has
- * no refined cells.
+ * @note The 2d input triangulation @p input must be a
+ * @ref GlossCoarseMesh "coarse mesh", i.e., it cannot have any
+ * refined cells.
*
- * @note Since @p input and @p output have different spatial dimensions no
+ * @note Since @p input and @p output have different spatial dimensions, no
* manifold objects are copied by this function regardless of the value of
* @p copy_manifold_ids.
*/
* walls in z direction. The bottom and top get the next two free boundary
* indicators.
*
- * @note The 2d input triangulation @p input must be a coarse mesh that has
- * no refined cells.
+ * @note The 2d input triangulation @p input must be a
+ * @ref GlossCoarseMesh "coarse mesh", i.e., it cannot have any
+ * refined cells.
*
* @note Since @p input and @p output have different spatial dimensions no
* manifold objects are copied (nor are any manifold ids set) by this
* to the corresponding faces on the volume one. This mapping is the return
* value of the function.
*
- * @note The function builds the surface mesh by creating a coarse mesh from
+ * @note The function builds the surface mesh by creating a
+ * @ref GlossCoarseMesh "coarse mesh" from
* the selected faces of the coarse cells of the volume mesh. It copies the
* boundary indicators of these faces to the cells of the coarse surface
* mesh. The surface mesh is then refined in the same way as the faces of
* It would seem that in two space dimensions, the maximum jump in levels
* between cells sharing a common vertex is two (as in the example above).
* However, this is not true if more than four cells meet at a vertex. It
- * is not uncommon that a coarse (initial) mesh contains vertices at which
+ * is not uncommon that a
+ * @ref GlossCoarseMesh "coarse (initial) mesh" contains vertices at which
* six or even eight cells meet, when small features of the domain have to
* be resolved even on the coarsest mesh. In that case, the maximum
* difference in levels is three or four, respectively. The problem gets
*/
patch_level_1 = 0x4,
/**
- * Each coarse grid cell is refined at least once, i.e. the triangulation
+ * Each @ref GlossCoarseMesh "coarse grid" cell is refined at least once,
+ * i.e., the triangulation
* might have active cells on level 1 but not on level 0. This flag
* ensures that a mesh which has coarsest_level_1 has still
* coarsest_level_1 after coarsening and refinement. It is, however, the
* Create a triangulation from a list of vertices and a list of cells, each
* of the latter being a list of <tt>1<<dim</tt> vertex indices. The
* triangulation must be empty upon calling this function and the cell list
- * should be useful (connected domain, etc.).
+ * should be useful (connected domain, etc.). The result of calling this
+ * function is a @ref GlossCoarseMesh "coarse mesh".
*
* Material data for the cells is given within the @p cells array, while
* boundary information is given in the @p subcelldata field.
projects / dealii.git / commitdiff