]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Revert some backwards-incompatible changes to GridGenerator. 18392/head
authorDavid Wells <drwells@email.unc.edu>
Sat, 26 Apr 2025 16:34:13 +0000 (12:34 -0400)
committerDavid Wells <drwells@email.unc.edu>
Wed, 28 May 2025 19:23:38 +0000 (15:23 -0400)
There's no way to gracefully handle these.

include/deal.II/grid/grid_generator.h
source/grid/grid_generator.cc
source/grid/grid_generator.inst.in
source/grid/grid_generator_from_name.cc
tests/grid/grid_generator_from_name_and_argument_02.cc
tests/grid/grid_generator_from_name_and_argument_02.output

index b41a125b76c8d45cb51c415f218b98a03c889356..2543f4da5fc5782afc8881dde45511002cea050b 100644 (file)
@@ -2655,14 +2655,9 @@ namespace GridGenerator
    * The number of vertices in coordinate
    * direction @p i is given by <tt>repetitions[i]+1</tt>.
    *
-   * This function takes the mesh produced by subdivided_hyper_rectangle() and
-   * further subdivides each cell. For @p dim 2, it subdivides each cell into 2
-   * triangles.  For @p dim 3, it subdivides each cell into 5 or 6 tetrahedra
-   * based on the value of @p periodic. If @p periodic is true, then we split
-   * each cell into 6 cells so that each face of the rectangular prism has
-   * the same stencil, enabling periodicity. If @p periodic is false, we
-   * instead subdivide each hexahedral cell into 5 tetrahedra. If @p dim is not
-   * 3, then @p periodic has no effect.
+   * @note This function takes the mesh produced by subdivided_hyper_rectangle()
+   * and further subdivides each cell into 2 triangles (for @p dim 2) or
+   * 5 tetrahedra (for @p dim 3), respectively.
    *
    * @note Currently, this function only works for `dim==spacedim`.
    *
@@ -2676,8 +2671,7 @@ namespace GridGenerator
     const std::vector<unsigned int> &repetitions,
     const Point<dim>                &p1,
     const Point<dim>                &p2,
-    const bool                       colorize = false,
-    const bool                       periodic = false);
+    const bool                       colorize = false);
 
   /**
    * Initialize the given triangulation with a hypercube (square in 2d and
@@ -2689,14 +2683,9 @@ namespace GridGenerator
    * the limits are given as arguments. They default to zero and unity, then
    * producing the unit hypercube.
    *
-   * This function takes the mesh produced by subdivided_hyper_cube() and
-   * further subdivides each cell. For @p dim 2, it subdivides each cell into 2
-   * triangles.  For @p dim 3, it subdivides each cell into 5 or 6 tetrahedra
-   * based on the value of @p periodic. If @p periodic is true, then we split
-   * each cell into 6 cells so that each face of the rectangular prism has
-   * the same stencil, enabling periodicity. If @p periodic is false, we
-   * instead subdivide each hexahedral cell into 5 tetrahedra. If @p dim is not
-   * 3, then @p periodic has no effect.
+   * @note This function takes the mesh produced by subdivided_hyper_cube()
+   * and further subdivides each cell into 2 triangles (for @p dim 2) or
+   * 5 tetrahedra (for @p dim 3), respectively.
    *
    * Also see
    * @ref simplex "Simplex support".
@@ -2707,8 +2696,7 @@ namespace GridGenerator
                                        const unsigned int repetitions,
                                        const double       p1       = 0.0,
                                        const double       p2       = 1.0,
-                                       const bool         colorize = false,
-                                       const bool         periodic = false);
+                                       const bool         colorize = false);
 
   /** @} */
 
index ff80925162c961ef45529ab775a1e5e6444b5370..d12fa1afab07f921b72343ff8d1c5acf8c1729ae 100644 (file)
@@ -22,7 +22,6 @@
 #include <deal.II/grid/filtered_iterator.h>
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/grid_tools.h>
-#include <deal.II/grid/grid_tools_topology.h>
 #include <deal.II/grid/intergrid_map.h>
 #include <deal.II/grid/manifold_lib.h>
 #include <deal.II/grid/tria.h>
