]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Remove many GeometricInfo usages from examples 10698/head
authorPeter Munch <peterrmuench@gmail.com>
Sun, 12 Jul 2020 13:01:47 +0000 (15:01 +0200)
committerPeter Munch <peterrmuench@gmail.com>
Fri, 17 Jul 2020 07:55:42 +0000 (09:55 +0200)
24 files changed:
examples/step-1/step-1.cc
examples/step-13/doc/results.dox
examples/step-13/step-13.cc
examples/step-14/step-14.cc
examples/step-18/step-18.cc
examples/step-2/step-2.cc
examples/step-21/step-21.cc
examples/step-27/step-27.cc
examples/step-29/step-29.cc
examples/step-30/step-30.cc
examples/step-33/step-33.cc
examples/step-41/step-41.cc
examples/step-42/step-42.cc
examples/step-46/doc/intro.dox
examples/step-46/step-46.cc
examples/step-49/doc/results.dox
examples/step-49/step-49.cc
examples/step-51/step-51.cc
examples/step-59/step-59.cc
examples/step-6/doc/results.dox
examples/step-60/step-60.cc
examples/step-65/step-65.cc
examples/step-69/step-69.cc
examples/step-9/step-9.cc

index 105e3a046c0caffbec26c8fcb6fa91b4babece09..38eadd26f1edacce0faf0c45d6e124127ff55fc5 100644 (file)
@@ -199,17 +199,13 @@ void second_grid()
           // classes used in deal.II, and @ref CPP11 for more information about
           // range-based for loops and the `auto` keyword.
           //
