]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Fix references to Boundary 5924/head
authorDaniel Arndt <daniel.arndt@iwr.uni-heidelberg.de>
Sun, 18 Feb 2018 11:59:35 +0000 (12:59 +0100)
committerDaniel Arndt <daniel.arndt@iwr.uni-heidelberg.de>
Tue, 20 Feb 2018 02:24:09 +0000 (03:24 +0100)
examples/step-32/doc/intro.dox
examples/step-38/doc/results.dox
examples/step-54/doc/intro.dox
include/deal.II/grid/grid_generator.h
include/deal.II/grid/manifold.h
include/deal.II/grid/manifold_lib.h

index 9c0d6d53260c2306e18a53bcd59eb550c8319380..7b125c0b1cde2c412046a558533ac7c9014a7bee 100644 (file)
@@ -629,7 +629,7 @@ the input file which one to use.
 In the program, we will use a spherical shell as domain. This means
 that the inner and outer boundary of the domain are no longer
 "straight" (by which we usually mean that they are bilinear surfaces
-that can be represented by the StraightBoundary class). Rather, they
+that can be represented by the FlatManifold class). Rather, they
 are curved and it seems prudent to use a curved approximation in the
 program if we are already using higher order finite elements for the
 velocity. Consequently, we will introduce a member variable of type