@@ -9048,348 +9047,179 @@ namespace GridGenerator
 
 
 
-  // Hide the implementation for two cases of
-  // subdivided_hyper_rectangle_with_simplices in an anonymous namespace.
-  namespace
+  template <int dim, int spacedim>
+  void
+  subdivided_hyper_rectangle_with_simplices(
+    Triangulation<dim, spacedim>    &tria,
+    const std::vector<unsigned int> &repetitions,
+    const Point<dim>                &p1,
+    const Point<dim>                &p2,
+    const bool                       colorize)
   {
-    template <int dim, int spacedim>
-    void
-    subdivided_hyper_rectangle_with_simplices_no_periodic(
-      Triangulation<dim, spacedim>    &tria,
-      const std::vector<unsigned int> &repetitions,
-      const Point<dim>                &p1,
-      const Point<dim>                &p2,
-      const bool                       colorize)
-    {
-      AssertDimension(dim, spacedim);
-
-      std::vector<Point<spacedim>> vertices;
-      std::vector<CellData<dim>>   cells;
-
-      if (dim == 2)
-        {
-          // determine cell sizes
-          const Point<dim> dx((p2[0] - p1[0]) / repetitions[0],
-                              (p2[1] - p1[1]) / repetitions[1]);
-
-          // create vertices
-          for (unsigned int j = 0; j <= repetitions[1]; ++j)
-            for (unsigned int i = 0; i <= repetitions[0]; ++i)
-              vertices.push_back(
-                Point<spacedim>(p1[0] + dx[0] * i, p1[1] + dx[1] * j));
-
-          // create cells
-          for (unsigned int j = 0; j < repetitions[1]; ++j)
-            for (unsigned int i = 0; i < repetitions[0]; ++i)
-              {
-                // create reference QUAD cell
-                std::array<unsigned int, 4> quad{{
-                  (j + 0) * (repetitions[0] + 1) + i + 0, //
-                  (j + 0) * (repetitions[0] + 1) + i + 1, //
-                  (j + 1) * (repetitions[0] + 1) + i + 0, //
-                  (j + 1) * (repetitions[0] + 1) + i + 1  //
-                }};                                       //
-
-                // TRI cell 0
-                {
-                  CellData<dim> tri;
-                  tri.vertices = {quad[0], quad[1], quad[2]};
-                  cells.push_back(tri);
-                }
-
-                // TRI cell 1
-                {
-                  CellData<dim> tri;
-                  tri.vertices = {quad[3], quad[2], quad[1]};
-                  cells.push_back(tri);
-                }
-              }
-        }
-      else if (dim == 3)
-        {
-          // determine cell sizes
-          const Point<dim> dx((p2[0] - p1[0]) / repetitions[0],
-                              (p2[1] - p1[1]) / repetitions[1],
-                              (p2[2] - p1[2]) / repetitions[2]);
-
-          // create vertices
-          for (unsigned int k = 0; k <= repetitions[2]; ++k)
-            for (unsigned int j = 0; j <= repetitions[1]; ++j)
-              for (unsigned int i = 0; i <= repetitions[0]; ++i)
-                vertices.push_back(Point<spacedim>(p1[0] + dx[0] * i,
-                                                   p1[1] + dx[1] * j,
-                                                   p1[2] + dx[2] * k));
-
-          // create cells
-          for (unsigned int k = 0; k < repetitions[2]; ++k)
-            for (unsigned int j = 0; j < repetitions[1]; ++j)
-              for (unsigned int i = 0; i < repetitions[0]; ++i)
-                {
-                  // create reference HEX cell
-                  std::array<unsigned int, 8> quad{
-                    {(k + 0) * (repetitions[0] + 1) * (repetitions[1] + 1) +
-                       (j + 0) * (repetitions[0] + 1) + i + 0,
-                     (k + 0) * (repetitions[0] + 1) * (repetitions[1] + 1) +
-                       (j + 0) * (repetitions[0] + 1) + i + 1,
-                     (k + 0) * (repetitions[0] + 1) * (repetitions[1] + 1) +
-                       (j + 1) * (repetitions[0] + 1) + i + 0,
-                     (k + 0) * (repetitions[0] + 1) * (repetitions[1] + 1) +
-                       (j + 1) * (repetitions[0] + 1) + i + 1,
-                     (k + 1) * (repetitions[0] + 1) * (repetitions[1] + 1) +
-                       (j + 0) * (repetitions[0] + 1) + i + 0,
-                     (k + 1) * (repetitions[0] + 1) * (repetitions[1] + 1) +
-                       (j + 0) * (repetitions[0] + 1) + i + 1,
-                     (k + 1) * (repetitions[0] + 1) * (repetitions[1] + 1) +
-                       (j + 1) * (repetitions[0] + 1) + i + 0,
-                     (k + 1) * (repetitions[0] + 1) * (repetitions[1] + 1) +
-                       (j + 1) * (repetitions[0] + 1) + i + 1}};
-
-                  // TET cell 0
-                  {
-                    CellData<dim> cell;
-                    if (((i % 2) + (j % 2) + (k % 2)) % 2 == 0)
-                      cell.vertices = {{quad[0], quad[1], quad[2], quad[4]}};
-                    else
-                      cell.vertices = {{quad[0], quad[1], quad[3], quad[5]}};
-
-                    cells.push_back(cell);
-                  }
-
-                  // TET cell 1
-                  {
-                    CellData<dim> cell;
-                    if (((i % 2) + (j % 2) + (k % 2)) % 2 == 0)
-                      cell.vertices = {{quad[2], quad[1], quad[3], quad[7]}};
-                    else
-                      cell.vertices = {{quad[0], quad[3], quad[2], quad[6]}};
-                    cells.push_back(cell);
-                  }
-
-                  // TET cell 2
-                  {
-                    CellData<dim> cell;
-                    if (((i % 2) + (j % 2) + (k % 2)) % 2 == 0)
-                      cell.vertices = {{quad[1], quad[4], quad[5], quad[7]}};
-                    else
-                      cell.vertices = {{quad[0], quad[4], quad[5], quad[6]}};
-                    cells.push_back(cell);
-                  }
-
-                  // TET cell 3
-                  {
-                    CellData<dim> cell;
-                    if (((i % 2) + (j % 2) + (k % 2)) % 2 == 0)
-                      cell.vertices = {{quad[2], quad[4], quad[7], quad[6]}};
-                    else
-                      cell.vertices = {{quad[3], quad[5], quad[7], quad[6]}};
-                    cells.push_back(cell);
-                  }
-
-                  // TET cell 4
-                  {
-                    CellData<dim> cell;
-                    if (((i % 2) + (j % 2) + (k % 2)) % 2 == 0)
-                      cell.vertices = {{quad[1], quad[2], quad[4], quad[7]}};
-                    else
-                      cell.vertices = {{quad[0], quad[3], quad[6], quad[5]}};
-                    cells.push_back(cell);
-                  }
-                }
-        }
-      else
-        {
-          AssertThrow(false, ExcNotImplemented());
-        }
-
-      // actually create triangulation
-      tria.create_triangulation(vertices, cells, SubCellData());
-
-      if (colorize)
-        {
-          // to colorize, run through all
-          // faces of all cells and set
-          // boundary indicator to the
-          // correct value if it was 0.
-
-          // use a large epsilon to
-          // compare numbers to avoid
-          // roundoff problems.
-          double epsilon = std::numeric_limits<double>::max();
-          for (unsigned int i = 0; i < dim; ++i)
-            epsilon =
-              std::min(epsilon,
-                       0.01 * (std::abs(p2[i] - p1[i]) / repetitions[i]));
-          Assert(epsilon > 0,
-                 ExcMessage(
-                   "The distance between corner points must be positive."));
-
-          // actual code is external since
-          // 1-D is different from 2/3d.
-          colorize_subdivided_hyper_rectangle(tria, p1, p2, epsilon);
-        }
-    }
+    AssertDimension(dim, spacedim);
 
+    std::vector<Point<spacedim>> vertices;
+    std::vector<CellData<dim>>   cells;
 
+    if (dim == 2)
+      {
+        // determine cell sizes
+        const Point<dim> dx((p2[0] - p1[0]) / repetitions[0],
+                            (p2[1] - p1[1]) / repetitions[1]);
 
-    // This function is only needed in 3D.
-    template <int dim, int spacedim>
-    void
-    subdivided_hyper_rectangle_with_simplices_periodic(
-      Triangulation<dim, spacedim>    &tria,
-      const std::vector<unsigned int> &repetitions,
-      const Point<dim>                &p1,
-      const Point<dim>                &p2,
-      const bool                       colorize)
-    {
-      // This function is only needed in 3D (and hypothetically in higher
-      // dimension), so library internals should ensure it is never called
-      // unless dim == 3.
-      Assert(dim == 3, ExcInternalError());
-      AssertDimension(dim, spacedim);
-
-      std::vector<Point<spacedim>> vertices;
-      std::vector<CellData<dim>>   cells;
-
-      // determine cell sizes
-      const Point<dim> dx((p2[0] - p1[0]) / repetitions[0],
-                          (p2[1] - p1[1]) / repetitions[1],
-                          (p2[2] - p1[2]) / repetitions[2]);
-
-      // create vertices
-      for (unsigned int k = 0; k <= repetitions[2]; ++k)
+        // create vertices
         for (unsigned int j = 0; j <= repetitions[1]; ++j)
           for (unsigned int i = 0; i <= repetitions[0]; ++i)
-            vertices.push_back(Point<spacedim>(p1[0] + dx[0] * i,
-                                               p1[1] + dx[1] * j,
-                                               p1[2] + dx[2] * k));
+            vertices.push_back(
+              Point<spacedim>(p1[0] + dx[0] * i, p1[1] + dx[1] * j));
 
-      // create cells
-      for (unsigned int k = 0; k < repetitions[2]; ++k)
+        // create cells
         for (unsigned int j = 0; j < repetitions[1]; ++j)
           for (unsigned int i = 0; i < repetitions[0]; ++i)
             {
-              // create reference HEX cell
-              std::array<unsigned int, 8> quad{
-                {(k + 0) * (repetitions[0] + 1) * (repetitions[1] + 1) +
-                   (j + 0) * (repetitions[0] + 1) + i + 0,
-                 (k + 0) * (repetitions[0] + 1) * (repetitions[1] + 1) +
-                   (j + 0) * (repetitions[0] + 1) + i + 1,
-                 (k + 0) * (repetitions[0] + 1) * (repetitions[1] + 1) +
-                   (j + 1) * (repetitions[0] + 1) + i + 0,
-                 (k + 0) * (repetitions[0] + 1) * (repetitions[1] + 1) +
-                   (j + 1) * (repetitions[0] + 1) + i + 1,
-                 (k + 1) * (repetitions[0] + 1) * (repetitions[1] + 1) +
-                   (j + 0) * (repetitions[0] + 1) + i + 0,
-                 (k + 1) * (repetitions[0] + 1) * (repetitions[1] + 1) +
-                   (j + 0) * (repetitions[0] + 1) + i + 1,
-                 (k + 1) * (repetitions[0] + 1) * (repetitions[1] + 1) +
-                   (j + 1) * (repetitions[0] + 1) + i + 0,
-                 (k + 1) * (repetitions[0] + 1) * (repetitions[1] + 1) +
-                   (j + 1) * (repetitions[0] + 1) + i + 1}};
-
-              // TET cell 0
-              {
-                CellData<dim> cell;
-                cell.vertices = {{quad[0], quad[1], quad[3], quad[7]}};
-                cells.push_back(cell);
-              }
-
-              // TET cell 1
-              {
-                CellData<dim> cell;
-                cell.vertices = {{quad[0], quad[1], quad[7], quad[5]}};
-                cells.push_back(cell);
-              }
-
-              // TET cell 2
+              // create reference QUAD cell
+              std::array<unsigned int, 4> quad{{
+                (j + 0) * (repetitions[0] + 1) + i + 0, //
+                (j + 0) * (repetitions[0] + 1) + i + 1, //
+                (j + 1) * (repetitions[0] + 1) + i + 0, //
+                (j + 1) * (repetitions[0] + 1) + i + 1  //
+              }};                                       //
+
+              // TRI cell 0
               {
-                CellData<dim> cell;
-                cell.vertices = {{quad[0], quad[7], quad[3], quad[2]}};
-                cells.push_back(cell);
+                CellData<dim> tri;
+                tri.vertices = {quad[0], quad[1], quad[2]};
+                cells.push_back(tri);
               }
 
-              // TET cell 3
+              // TRI cell 1
               {
-                CellData<dim> cell;
-                cell.vertices = {{quad[2], quad[6], quad[0], quad[7]}};
-                cells.push_back(cell);
+                CellData<dim> tri;
+                tri.vertices = {quad[3], quad[2], quad[1]};
+                cells.push_back(tri);
               }
+            }
+      }
+    else if (dim == 3)
+      {
+        // determine cell sizes
+        const Point<dim> dx((p2[0] - p1[0]) / repetitions[0],
+                            (p2[1] - p1[1]) / repetitions[1],
+                            (p2[2] - p1[2]) / repetitions[2]);
 
-              // TET cell 4
-              {
-                CellData<dim> cell;
-                cell.vertices = {{quad[4], quad[7], quad[5], quad[0]}};
-                cells.push_back(cell);
-              }
+        // create vertices
+        for (unsigned int k = 0; k <= repetitions[2]; ++k)
+          for (unsigned int j = 0; j <= repetitions[1]; ++j)
+            for (unsigned int i = 0; i <= repetitions[0]; ++i)
+              vertices.push_back(Point<spacedim>(p1[0] + dx[0] * i,
+                                                 p1[1] + dx[1] * j,
+                                                 p1[2] + dx[2] * k));
 
-              // TET cell 5
+        // create cells
+        for (unsigned int k = 0; k < repetitions[2]; ++k)
+          for (unsigned int j = 0; j < repetitions[1]; ++j)
+            for (unsigned int i = 0; i < repetitions[0]; ++i)
               {
-                CellData<dim> cell;
-                cell.vertices = {{quad[4], quad[6], quad[7], quad[0]}};
-                cells.push_back(cell);
-              }
-            }
-
-      // actually create triangulation
-      tria.create_triangulation(vertices, cells, SubCellData());
+                // create reference HEX cell
+                std::array<unsigned int, 8> quad{
+                  {(k + 0) * (repetitions[0] + 1) * (repetitions[1] + 1) +
+                     (j + 0) * (repetitions[0] + 1) + i + 0,
+                   (k + 0) * (repetitions[0] + 1) * (repetitions[1] + 1) +
+                     (j + 0) * (repetitions[0] + 1) + i + 1,
+                   (k + 0) * (repetitions[0] + 1) * (repetitions[1] + 1) +
+                     (j + 1) * (repetitions[0] + 1) + i + 0,
+                   (k + 0) * (repetitions[0] + 1) * (repetitions[1] + 1) +
+                     (j + 1) * (repetitions[0] + 1) + i + 1,
+                   (k + 1) * (repetitions[0] + 1) * (repetitions[1] + 1) +
+                     (j + 0) * (repetitions[0] + 1) + i + 0,
+                   (k + 1) * (repetitions[0] + 1) * (repetitions[1] + 1) +
+                     (j + 0) * (repetitions[0] + 1) + i + 1,
+                   (k + 1) * (repetitions[0] + 1) * (repetitions[1] + 1) +
+                     (j + 1) * (repetitions[0] + 1) + i + 0,
+                   (k + 1) * (repetitions[0] + 1) * (repetitions[1] + 1) +
+                     (j + 1) * (repetitions[0] + 1) + i + 1}};
+
+                // TET cell 0
+                {
+                  CellData<dim> cell;
+                  if (((i % 2) + (j % 2) + (k % 2)) % 2 == 0)
+                    cell.vertices = {{quad[0], quad[1], quad[2], quad[4]}};
+                  else
+                    cell.vertices = {{quad[0], quad[1], quad[3], quad[5]}};
 
-      if (colorize)
-        {
-          // to colorize, run through all
-          // faces of all cells and set
-          // boundary indicator to the
-          // correct value if it was 0.
-
-          // use a large epsilon to
-          // compare numbers to avoid
-          // roundoff problems.
-          double epsilon = std::numeric_limits<double>::max();
-          for (unsigned int i = 0; i < dim; ++i)
-            epsilon =
-              std::min(epsilon,
-                       0.01 * (std::abs(p2[i] - p1[i]) / repetitions[i]));
-          Assert(epsilon > 0,
-                 ExcMessage(
-                   "The distance between corner points must be positive."));
+                  cells.push_back(cell);
+                }
 
-          // actual code is external since
-          // 1-D is different from 2/3d.
-          colorize_subdivided_hyper_rectangle(tria, p1, p2, epsilon);
-        }
-    }
-  } // namespace
+                // TET cell 1
+                {
+                  CellData<dim> cell;
+                  if (((i % 2) + (j % 2) + (k % 2)) % 2 == 0)
+                    cell.vertices = {{quad[2], quad[1], quad[3], quad[7]}};
+                  else
+                    cell.vertices = {{quad[0], quad[3], quad[2], quad[6]}};
+                  cells.push_back(cell);
+                }
 
