Clean up code by using C++ ranges for some objects (#126)

Author: jorgensd

cpp/ContactConstraint.h

@@ -118,7 +118,7 @@ dolfinx_mpc::mpc_data<T> compute_master_contributions(
   std::vector<std::int64_t> global_blocks;
 
   // Reuse num_masters_local for insertion
-  std::fill(num_masters_local.begin(), num_masters_local.end(), 0);
+  std::ranges::fill(num_masters_local, 0);
   for (std::size_t i = 0; i < num_slaves_local; ++i)
   {
     if (const std::int32_t cell = local_colliding_cell[i]; cell != -1)
@@ -241,7 +241,7 @@ dolfinx_mpc::mpc_data<T> compute_block_contributions(
                       masters_offsets.begin() + 1);
 
   // Reuse num masters as fill position array
-  std::fill(num_masters_in_cell.begin(), num_masters_in_cell.end(), 0);
+  std::ranges::fill(num_masters_in_cell, 0);
 
   // Compute coeffs and owners for local cells
   std::vector<std::int64_t> global_slave_blocks(local_slaves.size());
@@ -308,7 +308,7 @@ dolfinx_mpc::mpc_data<T> concatenate(dolfinx_mpc::mpc_data<T>& mpc0,
                       num_masters_per_slave.end(), masters_offsets.begin() + 1);
 
   // Reuse num_masters_per_slave for indexing
-  std::fill(num_masters_per_slave.begin(), num_masters_per_slave.end(), 0);
+  std::ranges::fill(num_masters_per_slave, 0);
   std::vector<std::int64_t> masters_out(masters_offsets.back());
   std::vector<T> coefficients_out(masters_offsets.back());
   std::vector<std::int32_t> owners_out(masters_offsets.back());
@@ -389,14 +389,14 @@ mpc_data<T> create_contact_slip_condition(
         = impl::locate_slave_dofs<U>(V, meshtags, slave_marker);
 
     local_slave_blocks.reserve(slave_dofs.size());
-    std::for_each(slave_dofs.begin(), slave_dofs.end(),
-                  [&local_slave_blocks, bs = block_size,
-                   sl = size_local](const std::int32_t dof)
-                  {
-                    std::div_t div = std::div(dof, bs);
-                    if (div.quot < sl)
-                      local_slave_blocks.push_back(div.quot);
-                  });
+    std::ranges::for_each(slave_dofs,
+                          [&local_slave_blocks, bs = block_size,
+                           sl = size_local](const std::int32_t dof)
+                          {
+                            std::div_t div = std::div(dof, bs);
+                            if (div.quot < sl)
+                              local_slave_blocks.push_back(div.quot);
+                          });
   }
 
   // Data structures to hold information about slave data local to process
@@ -424,12 +424,12 @@ mpc_data<T> create_contact_slip_condition(
       normal[j] = std::real(normal_array[dofs[j]]);
     U norm = std::sqrt(normal[0] * normal[0] + normal[1] * normal[1]
                        + normal[2] * normal[2]);
-    std::for_each(normal.begin(), normal.end(),
-                  [norm](auto& n) { return std::abs(n / norm); });
+    std::ranges::for_each(normal,
+                          [norm](auto& n) { return std::abs(n / norm); });
     return std::distance(
         normal.begin(),
-        std::max_element(normal.begin(), normal.end(),
-                         [](T a, T b) { return std::norm(a) < std::norm(b); }));
+        std::ranges::max_element(normal, [](T a, T b)
+                                 { return std::norm(a) < std::norm(b); }));
   };
 
   // Determine which dof in local slave block is the actual slave
@@ -532,10 +532,10 @@ mpc_data<T> create_contact_slip_condition(
   {
     const std::int32_t slave_idx = slave_indices_remote[i];
     send_rems[i] = local_rems[slave_idx];
-    std::copy_n(std::next(slave_coordinates.begin(), 3 * slave_idx), 3,
-                std::next(coordinates_send.begin(), 3 * i));
-    std::copy_n(std::next(normals.begin(), 3 * slave_idx), 3,
-                std::next(normals_send.begin(), 3 * i));
+    std::ranges::copy_n(std::next(slave_coordinates.begin(), 3 * slave_idx), 3,
+                        std::next(coordinates_send.begin(), 3 * i));
+    std::ranges::copy_n(std::next(normals.begin(), 3 * slave_idx), 3,
+                        std::next(normals_send.begin(), 3 * i));
   }
 
   // Figure out how much data to receive from each neighbor
@@ -564,9 +564,9 @@ mpc_data<T> create_contact_slip_condition(
   // function data
   std::vector<std::int32_t> num_slaves_recv3;
   num_slaves_recv3.reserve(indegree);
-  std::transform(num_slaves_recv.begin(), num_slaves_recv.end(),
-                 std::back_inserter(num_slaves_recv3),
-                 [](std::int32_t num_slaves) { return 3 * num_slaves; });
+  std::ranges::transform(num_slaves_recv, std::back_inserter(num_slaves_recv3),
+                         [](std::int32_t num_slaves)
+                         { return 3 * num_slaves; });
   std::vector<int> disp3(indegree + 1, 0);
   std::partial_sum(num_slaves_recv3.begin(), num_slaves_recv3.end(),
                    disp3.begin() + 1);
@@ -612,9 +612,9 @@ mpc_data<T> create_contact_slip_condition(
   std::vector<std::int32_t> num_collision_masters(indegree + 1, 0);
   std::vector<int> num_out_offsets;
   num_out_offsets.reserve(indegree);
-  std::transform(num_slaves_recv.begin(), num_slaves_recv.end(),
-                 std::back_inserter(num_out_offsets),
-                 [](std::int32_t num_slaves) { return num_slaves + 1; });
+  std::ranges::transform(num_slaves_recv, std::back_inserter(num_out_offsets),
+                         [](std::int32_t num_slaves)
+                         { return num_slaves + 1; });
   const std::int32_t num_offsets
       = std::accumulate(num_out_offsets.begin(), num_out_offsets.end(), 0);
   std::vector<std::int32_t> offsets_remote(num_offsets);
@@ -698,7 +698,7 @@ mpc_data<T> create_contact_slip_condition(
   std::vector<MPI_Status> status(4);
   MPI_Wait(&requests[0], &status[0]);
 
-  std::vector<bool> slave_found(slave_indices_remote.size(), false);
+  std::vector<std::int8_t> slave_found(slave_indices_remote.size(), false);
   std::vector<std::int32_t> num_inc_masters(slave_indices_remote.size());
   // Iterate through the processors and find one set of inputs per slave that
   // was sent to the other processes
@@ -744,7 +744,7 @@ mpc_data<T> create_contact_slip_condition(
   std::vector<T> offproc_coeffs(offproc_offsets.back());
   std::vector<std::int32_t> offproc_owners(offproc_offsets.back());
 
-  std::fill(slave_found.begin(), slave_found.end(), false);
+  std::ranges::fill(slave_found, false);
   for (std::size_t i = 0; i < src_ranks_rev.size(); ++i)
   {
     const std::int32_t proc_start = disp_inc_masters[i];
@@ -919,8 +919,8 @@ mpc_data<T> create_contact_inelastic_condition(
 
   std::vector<std::int32_t> slave_blocks
       = impl::locate_slave_dofs<U>(V, meshtags, slave_marker);
-  std::for_each(slave_blocks.begin(), slave_blocks.end(),
-                [block_size](std::int32_t& d) { d /= block_size; });
+  std::ranges::for_each(slave_blocks,
+                        [block_size](std::int32_t& d) { d /= block_size; });
 
   // Vector holding what blocks local to process are slaves
   std::vector<std::int32_t> local_blocks;
@@ -930,8 +930,8 @@ mpc_data<T> create_contact_inelastic_condition(
   std::vector<std::int32_t> ghost_blocks;
 
   // Map slave blocks to arrays holding local bocks and ghost blocks
-  std::for_each(
-      slave_blocks.begin(), slave_blocks.end(),
+  std::ranges::for_each(
+      slave_blocks,
       [size_local, &local_blocks, &ghost_blocks](const std::int32_t block)
       {
         if (block < size_local)
@@ -1069,8 +1069,9 @@ mpc_data<T> create_contact_inelastic_condition(
   std::vector<U> distribute_coordinates(blocks_wo_local_collision.size() * 3);
   for (std::size_t i = 0; i < collision_to_local.size(); ++i)
   {
-    std::copy_n(std::next(slave_coordinates.begin(), 3 * collision_to_local[i]),
-                3, std::next(distribute_coordinates.begin(), 3 * i));
+    std::ranges::copy_n(
+        std::next(slave_coordinates.begin(), 3 * collision_to_local[i]), 3,
+        std::next(distribute_coordinates.begin(), 3 * i));
   }
   dolfinx_mpc::mpc_data<T> mpc;
 
@@ -1096,8 +1097,8 @@ mpc_data<T> create_contact_inelastic_condition(
     // slaves)
     std::vector<std::int32_t> slaves;
     slaves.reserve(block_size * local_blocks.size());
-    std::for_each(
-        local_blocks.begin(), local_blocks.end(),
+    std::ranges::for_each(
+        local_blocks,
         [block_size, tdim, &masters_out, &local_masters, &coeffs_out,
          &local_coeffs, &offsets_out, &slaves](const std::int32_t block)
         {
@@ -1113,7 +1114,7 @@ mpc_data<T> create_contact_inelastic_condition(
           }
         });
     std::vector<std::int32_t> owners(masters_out.size());
-    std::fill(owners.begin(), owners.end(), 0);
+    std::ranges::fill(owners, 0);
     mpc.slaves = slaves;
     mpc.masters = masters_out;
     mpc.offsets = offsets_out;
@@ -1478,17 +1479,18 @@ mpc_data<T> create_contact_inelastic_condition(
 
   // Count number of incoming slaves
   std::vector<std::int32_t> inc_num_slaves(src_ranks_ghost.size(), 0);
-  std::for_each(ghost_slaves.begin(), ghost_slaves.end(),
-                [block_size, size_local, &ghost_owners, &inc_num_slaves,
-                 &src_ranks_ghost](std::int32_t slave)
-                {
-                  const std::int32_t owner
-                      = ghost_owners[slave / block_size - size_local];
-                  const auto it = std::find(src_ranks_ghost.begin(),
-                                            src_ranks_ghost.end(), owner);
-                  const auto index = std::distance(src_ranks_ghost.begin(), it);
-                  inc_num_slaves[index]++;
-                });
+  std::ranges::for_each(
+      ghost_slaves,
+      [block_size, size_local, &ghost_owners, &inc_num_slaves,
+       &src_ranks_ghost](std::int32_t slave)
+      {
+        const std::int32_t owner
+            = ghost_owners[slave / block_size - size_local];
+        const auto it
+            = std::find(src_ranks_ghost.begin(), src_ranks_ghost.end(), owner);
+        const auto index = std::distance(src_ranks_ghost.begin(), it);
+        inc_num_slaves[index]++;
+      });
   // Count number of outgoing slaves and masters
   dolfinx::graph::AdjacencyList<int> shared_indices
       = slave_index_map->index_to_dest_ranks();
@@ -1505,8 +1507,8 @@ mpc_data<T> create_contact_inelastic_condition(
   std::vector<std::int32_t> loc_block(1);
   std::vector<std::int64_t> glob_block(1);
 
-  std::for_each(
-      local_blocks.begin(), local_blocks.end(),
+  std::ranges::for_each(
+      local_blocks,
       [block_size, &local_masters, &local_coeffs, &local_owners,
        &shared_indices, &dest_ranks_ghost, &loc_block, &glob_block,
        &out_num_masters, &out_num_slaves, &imap, &proc_to_ghost,
@@ -1663,8 +1665,8 @@ mpc_data<T> create_contact_inelastic_condition(
   std::vector<std::int32_t> offsets = {0};
   offsets.reserve(slaves.size() + 1);
 
-  std::for_each(
-      local_blocks.begin(), local_blocks.end(),
+  std::ranges::for_each(
+      local_blocks,
       [block_size, tdim, &masters, &local_masters, &coeffs_out, &local_coeffs,
        &owners_out, &local_owners, &offsets, &slaves](const std::int32_t block)
       {

cpp/MultiPointConstraint.h

@@ -68,7 +68,7 @@ class MultiPointConstraint
     // Create adjacency list with all local dofs, where the slave dofs maps to
     // its masters
     std::vector<std::int32_t> _num_masters(num_dofs_local);
-    std::fill(_num_masters.begin(), _num_masters.end(), 0);
+    std::ranges::fill(_num_masters, 0);
     for (std::int32_t i = 0; i < slaves.size(); i++)
       _num_masters[slaves[i]] = offsets[i + 1] - offsets[i];
     std::vector<std::int32_t> masters_offsets(num_dofs_local + 1);
@@ -77,7 +77,7 @@ class MultiPointConstraint
                         masters_offsets.begin() + 1);
 
     // Reuse num masters as fill position array
-    std::fill(_num_masters.begin(), _num_masters.end(), 0);
+    std::ranges::fill(_num_masters, 0);
     std::vector<std::int64_t> _master_data(masters.size());
     std::vector<T> _coeff_data(masters.size());
     std::vector<std::int32_t> _owner_data(masters.size());
@@ -111,7 +111,7 @@ class MultiPointConstraint
 
     const std::int32_t num_local
         = dofmap.index_map_bs() * dofmap.index_map->size_local();
-    auto it = std::lower_bound(_slaves.begin(), _slaves.end(), num_local);
+    auto it = std::ranges::lower_bound(_slaves, num_local);
     _num_local_slaves = std::distance(_slaves.begin(), it);
 
     // Create new function space with extended index map

cpp/PeriodicConstraint.h

@@ -33,8 +33,9 @@ dolfinx_mpc::mpc_data<T> _create_periodic_condition(
   auto sub_to_parent = [&parent_map](const std::vector<std::int32_t>& sub_dofs)
   {
     std::vector<std::int32_t> parent_dofs(sub_dofs.size());
-    std::transform(sub_dofs.cbegin(), sub_dofs.cend(), parent_dofs.begin(),
-                   [&parent_map](auto& dof) { return parent_map(dof); });
+    std::ranges::transform(sub_dofs, parent_dofs.begin(),
+                           [&parent_map](auto& dof)
+                           { return parent_map(dof); });
     return parent_dofs;
   };
 
@@ -49,13 +50,13 @@ dolfinx_mpc::mpc_data<T> _create_periodic_condition(
     parent_rems.reserve(dofs.size());
     const auto bs = parent_dofmap->index_map_bs();
     // Split parent dofs into blocks and rems
-    std::for_each(dofs.cbegin(), dofs.cend(),
-                  [&parent_blocks, &parent_rems, &bs](auto dof)
-                  {
-                    std::div_t div = std::div(dof, bs);
-                    parent_blocks.push_back(div.quot);
-                    parent_rems.push_back(div.rem);
-                  });
+    std::ranges::for_each(dofs,
+                          [&parent_blocks, &parent_rems, &bs](auto dof)
+                          {
+                            std::div_t div = std::div(dof, bs);
+                            parent_blocks.push_back(div.quot);
+                            parent_rems.push_back(div.rem);
+                          });
     // Map blocks to global index
     std::vector<std::int64_t> parents_glob(dofs.size());
     parent_dofmap->index_map->local_to_global(parent_blocks, parents_glob);
@@ -86,12 +87,12 @@ dolfinx_mpc::mpc_data<T> _create_periodic_condition(
   // Only work with local blocks
   std::vector<std::int32_t> local_blocks;
   local_blocks.reserve(slave_blocks.size());
-  std::for_each(slave_blocks.begin(), slave_blocks.end(),
-                [&local_blocks, size_local](auto block)
-                {
-                  if (block < size_local)
-                    local_blocks.push_back(block);
-                });
+  std::ranges::for_each(slave_blocks,
+                        [&local_blocks, size_local](auto block)
+                        {
+                          if (block < size_local)
+                            local_blocks.push_back(block);
+                        });
 
   // Create map from slave dof blocks to a cell containing them
   std::vector<std::int32_t> slave_cells = dolfinx_mpc::create_block_to_cell_map(
@@ -301,8 +302,8 @@ dolfinx_mpc::mpc_data<T> _create_periodic_condition(
         const std::int32_t insert_location
             = disp_out[dist] + out_placement[dist]++;
         // Copy coordinates and dofs to output arrays
-        std::copy_n(std::next(mapped_T_b.begin(), 3 * i), 3,
-                    std::next(coords_out.begin(), 3 * insert_location));
+        std::ranges::copy_n(std::next(mapped_T_b.begin(), 3 * i), 3,
+                            std::next(coords_out.begin(), 3 * insert_location));
         for (int b = 0; b < bs; b++)
         {
           searching_dofs[insert_location * bs + b]
@@ -323,10 +324,10 @@ dolfinx_mpc::mpc_data<T> _create_periodic_condition(
 
   // Take into account that we send three values per slave
   auto m_3 = [](auto& num) { num *= 3; };
-  std::for_each(disp_out.begin(), disp_out.end(), m_3);
-  std::for_each(num_out_slaves.begin(), num_out_slaves.end(), m_3);
-  std::for_each(disp_in.begin(), disp_in.end(), m_3);
-  std::for_each(num_recv_slaves.begin(), num_recv_slaves.end(), m_3);
+  std::ranges::for_each(disp_out, m_3);
+  std::ranges::for_each(num_out_slaves, m_3);
+  std::ranges::for_each(disp_in, m_3);
+  std::ranges::for_each(num_recv_slaves, m_3);
 
   // Communicate coordinates
   MPI_Neighbor_alltoallv(
@@ -336,12 +337,12 @@ dolfinx_mpc::mpc_data<T> _create_periodic_condition(
 
   // Reset in_displacements to be per block for later usage
   auto d_3 = [](auto& num) { num /= 3; };
-  std::for_each(disp_in.begin(), disp_in.end(), d_3);
+  std::ranges::for_each(disp_in, d_3);
 
   // Reset out_displacments to be for every slave
   auto m_bs_d_3 = [bs](auto& num) { num = num * bs / 3; };
-  std::for_each(disp_out.begin(), disp_out.end(), m_bs_d_3);
-  std::for_each(num_out_slaves.begin(), num_out_slaves.end(), m_bs_d_3);
+  std::ranges::for_each(disp_out, m_bs_d_3);
+  std::ranges::for_each(num_out_slaves, m_bs_d_3);
 
   // Create remote arrays
   std::vector<std::int64_t> masters_remote;

cpp/SlipConstraint.h

@@ -117,9 +117,8 @@ mpc_data<T> create_slip_condition(
 
     // Determine slave dof by component with biggest normal vector (to avoid
     // issues with grids aligned with coordiante system)
-    auto max_el = std::max_element(normal.begin(), normal.end(),
-                                   [](T a, T b)
-                                   { return std::norm(a) < std::norm(b); });
+    auto max_el = std::ranges::max_element(
+        normal, [](T a, T b) { return std::norm(a) < std::norm(b); });
     auto slave_index = std::distance(normal.begin(), max_el);
     assert(slave_index < num_normal_components);
     std::int32_t parent_slave
@@ -147,8 +146,7 @@ mpc_data<T> create_slip_condition(
     }
     // Convert local parent dof to local parent block
     std::vector<std::int32_t> parent_blocks = parent_masters;
-    std::for_each(parent_blocks.begin(), parent_blocks.end(),
-                  [W_bs](auto& b) { b /= W_bs; });
+    std::ranges::for_each(parent_blocks, [W_bs](auto& b) { b /= W_bs; });
     // Map blocks from local to global
     pair_m.resize(parent_masters.size());
     W_imap->local_to_global(parent_blocks, pair_m);