Use FEValuesBase::quadrature_point_indices() in fe tests

diff --git a/tests/fe/abf_01.cc b/tests/fe/abf_01.cc
index 764f5ae108a3e94ee1b667d799e80fdabe9b3941..8c3210b5fc73bb6d51c14cfd42eee95b67a70d39 100644 (file)
--- a/tests/fe/abf_01.cc
+++ b/tests/fe/abf_01.cc
@@ -99,7 +99,7 @@ void EvaluateDerivative(DoFHandler<2> *dof_handler, Vector<double> &solution)
         n_q_points, std::vector<Tensor<1, 2>>(n_components));
       fe_values.get_function_gradients(solution, grads_here);
 
-      for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+      for (const auto q_point : fe_values.quadrature_point_indices())
         {
           //    double u0 = this_value[q_point](0);
           // double v0 = this_value[q_point](1);
@@ -186,7 +186,7 @@ create_mass_matrix(const Mapping<dim> &       mapping,
             {
               coefficient->value_list(fe_values.get_quadrature_points(),
                                       coefficient_values);
-              for (unsigned int point = 0; point < n_q_points; ++point)
+              for (const auto point : fe_values.quadrature_point_indices())
                 {
                   const double weight = fe_values.JxW(point);
                   for (unsigned int i = 0; i < dofs_per_cell; ++i)
@@ -209,7 +209,7 @@ create_mass_matrix(const Mapping<dim> &       mapping,
             {
               coefficient->vector_value_list(fe_values.get_quadrature_points(),
                                              coefficient_vector_values);
-              for (unsigned int point = 0; point < n_q_points; ++point)
+              for (const auto point : fe_values.quadrature_point_indices())
                 {
                   const double weight = fe_values.JxW(point);
                   for (unsigned int i = 0; i < dofs_per_cell; ++i)
@@ -260,7 +260,7 @@ create_mass_matrix(const Mapping<dim> &       mapping,
             }
           */
 
-          for (unsigned int point = 0; point < n_q_points; ++point)
+          for (const auto point : fe_values.quadrature_point_indices())
             {
               const double weight = fe_values.JxW(point);
               //      const double weight = q.weight(point);
@@ -368,7 +368,7 @@ create_right_hand_side(const Mapping<dim> &   mapping,
                                   rhs_values);
 
           cell_vector = 0;
-          for (unsigned int point = 0; point < n_q_points; ++point)
+          for (const auto point : fe_values.quadrature_point_indices())
             for (unsigned int i = 0; i < dofs_per_cell; ++i)
               cell_vector(i) += rhs_values[point] *
                                 fe_values.shape_value(i, point) *
@@ -394,7 +394,7 @@ create_right_hand_side(const Mapping<dim> &   mapping,
                                          rhs_values);
 
           cell_vector = 0;
-          for (unsigned int point = 0; point < n_q_points; ++point)
+          for (const auto point : fe_values.quadrature_point_indices())
             for (unsigned int i = 0; i < dofs_per_cell; ++i)
               for (unsigned int comp_i = 0; comp_i < fe.n_components();
                    ++comp_i)

diff --git a/tests/fe/abf_02.cc b/tests/fe/abf_02.cc
index b25ee669382fe802172a474a299d2fccedc5fb77..afe2f4ad1e5eb44396769736b7ff4050b3aed2fa 100644 (file)
--- a/tests/fe/abf_02.cc
+++ b/tests/fe/abf_02.cc
@@ -98,7 +98,7 @@ void EvaluateDerivative(DoFHandler<3> &dof_handler, Vector<double> &solution)
         n_q_points, std::vector<Tensor<1, 3>>(n_components));
       fe_values.get_function_gradients(solution, grads_here);
 
-      for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+      for (const auto q_point : fe_values.quadrature_point_indices())
         {
           double u0 = 0;
           double v0 = 0;
@@ -197,7 +197,7 @@ create_mass_matrix(const Mapping<dim> &       mapping,
             {
               coefficient->value_list(fe_values.get_quadrature_points(),
                                       coefficient_values);
-              for (unsigned int point = 0; point < n_q_points; ++point)
+              for (const auto point : fe_values.quadrature_point_indices())
                 {
                   const double weight = fe_values.JxW(point);
                   for (unsigned int i = 0; i < dofs_per_cell; ++i)
@@ -220,7 +220,7 @@ create_mass_matrix(const Mapping<dim> &       mapping,
             {
               coefficient->vector_value_list(fe_values.get_quadrature_points(),
                                              coefficient_vector_values);
-              for (unsigned int point = 0; point < n_q_points; ++point)
+              for (const auto point : fe_values.quadrature_point_indices())
                 {
                   const double weight = fe_values.JxW(point);
                   for (unsigned int i = 0; i < dofs_per_cell; ++i)
@@ -250,7 +250,7 @@ create_mass_matrix(const Mapping<dim> &       mapping,
           const unsigned int        dofs_per_face = fe.dofs_per_face;
           std::vector<unsigned int> face_dof_indices(dofs_per_face);
 
-          for (unsigned int point = 0; point < n_q_points; ++point)
+          for (const auto point : fe_values.quadrature_point_indices())
             {
               const double weight = fe_values.JxW(point);
               //      const double weight = q.weight(point);
@@ -350,7 +350,7 @@ create_right_hand_side(const Mapping<dim> &   mapping,
                                   rhs_values);
 
           cell_vector = 0;
-          for (unsigned int point = 0; point < n_q_points; ++point)
+          for (const auto point : fe_values.quadrature_point_indices())
             for (unsigned int i = 0; i < dofs_per_cell; ++i)
               cell_vector(i) += rhs_values[point] *
                                 fe_values.shape_value(i, point) *
@@ -376,7 +376,7 @@ create_right_hand_side(const Mapping<dim> &   mapping,
                                          rhs_values);
 
           cell_vector = 0;
-          for (unsigned int point = 0; point < n_q_points; ++point)
+          for (const auto point : fe_values.quadrature_point_indices())
             for (unsigned int i = 0; i < dofs_per_cell; ++i)
               for (unsigned int comp_i = 0; comp_i < fe.n_components();
                    ++comp_i)

diff --git a/tests/fe/br_approximation_01.cc b/tests/fe/br_approximation_01.cc
index 0e4758d85837cf6c48a8767e662c1737fca14034..365bb002e329966a5af1bff757575f5fa377d088 100644 (file)
--- a/tests/fe/br_approximation_01.cc
+++ b/tests/fe/br_approximation_01.cc
@@ -376,7 +376,7 @@ double TestProjection(Mapping<2> &mapping, DoFHandler<2> *dof_handler)
                                                  Vector<double>(n_components));
           fe_values.get_function_values(solution, this_value);
 
-          for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+          for (const auto q_point : fe_values.quadrature_point_indices())
             {
               double   u = this_value[q_point](0), v = this_value[q_point](1);
               Point<2> p = fe_values.quadrature_point(q_point);

diff --git a/tests/fe/cell_similarity_01.cc b/tests/fe/cell_similarity_01.cc
index bc076c02a7fb5862ed210d7d8437a8403991a364..81f60f915aa30d151f0f8a77284b9b5677ea085a 100644 (file)
--- a/tests/fe/cell_similarity_01.cc
+++ b/tests/fe/cell_similarity_01.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_02.cc b/tests/fe/cell_similarity_02.cc
index fa58ded7ef1499436ff8949c207d3fe58f74f55d..3f81faed719959b1a5700d1495f1353e2271b56c 100644 (file)
--- a/tests/fe/cell_similarity_02.cc
+++ b/tests/fe/cell_similarity_02.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_03.cc b/tests/fe/cell_similarity_03.cc
index a90412198d6c29eff923483a6126114c118c9167..85c3caa9e91ffa6df2c3929e18f169e0ec0ff15e 100644 (file)
--- a/tests/fe/cell_similarity_03.cc
+++ b/tests/fe/cell_similarity_03.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_04.cc b/tests/fe/cell_similarity_04.cc
index f561ed6144f22be6583304dd0874a24597e8bf29..ec3e226664390d0968d469ad703896c2c0678ccd 100644 (file)
--- a/tests/fe/cell_similarity_04.cc
+++ b/tests/fe/cell_similarity_04.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_05.cc b/tests/fe/cell_similarity_05.cc
index ed0b67819e80b9ba3bf8ae79e06d967c3b227721..4bb9d30bef49901f4b4f3401dda83b289beb4cb0 100644 (file)
--- a/tests/fe/cell_similarity_05.cc
+++ b/tests/fe/cell_similarity_05.cc
@@ -99,7 +99,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_06.cc b/tests/fe/cell_similarity_06.cc
index 2beeba42ebcf0eda6966707886bb7df2ce01d35e..69dcb5942e9e83efa551aca205fef3a1e2cf0a46 100644 (file)
--- a/tests/fe/cell_similarity_06.cc
+++ b/tests/fe/cell_similarity_06.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_07.cc b/tests/fe/cell_similarity_07.cc
index 8c460603c473ca8c14cb1e0812ae461d4a475259..3b0a4fbcdd859c84142b8ed9e41fc4f7f360e167 100644 (file)
--- a/tests/fe/cell_similarity_07.cc
+++ b/tests/fe/cell_similarity_07.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_08.cc b/tests/fe/cell_similarity_08.cc
index d188ccbb628876433ab9fef1fd97ceab0fcfd818..1ed45d7decbe23b63004d42170d56d3550d550f1 100644 (file)
--- a/tests/fe/cell_similarity_08.cc
+++ b/tests/fe/cell_similarity_08.cc
@@ -99,7 +99,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_09.cc b/tests/fe/cell_similarity_09.cc
index 4546c54813087cc743468f120f71c310b3b014ee..4a4320d51019cc79e14aeb2e805b6bf3077ce74b 100644 (file)
--- a/tests/fe/cell_similarity_09.cc
+++ b/tests/fe/cell_similarity_09.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_10.cc b/tests/fe/cell_similarity_10.cc
index 622a48a317a5550e79a9181e85e45d26310c6c5e..c689b873b8f14df7f00143a09d7676f18abdf38e 100644 (file)
--- a/tests/fe/cell_similarity_10.cc
+++ b/tests/fe/cell_similarity_10.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_11.cc b/tests/fe/cell_similarity_11.cc
index 59af03ce22c2b42fe1388cb102cccc8e97817298..1995cab4cc8fee8285f2a8d1d6ff8fed03fc6762 100644 (file)
--- a/tests/fe/cell_similarity_11.cc
+++ b/tests/fe/cell_similarity_11.cc
@@ -78,7 +78,7 @@ test(const Triangulation<dim> &tr)
       fe_values.reinit(cell);
 
       deallog << "Jacobians: ";
-      for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+      for (const auto q : fe_values.quadrature_point_indices())
         {
           deallog << "[ ";
           for (unsigned int d = 0; d < dim; ++d)
@@ -88,7 +88,7 @@ test(const Triangulation<dim> &tr)
         }
       deallog << std::endl;
       deallog << "Derivatives of shape function: ";
-      for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+      for (const auto q : fe_values.quadrature_point_indices())
         {
           deallog << "[ ";
           for (unsigned int d = 0; d < dim; ++d)

diff --git a/tests/fe/cell_similarity_12.cc b/tests/fe/cell_similarity_12.cc
index fe0e482eb41f3832aa8a6b81ac88e5907a0a8086..1135bdf40934ead63f73899b6d0ffb44db8e8137 100644 (file)
--- a/tests/fe/cell_similarity_12.cc
+++ b/tests/fe/cell_similarity_12.cc
@@ -79,7 +79,7 @@ test(const unsigned int degree)
         fe_values.reinit(cell);
 
         deallog << "Jacobians: ";
-        for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+        for (const auto q : fe_values.quadrature_point_indices())
           {
             deallog << "[ ";
             for (unsigned int d = 0; d < dim; ++d)
@@ -89,7 +89,7 @@ test(const unsigned int degree)
           }
         deallog << std::endl;
         deallog << "Derivatives of shape function: ";
-        for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+        for (const auto q : fe_values.quadrature_point_indices())
           {
             deallog << "[ ";
             for (unsigned int d = 0; d < dim; ++d)

diff --git a/tests/fe/cell_similarity_13.cc b/tests/fe/cell_similarity_13.cc
index 6e47fb7dfc7e7a7e3065bf805e967fa3587f4663..1312451d0109d40f4ddb501bb2139c19de294639 100644 (file)
--- a/tests/fe/cell_similarity_13.cc
+++ b/tests/fe/cell_similarity_13.cc
@@ -72,7 +72,7 @@ test()
       fe_values.reinit(cell);
 
       deallog << "Jacobians: ";
-      for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+      for (const auto q : fe_values.quadrature_point_indices())
         {
           deallog << "[ ";
           for (unsigned int d = 0; d < dim; ++d)
@@ -82,7 +82,7 @@ test()
         }
       deallog << std::endl;
       deallog << "Derivatives of shape function: ";
-      for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+      for (const auto q : fe_values.quadrature_point_indices())
         {
           deallog << "[ ";
           for (unsigned int d = 0; d < dim; ++d)

diff --git a/tests/fe/cell_similarity_dgp_monomial_01.cc b/tests/fe/cell_similarity_dgp_monomial_01.cc
index 37716797cb82a5cd6249a40c6130e2f8bb9593e2..d9452be4c0f4f72117f3322cfacbe3709b004696 100644 (file)
--- a/tests/fe/cell_similarity_dgp_monomial_01.cc
+++ b/tests/fe/cell_similarity_dgp_monomial_01.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_dgp_monomial_02.cc b/tests/fe/cell_similarity_dgp_monomial_02.cc
index 0f7b51e11fc935490159cf1402398323ee28b750..b40ade24696f1efcba7e6d2278acce8cd4180b18 100644 (file)
--- a/tests/fe/cell_similarity_dgp_monomial_02.cc
+++ b/tests/fe/cell_similarity_dgp_monomial_02.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_dgp_monomial_03.cc b/tests/fe/cell_similarity_dgp_monomial_03.cc
index ccac23ea3132e3f3a32d5e9a7f7d7b70204a6e95..78a75cfcdcf5d2492cae5cbe1be9fb675148aeda 100644 (file)
--- a/tests/fe/cell_similarity_dgp_monomial_03.cc
+++ b/tests/fe/cell_similarity_dgp_monomial_03.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_dgp_monomial_04.cc b/tests/fe/cell_similarity_dgp_monomial_04.cc
index 0cab031577f08686c2806fe94024c515a5204fb5..7e5592940290522b9d4c8f7410c02d209fb1741c 100644 (file)
--- a/tests/fe/cell_similarity_dgp_monomial_04.cc
+++ b/tests/fe/cell_similarity_dgp_monomial_04.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_dgp_monomial_05.cc b/tests/fe/cell_similarity_dgp_monomial_05.cc
index 13dd9c027d2d28059b58ea5401fcee9b0e6116c8..51ae79c9851887e19d7e16ea239d6eab892c2139 100644 (file)
--- a/tests/fe/cell_similarity_dgp_monomial_05.cc
+++ b/tests/fe/cell_similarity_dgp_monomial_05.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_dgp_monomial_06.cc b/tests/fe/cell_similarity_dgp_monomial_06.cc
index 4a479c5c9ffa4dabf414183fc51e667e3d7f5c9c..5161000f2ce424e9588b0dcf7dcfa7175546eabb 100644 (file)
--- a/tests/fe/cell_similarity_dgp_monomial_06.cc
+++ b/tests/fe/cell_similarity_dgp_monomial_06.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_dgp_monomial_07.cc b/tests/fe/cell_similarity_dgp_monomial_07.cc
index 5acc0e4db398b3de201d39fb913f78e675ef3e51..09729810f848751e7d401060e4224b6cf0350a80 100644 (file)
--- a/tests/fe/cell_similarity_dgp_monomial_07.cc
+++ b/tests/fe/cell_similarity_dgp_monomial_07.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_dgp_monomial_08.cc b/tests/fe/cell_similarity_dgp_monomial_08.cc
index 36f4b7e3d58e3be1f41a7d4093654eac69bc30a7..d722d680e1402a2d88f31fd419811363ff888d10 100644 (file)
--- a/tests/fe/cell_similarity_dgp_monomial_08.cc
+++ b/tests/fe/cell_similarity_dgp_monomial_08.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_dgp_monomial_09.cc b/tests/fe/cell_similarity_dgp_monomial_09.cc
index bd8724a47fca7bb9fa1d60a569f09a9284cf0246..84678074f079a944a2fd4e9dfa2d144140ec7470 100644 (file)
--- a/tests/fe/cell_similarity_dgp_monomial_09.cc
+++ b/tests/fe/cell_similarity_dgp_monomial_09.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_dgp_monomial_10.cc b/tests/fe/cell_similarity_dgp_monomial_10.cc
index 9b06eca60c319243c7e320bf0a0a361362420e3e..2d9df34f06334f9d96ecf727859e57bea3d8ae6c 100644 (file)
--- a/tests/fe/cell_similarity_dgp_monomial_10.cc
+++ b/tests/fe/cell_similarity_dgp_monomial_10.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_dgp_nonparametric_01.cc b/tests/fe/cell_similarity_dgp_nonparametric_01.cc
index fe4536309cc388be6affb84ae9250f35da4a3bf0..9fd1b1fa29b6b6a673fb449e7bf5dca5f5044819 100644 (file)
--- a/tests/fe/cell_similarity_dgp_nonparametric_01.cc
+++ b/tests/fe/cell_similarity_dgp_nonparametric_01.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_dgp_nonparametric_02.cc b/tests/fe/cell_similarity_dgp_nonparametric_02.cc
index 098d36c2ffe86226239ff635e5685ff96fe89789..3bdba170d66346470cb82e217b733eccc490486e 100644 (file)
--- a/tests/fe/cell_similarity_dgp_nonparametric_02.cc
+++ b/tests/fe/cell_similarity_dgp_nonparametric_02.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_dgp_nonparametric_03.cc b/tests/fe/cell_similarity_dgp_nonparametric_03.cc
index a54bac82ba842b32775100abf758750ee23d1ad6..cefbbc02b62139b191a7e205ea97d3270cae1169 100644 (file)
--- a/tests/fe/cell_similarity_dgp_nonparametric_03.cc
+++ b/tests/fe/cell_similarity_dgp_nonparametric_03.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_dgp_nonparametric_04.cc b/tests/fe/cell_similarity_dgp_nonparametric_04.cc
index 8cd206e03f779e6d1ed3fd7e72df22d90741c65e..3b3e9f53147aae04435c53d512b5afc4d6dfc381 100644 (file)
--- a/tests/fe/cell_similarity_dgp_nonparametric_04.cc
+++ b/tests/fe/cell_similarity_dgp_nonparametric_04.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_dgp_nonparametric_05.cc b/tests/fe/cell_similarity_dgp_nonparametric_05.cc
index 01b84e7d513c8b465b07048d675af45698d7058f..31d79e2d19fcbcdd243b68e492d17313e83b9f82 100644 (file)
--- a/tests/fe/cell_similarity_dgp_nonparametric_05.cc
+++ b/tests/fe/cell_similarity_dgp_nonparametric_05.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_dgp_nonparametric_06.cc b/tests/fe/cell_similarity_dgp_nonparametric_06.cc
index f4e73f97db49d206a1a9f09404e69f3f854372f6..6951cb5ed586fbdc72a329ab6a2182dfa8d78298 100644 (file)
--- a/tests/fe/cell_similarity_dgp_nonparametric_06.cc
+++ b/tests/fe/cell_similarity_dgp_nonparametric_06.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_dgp_nonparametric_07.cc b/tests/fe/cell_similarity_dgp_nonparametric_07.cc
index 81becf6d933ef9eaad0a7ed3e09ee2805754182d..b7279e242aa95c4b7934cd6f7fd768fb42412c79 100644 (file)
--- a/tests/fe/cell_similarity_dgp_nonparametric_07.cc
+++ b/tests/fe/cell_similarity_dgp_nonparametric_07.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_dgp_nonparametric_08.cc b/tests/fe/cell_similarity_dgp_nonparametric_08.cc
index cfb9ccc4341525db101a7837516509f6095d291d..b6ace3c40db3bfc07f0f1c0ca57abbfefdd5aea3 100644 (file)
--- a/tests/fe/cell_similarity_dgp_nonparametric_08.cc
+++ b/tests/fe/cell_similarity_dgp_nonparametric_08.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_dgp_nonparametric_09.cc b/tests/fe/cell_similarity_dgp_nonparametric_09.cc
index a38b42f4080a0c527a535440ef694656497a2fdd..8a5e8dc4049b1c85904da2d79147c12e52391389 100644 (file)
--- a/tests/fe/cell_similarity_dgp_nonparametric_09.cc
+++ b/tests/fe/cell_similarity_dgp_nonparametric_09.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/cell_similarity_dgp_nonparametric_10.cc b/tests/fe/cell_similarity_dgp_nonparametric_10.cc
index e4d71656e248c8be0084535b84d9812177826945..683ae7f92dec118e59a56e4eed125b867b1d255d 100644 (file)
--- a/tests/fe/cell_similarity_dgp_nonparametric_10.cc
+++ b/tests/fe/cell_similarity_dgp_nonparametric_10.cc
@@ -98,7 +98,7 @@ test(const Triangulation<dim> &tr)
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
         for (unsigned int j = 0; j < fe_values.dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               mass_matrix[cell->index()](i, j) += fe_values.shape_value(i, q) *
                                                   fe_values.shape_value(j, q) *

diff --git a/tests/fe/curl_curl_01.cc b/tests/fe/curl_curl_01.cc
index 6ae2aee7e64057796700bb840fdd375979f187dc..95568c013d9a2bab666d253302ad87302bc73168 100644 (file)
--- a/tests/fe/curl_curl_01.cc
+++ b/tests/fe/curl_curl_01.cc
@@ -348,7 +348,7 @@ MaxwellProblem<dim>::assemble_system()
       fe_values.reinit(cell);
       right_hand_side.vector_value_list(fe_values.get_quadrature_points(),
                                         rhs_values);
-      for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+      for (const auto q_point : fe_values.quadrature_point_indices())
         {
           for (unsigned int i = 0; i < dofs_per_cell; ++i)
             {

diff --git a/tests/fe/deformed_projection.h b/tests/fe/deformed_projection.h
index 81f67dfb35dfda94b768b3fb91301a99348cff37..f957134a5d667608d16d235f824dee1f44005899 100644 (file)
--- a/tests/fe/deformed_projection.h
+++ b/tests/fe/deformed_projection.h
@@ -151,7 +151,7 @@ void EvaluateDerivative(DoFHandler<2> *dof_handler, Vector<double> &solution)
         n_q_points, std::vector<Tensor<1, 2>>(n_components));
       fe_values.get_function_gradients(solution, grads_here);
 
-      for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+      for (const auto q_point : fe_values.quadrature_point_indices())
         {
           //   double u0 = this_value[q_point](0);
           // double v0 = this_value[q_point](1);
@@ -243,7 +243,7 @@ create_mass_matrix(const Mapping<dim> &       mapping,
             {
               coefficient->value_list(fe_values.get_quadrature_points(),
                                       coefficient_values);
-              for (unsigned int point = 0; point < n_q_points; ++point)
+              for (auto point : fe_values.quadrature_point_indices())
                 {
                   const double weight = fe_values.JxW(point);
                   for (unsigned int i = 0; i < dofs_per_cell; ++i)
@@ -266,7 +266,7 @@ create_mass_matrix(const Mapping<dim> &       mapping,
             {
               coefficient->vector_value_list(fe_values.get_quadrature_points(),
                                              coefficient_vector_values);
-              for (unsigned int point = 0; point < n_q_points; ++point)
+              for (auto point : fe_values.quadrature_point_indices())
                 {
                   const double weight = fe_values.JxW(point);
                   for (unsigned int i = 0; i < dofs_per_cell; ++i)
@@ -316,7 +316,7 @@ create_mass_matrix(const Mapping<dim> &       mapping,
                 }
             }
 
-          for (unsigned int point = 0; point < n_q_points; ++point)
+          for (auto point : fe_values.quadrature_point_indices())
             {
               const double weight = fe_values.JxW(point);
               //     const double weight = q.weight(point);
@@ -425,7 +425,7 @@ create_right_hand_side(const Mapping<dim> &   mapping,
                                   rhs_values);
 
           cell_vector = 0;
-          for (unsigned int point = 0; point < n_q_points; ++point)
+          for (auto point : fe_values.quadrature_point_indices())
             for (unsigned int i = 0; i < dofs_per_cell; ++i)
               cell_vector(i) += rhs_values[point] *
                                 fe_values.shape_value(i, point) *
@@ -451,7 +451,7 @@ create_right_hand_side(const Mapping<dim> &   mapping,
                                          rhs_values);
 
           cell_vector = 0;
-          for (unsigned int point = 0; point < n_q_points; ++point)
+          for (auto point : fe_values.quadrature_point_indices())
             for (unsigned int i = 0; i < dofs_per_cell; ++i)
               for (unsigned int comp_i = 0; comp_i < fe.n_components();
                    ++comp_i)

diff --git a/tests/fe/dgp_01.cc b/tests/fe/dgp_01.cc
index 896990794abada8132884509ed44299c1715d036..6017e4da4f514e5b99974b4a80661c3438ad373f 100644 (file)
--- a/tests/fe/dgp_01.cc
+++ b/tests/fe/dgp_01.cc
@@ -57,7 +57,7 @@ test(const unsigned int degree)
        ++cell)
     {
       fe_values.reinit(cell);
-      for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+      for (const auto q : fe_values.quadrature_point_indices())
         AssertThrow(fe_values.shape_value(0, q) == 1, ExcInternalError());
     }
 

diff --git a/tests/fe/fe_abf_gradient_divergence_theorem.cc b/tests/fe/fe_abf_gradient_divergence_theorem.cc
index ad5ebc2d0a9d5b5e140d4be67c58936026a9af29..1d7c7ae1f84a3a1b8317d18120e9f55c0e72e054 100644 (file)
--- a/tests/fe/fe_abf_gradient_divergence_theorem.cc
+++ b/tests/fe/fe_abf_gradient_divergence_theorem.cc
@@ -104,7 +104,7 @@ test(const Triangulation<dim> &tr,
               ss << "component=" << c << ", dof=" << i << std::endl;
 
               Tensor<1, dim> bulk_integral;
-              for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+              for (const auto q : fe_values.quadrature_point_indices())
                 {
                   bulk_integral += fe_values[single_component].gradient(i, q) *
                                    fe_values.JxW(q);
@@ -114,9 +114,7 @@ test(const Triangulation<dim> &tr,
               for (const unsigned int face : GeometryInfo<dim>::face_indices())
                 {
                   fe_face_values.reinit(cell, face);
-                  for (unsigned int q = 0;
-                       q < fe_face_values.n_quadrature_points;
-                       ++q)
+                  for (const auto q : fe_face_values.quadrature_point_indices())
                     {
                       boundary_integral +=
                         fe_face_values[single_component].value(i, q) *

diff --git a/tests/fe/fe_br.cc b/tests/fe/fe_br.cc
index 45636bf8d7d9555a9cbe6e08c7e56b41462ef066..2e554873630d6b455d13c47e671fd7e06accb77a 100644 (file)
--- a/tests/fe/fe_br.cc
+++ b/tests/fe/fe_br.cc
@@ -93,7 +93,7 @@ test(const Triangulation<dim> &tr,
               ss << "component=" << c << ", dof=" << i << std::endl;
 
               Tensor<1, dim> bulk_integral;
-              for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+              for (const auto q : fe_values.quadrature_point_indices())
                 {
                   bulk_integral += fe_values[single_component].gradient(i, q) *
                                    fe_values.JxW(q);

diff --git a/tests/fe/fe_dgp_3rd_derivative_divergence_theorem.cc b/tests/fe/fe_dgp_3rd_derivative_divergence_theorem.cc
index 4add01e1d291cd0f5761d106d5832a423562fe55..d7b6cb6afbb461ef3a99e2b824579f9dad40786b 100644 (file)
--- a/tests/fe/fe_dgp_3rd_derivative_divergence_theorem.cc
+++ b/tests/fe/fe_dgp_3rd_derivative_divergence_theorem.cc
@@ -102,7 +102,7 @@ test(const Triangulation<dim> &tr,
               ss << "component=" << c << ", dof=" << i << std::endl;
 
               Tensor<3, dim> bulk_integral;
-              for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+              for (const auto q : fe_values.quadrature_point_indices())
                 {
                   bulk_integral +=
                     fe_values[single_component].third_derivative(i, q) *
@@ -116,9 +116,7 @@ test(const Triangulation<dim> &tr,
               for (const unsigned int face : GeometryInfo<dim>::face_indices())
                 {
                   fe_face_values.reinit(cell, face);
-                  for (unsigned int q = 0;
-                       q < fe_face_values.n_quadrature_points;
-                       ++q)
+                  for (const auto q : fe_face_values.quadrature_point_indices())
                     {
                       Tensor<2, dim> hessian =
                         fe_face_values[single_component].hessian(i, q);

diff --git a/tests/fe/fe_dgq_3rd_derivative_divergence_theorem.cc b/tests/fe/fe_dgq_3rd_derivative_divergence_theorem.cc
index 60719e0c5a6bd17070c9a84298c39c7123c3ad64..c2fed59e2bf5b3f1e0a442fc34d2b3198c9c15a4 100644 (file)
--- a/tests/fe/fe_dgq_3rd_derivative_divergence_theorem.cc
+++ b/tests/fe/fe_dgq_3rd_derivative_divergence_theorem.cc
@@ -101,7 +101,7 @@ test(const Triangulation<dim> &tr,
               ss << "component=" << c << ", dof=" << i << std::endl;
 
               Tensor<3, dim> bulk_integral;
-              for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+              for (const auto q : fe_values.quadrature_point_indices())
                 {
                   bulk_integral +=
                     fe_values[single_component].third_derivative(i, q) *
@@ -115,9 +115,7 @@ test(const Triangulation<dim> &tr,
               for (const unsigned int face : GeometryInfo<dim>::face_indices())
                 {
                   fe_face_values.reinit(cell, face);
-                  for (unsigned int q = 0;
-                       q < fe_face_values.n_quadrature_points;
-                       ++q)
+                  for (const auto q : fe_face_values.quadrature_point_indices())
                     {
                       Tensor<2, dim> hessian =
                         fe_face_values[single_component].hessian(i, q);

diff --git a/tests/fe/fe_dgq_gradient_divergence_theorem.cc b/tests/fe/fe_dgq_gradient_divergence_theorem.cc
index d1b4eacc53c9d54ead52bf3d3a10daea1b12d5d6..d988e963d24f3652c68e4fc72131b990603f55d8 100644 (file)
--- a/tests/fe/fe_dgq_gradient_divergence_theorem.cc
+++ b/tests/fe/fe_dgq_gradient_divergence_theorem.cc
@@ -103,7 +103,7 @@ test(const Triangulation<dim> &tr,
               ss << "component=" << c << ", dof=" << i << std::endl;
 
               Tensor<1, dim> bulk_integral;
-              for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+              for (const auto q : fe_values.quadrature_point_indices())
                 {
                   bulk_integral += fe_values[single_component].gradient(i, q) *
                                    fe_values.JxW(q);
@@ -113,9 +113,7 @@ test(const Triangulation<dim> &tr,
               for (const unsigned int face : GeometryInfo<dim>::face_indices())
                 {
                   fe_face_values.reinit(cell, face);
-                  for (unsigned int q = 0;
-                       q < fe_face_values.n_quadrature_points;
-                       ++q)
+                  for (const auto q : fe_face_values.quadrature_point_indices())
                     {
                       boundary_integral +=
                         fe_face_values[single_component].value(i, q) *

diff --git a/tests/fe/fe_dgq_hessian_divergence_theorem.cc b/tests/fe/fe_dgq_hessian_divergence_theorem.cc
index f8b2e29adde4395c2a8b0cff0c4518e03864d58a..292043c293a5ffb694c4bcb494624696169ddab8 100644 (file)
--- a/tests/fe/fe_dgq_hessian_divergence_theorem.cc
+++ b/tests/fe/fe_dgq_hessian_divergence_theorem.cc
@@ -103,7 +103,7 @@ test(const Triangulation<dim> &tr,
               ss << "component=" << c << ", dof=" << i << std::endl;
 
               Tensor<2, dim> bulk_integral;
-              for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+              for (const auto q : fe_values.quadrature_point_indices())
                 {
                   bulk_integral += fe_values[single_component].hessian(i, q) *
                                    fe_values.JxW(q);
@@ -113,9 +113,7 @@ test(const Triangulation<dim> &tr,
               for (const unsigned int face : GeometryInfo<dim>::face_indices())
                 {
                   fe_face_values.reinit(cell, face);
-                  for (unsigned int q = 0;
-                       q < fe_face_values.n_quadrature_points;
-                       ++q)
+                  for (const auto q : fe_face_values.quadrature_point_indices())
                     {
                       Tensor<1, dim> gradient =
                         fe_face_values[single_component].gradient(i, q);

diff --git a/tests/fe/fe_enriched_02.cc b/tests/fe/fe_enriched_02.cc
index 5a1649369d0ae959faa1395aee43a164ef83063c..90e5178aac67de10439f7bdb9628a402ab2995ca 100644 (file)
--- a/tests/fe/fe_enriched_02.cc
+++ b/tests/fe/fe_enriched_02.cc
@@ -111,7 +111,7 @@ test1()
         fe_values.get_quadrature_points();
 
       for (unsigned int i = 0; i < dofs_per_cell; ++i)
-        for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+        for (const auto q_point : fe_values.quadrature_point_indices())
           deallog << "dof=" << i << " qp=" << q_points[q_point]
                   << " f(qp)=" << function.value(q_points[q_point])
                   << " N(qp)=" << fe_values.shape_value(i, q_point)

diff --git a/tests/fe/fe_enriched_03.cc b/tests/fe/fe_enriched_03.cc
index 4b7a3249b40aeaf0d18f1dc507f6e6583f73ad77..b37de778f60aa31a52a59ddfb945c7861af69c95 100644 (file)
--- a/tests/fe/fe_enriched_03.cc
+++ b/tests/fe/fe_enriched_03.cc
@@ -105,7 +105,7 @@ test2()
           fe_face_values.get_quadrature_points();
 
         for (unsigned int i = 0; i < dofs_per_cell; ++i)
-          for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+          for (const auto q_point : fe_face_values.quadrature_point_indices())
             deallog << "dof=" << i << " qp=" << q_points[q_point]
                     << " f(qp)=" << function.value(q_points[q_point])
                     << " N(qp)=" << fe_face_values.shape_value(i, q_point)

diff --git a/tests/fe/fe_enriched_04.cc b/tests/fe/fe_enriched_04.cc
index b83b6e81240a81b934d4fee3766df94bef92fdae..53624c2b4fd876f8091a134d177b5fa475c93a8c 100644 (file)
--- a/tests/fe/fe_enriched_04.cc
+++ b/tests/fe/fe_enriched_04.cc
@@ -130,7 +130,7 @@ test3()
       fe_values.get_function_values(solution_pou, solution_values_pou);
       fe_values.get_function_values(solution, solution_values);
 
-      for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+      for (const auto q_point : fe_values.quadrature_point_indices())
         deallog << " qp=" << q_points[q_point]
                 << " f(qp)=" << function.value(q_points[q_point])
                 << " U_fe(qp)=" << solution_values_fe[q_point]

diff --git a/tests/fe/fe_enriched_06.cc b/tests/fe/fe_enriched_06.cc
index d75e79a89084bda721cd0ab759da029c7f6b8104..e635250d0ef297d181666abbf54a0511f873fce9 100644 (file)
--- a/tests/fe/fe_enriched_06.cc
+++ b/tests/fe/fe_enriched_06.cc
@@ -144,7 +144,7 @@ test5()
         fe_values.get_function_values(solution, solution_values);
 
         deallog << " cell=" << cell->center() << std::endl;
-        for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+        for (const auto q_point : fe_values.quadrature_point_indices())
           {
             // find non-zero shape_value
             deallog << " qp=" << q_points[q_point]

diff --git a/tests/fe/fe_enriched_color_07.cc b/tests/fe/fe_enriched_color_07.cc
index 89e4f4f55c6bcf1531efc2ae4bc35c504ec74cd7..dfdba4fbba5da3154bc8aa2512ce510a9af24636 100644 (file)
--- a/tests/fe/fe_enriched_color_07.cc
+++ b/tests/fe/fe_enriched_color_07.cc
@@ -752,7 +752,7 @@ EstimateEnrichmentFunction::assemble_system()
       rhs_values.resize(n_q_points);
       rhs.value_list(fe_values.get_quadrature_points(), rhs_values);
 
-      for (unsigned int q_index = 0; q_index < n_q_points; ++q_index)
+      for (const auto q_index : fe_values.quadrature_point_indices())
         {
           double radius = center.distance(fe_values.quadrature_point(q_index));
 
@@ -1521,7 +1521,7 @@ LaplaceProblem<dim>::assemble_system()
                                   tmp_rhs_value);
 
             // add tmp to the total one at quadrature points
-            for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+            for (const auto q_point : fe_values.quadrature_point_indices())
               {
                 rhs_value[q_point] += tmp_rhs_value[q_point];
               }
@@ -1534,7 +1534,7 @@ LaplaceProblem<dim>::assemble_system()
         cell_system_matrix = 0;
         cell_rhs           = 0;
 
-        for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+        for (const auto q_point : fe_values.quadrature_point_indices())
           for (unsigned int i = 0; i < dofs_per_cell; ++i)
             {
               for (unsigned int j = i; j < dofs_per_cell; ++j)

diff --git a/tests/fe/fe_enriched_compare_to_fe_system.cc b/tests/fe/fe_enriched_compare_to_fe_system.cc
index e03ad8e44a6e30d477d27d9ee19627dd3dcbffa8..f2f1ca9dd7b5fb511b5a05da01a3d790ce924b4c 100644 (file)
--- a/tests/fe/fe_enriched_compare_to_fe_system.cc
+++ b/tests/fe/fe_enriched_compare_to_fe_system.cc
@@ -229,7 +229,7 @@ test(const FiniteElement<dim> & fe1,
 
       // check shape functions
       for (unsigned int i = 0; i < dofs_per_cell; ++i)
-        for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+        for (const auto q_point : fe_values_system.quadrature_point_indices())
           check_consistency(
             q_points[q_point],
             function,
@@ -252,7 +252,8 @@ test(const FiniteElement<dim> & fe1,
             fe_face_values_system.get_quadrature_points();
 
           for (unsigned int i = 0; i < dofs_per_cell; ++i)
-            for (unsigned int q_point = 0; q_point < n_q_points_face; ++q_point)
+            for (const auto q_point :
+                 fe_face_values_system.quadrature_point_indices())
               check_consistency(
                 q_points[q_point],
                 function,

diff --git a/tests/fe/fe_enriched_compare_to_fe_system_2.cc b/tests/fe/fe_enriched_compare_to_fe_system_2.cc
index ab3550f94e5a162df408d8462b8d11cbe077bbfd..21dc8784a58721840207266b04ef01caf9a3a9ef 100644 (file)
--- a/tests/fe/fe_enriched_compare_to_fe_system_2.cc
+++ b/tests/fe/fe_enriched_compare_to_fe_system_2.cc
@@ -308,7 +308,7 @@ test(const FiniteElement<dim> & fe_base,
 
       // check shape functions
       for (unsigned int i = 0; i < dofs_per_cell; ++i)
-        for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+        for (const auto q_point : fe_values_system.quadrature_point_indices())
           check_consistency(
             q_points[q_point],
             fun1,
@@ -339,7 +339,8 @@ test(const FiniteElement<dim> & fe_base,
             fe_face_values_system.get_quadrature_points();
 
           for (unsigned int i = 0; i < dofs_per_cell; ++i)
-            for (unsigned int q_point = 0; q_point < n_q_points_face; ++q_point)
+            for (const auto q_point :
+                 fe_face_values_system.quadrature_point_indices())
               check_consistency(
                 q_points[q_point],
                 fun1,

diff --git a/tests/fe/fe_enriched_step-36.cc b/tests/fe/fe_enriched_step-36.cc
index 82cd66b7907f5254f98f51260b1ecfcfb7a87d3f..0add928260a2339b19222d3dcb85a59f15608ae3 100644 (file)
--- a/tests/fe/fe_enriched_step-36.cc
+++ b/tests/fe/fe_enriched_step-36.cc
@@ -410,7 +410,7 @@ namespace Step36
           potential.value_list(fe_values.get_quadrature_points(),
                                potential_values);
 
-          for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+          for (const auto q_point : fe_values.quadrature_point_indices())
             for (unsigned int i = 0; i < dofs_per_cell; ++i)
               for (unsigned int j = i; j < dofs_per_cell; ++j)
                 {

diff --git a/tests/fe/fe_enriched_step-36b.cc b/tests/fe/fe_enriched_step-36b.cc
index 8a6187bf815922932aaeefe61fe0ff863fe1b417..38c79aa84e17d2aa390c5bb06dba12e27745f634 100644 (file)
--- a/tests/fe/fe_enriched_step-36b.cc
+++ b/tests/fe/fe_enriched_step-36b.cc
@@ -480,7 +480,7 @@ namespace Step36
 
           if (cell->active_fe_index() == 0) // plain FE
             {
-              for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+              for (const auto q_point : fe_values.quadrature_point_indices())
                 for (unsigned int i = 0; i < dofs_per_cell; ++i)
                   for (unsigned int j = i; j < dofs_per_cell; ++j)
                     {
@@ -518,8 +518,8 @@ namespace Step36
 
                       if (i_group == fe_group && j_group == fe_group) // fe - fe
                         {
-                          for (unsigned int q_point = 0; q_point < n_q_points;
-                               ++q_point)
+                          for (const auto q_point :
+                               fe_values.quadrature_point_indices())
                             {
                               cell_stiffness_matrix(i, j) +=
                                 (fe_values[fe_extractor].gradient(i, q_point) *
@@ -540,8 +540,8 @@ namespace Step36
                       else if (i_group == fe_group &&
                                j_group == pou_group) // fe - pou
                         {
-                          for (unsigned int q_point = 0; q_point < n_q_points;
-                               ++q_point)
+                          for (const auto q_point :
+                               fe_values.quadrature_point_indices())
                             {
                               cell_stiffness_matrix(i, j) +=
                                 (fe_values[fe_extractor].gradient(i, q_point) *
@@ -567,8 +567,8 @@ namespace Step36
                       else if (i_group == pou_group &&
                                j_group == fe_group) // pou - fe
                         {
-                          for (unsigned int q_point = 0; q_point < n_q_points;
-                               ++q_point)
+                          for (const auto q_point :
+                               fe_values.quadrature_point_indices())
                             {
                               cell_stiffness_matrix(i, j) +=
                                 ((fe_values[pou_extractor].gradient(i,
@@ -597,8 +597,8 @@ namespace Step36
                           Assert(i_group == pou_group && j_group == pou_group,
                                  ExcInternalError());
 
-                          for (unsigned int q_point = 0; q_point < n_q_points;
-                               ++q_point)
+                          for (const auto q_point :
+                               fe_values.quadrature_point_indices())
                             {
                               cell_stiffness_matrix(i, j) +=
                                 ((fe_values[pou_extractor].gradient(i,

diff --git a/tests/fe/fe_face_orientation_nedelec.h b/tests/fe/fe_face_orientation_nedelec.h
index 8d8c0c4fb123b2762c109c6b3af259cb20955061..b0ac7a98f421a53131d0d0e22b5fa4f113ef3fe1 100644 (file)
--- a/tests/fe/fe_face_orientation_nedelec.h
+++ b/tests/fe/fe_face_orientation_nedelec.h
@@ -212,7 +212,7 @@ evaluate(const FE_Nedelec<3> & fe,
       fe_field_function.vector_value_list(fe_values.get_quadrature_points(),
                                           values);
 
-      for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+      for (const auto q_point : fe_values.quadrature_point_indices())
         {
           for (unsigned int d = 0; d < 3; ++d)
             deallog << values_ref[q_point][d] - values[q_point](d) << "  ";

diff --git a/tests/fe/fe_face_orientation_nedelec_0.cc b/tests/fe/fe_face_orientation_nedelec_0.cc
index c5e6deaeeebc84e6e44841844d3e7384b02fe1d2..f47f8d7de36170ccde18ab922203a76c2660449f 100644 (file)
--- a/tests/fe/fe_face_orientation_nedelec_0.cc
+++ b/tests/fe/fe_face_orientation_nedelec_0.cc
@@ -129,7 +129,7 @@ evaluate(const FE_Nedelec<3> & fe,
                                           values);
       std::vector<types::global_dof_index> dof_indices(fe.dofs_per_cell);
       cell->get_dof_indices(dof_indices);
-      for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+      for (const auto q_point : fe_values.quadrature_point_indices())
         {
           for (unsigned int d = 0; d < 3; ++d)
             deallog << values_ref[q_point][d] - values[q_point](d) << "  ";

diff --git a/tests/fe/fe_nedelec_gradient_divergence_theorem.cc b/tests/fe/fe_nedelec_gradient_divergence_theorem.cc
index d8818c47053a7b4369ed82433e4add11c2358b53..f5091d50c42f06c1f7c8899f590600ae305c6240 100644 (file)
--- a/tests/fe/fe_nedelec_gradient_divergence_theorem.cc
+++ b/tests/fe/fe_nedelec_gradient_divergence_theorem.cc
@@ -103,7 +103,7 @@ test(const Triangulation<dim> &tr,
               ss << "component=" << c << ", dof=" << i << std::endl;
 
               Tensor<1, dim> bulk_integral;
-              for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+              for (const auto q : fe_values.quadrature_point_indices())
                 {
                   bulk_integral += fe_values[single_component].gradient(i, q) *
                                    fe_values.JxW(q);
@@ -113,9 +113,7 @@ test(const Triangulation<dim> &tr,
               for (const unsigned int face : GeometryInfo<dim>::face_indices())
                 {
                   fe_face_values.reinit(cell, face);
-                  for (unsigned int q = 0;
-                       q < fe_face_values.n_quadrature_points;
-                       ++q)
+                  for (const auto q : fe_face_values.quadrature_point_indices())
                     {
                       boundary_integral +=
                         fe_face_values[single_component].value(i, q) *

diff --git a/tests/fe/fe_nedelec_hessian_divergence_theorem.cc b/tests/fe/fe_nedelec_hessian_divergence_theorem.cc
index 629f04d0e04d15e3fff2e2d1f389f30d33779aa3..f669ee5310224cca879f2586c63e554054e9b186 100644 (file)
--- a/tests/fe/fe_nedelec_hessian_divergence_theorem.cc
+++ b/tests/fe/fe_nedelec_hessian_divergence_theorem.cc
@@ -103,7 +103,7 @@ test(const Triangulation<dim> &tr,
               ss << "component=" << c << ", dof=" << i << std::endl;
 
               Tensor<2, dim> bulk_integral;
-              for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+              for (const auto q : fe_values.quadrature_point_indices())
                 {
                   bulk_integral += fe_values[single_component].hessian(i, q) *
                                    fe_values.JxW(q);
@@ -113,9 +113,7 @@ test(const Triangulation<dim> &tr,
               for (const unsigned int face : GeometryInfo<dim>::face_indices())
                 {
                   fe_face_values.reinit(cell, face);
-                  for (unsigned int q = 0;
-                       q < fe_face_values.n_quadrature_points;
-                       ++q)
+                  for (const auto q : fe_face_values.quadrature_point_indices())
                     {
                       Tensor<1, dim> gradient =
                         fe_face_values[single_component].gradient(i, q);

diff --git a/tests/fe/fe_nedelec_singularity_01.cc b/tests/fe/fe_nedelec_singularity_01.cc
index 52f3b4428f350ec79c289b33a500915ee9100d23..24569204582985bebd8d8505cdcf2b681a229d49 100644 (file)
--- a/tests/fe/fe_nedelec_singularity_01.cc
+++ b/tests/fe/fe_nedelec_singularity_01.cc
@@ -448,7 +448,7 @@ namespace nedelec_singularity
             right_hand_side.vector_value_list(fe_values.get_quadrature_points(),
                                               rhs_values);
 
-            for (unsigned int q = 0; q < n_q_points; ++q)
+            for (const auto q : fe_values.quadrature_point_indices())
               {
                 Tensor<1, dim, std::complex<double>> rhs;
 

diff --git a/tests/fe/fe_nedelec_singularity_02.cc b/tests/fe/fe_nedelec_singularity_02.cc
index 3987aebf31ca5208146e7d52c57d445e15243a2f..107a153f2e3acb9314f9acc36a9e46bc7e7f8d2a 100644 (file)
--- a/tests/fe/fe_nedelec_singularity_02.cc
+++ b/tests/fe/fe_nedelec_singularity_02.cc
@@ -437,7 +437,7 @@ namespace nedelec_singularity
             right_hand_side.vector_value_list(fe_values.get_quadrature_points(),
                                               rhs_values);
 
-            for (unsigned int q = 0; q < n_q_points; ++q)
+            for (const auto q : fe_values.quadrature_point_indices())
               {
                 Tensor<1, dim> rhs;
 

diff --git a/tests/fe/fe_nedelec_sz_gradient_divergence_theorem.cc b/tests/fe/fe_nedelec_sz_gradient_divergence_theorem.cc
index ffc09e9ec9ec28398f50a04d7a74f156e27f2b11..55ed223edc23f1875cf5d45c655316a8811439d9 100644 (file)
--- a/tests/fe/fe_nedelec_sz_gradient_divergence_theorem.cc
+++ b/tests/fe/fe_nedelec_sz_gradient_divergence_theorem.cc
@@ -102,7 +102,7 @@ test(const Triangulation<dim> &tr,
               ss << "component=" << c << ", dof=" << i << std::endl;
 
               Tensor<1, dim> bulk_integral;
-              for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+              for (const auto q : fe_values.quadrature_point_indices())
                 {
                   bulk_integral += fe_values[single_component].gradient(i, q) *
                                    fe_values.JxW(q);
@@ -112,9 +112,7 @@ test(const Triangulation<dim> &tr,
               for (const unsigned int face : GeometryInfo<dim>::face_indices())
                 {
                   fe_face_values.reinit(cell, face);
-                  for (unsigned int q = 0;
-                       q < fe_face_values.n_quadrature_points;
-                       ++q)
+                  for (const auto q : fe_face_values.quadrature_point_indices())
                     {
                       boundary_integral +=
                         fe_face_values[single_component].value(i, q) *

diff --git a/tests/fe/fe_nedelec_sz_non_rect_2d.cc b/tests/fe/fe_nedelec_sz_non_rect_2d.cc
index b06269d40db7c6c01f79784960cb8edf5c0a931f..2e1e97010e35093dad7d77a9e5d3ec9b6f6c38bb 100644 (file)
--- a/tests/fe/fe_nedelec_sz_non_rect_2d.cc
+++ b/tests/fe/fe_nedelec_sz_non_rect_2d.cc
@@ -252,7 +252,7 @@ namespace polytest
 
         right_hand_side.rhs_value_list(fe_values.get_quadrature_points(),
                                        rhs_value_list);
-        for (unsigned int q = 0; q < n_q_points; ++q)
+        for (const auto q : fe_values.quadrature_point_indices())
           {
             Tensor<1, dim> rhs_value;
             for (unsigned int d = 0; d < dim; ++d)

diff --git a/tests/fe/fe_nedelec_sz_non_rect_face.cc b/tests/fe/fe_nedelec_sz_non_rect_face.cc
index 2546263d0f0ebade0bb0f10bbe8076246df7eb53..13d9f254312c3bc0edd824748b3170b9e7ce78ab 100644 (file)
--- a/tests/fe/fe_nedelec_sz_non_rect_face.cc
+++ b/tests/fe/fe_nedelec_sz_non_rect_face.cc
@@ -254,7 +254,7 @@ namespace Maxwell
         // Calc values of curlE from fe solution:
         cell->get_dof_indices(local_dof_indices);
         // Loop over quad points to calculate solution:
-        for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+        for (const auto q_point : fe_values.quadrature_point_indices())
           {
             // Split exact solution into real/imaginary parts:
             for (unsigned int component = 0; component < dim; component++)
@@ -371,7 +371,7 @@ namespace Maxwell
                                          rhs_value_list);
 
         // Loop over all element quad points:
-        for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+        for (const auto q_point : fe_values.quadrature_point_indices())
           {
             // store rhs value at this q point & turn into tensor
             for (unsigned int component = 0; component < dim; component++)

diff --git a/tests/fe/fe_project_2d.cc b/tests/fe/fe_project_2d.cc
index c52d5828ef39693e7e5fc661372586183c6d916e..c0ebd4c984c9fc764436552f964bc744c7f8f64f 100644 (file)
--- a/tests/fe/fe_project_2d.cc
+++ b/tests/fe/fe_project_2d.cc
@@ -228,7 +228,7 @@ test(const FiniteElement<dim> &fe,
           const std::vector<double> &JxW_values = fe_values.get_JxW_values();
           fe_values[vec].get_function_divergences(v, div_v);
           fe_values[vec].get_function_curls(v, curl_v);
-          for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+          for (const auto q_point : fe_values.quadrature_point_indices())
             {
               total_div += JxW_values[q_point] * div_v[q_point];
               total_curl += JxW_values[q_point] * curl_v[q_point];

diff --git a/tests/fe/fe_project_3d.cc b/tests/fe/fe_project_3d.cc
index fb94bb407a73ff82886165f6daad1b67565a50d0..9c64fd11e63a69df1f22147d2a0d41f4c15dd856 100644 (file)
--- a/tests/fe/fe_project_3d.cc
+++ b/tests/fe/fe_project_3d.cc
@@ -311,7 +311,7 @@ test(const FiniteElement<dim> &fe,
           fe_values[vec].get_function_divergences(v, div_v);
           fe_values[vec].get_function_curls(v, curl_v);
           fe_values[vec].get_function_hessians(v, hessians);
-          for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+          for (const auto q_point : fe_values.quadrature_point_indices())
             {
               total_div += JxW_values[q_point] * div_v[q_point];
               total_curl += JxW_values[q_point] * curl_v[q_point];

diff --git a/tests/fe/fe_q_3rd_derivative_divergence_theorem.cc b/tests/fe/fe_q_3rd_derivative_divergence_theorem.cc
index a6e826c6c018d3e644ad91f39c9c590a4f56350f..5b40e594e9b6e9f3f4386883334f55a0cf6debda 100644 (file)
--- a/tests/fe/fe_q_3rd_derivative_divergence_theorem.cc
+++ b/tests/fe/fe_q_3rd_derivative_divergence_theorem.cc
@@ -101,7 +101,7 @@ test(const Triangulation<dim> &tr,
               ss << "component=" << c << ", dof=" << i << std::endl;
 
               Tensor<3, dim> bulk_integral;
-              for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+              for (const auto q : fe_values.quadrature_point_indices())
                 {
                   bulk_integral +=
                     fe_values[single_component].third_derivative(i, q) *
@@ -115,9 +115,7 @@ test(const Triangulation<dim> &tr,
               for (const unsigned int face : GeometryInfo<dim>::face_indices())
                 {
                   fe_face_values.reinit(cell, face);
-                  for (unsigned int q = 0;
-                       q < fe_face_values.n_quadrature_points;
-                       ++q)
+                  for (const auto q : fe_face_values.quadrature_point_indices())
                     {
                       Tensor<2, dim> hessian =
                         fe_face_values[single_component].hessian(i, q);

diff --git a/tests/fe/fe_q_bubbles.cc b/tests/fe/fe_q_bubbles.cc
index 2cb779ee82fe85d46888a190f46b883fd059801b..aa0df744962badf89e27e07a95bdc22cbdb6fb80 100644 (file)
--- a/tests/fe/fe_q_bubbles.cc
+++ b/tests/fe/fe_q_bubbles.cc
@@ -222,7 +222,7 @@ Step3<dim>::assemble_system(unsigned int i)
       cell_rhs    = 0;
 
       for (unsigned int i = 0; i < dofs_per_cell; ++i)
-        for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+        for (const auto q_point : fe_values.quadrature_point_indices())
           {
             for (unsigned int j = 0; j < dofs_per_cell; ++j)
               cell_matrix(i, j) +=

diff --git a/tests/fe/fe_q_dg0.cc b/tests/fe/fe_q_dg0.cc
index 618224d1981affd1b4e1d04e932b6ba609db874d..b216d956bf5a35c714582c8b2b756e5e0b55d931 100644 (file)
--- a/tests/fe/fe_q_dg0.cc
+++ b/tests/fe/fe_q_dg0.cc
@@ -556,7 +556,7 @@ namespace Step22
 
         right_hand_side.vector_value_list(fe_values.get_quadrature_points(),
                                           rhs_values);
-        for (unsigned int q = 0; q < n_q_points; ++q)
+        for (const auto q : fe_values.quadrature_point_indices())
           {
             for (unsigned int k = 0; k < dofs_per_cell; ++k)
               {
@@ -604,7 +604,7 @@ namespace Step22
                     const std::vector<Point<dim>> &quad_points =
                       fe_v_face.get_quadrature_points();
 
-                    for (unsigned int q = 0; q < n_q_face; ++q)
+                    for (const auto q : fe_v_face.quadrature_point_indices())
                       {
                         double jump =
                           jumpfunction.jump(quad_points[q], normals[q]);
@@ -932,7 +932,7 @@ namespace Step22
         fe_v.reinit(cell);
         cell->get_dof_indices(local_dof_indices);
 
-        for (unsigned int q = 0; q < n_q_points; ++q)
+        for (const auto q : fe_v.quadrature_point_indices())
           {
             double div = 0;
             for (unsigned int i = 0; i < dofs_per_cell - 1; ++i)

diff --git a/tests/fe/fe_q_gradient_divergence_theorem.cc b/tests/fe/fe_q_gradient_divergence_theorem.cc
index 85dd24de4baa565a5534bdc4e5d0614728cd3363..3f221ee4c75b2124dc92f5af862c6e67280e21ce 100644 (file)
--- a/tests/fe/fe_q_gradient_divergence_theorem.cc
+++ b/tests/fe/fe_q_gradient_divergence_theorem.cc
@@ -103,7 +103,7 @@ test(const Triangulation<dim> &tr,
               ss << "component=" << c << ", dof=" << i << std::endl;
 
               Tensor<1, dim> bulk_integral;
-              for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+              for (const auto q : fe_values.quadrature_point_indices())
                 {
                   bulk_integral += fe_values[single_component].gradient(i, q) *
                                    fe_values.JxW(q);
@@ -113,9 +113,7 @@ test(const Triangulation<dim> &tr,
               for (const unsigned int face : GeometryInfo<dim>::face_indices())
                 {
                   fe_face_values.reinit(cell, face);
-                  for (unsigned int q = 0;
-                       q < fe_face_values.n_quadrature_points;
-                       ++q)
+                  for (const auto q : fe_face_values.quadrature_point_indices())
                     {
                       boundary_integral +=
                         fe_face_values[single_component].value(i, q) *

diff --git a/tests/fe/fe_q_hessian_divergence_theorem.cc b/tests/fe/fe_q_hessian_divergence_theorem.cc
index 42f83c22a53f7b5e51f8a36d552ed97cae0d39c9..fa016d9b0ac78bab6a0e71baf7ac19536a5f2714 100644 (file)
--- a/tests/fe/fe_q_hessian_divergence_theorem.cc
+++ b/tests/fe/fe_q_hessian_divergence_theorem.cc
@@ -103,7 +103,7 @@ test(const Triangulation<dim> &tr,
               ss << "component=" << c << ", dof=" << i << std::endl;
 
               Tensor<2, dim> bulk_integral;
-              for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+              for (const auto q : fe_values.quadrature_point_indices())
                 {
                   bulk_integral += fe_values[single_component].hessian(i, q) *
                                    fe_values.JxW(q);
@@ -113,9 +113,7 @@ test(const Triangulation<dim> &tr,
               for (const unsigned int face : GeometryInfo<dim>::face_indices())
                 {
                   fe_face_values.reinit(cell, face);
-                  for (unsigned int q = 0;
-                       q < fe_face_values.n_quadrature_points;
-                       ++q)
+                  for (const auto q : fe_face_values.quadrature_point_indices())
                     {
                       Tensor<1, dim> gradient =
                         fe_face_values[single_component].gradient(i, q);

diff --git a/tests/fe/fe_q_hierarchical_3rd_derivative_divergence_theorem.cc b/tests/fe/fe_q_hierarchical_3rd_derivative_divergence_theorem.cc
index 5b60be2f452440ebb7c051da9073ee58a6cd971c..0ff447428ff6ba919feb851db597b919f7e3927a 100644 (file)
--- a/tests/fe/fe_q_hierarchical_3rd_derivative_divergence_theorem.cc
+++ b/tests/fe/fe_q_hierarchical_3rd_derivative_divergence_theorem.cc
@@ -102,7 +102,7 @@ test(const Triangulation<dim> &tr,
               ss << "component=" << c << ", dof=" << i << std::endl;
 
               Tensor<3, dim> bulk_integral;
-              for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+              for (const auto q : fe_values.quadrature_point_indices())
                 {
                   bulk_integral +=
                     fe_values[single_component].third_derivative(i, q) *
@@ -116,9 +116,7 @@ test(const Triangulation<dim> &tr,
               for (const unsigned int face : GeometryInfo<dim>::face_indices())
                 {
                   fe_face_values.reinit(cell, face);
-                  for (unsigned int q = 0;
-                       q < fe_face_values.n_quadrature_points;
-                       ++q)
+                  for (const auto q : fe_face_values.quadrature_point_indices())
                     {
                       Tensor<2, dim> hessian =
                         fe_face_values[single_component].hessian(i, q);

diff --git a/tests/fe/fe_rt_gradient_divergence_theorem.cc b/tests/fe/fe_rt_gradient_divergence_theorem.cc
index f9e3615777025bec92816c546f5714bda4f10c64..c9931a78efa6f2e42216e080db07294b9ee02bb6 100644 (file)
--- a/tests/fe/fe_rt_gradient_divergence_theorem.cc
+++ b/tests/fe/fe_rt_gradient_divergence_theorem.cc
@@ -103,7 +103,7 @@ test(const Triangulation<dim> &tr,
               ss << "component=" << c << ", dof=" << i << std::endl;
 
               Tensor<1, dim> bulk_integral;
-              for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+              for (const auto q : fe_values.quadrature_point_indices())
                 {
                   bulk_integral += fe_values[single_component].gradient(i, q) *
                                    fe_values.JxW(q);
@@ -113,9 +113,7 @@ test(const Triangulation<dim> &tr,
               for (const unsigned int face : GeometryInfo<dim>::face_indices())
                 {
                   fe_face_values.reinit(cell, face);
-                  for (unsigned int q = 0;
-                       q < fe_face_values.n_quadrature_points;
-                       ++q)
+                  for (const auto q : fe_face_values.quadrature_point_indices())
                     {
                       boundary_integral +=
                         fe_face_values[single_component].value(i, q) *

diff --git a/tests/fe/fe_rt_hessian_divergence_theorem.cc b/tests/fe/fe_rt_hessian_divergence_theorem.cc
index 7e1b90f2b2670ea5c8dbdad67b12996b5bf90d2f..59370e79938fcb40c66f3bcb34476711722dbbcd 100644 (file)
--- a/tests/fe/fe_rt_hessian_divergence_theorem.cc
+++ b/tests/fe/fe_rt_hessian_divergence_theorem.cc
@@ -97,7 +97,7 @@ test(const Triangulation<dim> &tr,
               ss << "component=" << c << ", dof=" << i << std::endl;
 
               Tensor<2, dim> bulk_integral;
-              for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+              for (const auto q : fe_values.quadrature_point_indices())
                 {
                   bulk_integral += fe_values[single_component].hessian(i, q) *
                                    fe_values.JxW(q);
@@ -107,9 +107,7 @@ test(const Triangulation<dim> &tr,
               for (const unsigned int face : GeometryInfo<dim>::face_indices())
                 {
                   fe_face_values.reinit(cell, face);
-                  for (unsigned int q = 0;
-                       q < fe_face_values.n_quadrature_points;
-                       ++q)
+                  for (const auto q : fe_face_values.quadrature_point_indices())
                     {
                       Tensor<1, dim> gradient =
                         fe_face_values[single_component].gradient(i, q);

diff --git a/tests/fe/fe_system_3rd_derivative_divergence_theorem.cc b/tests/fe/fe_system_3rd_derivative_divergence_theorem.cc
index 7b08f3b088dcab4b1e1d38414039ea9951114757..6ba744632ae85d0f303e73a5adc991c100e5085e 100644 (file)
--- a/tests/fe/fe_system_3rd_derivative_divergence_theorem.cc
+++ b/tests/fe/fe_system_3rd_derivative_divergence_theorem.cc
@@ -101,7 +101,7 @@ test(const Triangulation<dim> &tr,
               ss << "component=" << c << ", dof=" << i << std::endl;
 
               Tensor<3, dim> bulk_integral;
-              for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+              for (const auto q : fe_values.quadrature_point_indices())
                 {
                   bulk_integral +=
                     fe_values[single_component].third_derivative(i, q) *
@@ -115,9 +115,7 @@ test(const Triangulation<dim> &tr,
               for (const unsigned int face : GeometryInfo<dim>::face_indices())
                 {
                   fe_face_values.reinit(cell, face);
-                  for (unsigned int q = 0;
-                       q < fe_face_values.n_quadrature_points;
-                       ++q)
+                  for (const auto q : fe_face_values.quadrature_point_indices())
                     {
                       Tensor<2, dim> hessian =
                         fe_face_values[single_component].hessian(i, q);

diff --git a/tests/fe/fe_values_function_manifold.cc b/tests/fe/fe_values_function_manifold.cc
index 2bdad7b9e83ec3445cfbb31cc4e26dc9248670b0..58b706a69d1bd0a1b0cc9bb78cdb21524cad6312 100644 (file)
--- a/tests/fe/fe_values_function_manifold.cc
+++ b/tests/fe/fe_values_function_manifold.cc
@@ -320,9 +320,7 @@ JxWError<dim>::setup_matrices()
       cell_rhs    = 0.0;
       fe_values.reinit(cell);
 
-      for (unsigned int q_point_n = 0;
-           q_point_n < fe_values.n_quadrature_points;
-           ++q_point_n)
+      for (const auto q_point_n : fe_values.quadrature_point_indices())
         {
           const double point_forcing =
             manufactured_forcing->value(fe_values.quadrature_point(q_point_n));

diff --git a/tests/fe/fe_values_view_01.cc b/tests/fe/fe_values_view_01.cc
index 9c91670ba6e96414b83c74c1ced395ffc0276dfc..7682ae65c3080462215b5edfd93f13d65fb80f2f 100644 (file)
--- a/tests/fe/fe_values_view_01.cc
+++ b/tests/fe/fe_values_view_01.cc
@@ -58,7 +58,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
       FEValuesExtractors::Scalar single_component(c);
 
       for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
-        for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+        for (const auto q : fe_values.quadrature_point_indices())
           {
             deallog << "i=" << i << ", q=" << q << std::endl;
             deallog << "   " << fe_values[single_component].value(i, q) << ' ';

diff --git a/tests/fe/fe_values_view_02.cc b/tests/fe/fe_values_view_02.cc
index 3876bec6bda6151b6d030fcc9aeb2cfa6a609cc2..dac397d4c24d2f4d0ad1aa4c5f39e8a090d8e64d 100644 (file)
--- a/tests/fe/fe_values_view_02.cc
+++ b/tests/fe/fe_values_view_02.cc
@@ -64,7 +64,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
         FEValuesExtractors::Vector vec_components(c);
 
         for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
-          for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               deallog << "i=" << i << ", q=" << q << std::endl;
               deallog << "   " << fe_values[vec_components].value(i, q) << ' ';

diff --git a/tests/fe/fe_values_view_03.cc b/tests/fe/fe_values_view_03.cc
index c9fddb271ff69d9680e1cacbc75ce885930b7e8b..1db642e4a9c62207e3cfb01c63f7694620049b21 100644 (file)
--- a/tests/fe/fe_values_view_03.cc
+++ b/tests/fe/fe_values_view_03.cc
@@ -64,7 +64,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
           FEValuesExtractors::Scalar single_component(c);
 
           for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
-            for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+            for (const auto q : fe_values.quadrature_point_indices())
               {
                 deallog << "i=" << i << ", q=" << q << std::endl;
                 deallog << "   " << fe_values[single_component].value(i, q)

diff --git a/tests/fe/fe_values_view_04.cc b/tests/fe/fe_values_view_04.cc
index 71349450cb9f1d44915eceb37d70d44702465ee3..bbfee129cfbb9afe2c6fe7a7bbecad5842be4711 100644 (file)
--- a/tests/fe/fe_values_view_04.cc
+++ b/tests/fe/fe_values_view_04.cc
@@ -69,7 +69,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
             FEValuesExtractors::Vector vec_components(c);
 
             for (unsigned int i = 0; i < fe_values.dofs_per_cell; ++i)
-              for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+              for (const auto q : fe_values.quadrature_point_indices())
                 {
                   deallog << "i=" << i << ", q=" << q << std::endl;
                   deallog << "   ";

diff --git a/tests/fe/fe_values_view_05.cc b/tests/fe/fe_values_view_05.cc
index ea7e34643821added63bda50068696b86099f96d..aae9fcd18b7ab3bffc2bcbfe9812333f2efbfba9 100644 (file)
--- a/tests/fe/fe_values_view_05.cc
+++ b/tests/fe/fe_values_view_05.cc
@@ -70,7 +70,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
                                                       scalar_values);
       deallog << "component=" << c << std::endl;
 
-      for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+      for (const auto q : fe_values.quadrature_point_indices())
         {
           deallog << scalar_values[q] << std::endl;
           Assert(std::fabs(scalar_values[q] - vector_values[q](c)) <=

diff --git a/tests/fe/fe_values_view_06.cc b/tests/fe/fe_values_view_06.cc
index 7a94c8ed6635d039f230f34716f30a5a5565a7bb..8830080b629b8d956fa9ccd24b09845762aff63a 100644 (file)
--- a/tests/fe/fe_values_view_06.cc
+++ b/tests/fe/fe_values_view_06.cc
@@ -70,7 +70,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
                                                          scalar_values);
       deallog << "component=" << c << std::endl;
 
-      for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+      for (const auto q : fe_values.quadrature_point_indices())
         {
           deallog << scalar_values[q] << std::endl;
           Assert((scalar_values[q] - vector_values[q][c]).norm() <=

diff --git a/tests/fe/fe_values_view_07.cc b/tests/fe/fe_values_view_07.cc
index 3edbbb0b2cdc4cb4defdbfb469a57b40b9904c98..d49bfd85c2ea999566fe69f0f029f76ec17463be 100644 (file)
--- a/tests/fe/fe_values_view_07.cc
+++ b/tests/fe/fe_values_view_07.cc
@@ -70,7 +70,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
                                                         scalar_values);
       deallog << "component=" << c << std::endl;
 
-      for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+      for (const auto q : fe_values.quadrature_point_indices())
         {
           deallog << scalar_values[q] << std::endl;
           Assert((scalar_values[q] - vector_values[q][c]).norm() <=

diff --git a/tests/fe/fe_values_view_08.cc b/tests/fe/fe_values_view_08.cc
index c6672347a5213b41218ef20ed17481a0e2362a3f..bfe9fe2d5f562d08151d76b3fcbb5c585d7768a6 100644 (file)
--- a/tests/fe/fe_values_view_08.cc
+++ b/tests/fe/fe_values_view_08.cc
@@ -72,7 +72,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
                                                       scalar_values);
       deallog << "component=" << c << std::endl;
 
-      for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+      for (const auto q : fe_values.quadrature_point_indices())
         {
           deallog << scalar_values[q] << std::endl;
           Assert(std::fabs(scalar_values[q] - vector_values[q](c)) <=

diff --git a/tests/fe/fe_values_view_09.cc b/tests/fe/fe_values_view_09.cc
index fba93b0b80385a535908b385e930e85b71bce741..272c05792b92765f19dc6a824a1ca4d5998804a2 100644 (file)
--- a/tests/fe/fe_values_view_09.cc
+++ b/tests/fe/fe_values_view_09.cc
@@ -72,7 +72,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
                                                          scalar_values);
       deallog << "component=" << c << std::endl;
 
-      for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+      for (const auto q : fe_values.quadrature_point_indices())
         {
           for (unsigned int d = 0; d < dim; ++d)
             deallog << scalar_values[q][d] << (d < dim - 1 ? " " : "");

diff --git a/tests/fe/fe_values_view_10.cc b/tests/fe/fe_values_view_10.cc
index d458788d2f7dc466c6fce9f9f8de4d283f191565..202e4b3bd09bdf7a480c6c7bc6b0bff6acb1d4fe 100644 (file)
--- a/tests/fe/fe_values_view_10.cc
+++ b/tests/fe/fe_values_view_10.cc
@@ -72,7 +72,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
                                                         scalar_values);
       deallog << "component=" << c << std::endl;
 
-      for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+      for (const auto q : fe_values.quadrature_point_indices())
         {
           for (unsigned int d = 0; d < dim; ++d)
             for (unsigned int e = 0; e < dim; ++e)

diff --git a/tests/fe/fe_values_view_10_single_01.cc b/tests/fe/fe_values_view_10_single_01.cc
index 3f62b6aca0b1993428512ffa9fd356edc9c7c817..6223c548255e81cd8bf50e1788b1e4704f12cb61 100644 (file)
--- a/tests/fe/fe_values_view_10_single_01.cc
+++ b/tests/fe/fe_values_view_10_single_01.cc
@@ -75,7 +75,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
                                                         scalar_values);
       deallog << "component=" << c << std::endl;
 
-      for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+      for (const auto q : fe_values.quadrature_point_indices())
         {
           for (unsigned int d = 0; d < dim; ++d)
             for (unsigned int e = 0; e < dim; ++e)

diff --git a/tests/fe/fe_values_view_10_single_02.cc b/tests/fe/fe_values_view_10_single_02.cc
index d12c5388b9d12c3d7b905c0dda5cf9779559da41..16eef00a8aa6d9c19e8f31efc0ca74765acf905a 100644 (file)
--- a/tests/fe/fe_values_view_10_single_02.cc
+++ b/tests/fe/fe_values_view_10_single_02.cc
@@ -75,7 +75,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
                                                         scalar_values);
       deallog << "component=" << c << std::endl;
 
-      for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+      for (const auto q : fe_values.quadrature_point_indices())
         {
           for (unsigned int d = 0; d < dim; ++d)
             for (unsigned int e = 0; e < dim; ++e)

diff --git a/tests/fe/fe_values_view_10_single_03.cc b/tests/fe/fe_values_view_10_single_03.cc
index 4d211b6f10156fcd25401d9f11e983a376cbba9a..33f582cfe9e1f21d7c07fee33917d9bd52591c20 100644 (file)
--- a/tests/fe/fe_values_view_10_single_03.cc
+++ b/tests/fe/fe_values_view_10_single_03.cc
@@ -75,7 +75,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
                                                         scalar_values);
       deallog << "component=" << c << std::endl;
 
-      for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+      for (const auto q : fe_values.quadrature_point_indices())
         {
           for (unsigned int d = 0; d < dim; ++d)
             for (unsigned int e = 0; e < dim; ++e)

diff --git a/tests/fe/fe_values_view_11.cc b/tests/fe/fe_values_view_11.cc
index 5468337e949f1ffe537d8dd8131dbc23bd35ef56..9290cebf57ad730255773cf9a411aaa8f1320bc3 100644 (file)
--- a/tests/fe/fe_values_view_11.cc
+++ b/tests/fe/fe_values_view_11.cc
@@ -75,7 +75,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
           fe_function, selected_vector_values);
         deallog << "component=" << c << std::endl;
 
-        for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+        for (const auto q : fe_values.quadrature_point_indices())
           for (unsigned int d = 0; d < dim; ++d)
             {
               deallog << selected_vector_values[q][d] << std::endl;

diff --git a/tests/fe/fe_values_view_12.cc b/tests/fe/fe_values_view_12.cc
index e71e558ec91161335288677066be513043274707..8a983d059698f0c190194ca0af63a2400f2a220e 100644 (file)
--- a/tests/fe/fe_values_view_12.cc
+++ b/tests/fe/fe_values_view_12.cc
@@ -75,7 +75,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
           fe_function, selected_vector_values);
         deallog << "component=" << c << std::endl;
 
-        for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+        for (const auto q : fe_values.quadrature_point_indices())
           for (unsigned int d = 0; d < dim; ++d)
             {
               deallog << selected_vector_values[q][d] << std::endl;

diff --git a/tests/fe/fe_values_view_13.cc b/tests/fe/fe_values_view_13.cc
index 4f11d8bc15ea376570d55e6fd7f5023ca950d791..8766887332d77b7089f7a5ccc5f3cf897422f165 100644 (file)
--- a/tests/fe/fe_values_view_13.cc
+++ b/tests/fe/fe_values_view_13.cc
@@ -75,7 +75,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
           fe_function, selected_vector_values);
         deallog << "component=" << c << std::endl;
 
-        for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+        for (const auto q : fe_values.quadrature_point_indices())
           for (unsigned int d = 0; d < dim; ++d)
             {
               deallog << selected_vector_values[q][d] << std::endl;

diff --git a/tests/fe/fe_values_view_14.cc b/tests/fe/fe_values_view_14.cc
index 418d0411a3ed0875499037e72b2498b5acefbf86..573438f541765c8c9caa097a89f49545a4a729af 100644 (file)
--- a/tests/fe/fe_values_view_14.cc
+++ b/tests/fe/fe_values_view_14.cc
@@ -77,7 +77,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
           fe_function, selected_vector_values);
         deallog << "component=" << c << std::endl;
 
-        for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+        for (const auto q : fe_values.quadrature_point_indices())
           for (unsigned int d = 0; d < dim; ++d)
             {
               deallog << selected_vector_values[q][d] << std::endl;

diff --git a/tests/fe/fe_values_view_15.cc b/tests/fe/fe_values_view_15.cc
index 828608e5756e455a0a1e6b786f15ba211303a28d..f7e8271019886629037c049a2b43e7344e2dfb9d 100644 (file)
--- a/tests/fe/fe_values_view_15.cc
+++ b/tests/fe/fe_values_view_15.cc
@@ -77,7 +77,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
           fe_function, selected_vector_values);
         deallog << "component=" << c << std::endl;
 
-        for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+        for (const auto q : fe_values.quadrature_point_indices())
           for (unsigned int d = 0; d < dim; ++d)
             {
               for (unsigned int e = 0; e < dim; ++e)

diff --git a/tests/fe/fe_values_view_16.cc b/tests/fe/fe_values_view_16.cc
index 3e1acfa267aa19527181d4a3146d51bd632cba08..4b16042cf28b12e8c0eb18a3967ebd5c2b8ecb40 100644 (file)
--- a/tests/fe/fe_values_view_16.cc
+++ b/tests/fe/fe_values_view_16.cc
@@ -77,7 +77,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
           fe_function, selected_vector_values);
         deallog << "component=" << c << std::endl;
 
-        for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+        for (const auto q : fe_values.quadrature_point_indices())
           for (unsigned int d = 0; d < dim; ++d)
             {
               for (unsigned int e = 0; e < dim; ++e)

diff --git a/tests/fe/fe_values_view_17.cc b/tests/fe/fe_values_view_17.cc
index 4f179c88a2034562005187b0a3cb2086797c5fa9..b834b6c6ed52c2d96f9e83b1996ac7209a40c64b 100644 (file)
--- a/tests/fe/fe_values_view_17.cc
+++ b/tests/fe/fe_values_view_17.cc
@@ -77,7 +77,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
           fe_function, selected_vector_values);
         deallog << "component=" << c << std::endl;
 
-        for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+        for (const auto q : fe_values.quadrature_point_indices())
           {
             deallog << selected_vector_values[q] << std::endl;
 

diff --git a/tests/fe/fe_values_view_18.cc b/tests/fe/fe_values_view_18.cc
index 2ccbc247ddd5418ddabd8181c2ec7c24d8caabbf..52ca56c42a813811c89487c76fe6cbfaf7706b86 100644 (file)
--- a/tests/fe/fe_values_view_18.cc
+++ b/tests/fe/fe_values_view_18.cc
@@ -79,7 +79,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
           fe_function, selected_vector_values);
         deallog << "component=" << c << std::endl;
 
-        for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+        for (const auto q : fe_values.quadrature_point_indices())
           {
             for (unsigned int d = 0; d < dim; ++d)
               for (unsigned int e = 0; e < dim; ++e)

diff --git a/tests/fe/fe_values_view_19.cc b/tests/fe/fe_values_view_19.cc
index d39fb0c8fc6f31ad75892142ddc066d662ea2c30..52d0b582070fd9dd21278d0cc4930f9971a35964 100644 (file)
--- a/tests/fe/fe_values_view_19.cc
+++ b/tests/fe/fe_values_view_19.cc
@@ -75,7 +75,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
           fe_function, selected_vector_values);
         deallog << "component=" << c << std::endl;
 
-        for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+        for (const auto q : fe_values.quadrature_point_indices())
           {
             deallog << selected_vector_values[q] << std::endl;
 

diff --git a/tests/fe/fe_values_view_20.cc b/tests/fe/fe_values_view_20.cc
index 8f22e121146db1f1bdb42f9177fd7d32ba278643..ebf84a201466abc12b137f5d7ba27ac46e7d549a 100644 (file)
--- a/tests/fe/fe_values_view_20.cc
+++ b/tests/fe/fe_values_view_20.cc
@@ -77,7 +77,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
           fe_function, selected_vector_values);
         deallog << "component=" << c << std::endl;
 
-        for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+        for (const auto q : fe_values.quadrature_point_indices())
           {
             deallog << selected_vector_values[q] << std::endl;
 

diff --git a/tests/fe/fe_values_view_30.cc b/tests/fe/fe_values_view_30.cc
index 3796c427f120fd0d7255943ae0ad3aa945870dc8..bc993f9efe19c73eaeba279c700fd7a5cd8079c6 100644 (file)
--- a/tests/fe/fe_values_view_30.cc
+++ b/tests/fe/fe_values_view_30.cc
@@ -155,7 +155,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
           function_vals, selected_vector_values);
         deallog << "component=" << c << std::endl;
 
-        for (unsigned int q = 0; q < fe_values.n_quadrature_points; ++q)
+        for (const auto q : fe_values.quadrature_point_indices())
           for (unsigned int d = 0; d < dim; ++d)
             {
               for (unsigned int e = 0; e < dim; ++e)

diff --git a/tests/fe/nedelec_non_rect_2d.cc b/tests/fe/nedelec_non_rect_2d.cc
index 61e3d6a53f36a1283781d0be9ac21e7fe841d40c..8b94c637da14c93579d293fe2379b6cbdf1dde2b 100644 (file)
--- a/tests/fe/nedelec_non_rect_2d.cc
+++ b/tests/fe/nedelec_non_rect_2d.cc
@@ -250,7 +250,7 @@ namespace polytest
 
         right_hand_side.rhs_value_list(fe_values.get_quadrature_points(),
                                        rhs_value_list);
-        for (unsigned int q = 0; q < n_q_points; ++q)
+        for (const auto q : fe_values.quadrature_point_indices())
           {
             Tensor<1, dim> rhs_value;
             for (unsigned int d = 0; d < dim; ++d)

diff --git a/tests/fe/nedelec_non_rect_face.cc b/tests/fe/nedelec_non_rect_face.cc
index 87294f7fd5c54e036a9e2fcd61d29bdfcde84ec8..e90ab77adfcbe7088baa6e98a7f74a7e7214ada6 100644 (file)
--- a/tests/fe/nedelec_non_rect_face.cc
+++ b/tests/fe/nedelec_non_rect_face.cc
@@ -255,7 +255,7 @@ namespace Maxwell
         // Calc values of curlE from fe solution:
         cell->get_dof_indices(local_dof_indices);
         // Loop over quad points to calculate solution:
-        for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+        for (const auto q_point : fe_values.quadrature_point_indices())
           {
             // Split exact solution into real/imaginary parts:
             for (unsigned int component = 0; component < dim; component++)
@@ -372,7 +372,7 @@ namespace Maxwell
                                          rhs_value_list);
 
         // Loop over all element quad points:
-        for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+        for (const auto q_point : fe_values.quadrature_point_indices())
           {
             // store rhs value at this q point & turn into tensor
             for (unsigned int component = 0; component < dim; component++)

diff --git a/tests/fe/non_primitive_1.cc b/tests/fe/non_primitive_1.cc
index 71cfda8a1e444375a905b2dd6ce940959e856b0f..1910e32a51a550b584a253cb70f4d85bca24c2e8 100644 (file)
--- a/tests/fe/non_primitive_1.cc
+++ b/tests/fe/non_primitive_1.cc
@@ -79,7 +79,7 @@ create_stokes_matrix_1(const DoFHandler<dim> &dof_handler,
 
       for (unsigned int i = 0; i < dofs_per_cell; ++i)
         for (unsigned int j = 0; j < dofs_per_cell; ++j)
-          for (unsigned int q = 0; q < n_q_points; ++q)
+          for (const auto q : fe_values.quadrature_point_indices())
             {
               const unsigned int comp_i = fe.system_to_component_index(i).first,
                                  comp_j = fe.system_to_component_index(j).first;
@@ -150,7 +150,7 @@ create_stokes_matrix_2(const DoFHandler<dim> &dof_handler,
         for (unsigned int comp_i = 0; comp_i < fe.n_components(); ++comp_i)
           for (unsigned int j = 0; j < fe.dofs_per_cell; ++j)
             for (unsigned int comp_j = 0; comp_j < fe.n_components(); ++comp_j)
-              for (unsigned int q = 0; q < n_q_points; ++q)
+              for (const auto q : fe_values.quadrature_point_indices())
                 {
                   // velocity-velocity coupling?
                   if ((comp_i < dim) && (comp_j < dim))
@@ -227,7 +227,7 @@ create_stokes_matrix_3(const DoFHandler<dim> &dof_handler,
               for (unsigned int comp_j = 0; comp_j < fe.n_components();
                    ++comp_j)
                 if (fe.get_nonzero_components(j)[comp_j] == true)
-                  for (unsigned int q = 0; q < n_q_points; ++q)
+                  for (const auto q : fe_values.quadrature_point_indices())
                     {
                       // velocity-velocity coupling?
                       if ((comp_i < dim) && (comp_j < dim))

diff --git a/tests/fe/non_primitive_2.cc b/tests/fe/non_primitive_2.cc
index 90a6f002292fb81dee16613c7ef8219a57622d19..8f7e5f0d65dbed779868b5a03b03007070f93c1a 100644 (file)
--- a/tests/fe/non_primitive_2.cc
+++ b/tests/fe/non_primitive_2.cc
@@ -83,7 +83,7 @@ create_stokes_matrix_2(const DoFHandler<dim> &dof_handler,
         for (unsigned int comp_i = 0; comp_i < fe.n_components(); ++comp_i)
           for (unsigned int j = 0; j < fe.dofs_per_cell; ++j)
             for (unsigned int comp_j = 0; comp_j < fe.n_components(); ++comp_j)
-              for (unsigned int q = 0; q < n_q_points; ++q)
+              for (const auto q : fe_values.quadrature_point_indices())
                 {
                   // velocity-velocity coupling?
                   if ((comp_i < dim) && (comp_j < dim))
@@ -160,7 +160,7 @@ create_stokes_matrix_3(const DoFHandler<dim> &dof_handler,
               for (unsigned int comp_j = 0; comp_j < fe.n_components();
                    ++comp_j)
                 if (fe.get_nonzero_components(j)[comp_j] == true)
-                  for (unsigned int q = 0; q < n_q_points; ++q)
+                  for (const auto q : fe_values.quadrature_point_indices())
                     {
                       // velocity-velocity coupling?
                       if ((comp_i < dim) && (comp_j < dim))

diff --git a/tests/fe/rt_approximation_01.cc b/tests/fe/rt_approximation_01.cc
index 465f8fb7e86fb395725fbc2bfc4dfd8b0aabc69c..2b1d5356857a0975056c2e56f84fd7f78bc23e1e 100644 (file)
--- a/tests/fe/rt_approximation_01.cc
+++ b/tests/fe/rt_approximation_01.cc
@@ -388,7 +388,7 @@ double TestProjection(Mapping<2> &mapping, DoFHandler<2> *dof_handler)
                                                  Vector<double>(n_components));
           fe_values.get_function_values(solution, this_value);
 
-          for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+          for (const auto q_point : fe_values.quadrature_point_indices())
             {
               double   u = this_value[q_point](0), v = this_value[q_point](1);
               Point<2> p = fe_values.quadrature_point(q_point);

diff --git a/tests/fe/rt_normal_02.cc b/tests/fe/rt_normal_02.cc
index 37b6c43a664c10db0674f52fd2600f24ba0a0c9e..dbf4e82f48b779cd1fa0190b02d441e3315f5368 100644 (file)
--- a/tests/fe/rt_normal_02.cc
+++ b/tests/fe/rt_normal_02.cc
@@ -136,7 +136,7 @@ void EvaluateNormal2(DoFHandler<2> *dof_handler, Vector<double> &solution)
                 n_q_proj, Vector<double>(n_components));
               fe_v_n.get_function_values(solution, this_value_n);
 
-              for (unsigned int q_point = 0; q_point < n_q_face; ++q_point)
+              for (const auto q_point : fe_v_face.quadrature_point_indices())
                 {
                   Tensor<1, 2> vn = fe_v_face.normal_vector(q_point);
                   double       nx = vn[0];
@@ -218,7 +218,7 @@ void EvaluateNormal(DoFHandler<2> *dof_handler, Vector<double> &solution)
                 n_q_face, Vector<double>(n_components));
               fe_v_face_n.get_function_values(solution, this_value_n);
 
-              for (unsigned int q_point = 0; q_point < n_q_face; ++q_point)
+              for (const auto q_point : fe_v_face.quadrature_point_indices())
                 {
                   Tensor<1, 2> vn = fe_v_face.normal_vector(q_point);
                   double       nx = vn[0];