+                // TET cell 2
+                {
+                  CellData<dim> cell;
+                  if (((i % 2) + (j % 2) + (k % 2)) % 2 == 0)
+                    cell.vertices = {{quad[1], quad[4], quad[5], quad[7]}};
+                  else
+                    cell.vertices = {{quad[0], quad[4], quad[5], quad[6]}};
+                  cells.push_back(cell);
+                }
 
+                // TET cell 3
+                {
+                  CellData<dim> cell;
+                  if (((i % 2) + (j % 2) + (k % 2)) % 2 == 0)
+                    cell.vertices = {{quad[2], quad[4], quad[7], quad[6]}};
+                  else
+                    cell.vertices = {{quad[3], quad[5], quad[7], quad[6]}};
+                  cells.push_back(cell);
+                }
 
-  template <int dim, int spacedim>
-  void
-  subdivided_hyper_rectangle_with_simplices(
-    Triangulation<dim, spacedim>    &tria,
-    const std::vector<unsigned int> &repetitions,
-    const Point<dim>                &p1,
-    const Point<dim>                &p2,
-    const bool                       colorize,
-    const bool                       periodic)
-  {
-    // We only need to call the "periodic" variant if it was requested and we
-    // are in 3D.
-    if (dim != 3)
-      {
-        subdivided_hyper_rectangle_with_simplices_no_periodic(
-          tria, repetitions, p1, p2, colorize);
-        return;
+                // TET cell 4
+                {
+                  CellData<dim> cell;
+                  if (((i % 2) + (j % 2) + (k % 2)) % 2 == 0)
+                    cell.vertices = {{quad[1], quad[2], quad[4], quad[7]}};
+                  else
+                    cell.vertices = {{quad[0], quad[3], quad[6], quad[5]}};
+                  cells.push_back(cell);
+                }
+              }
       }