index d177a169e6765e079c3ce7a78a207ced20537a93..06b9bb82033e2e297861f5ba48863e3996636e7c 100644 (file)
@@ -111,15 +111,15 @@ above, this would look as follows:
 template <int spacedim>
 void LaplaceBeltrami<spacedim>::make_grid_and_dofs ()
 {
-  static HyperBallBoundary<dim,spacedim> surface_description;
-  triangulation.set_boundary (0, surface_description);
+  static SphericalManifold<dim,spacedim> surface_description;
+  triangulation.set_manifold (0, surface_description);
 
   {
-    HyperBallBoundary<spacedim> boundary_description;
+    SphericalManifold<spacedim> boundary_description;
     Triangulation<spacedim> volume_mesh;
     GridGenerator::half_hyper_ball(volume_mesh);
 
-    volume_mesh.set_boundary (0, boundary_description);
+    volume_mesh.set_manifold (0, boundary_description);
     volume_mesh.refine_global (4);
 
     std::set<unsigned char> boundary_ids;
@@ -127,8 +127,8 @@ void LaplaceBeltrami<spacedim>::make_grid_and_dofs ()
 
     GridGenerator::extract_boundary_mesh (volume_mesh, triangulation,
                                           boundary_ids);
-    triangulation.set_boundary (1);                            /* ** */
-    triangulation.set_boundary (0);                            /* ** */
+    triangulation.set_manifold (1);                            /* ** */
+    triangulation.set_manifold (0);                            /* ** */
     GridTools::transform (&warp<spacedim>, triangulation);     /* ** */
     std::ofstream x("x"), y("y");
     GridOut().write_gnuplot (volume_mesh, x);
@@ -147,7 +147,7 @@ asterisks. It is worth pointing out one other thing here, though: because we
 detach the manifold description from the surface mesh, whenever we use a
 mapping object in the rest of the program, it has no curves boundary
 description to go on any more. Rather, it will have to use the implicit,
-StraightBoundary class that is used on all parts of the boundary not
+FlatManifold class that is used on all parts of the domain not
 explicitly assigned a different manifold object. Consequently, whether we use
 MappingQ(2), MappingQ(15) or MappingQ1, each cell of our mesh will be mapped
 using a bilinear approximation.
index 739c812b160b7f54baf05d76e9f2110333ec4c56..b25388c7f39db2f9d809a6c56d179235efb79e43 100644 (file)
@@ -66,30 +66,28 @@ the OpenCASCADE framework. From a <code>TopoDS_Shape</code>, it is then
 possible to access all the sub-shapes (such as vertices, edges and faces)
 composing it, along with their geometrical description.  In the deal.II
 framework, the topological entities composing a shape are used to create
-objects of the Manifold or Boundary classes. In Step-6 we saw how to build a
-HyperBallBoundary and assign it to a set of faces (or cells, for co-dimension
+a corresponding Manifold representation. In Step-6 we saw how to build a
+SphericalManifold and assign it to a set of faces (or cells, for co-dimension
 1) of a Triangulation, to have cells and faces refined on a sphere or circle.
 The functions of the CAD modeling interface have been designed to retain the
 same structure, allowing the user to build a projector object using the
 imported CAD shapes, maintaining the very same procedure we use with
-HyperBallBoundary, i.e., assigning such projector object to cells, faces or
+SphericalManifold, i.e., assigning such projector object to cells, faces or
 edges of a coarse mesh. At each refinement cycle, the new mesh nodes will be
 then automatically generated by projecting a midpoint of an existing object
 onto the specified geometry.
 
 Differently from a spherical or circular boundary, a boundary with a complex
 geometry poses problems as to where it is best to place the new nodes created
-upon refinement on the prescribed shape.  HyperBallBoundary first creates the
-new nodes on the face or edge to be refined by averaging the surrounding
-points in the same way as FlatManifold does. Then, it goes on to project such
-nodes on the circle or sphere along the radial direction. On such a geometry,
-the radial direction ensures that the newly generated nodes remain evenly
-spaced when remaining on a given refinement level.
-
-In the case of an arbitrary and complex shape though, the best direction of
-the projection cannot be identified that easily.  The OpenCASCADE wrappers in
-deal.II provide several projector classes that employ different projection
-strategies. A first projector, implemented in the
+upon refinement on the prescribed shape. PolarManifold, for example, transforms
+the surrounding points to polar coordinates, calculates the average in that
+coordinate system (for each coordinate individually) and finally transforms
+the point back to Cartesian coordinates.
+
+In the case of an arbitrary and complex shape though, an appropriate choice for
+the placement of a new node cannot be identified that easily. The OpenCASCADE
+wrappers in deal.II provide several projector classes that employ different
+projection strategies. A first projector, implemented in the
 OpenCASCADE::ArclengthProjectionLineManifold class, is to be used only for
 edge refinement. It is built assigning it a topological shape of dimension
 one, either a <code>TopoDS_Edge</code> or a <code>TopoDS_Wire</code> (which is
index 946a84646bfa25d433a5c6b8c0dbf358975b25d6..175cdf55b06ee1b04f68078dcecd8be5fb92810b 100644 (file)
@@ -1127,12 +1127,12 @@ namespace GridGenerator
    * mesh. The surface mesh is then refined in the same way as the faces of
    * the volume mesh are. In order to ensure that the surface mesh has the
    * same vertices as the volume mesh, it is therefore important that you
-   * assign appropriate boundary objects through Triangulation::set_boundary()
-   * to the surface mesh object before calling this function. If you don't,
-   * the refinement will happen under the assumption that all faces are
-   * straight (i.e using the StraightBoundary class) rather than any curved
-   * boundary object you may want to use to determine the location of new
-   * vertices.
+   * assign appropriate boundary descriptions through
+   * Triangulation::set_manifold() to the surface mesh object before calling
+   * this function. If you don't, the refinement will happen under the
+   * assumption that all faces are straight (i.e using the FlatManifold class)
+   * rather than utilizing the Manifold object you may want to use to determine
+   * the location of new vertices.
    *
    * @tparam MeshType A type that satisfies the requirements of the
    * @ref ConceptMeshType "MeshType concept".
index e3edfbfba173a38834c6de3ff7e8a5289ee18fc5..34fcc77462c0d02670906f33b5d885023766c2c7 100644 (file)
@@ -605,7 +605,7 @@ public:
    * The face iterator gives an indication which face this function is
    * supposed to compute the normal vector for.  This is useful if the
    * boundary of the domain is composed of different nondifferential
-   * pieces (for example when using the StraightBoundary class to
+   * pieces (for example when using the FlatManifold class to
    * approximate a geometry that is completely described by the coarse
    * mesh, with piecewise (bi-)linear components between the vertices,
    * but where the boundary may have a kink at the vertices itself).
index c019ba58da0cdb8521a9694cbe6ead6ec5e538b8..75e69f78df1201254700e081c062c3560d407f5d 100644 (file)
@@ -45,7 +45,7 @@ DEAL_II_NAMESPACE_OPEN
  *
  * This class works by transforming points to polar coordinates (in
  * both two and three dimensions), taking the average in that
- * coordinate system, and then transforming back the point to
+ * coordinate system, and then transforming the point back to
  * Cartesian coordinates. In order for this manifold to work
  * correctly, it cannot be attached to cells containing the center of
  * the coordinate system or the north and south poles in three

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.