-          // Next, we want to loop over all vertices of the cells. Since we are
-          // in 2d, we know that each cell has exactly four vertices. However,
-          // instead of penning down a 4 in the loop bound, we make a first
-          // attempt at writing it in a dimension-independent way by which we
-          // find out about the number of vertices of a cell. Using the
-          // GeometryInfo class, we will later have an easier time getting the
-          // program to also run in 3d: we only have to change all occurrences
-          // of <code>&lt;2&gt;</code> to <code>&lt;3&gt;</code>, and do not
-          // have to audit our code for the hidden appearance of magic numbers
-          // like a 4 that needs to be replaced by an 8:
-          for (unsigned int v = 0; v < GeometryInfo<2>::vertices_per_cell; ++v)
+          // Next, we loop over all vertices of the cells. For that purpose
+          // we query an iterator over indices from zero to four, which happens
+          // to be the number of vertices in 2d. Since the upper bound is
+          // automatically adjusted in all dimensions this enables us a
+          // dimension-independent programming. This will later enable us to
+          // get the program to also run in 3d.
+          for (const auto v : cell->vertex_indices())
             {
               // If this cell is at the inner boundary, then at least one of its
               // vertices must sit on the inner ring and therefore have a radial
index df4cf57daffd5440485e8200428466fb1ce65308..3d8c8c9f2a2efa6d6549da11b3440df66676cca0 100644 (file)
@@ -162,7 +162,7 @@ profit. Answer 2: this quick hack
 @code
   bool refinement_indicated = false;
   for (const auto &cell : triangulation.active_cell_iterators())
-    for (unsigned int v=0; v<GeometryInfo<dim>::vertices_per_cell; ++v)
+    for (const auto v : cell->vertex_indices())
          if (cell->vertex(v) == Point<dim>(.5,.5))
            {
              cell->clear_coarsen_flag();
@@ -170,7 +170,7 @@ profit. Answer 2: this quick hack
            }
   if (refinement_indicated)
     for (const auto &cell : triangulation.active_cell_iterators())
-      for (unsigned int v=0; v<GeometryInfo<dim>::vertices_per_cell; ++v)
+      for (const auto v : cell->vertex_indices())
            if (cell->vertex(v) == Point<dim>(.5,.5))
              cell->set_refine_flag ();
 @endcode
index a64963d3ad92ad83f954be466d7f4779c58e68ce..9b0aaafbbd708cbb105b94d46fad25ae6f40ef6d 100644 (file)
@@ -221,9 +221,7 @@ namespace Step13
       bool evaluation_point_found = false;
       for (const auto &cell : dof_handler.active_cell_iterators())
         if (!evaluation_point_found)
-          for (unsigned int vertex = 0;
-               vertex < GeometryInfo<dim>::vertices_per_cell;
-               ++vertex)
+          for (const auto vertex : cell->vertex_indices())
             if (cell->vertex(vertex) == evaluation_point)
               {
                 // In order to extract the point value from the global solution
index 109866d65cacb9de40399382d4c4dfa112ee6c7a..6e812744e94374a555a22a743eaf70f76309b8a8 100644 (file)
@@ -135,9 +135,7 @@ namespace Step14
       bool evaluation_point_found = false;
       for (const auto &cell : dof_handler.active_cell_iterators())
         if (!evaluation_point_found)
-          for (unsigned int vertex = 0;
-               vertex < GeometryInfo<dim>::vertices_per_cell;
-               ++vertex)
+          for (const auto vertex : cell->vertex_indices())
             if (cell->vertex(vertex).distance(evaluation_point) <
                 cell->diameter() * 1e-8)
               {
@@ -218,9 +216,7 @@ namespace Step14
       // often the vertex has been found:
       unsigned int evaluation_point_hits = 0;
       for (const auto &cell : dof_handler.active_cell_iterators())
-        for (unsigned int vertex = 0;
-             vertex < GeometryInfo<dim>::vertices_per_cell;
-             ++vertex)
+        for (const auto vertex : cell->vertex_indices())
           if (cell->vertex(vertex) == evaluation_point)
             {
               // Things are now no more as simple, since we can't get the
@@ -1294,8 +1290,7 @@ namespace Step14
       std::vector<CellData<dim>> cells(n_cells, CellData<dim>());
       for (unsigned int i = 0; i < n_cells; ++i)
         {
-          for (unsigned int j = 0; j < GeometryInfo<dim>::vertices_per_cell;
-               ++j)
+          for (unsigned int j = 0; j < cell_vertices[i].size(); ++j)
             cells[i].vertices[j] = cell_vertices[i][j];
           cells[i].material_id = 0;
         }
@@ -1447,9 +1442,7 @@ namespace Step14
       // vertices (or very close to a vertex, which may happen due to floating
       // point round-off):
       for (const auto &cell : dof_handler.active_cell_iterators())
-        for (unsigned int vertex = 0;
-             vertex < GeometryInfo<dim>::vertices_per_cell;
-             ++vertex)
+        for (const auto vertex : cell->vertex_indices())
           if (cell->vertex(vertex).distance(evaluation_point) <
               cell->diameter() * 1e-8)
             {
@@ -2273,7 +2266,7 @@ namespace Step14
       // After computing the cell terms, turn to the face terms. For this,
       // loop over all faces of the present cell, and see whether
       // something needs to be computed on it:
-      for (unsigned int face_no : GeometryInfo<dim>::face_indices())
+      for (const auto face_no : cell->face_indices())
         {
           // First, if this face is part of the boundary, then there is
           // nothing to do. However, to make things easier when summing up
index 268b9ef651f4d725ff0991de3c2850e2bb0b8eff..d6b937b936a2fd833ff6ca777f6922b471f70984 100644 (file)
@@ -1482,7 +1482,7 @@ namespace Step18
   // points, see @ref GlossSupport "support points"). For such a case, one
   // could construct a custom quadrature rule using
   // FiniteElement::get_unit_support_points(). The first
-  // <code>GeometryInfo@<dim@>::%vertices_per_cell*fe.dofs_per_vertex</code>
+  // <code>cell-&gt;n_vertices()*fe.dofs_per_vertex</code>
   // quadrature points will then correspond to the vertices of the cell and
   // are ordered consistent with <code>cell-@>vertex(i)</code>, taking into
   // account that support points for vector elements will be duplicated
@@ -1515,7 +1515,7 @@ namespace Step18
 
     std::vector<bool> vertex_touched(triangulation.n_vertices(), false);
     for (auto &cell : dof_handler.active_cell_iterators())
-      for (unsigned int v = 0; v < GeometryInfo<dim>::vertices_per_cell; ++v)
+      for (const auto v : cell->vertex_indices())
         if (vertex_touched[cell->vertex_index(v)] == false)
           {
             vertex_touched[cell->vertex_index(v)] = true;
index 9e888adcbfc9bb628851105813c6d956731db43e..e8a25a9d04c14b57d1ef0f62bb3cd113ae3fbc9a 100644 (file)
@@ -75,7 +75,7 @@ void make_grid(Triangulation<2> &triangulation)
   for (unsigned int step = 0; step < 3; ++step)
     {
       for (auto &cell : triangulation.active_cell_iterators())
-        for (unsigned int v = 0; v < GeometryInfo<2>::vertices_per_cell; ++v)
+        for (const auto v : cell->vertex_indices())
           {
             const double distance_from_center =
               center.distance(cell->vertex(v));
index 1a8ec623dd7b47cfc498309f7f28fbb20e50d372..d33a889c2245b976512fb964e441d40bd5759108 100644 (file)
@@ -851,7 +851,7 @@ namespace Step21
         //
         // All this is a bit tricky, but has been explained in some detail
         // already in step-9. Take a look there how this is supposed to work!
-        for (unsigned int face_no : GeometryInfo<dim>::face_indices())
+        for (const auto face_no : cell->face_indices())
           {
             fe_face_values.reinit(cell, face_no);
 
index a371f16980b0e91df5805bd0c28a07ef01aa3794..911b8f23e7226b8542e6a45533c50818a33913c6 100644 (file)
@@ -570,7 +570,7 @@ namespace Step27
     std::vector<CellData<dim>> cells(n_cells, CellData<dim>());
     for (unsigned int i = 0; i < n_cells; ++i)
       {
-        for (unsigned int j = 0; j < GeometryInfo<dim>::vertices_per_cell; ++j)
+        for (unsigned int j = 0; j < cell_vertices[i].size(); ++j)
           cells[i].vertices[j] = cell_vertices[i][j];
         cells[i].material_id = 0;
       }
index df2319b1ac64bcca1eb10c14fc1a781cb83f707c..102fd53144e32fbef5ed02931e5d95588b0068ec 100644 (file)
@@ -651,7 +651,7 @@ namespace Step29
         // is at the boundary, and second has the correct boundary indicator
         // associated with $\Gamma_2$, the part of the boundary where we have
         // absorbing boundary conditions:
-        for (unsigned int face_no : GeometryInfo<dim>::face_indices())
+        for (const auto face_no : cell->face_indices())
           if (cell->face(face_no)->at_boundary() &&
               (cell->face(face_no)->boundary_id() == 0))
             {
index a5abbf0a57bb9eb42e92b869b7de63d5ac0be4cd..cc943a12a6a43954d773634aef2d29c1c6bf8ab2 100644 (file)
@@ -451,7 +451,7 @@ namespace Step30
 
         cell->get_dof_indices(dofs);
 
-        for (unsigned int face_no : GeometryInfo<dim>::face_indices())
+        for (const auto face_no : cell->face_indices())
           {
             const auto face = cell->face(face_no);
 
@@ -724,7 +724,7 @@ namespace Step30
           Point<dim> jump;
           Point<dim> area;
 
-          for (unsigned int face_no : GeometryInfo<dim>::face_indices())
+          for (const auto face_no : cell->face_indices())
             {
               const auto face = cell->face(face_no);
 
@@ -839,8 +839,7 @@ namespace Step30
                           std::pair<unsigned int, unsigned int>
                             neighbor_face_subface =
                               cell->neighbor_of_coarser_neighbor(face_no);
-                          Assert(neighbor_face_subface.first <
-                                   GeometryInfo<dim>::faces_per_cell,
+                          Assert(neighbor_face_subface.first < cell->n_faces(),
                                  ExcInternalError());
                           Assert(neighbor_face_subface.second <
                                    neighbor->face(neighbor_face_subface.first)
index aa657dc310ae982e6afce2c3eddfcb6d72bc0d2b..4c5fcd3422a202394a5e8e449da43a2f7be18dda 100644 (file)
@@ -1486,7 +1486,7 @@ namespace Step33
         // whether we are working on an external or internal face; if it is an
         // external face, the fourth argument denoting the degrees of freedom
         // indices of the neighbor is ignored, so we pass an empty vector):
-        for (unsigned int face_no : GeometryInfo<dim>::face_indices())
+        for (const auto face_no : cell->face_indices())
           if (cell->at_boundary(face_no))
             {
               fe_v_face.reinit(cell, face_no);
index b1d05969af9ba61b1de7a6ca0443af5efc1b1fd4..02a5cfc1f48674d0540cdfba9735024c0babef79 100644 (file)
@@ -443,10 +443,9 @@ namespace Step41
     std::vector<bool>   dof_touched(dof_handler.n_dofs(), false);
 
     for (const auto &cell : dof_handler.active_cell_iterators())
-      for (unsigned int v = 0; v < GeometryInfo<dim>::vertices_per_cell; ++v)
+      for (const auto v : cell->vertex_indices())
         {
-          Assert(dof_handler.get_fe().n_dofs_per_cell() ==
-                   GeometryInfo<dim>::vertices_per_cell,
+          Assert(dof_handler.get_fe().n_dofs_per_cell() == cell->n_vertices(),
                  ExcNotImplemented());
 
           const unsigned int dof_index = cell->vertex_dof_index(v, 0);
index 2d766976d0aedacfebe6a591b86bf835426b085c..a684ba9495e5ac9cceeab5cc48426998c6c1d253 100644 (file)
@@ -1929,7 +1929,7 @@ namespace Step42
 
     for (const auto &cell : dof_handler.active_cell_iterators())
       if (cell->is_locally_owned())
-        for (unsigned int v = 0; v < GeometryInfo<dim>::vertices_per_cell; ++v)
+        for (const auto v : cell->vertex_indices())
           if (vertex_touched[cell->vertex_index(v)] == false)
             {
               vertex_touched[cell->vertex_index(v)] = true;
index 2455b1e65f61097b4da900a318b24316fb3edd48..95b93a515aa12ea3bce92b0879c3175cd4b0df84 100644 (file)
@@ -468,7 +468,7 @@ solid cell is refined, yielding the following code:
 std::vector<unsigned int> local_face_dof_indices (stokes_fe.dofs_per_face);
 for (const auto &cell: dof_handler.active_cell_iterators())
   if (cell_is_in_fluid_domain (cell))
-    for (unsigned int f : GeometryInfo<dim>::face_indices())
+    for (const auto f : cell->face_indices())
       if (!cell->at_boundary(f))
         {
           bool face_is_on_interface = false;
index c4b942b7e12df68429d98092010d0cbada59a113..05c1d0118a52677a79bb4c13f0b55a2309757b5b 100644 (file)
@@ -367,7 +367,7 @@ namespace Step46
         stokes_fe.n_dofs_per_face());
       for (const auto &cell : dof_handler.active_cell_iterators())
         if (cell_is_in_fluid_domain(cell))
-          for (unsigned int face_no : GeometryInfo<dim>::face_indices())
+          for (const auto face_no : cell->face_indices())
             {
               bool face_is_on_interface = false;
 
@@ -641,7 +641,7 @@ namespace Step46
         // boundary and the potential neighbor behind it is part of the fluid
         // domain. Let's start with these conditions:
         if (cell_is_in_solid_domain(cell))
-          for (unsigned int f : GeometryInfo<dim>::face_indices())
+          for (const auto f : cell->face_indices())
             {
               // At this point we know that the current cell is a candidate
               // for integration and that a neighbor behind face
@@ -950,7 +950,7 @@ namespace Step46
     // encountered when assembling interface terms in
     // <code>assemble_system</code>.
     for (const auto &cell : dof_handler.active_cell_iterators())
-      for (unsigned int f : GeometryInfo<dim>::face_indices())
+      for (const auto f : cell->face_indices())
         if (cell_is_in_solid_domain(cell))
           {
             if ((cell->at_boundary(f) == false) &&
index 18fa810625eff3b68d9b3752b1da3f8df95ae989..afad98309426a48f392e82eb0cbc1ab5b709b7ce 100644 (file)
@@ -91,7 +91,7 @@ void create_2d_grid(
   std::vector<CellData<2>> cells(vertex_indices.size());
   for (unsigned int i = 0; i < cells.size(); ++i)
     {
-      for (unsigned int j = 0; j < GeometryInfo<2>::vertices_per_cell; ++j)
+      for (unsigned int j = 0; j < vertex_indices[i].size(); ++j)
         cells[i].vertices[j] = vertex_indices[i][j];
     }
 
index dbd7d9dac51d981ec794fec0bfc5384673576112..b4319f7a133084e3bf032150da87a6023900f7ae 100644 (file)
@@ -168,7 +168,7 @@ void grid_3()
 
   for (const auto &cell : triangulation.active_cell_iterators())
     {
-      for (unsigned int i = 0; i < GeometryInfo<2>::vertices_per_cell; ++i)
+      for (const auto i : cell->vertex_indices())
         {
           Point<2> &v = cell->vertex(i);
           if (std::abs(v(1) - 1.0) < 1e-5)
index e8e1c1eb1a1af76d9b55d26ca5d1d6732de5fa60..32536b711a3957bdbb2c3e02bd0de070bec68eac 100644 (file)
@@ -766,7 +766,7 @@ namespace Step51
     // Face terms are assembled on all faces of all elements. This is in
     // contrast to more traditional DG methods, where each face is only visited
     // once in the assembly procedure.
-    for (unsigned int face_no : GeometryInfo<dim>::face_indices())
+    for (const auto face_no : cell->face_indices())
       {
         scratch.fe_face_values_local.reinit(loc_cell, face_no);
         scratch.fe_face_values.reinit(cell, face_no);
index a541f5fe72839ca356e392a73126c27423f43f94..4df20ebcd7f4309dd1652112deb53485053d7a0a 100644 (file)
@@ -1339,7 +1339,9 @@ namespace Step59
             triangulation.begin_active()->face(0)->set_boundary_id(10);
             triangulation.begin_active()->face(1)->set_boundary_id(11);
             triangulation.begin_active()->face(2)->set_boundary_id(0);
-            for (unsigned int f = 3; f < GeometryInfo<dim>::faces_per_cell; ++f)
+            for (unsigned int f = 3;
+                 f < triangulation.begin_active()->n_faces();
+                 ++f)
               triangulation.begin_active()->face(f)->set_boundary_id(1);
 
             std::vector<GridTools::PeriodicFacePair<
index b86c603ec58e8d473f9c3b507ff3d39f196f57b4..2927a0cab89dd4a0a4235a5b656e22bb19575593 100644 (file)
@@ -327,9 +327,7 @@ const double core_radius  = 1.0/5.0,
 for (const auto &cell : triangulation.active_cell_iterators())
   if (mesh_center.distance(cell->center()) < 1e-5)
     {
-      for (unsigned int v=0;
-           v < GeometryInfo<dim>::vertices_per_cell;
-           ++v)
+      for (const auto v : cell->vertex_indices())
         cell->vertex(v) *= core_radius/mesh_center.distance(cell->vertex(v));
     }
 
@@ -348,7 +346,7 @@ triangulation.execute_coarsening_and_refinement();
 // created in radial direction to a place where we need
 // them.
 for (const auto &cell : triangulation.active_cell_iterators())
-  for (unsigned int v=0; v < GeometryInfo<dim>::vertices_per_cell; ++v)
+  for (const auto v : cell->vertex_indices())
     {
       const double dist = mesh_center.distance(cell->vertex(v));
       if (dist > core_radius*1.0001 && dist < 0.9999)
@@ -369,7 +367,7 @@ for (const auto &cell : triangulation.active_cell_iterators())
 for (const auto &cell : triangulation.active_cell_iterators())
   {
     bool is_in_inner_circle = false;
-    for (unsigned int v=0; v < GeometryInfo<2>::vertices_per_cell; ++v)
+    for (const auto v : cell->vertex_indices())
       if (mesh_center.distance(cell->vertex(v)) < inner_radius)
         {
           is_in_inner_circle = true;
index e93e0314fca34b1e623be2fd1459452eacc1a80f..d9885590b082d422480608e34d5d7d34aa7d4d55 100644 (file)
@@ -772,7 +772,7 @@ namespace Step60
         for (auto &cell : cells)
           {
             cell->set_refine_flag();
-            for (unsigned int face_no : GeometryInfo<spacedim>::face_indices())
+            for (const auto face_no : cell->face_indices())
               if (!cell->at_boundary(face_no))
                 cell->neighbor(face_no)->set_refine_flag();
           }
index 7986e091c2d58c4929fe6f465d4a5020cf2ca116..bd48400a88292135eba5c4479c2b6f791e7f80f3 100644 (file)
@@ -230,9 +230,7 @@ namespace Step65
         for (const auto &face : cell->face_iterators())
           {
             bool face_at_sphere_boundary = true;
-            for (unsigned int v = 0;
-                 v < GeometryInfo<dim - 1>::vertices_per_cell;
-                 ++v)
+            for (const auto v : face->vertex_indices())
               {
                 if (std::abs(face->vertex(v).norm_square() - 0.25) > 1e-12)
                   face_at_sphere_boundary = false;
index 183a427e1a30e92070f4dd8eb08f102c0d737596..c6c428642f30ad7ae155f4d139ed6f60dd649088 100644 (file)
@@ -630,7 +630,7 @@ namespace Step69
 
     for (const auto &cell : triangulation.active_cell_iterators())
       {
-        for (unsigned int v = 0; v < GeometryInfo<dim>::vertices_per_cell; ++v)
+        for (const auto v : cell->vertex_indices())
           {
             if (cell->vertex(v)[0] <= -disk_diameter + 1.e-6)
               cell->vertex(v)[0] = -disk_position;
@@ -639,7 +639,7 @@ namespace Step69
 
     for (const auto &cell : triangulation.active_cell_iterators())
       {
-        for (auto f : GeometryInfo<dim>::face_indices())
+        for (const auto f : cell->face_indices())
           {
             const auto face = cell->face(f);
 
@@ -1090,7 +1090,7 @@ namespace Step69
           // Now we have to compute the boundary normals. Note that the
           // following loop does not do much unless the element has faces on
           // the boundary of the domain.
-          for (auto f : GeometryInfo<dim>::face_indices())
+          for (const auto f : cell->face_indices())
             {
               const auto face = cell->face(f);
               const auto id   = face->boundary_id();
@@ -1126,9 +1126,7 @@ namespace Step69
                   const auto index = copy.local_dof_indices[j];
 
                   Point<dim> position;
-                  for (unsigned int v = 0;
-                       v < GeometryInfo<dim>::vertices_per_cell;
-                       ++v)
+                  for (const auto v : cell->vertex_indices())
                     if (cell->vertex_dof_index(v, 0) ==
                         partitioner->local_to_global(index))
                       {
@@ -1351,7 +1349,7 @@ namespace Step69
           for (auto &matrix : copy.cell_cij_matrix)
             matrix = 0.;
 
-          for (auto f : GeometryInfo<dim>::face_indices())
+          for (const auto f : cell->face_indices())
             {
               const auto face = cell->face(f);
               const auto id   = face->boundary_id();
index 277093b63ae5b22d6db75772d5456f0b8d38347e..8a89bba69ee555119b52b3a8822a71b8bdd2a284 100644 (file)
@@ -1043,7 +1043,7 @@ namespace Step9
     // have to clear the array storing the iterators to the active
     // neighbors, of course.
     scratch_data.active_neighbors.clear();
-    for (unsigned int face_n : GeometryInfo<dim>::face_indices())
+    for (const auto face_n : cell->face_indices())
       if (!cell->at_boundary(face_n))
         {
           // First define an abbreviation for the iterator to the face and

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.