-    else if (!periodic)
+    else
       {
-        subdivided_hyper_rectangle_with_simplices_no_periodic(
-          tria, repetitions, p1, p2, colorize);
-        return;
+        AssertThrow(false, ExcNotImplemented());
       }
-    else
+
+    // actually create triangulation
+    tria.create_triangulation(vertices, cells, SubCellData());
+
+    if (colorize)
       {
-        subdivided_hyper_rectangle_with_simplices_periodic(
-          tria, repetitions, p1, p2, colorize);
-        return;
+        // to colorize, run through all
+        // faces of all cells and set
+        // boundary indicator to the
+        // correct value if it was 0.
+
+        // use a large epsilon to
+        // compare numbers to avoid
+        // roundoff problems.
+        double epsilon = std::numeric_limits<double>::max();
+        for (unsigned int i = 0; i < dim; ++i)
+          epsilon = std::min(epsilon,
+                             0.01 * (std::abs(p2[i] - p1[i]) / repetitions[i]));
+        Assert(epsilon > 0,
+               ExcMessage(
+                 "The distance between corner points must be positive."));
+
+        // actual code is external since
+        // 1-D is different from 2/3d.
+        colorize_subdivided_hyper_rectangle(tria, p1, p2, epsilon);
       }
   }
 
@@ -9401,17 +9231,12 @@ namespace GridGenerator
                                        const unsigned int repetitions,
                                        const double       p1,
                                        const double       p2,
