Convert steps 3,4,5,6,8 to FEValues::dof_indices()Do some FeValues::quadrature_point_...

diff --git a/examples/step-3/step-3.cc b/examples/step-3/step-3.cc
index 91d6337d9241c257879213524af9524e9a5c3ab7..e8fd779d8ef0ef6fab4c392cf1649da8c99894aa 100644 (file)
--- a/examples/step-3/step-3.cc
+++ b/examples/step-3/step-3.cc
@@ -437,8 +437,8 @@ void Step3::assemble_system()
           // determinant and the quadrature point weight (that one
           // gets together by the call to FEValues::JxW() ). Finally,
           // this is repeated for all shape functions $i$ and $j$:
-          for (unsigned int i = 0; i < dofs_per_cell; ++i)
-            for (unsigned int j = 0; j < dofs_per_cell; ++j)
+          for (const unsigned int i : fe_values.dof_indices())
+            for (const unsigned int j : fe_values.dof_indices())
               cell_matrix(i, j) +=
                 (fe_values.shape_grad(i, q_index) * // grad phi_i(x_q)
                  fe_values.shape_grad(j, q_index) * // grad phi_j(x_q)
@@ -449,7 +449,7 @@ void Step3::assemble_system()
           // hand side function, which we choose to be the function
           // with constant value one (more interesting examples will
           // be considered in the following programs).
-          for (unsigned int i = 0; i < dofs_per_cell; ++i)
+          for (const unsigned int i : fe_values.dof_indices())
             cell_rhs(i) += (fe_values.shape_value(i, q_index) * // phi_i(x_q)
                             1 *                                 // f(x_q)
                             fe_values.JxW(q_index));            // dx
@@ -463,14 +463,14 @@ void Step3::assemble_system()
       // Then again loop over all shape functions i and j and transfer the
       // local elements to the global matrix. The global numbers can be
       // obtained using local_dof_indices[i]:
-      for (unsigned int i = 0; i < dofs_per_cell; ++i)
-        for (unsigned int j = 0; j < dofs_per_cell; ++j)
+      for (const unsigned int i : fe_values.dof_indices())
+        for (const unsigned int j : fe_values.dof_indices())
           system_matrix.add(local_dof_indices[i],
                             local_dof_indices[j],
                             cell_matrix(i, j));
 
       // And again, we do the same thing for the right hand side vector.
-      for (unsigned int i = 0; i < dofs_per_cell; ++i)
+      for (const unsigned int i : fe_values.dof_indices())
         system_rhs(local_dof_indices[i]) += cell_rhs(i);
     }
 

diff --git a/examples/step-4/step-4.cc b/examples/step-4/step-4.cc
index 324a55cf83ba0f3f1dfefb443a02b3de905e4897..b34c5c2dfaa6f61141e5e3ff2bb9bac4301761c8 100644 (file)
--- a/examples/step-4/step-4.cc
+++ b/examples/step-4/step-4.cc
@@ -373,9 +373,9 @@ void Step4<dim>::assemble_system()
       // constant right hand side with value 1, we use the object representing
       // the right hand side and evaluate it at the quadrature points:
       for (const unsigned int q_index : fe_values.quadrature_point_indices())