-                                       const bool         colorize,
-                                       const bool         periodic)
+                                       const bool         colorize)
   {
     if (dim == 2)
       {
-        subdivided_hyper_rectangle_with_simplices(tria,
-                                                  {{repetitions, repetitions}},
-                                                  {p1, p1},
-                                                  {p2, p2},
-                                                  colorize,
-                                                  periodic);
+        subdivided_hyper_rectangle_with_simplices(
+          tria, {{repetitions, repetitions}}, {p1, p1}, {p2, p2}, colorize);
       }
     else if (dim == 3)
       {
@@ -9420,8 +9245,7 @@ namespace GridGenerator
           {{repetitions, repetitions, repetitions}},
           {p1, p1, p1},
           {p2, p2, p2},
-          colorize,
-          periodic);
+          colorize);
       }
     else
       {
index 8be73d5fa4c83c6b5e98b51fa08c954dcf5fc8ca..200d16127bd8888ce939efb585640d369699fd01 100644 (file)
@@ -303,14 +303,12 @@ for (deal_II_dimension : DIMENSIONS)
       const std::vector<unsigned int> &repetitions,
       const Point<deal_II_dimension>  &p1,
       const Point<deal_II_dimension>  &p2,
-      const bool                       colorize,
-      const bool                       periodic);
+      const bool                       colorize);
 
     template void GridGenerator::subdivided_hyper_cube_with_simplices(
       Triangulation<deal_II_dimension> & tria,
       const unsigned int repetitions,
       const double       p1,
       const double       p2,
-      const bool         colorize,
-      const bool         periodic);
+      const bool         colorize);
   }
index bc0b89a38fc887635168890f59b1b6c7f63572c2..361915d5f26086c6e130946c77389ea96483d5a1 100644 (file)
@@ -232,7 +232,7 @@ namespace GridGenerator
                          bool>(concentric_hyper_shells, arguments, tria);
 
       else if (name == "subdivided_hyper_cube_with_simplices")
-        parse_and_create<dim, dim, unsigned int, double, double, bool, bool>(
+        parse_and_create<dim, dim, unsigned int, double, double, bool>(
           subdivided_hyper_cube_with_simplices, arguments, tria);
 
       else if (name == "subdivided_hyper_rectangle_with_simplices")
@@ -241,7 +241,6 @@ namespace GridGenerator
                          const std::vector<unsigned int> &,
                          const Point<dim> &,
                          const Point<dim> &,
-                         bool,
                          bool>(subdivided_hyper_rectangle_with_simplices,
                                arguments,
                                tria);
index 40d9b1929743f1b9da7c68779fe0da46a7139cc3..2883b09d6e0fb6b135a4b838a319e3bcd292f93b 100644 (file)
@@ -54,15 +54,13 @@ main()
   test<2, 2>("hyper_ball_balanced", "0,0 : 1");
   test<3, 3>("hyper_ball_balanced", "0,0,0 : 1");
 
-  test<2, 2>("subdivided_hyper_cube_with_simplices",
-             "2 : 0.0 : 1.0 : false : false");
-  test<3, 3>("subdivided_hyper_cube_with_simplices",
-             "2 : 0.0 : 1.0 : false : false");
+  test<2, 2>("subdivided_hyper_cube_with_simplices", "2 : 0.0 : 1.0 : false");
+  test<3, 3>("subdivided_hyper_cube_with_simplices", "2 : 0.0 : 1.0 : false");
 
   test<2, 2>("subdivided_hyper_rectangle_with_simplices",
-             "2, 2 : 0.0, 0.0 : 1.0, 2.0 : false : false");
+             "2, 2 : 0.0, 0.0 : 1.0, 2.0 : false");
   test<3, 3>("subdivided_hyper_rectangle_with_simplices",
-             "2, 2, 3 : 0.0, 0.0, 1.0 : 1.0, 2.0, 3.0 : false : false");
+             "2, 2, 3 : 0.0, 0.0, 1.0 : 1.0, 2.0, 3.0 : false");
 
   test<2, 2>("subdivided_hyper_L", "5, 5 : 0, 0 : 1, 1 : 2, 3");
   test<3, 3>("subdivided_hyper_L", "5, 5, 5 : 0, 0, 0 : 1, 1, 1 : 2, 2, 3");