-        for (unsigned int i = 0; i < dofs_per_cell; ++i)
+        for (const unsigned int i : fe_values.dof_indices())
           {
-            for (unsigned int j = 0; j < dofs_per_cell; ++j)
+            for (const unsigned int j : fe_values.dof_indices())
               cell_matrix(i, j) +=
                 (fe_values.shape_grad(i, q_index) * // grad phi_i(x_q)
                  fe_values.shape_grad(j, q_index) * // grad phi_j(x_q)
@@ -409,9 +409,9 @@ void Step4<dim>::assemble_system()
       // and right hand side is done exactly as before, but here we have again
       // merged some loops for efficiency:
       cell->get_dof_indices(local_dof_indices);
-      for (unsigned int i = 0; i < dofs_per_cell; ++i)
+      for (const unsigned int i : fe_values.dof_indices())
         {
-          for (unsigned int j = 0; j < dofs_per_cell; ++j)
+          for (const unsigned int j : fe_values.dof_indices())
             system_matrix.add(local_dof_indices[i],
                               local_dof_indices[j],
                               cell_matrix(i, j));

diff --git a/examples/step-5/step-5.cc b/examples/step-5/step-5.cc
index e3f6f9a0c18021e34c5350399e4ebabc17acae59..cac2c2d6ead7bb9359a6c4a65d17787aba78a7b2 100644 (file)
--- a/examples/step-5/step-5.cc
+++ b/examples/step-5/step-5.cc
@@ -192,9 +192,9 @@ void Step5<dim>::assemble_system()
         {
           const double current_coefficient =
             coefficient<dim>(fe_values.quadrature_point(q_index));
-          for (unsigned int i = 0; i < dofs_per_cell; ++i)
+          for (const unsigned int i : fe_values.dof_indices())
             {
-              for (unsigned int j = 0; j < dofs_per_cell; ++j)
+              for (const unsigned int j : fe_values.dof_indices())
                 cell_matrix(i, j) +=
                   (current_coefficient *              // a(x_q)
                    fe_values.shape_grad(i, q_index) * // grad phi_i(x_q)
@@ -209,9 +209,9 @@ void Step5<dim>::assemble_system()
 
 
       cell->get_dof_indices(local_dof_indices);
-      for (unsigned int i = 0; i < dofs_per_cell; ++i)
+      for (const unsigned int i : fe_values.dof_indices())
         {
-          for (unsigned int j = 0; j < dofs_per_cell; ++j)
+          for (const unsigned int j : fe_values.dof_indices())
             system_matrix.add(local_dof_indices[i],
                               local_dof_indices[j],
                               cell_matrix(i, j));

diff --git a/examples/step-6/step-6.cc b/examples/step-6/step-6.cc
index f88995e82b677f0da3f03e6163a157adc5b5e770..8e1f3d8096f0d63b7c35c48ae18fdab742fe8dea 100644 (file)
--- a/examples/step-6/step-6.cc
+++ b/examples/step-6/step-6.cc
@@ -246,14 +246,14 @@ void Step6<dim>::setup_system()
 //
 // The rest of the code that forms the local contributions remains
 // unchanged. It is worth noting, however, that under the hood several things
-// are different than before. First, the variables <code>dofs_per_cell</code>
-// and <code>n_q_points</code> now are 9 each, where they were 4
-// before. Introducing such variables as abbreviations is a good strategy to
-// make code work with different elements without having to change too much
-// code. Secondly, the <code>fe_values</code> object of course needs to do
-// other things as well, since the shape functions are now quadratic, rather
-// than linear, in each coordinate variable. Again, however, this is something
-// that is completely handled by the library.
+// are different than before. First, the variable <code>dofs_per_cell</code>
+// and return value of <code>quadrature_formula.size()</code> now are 9 each,
+// where they were 4 before. Introducing such variables as abbreviations is a
+// good strategy to make code work with different elements without having to
+// change too much code. Secondly, the <code>fe_values</code> object of course
+// needs to do other things as well, since the shape functions are now
+// quadratic, rather than linear, in each coordinate variable. Again, however,
+// this is something that is completely handled by the library.
 template <int dim>
 void Step6<dim>::assemble_system()
 {
@@ -265,7 +265,6 @@ void Step6<dim>::assemble_system()
                             update_quadrature_points | update_JxW_values);
 
   const unsigned int dofs_per_cell = fe.dofs_per_cell;
-  const unsigned int n_q_points    = quadrature_formula.size();
 
   FullMatrix<double> cell_matrix(dofs_per_cell, dofs_per_cell);
   Vector<double>     cell_rhs(dofs_per_cell);
@@ -279,13 +278,13 @@ void Step6<dim>::assemble_system()
 
       fe_values.reinit(cell);
 
-      for (unsigned int q_index = 0; q_index < n_q_points; ++q_index)
+      for (const unsigned int q_index : fe_values.quadrature_point_indices())
         {
           const double current_coefficient =
             coefficient<dim>(fe_values.quadrature_point(q_index));
-          for (unsigned int i = 0; i < dofs_per_cell; ++i)
+          for (const unsigned int i : fe_values.dof_indices())
             {
-              for (unsigned int j = 0; j < dofs_per_cell; ++j)
+              for (const unsigned int j : fe_values.dof_indices())
                 cell_matrix(i, j) +=
                   (current_coefficient *              // a(x_q)
                    fe_values.shape_grad(i, q_index) * // grad phi_i(x_q)

diff --git a/examples/step-8/step-8.cc b/examples/step-8/step-8.cc
index 7015c289bf5a77027ea1f96aa1471482f7d255cf..6551a774bb297fbd971e873525cbf51df3db19ad 100644 (file)
--- a/examples/step-8/step-8.cc
+++ b/examples/step-8/step-8.cc
@@ -334,17 +334,18 @@ namespace Step8
         //
         // With this knowledge, we can assemble the local matrix
         // contributions:
-        for (unsigned int i = 0; i < dofs_per_cell; ++i)
+        for (const unsigned int i : fe_values.dof_indices())
           {
             const unsigned int component_i =
               fe.system_to_component_index(i).first;
 
-            for (unsigned int j = 0; j < dofs_per_cell; ++j)
+            for (const unsigned int j : fe_values.dof_indices())
               {
                 const unsigned int component_j =
                   fe.system_to_component_index(j).first;
 
-                for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+                for (const unsigned int q_point :
+                     fe_values.quadrature_point_indices())
                   {
                     cell_matrix(i, j) +=
                       // The first term is $\lambda \partial_i u_i, \partial_j
@@ -390,12 +391,13 @@ namespace Step8
 
         // Assembling the right hand side is also just as discussed in the
         // introduction:
-        for (unsigned int i = 0; i < dofs_per_cell; ++i)
+        for (const unsigned int i : fe_values.dof_indices())
           {
             const unsigned int component_i =
               fe.system_to_component_index(i).first;
 
-            for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+            for (const unsigned int q_point :
+                 fe_values.quadrature_point_indices())
               cell_rhs(i) += fe_values.shape_value(i, q_point) *
                              rhs_values[q_point][component_i] *
                              fe_values.JxW(q_point);