index 31b233c3f52ec1e61fe1390dc5d04b41f5e0148d..e5a39f8d22d620f85b0f1d5ee3662186acfd5eb0 100644 (file)
@@ -191,7 +191,7 @@ $ELM
 31 5 0 0 8 18 16 38 37 27 25 52 53 
 32 5 0 0 8 43 36 48 50 37 38 52 53 
 $ENDELM
-DEAL::Generating Triangulation<2, 2> : subdivided_hyper_cube_with_simplices(2 : 0.0 : 1.0 : false : false)
+DEAL::Generating Triangulation<2, 2> : subdivided_hyper_cube_with_simplices(2 : 0.0 : 1.0 : false)
 $NOD
 9
 1  0.00000 0.00000 0
@@ -215,7 +215,7 @@ $ELM
 7 2 0 0 3 5 6 8 
 8 2 0 0 3 9 8 6 
 $ENDELM
-DEAL::Generating Triangulation<3, 3> : subdivided_hyper_cube_with_simplices(2 : 0.0 : 1.0 : false : false)
+DEAL::Generating Triangulation<3, 3> : subdivided_hyper_cube_with_simplices(2 : 0.0 : 1.0 : false)
 $NOD
 27
 1  0.00000 0.00000 0.00000
@@ -289,7 +289,7 @@ $ELM
 39 4 0 0 4 18 24 27 26 
 40 4 0 0 4 14 18 26 24 
 $ENDELM
-DEAL::Generating Triangulation<2, 2> : subdivided_hyper_rectangle_with_simplices(2, 2 : 0.0, 0.0 : 1.0, 2.0 : false : false)
+DEAL::Generating Triangulation<2, 2> : subdivided_hyper_rectangle_with_simplices(2, 2 : 0.0, 0.0 : 1.0, 2.0 : false)
 $NOD
 9
 1  0.00000 0.00000 0
@@ -313,7 +313,7 @@ $ELM
 7 2 0 0 3 5 6 8 
 8 2 0 0 3 9 8 6 
 $ENDELM
-DEAL::Generating Triangulation<3, 3> : subdivided_hyper_rectangle_with_simplices(2, 2, 3 : 0.0, 0.0, 1.0 : 1.0, 2.0, 3.0 : false : false)
+DEAL::Generating Triangulation<3, 3> : subdivided_hyper_rectangle_with_simplices(2, 2, 3 : 0.0, 0.0, 1.0 : 1.0, 2.0, 3.0 : false)
 $NOD
 36
 1  0.00000 0.00000 1.00000

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.