Skip to content

Commit bbe3ec9

Browse files
authored
Clean up code by using C++ ranges for some objects (#126)
1 parent fbd3cb0 commit bbe3ec9

11 files changed

+188
-182
lines changed

cpp/ContactConstraint.h

+53-51
Original file line numberDiff line numberDiff line change
@@ -118,7 +118,7 @@ dolfinx_mpc::mpc_data<T> compute_master_contributions(
118118
std::vector<std::int64_t> global_blocks;
119119

120120
// Reuse num_masters_local for insertion
121-
std::fill(num_masters_local.begin(), num_masters_local.end(), 0);
121+
std::ranges::fill(num_masters_local, 0);
122122
for (std::size_t i = 0; i < num_slaves_local; ++i)
123123
{
124124
if (const std::int32_t cell = local_colliding_cell[i]; cell != -1)
@@ -241,7 +241,7 @@ dolfinx_mpc::mpc_data<T> compute_block_contributions(
241241
masters_offsets.begin() + 1);
242242

243243
// Reuse num masters as fill position array
244-
std::fill(num_masters_in_cell.begin(), num_masters_in_cell.end(), 0);
244+
std::ranges::fill(num_masters_in_cell, 0);
245245

246246
// Compute coeffs and owners for local cells
247247
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,
308308
num_masters_per_slave.end(), masters_offsets.begin() + 1);
309309

310310
// Reuse num_masters_per_slave for indexing
311-
std::fill(num_masters_per_slave.begin(), num_masters_per_slave.end(), 0);
311+
std::ranges::fill(num_masters_per_slave, 0);
312312
std::vector<std::int64_t> masters_out(masters_offsets.back());
313313
std::vector<T> coefficients_out(masters_offsets.back());
314314
std::vector<std::int32_t> owners_out(masters_offsets.back());
@@ -389,14 +389,14 @@ mpc_data<T> create_contact_slip_condition(
389389
= impl::locate_slave_dofs<U>(V, meshtags, slave_marker);
390390

391391
local_slave_blocks.reserve(slave_dofs.size());
392-
std::for_each(slave_dofs.begin(), slave_dofs.end(),
393-
[&local_slave_blocks, bs = block_size,
394-
sl = size_local](const std::int32_t dof)
395-
{
396-
std::div_t div = std::div(dof, bs);
397-
if (div.quot < sl)
398-
local_slave_blocks.push_back(div.quot);
399-
});
392+
std::ranges::for_each(slave_dofs,
393+
[&local_slave_blocks, bs = block_size,
394+
sl = size_local](const std::int32_t dof)
395+
{
396+
std::div_t div = std::div(dof, bs);
397+
if (div.quot < sl)
398+
local_slave_blocks.push_back(div.quot);
399+
});
400400
}
401401

402402
// Data structures to hold information about slave data local to process
@@ -424,12 +424,12 @@ mpc_data<T> create_contact_slip_condition(
424424
normal[j] = std::real(normal_array[dofs[j]]);
425425
U norm = std::sqrt(normal[0] * normal[0] + normal[1] * normal[1]
426426
+ normal[2] * normal[2]);
427-
std::for_each(normal.begin(), normal.end(),
428-
[norm](auto& n) { return std::abs(n / norm); });
427+
std::ranges::for_each(normal,
428+
[norm](auto& n) { return std::abs(n / norm); });
429429
return std::distance(
430430
normal.begin(),
431-
std::max_element(normal.begin(), normal.end(),
432-
[](T a, T b) { return std::norm(a) < std::norm(b); }));
431+
std::ranges::max_element(normal, [](T a, T b)
432+
{ return std::norm(a) < std::norm(b); }));
433433
};
434434

435435
// Determine which dof in local slave block is the actual slave
@@ -532,10 +532,10 @@ mpc_data<T> create_contact_slip_condition(
532532
{
533533
const std::int32_t slave_idx = slave_indices_remote[i];
534534
send_rems[i] = local_rems[slave_idx];
535-
std::copy_n(std::next(slave_coordinates.begin(), 3 * slave_idx), 3,
536-
std::next(coordinates_send.begin(), 3 * i));
537-
std::copy_n(std::next(normals.begin(), 3 * slave_idx), 3,
538-
std::next(normals_send.begin(), 3 * i));
535+
std::ranges::copy_n(std::next(slave_coordinates.begin(), 3 * slave_idx), 3,
536+
std::next(coordinates_send.begin(), 3 * i));
537+
std::ranges::copy_n(std::next(normals.begin(), 3 * slave_idx), 3,
538+
std::next(normals_send.begin(), 3 * i));
539539
}
540540

541541
// Figure out how much data to receive from each neighbor
@@ -564,9 +564,9 @@ mpc_data<T> create_contact_slip_condition(
564564
// function data
565565
std::vector<std::int32_t> num_slaves_recv3;
566566
num_slaves_recv3.reserve(indegree);
567-
std::transform(num_slaves_recv.begin(), num_slaves_recv.end(),
568-
std::back_inserter(num_slaves_recv3),
569-
[](std::int32_t num_slaves) { return 3 * num_slaves; });
567+
std::ranges::transform(num_slaves_recv, std::back_inserter(num_slaves_recv3),
568+
[](std::int32_t num_slaves)
569+
{ return 3 * num_slaves; });
570570
std::vector<int> disp3(indegree + 1, 0);
571571
std::partial_sum(num_slaves_recv3.begin(), num_slaves_recv3.end(),
572572
disp3.begin() + 1);
@@ -612,9 +612,9 @@ mpc_data<T> create_contact_slip_condition(
612612
std::vector<std::int32_t> num_collision_masters(indegree + 1, 0);
613613
std::vector<int> num_out_offsets;
614614
num_out_offsets.reserve(indegree);
615-
std::transform(num_slaves_recv.begin(), num_slaves_recv.end(),
616-
std::back_inserter(num_out_offsets),
617-
[](std::int32_t num_slaves) { return num_slaves + 1; });
615+
std::ranges::transform(num_slaves_recv, std::back_inserter(num_out_offsets),
616+
[](std::int32_t num_slaves)
617+
{ return num_slaves + 1; });
618618
const std::int32_t num_offsets
619619
= std::accumulate(num_out_offsets.begin(), num_out_offsets.end(), 0);
620620
std::vector<std::int32_t> offsets_remote(num_offsets);
@@ -698,7 +698,7 @@ mpc_data<T> create_contact_slip_condition(
698698
std::vector<MPI_Status> status(4);
699699
MPI_Wait(&requests[0], &status[0]);
700700

701-
std::vector<bool> slave_found(slave_indices_remote.size(), false);
701+
std::vector<std::int8_t> slave_found(slave_indices_remote.size(), false);
702702
std::vector<std::int32_t> num_inc_masters(slave_indices_remote.size());
703703
// Iterate through the processors and find one set of inputs per slave that
704704
// was sent to the other processes
@@ -744,7 +744,7 @@ mpc_data<T> create_contact_slip_condition(
744744
std::vector<T> offproc_coeffs(offproc_offsets.back());
745745
std::vector<std::int32_t> offproc_owners(offproc_offsets.back());
746746

747-
std::fill(slave_found.begin(), slave_found.end(), false);
747+
std::ranges::fill(slave_found, false);
748748
for (std::size_t i = 0; i < src_ranks_rev.size(); ++i)
749749
{
750750
const std::int32_t proc_start = disp_inc_masters[i];
@@ -919,8 +919,8 @@ mpc_data<T> create_contact_inelastic_condition(
919919

920920
std::vector<std::int32_t> slave_blocks
921921
= impl::locate_slave_dofs<U>(V, meshtags, slave_marker);
922-
std::for_each(slave_blocks.begin(), slave_blocks.end(),
923-
[block_size](std::int32_t& d) { d /= block_size; });
922+
std::ranges::for_each(slave_blocks,
923+
[block_size](std::int32_t& d) { d /= block_size; });
924924

925925
// Vector holding what blocks local to process are slaves
926926
std::vector<std::int32_t> local_blocks;
@@ -930,8 +930,8 @@ mpc_data<T> create_contact_inelastic_condition(
930930
std::vector<std::int32_t> ghost_blocks;
931931

932932
// Map slave blocks to arrays holding local bocks and ghost blocks
933-
std::for_each(
934-
slave_blocks.begin(), slave_blocks.end(),
933+
std::ranges::for_each(
934+
slave_blocks,
935935
[size_local, &local_blocks, &ghost_blocks](const std::int32_t block)
936936
{
937937
if (block < size_local)
@@ -1069,8 +1069,9 @@ mpc_data<T> create_contact_inelastic_condition(
10691069
std::vector<U> distribute_coordinates(blocks_wo_local_collision.size() * 3);
10701070
for (std::size_t i = 0; i < collision_to_local.size(); ++i)
10711071
{
1072-
std::copy_n(std::next(slave_coordinates.begin(), 3 * collision_to_local[i]),
1073-
3, std::next(distribute_coordinates.begin(), 3 * i));
1072+
std::ranges::copy_n(
1073+
std::next(slave_coordinates.begin(), 3 * collision_to_local[i]), 3,
1074+
std::next(distribute_coordinates.begin(), 3 * i));
10741075
}
10751076
dolfinx_mpc::mpc_data<T> mpc;
10761077

@@ -1096,8 +1097,8 @@ mpc_data<T> create_contact_inelastic_condition(
10961097
// slaves)
10971098
std::vector<std::int32_t> slaves;
10981099
slaves.reserve(block_size * local_blocks.size());
1099-
std::for_each(
1100-
local_blocks.begin(), local_blocks.end(),
1100+
std::ranges::for_each(
1101+
local_blocks,
11011102
[block_size, tdim, &masters_out, &local_masters, &coeffs_out,
11021103
&local_coeffs, &offsets_out, &slaves](const std::int32_t block)
11031104
{
@@ -1113,7 +1114,7 @@ mpc_data<T> create_contact_inelastic_condition(
11131114
}
11141115
});
11151116
std::vector<std::int32_t> owners(masters_out.size());
1116-
std::fill(owners.begin(), owners.end(), 0);
1117+
std::ranges::fill(owners, 0);
11171118
mpc.slaves = slaves;
11181119
mpc.masters = masters_out;
11191120
mpc.offsets = offsets_out;
@@ -1478,17 +1479,18 @@ mpc_data<T> create_contact_inelastic_condition(
14781479

14791480
// Count number of incoming slaves
14801481
std::vector<std::int32_t> inc_num_slaves(src_ranks_ghost.size(), 0);
1481-
std::for_each(ghost_slaves.begin(), ghost_slaves.end(),
1482-
[block_size, size_local, &ghost_owners, &inc_num_slaves,
1483-
&src_ranks_ghost](std::int32_t slave)
1484-
{
1485-
const std::int32_t owner
1486-
= ghost_owners[slave / block_size - size_local];
1487-
const auto it = std::find(src_ranks_ghost.begin(),
1488-
src_ranks_ghost.end(), owner);
1489-
const auto index = std::distance(src_ranks_ghost.begin(), it);
1490-
inc_num_slaves[index]++;
1491-
});
1482+
std::ranges::for_each(
1483+
ghost_slaves,
1484+
[block_size, size_local, &ghost_owners, &inc_num_slaves,
1485+
&src_ranks_ghost](std::int32_t slave)
1486+
{
1487+
const std::int32_t owner
1488+
= ghost_owners[slave / block_size - size_local];
1489+
const auto it
1490+
= std::find(src_ranks_ghost.begin(), src_ranks_ghost.end(), owner);
1491+
const auto index = std::distance(src_ranks_ghost.begin(), it);
1492+
inc_num_slaves[index]++;
1493+
});
14921494
// Count number of outgoing slaves and masters
14931495
dolfinx::graph::AdjacencyList<int> shared_indices
14941496
= slave_index_map->index_to_dest_ranks();
@@ -1505,8 +1507,8 @@ mpc_data<T> create_contact_inelastic_condition(
15051507
std::vector<std::int32_t> loc_block(1);
15061508
std::vector<std::int64_t> glob_block(1);
15071509

1508-
std::for_each(
1509-
local_blocks.begin(), local_blocks.end(),
1510+
std::ranges::for_each(
1511+
local_blocks,
15101512
[block_size, &local_masters, &local_coeffs, &local_owners,
15111513
&shared_indices, &dest_ranks_ghost, &loc_block, &glob_block,
15121514
&out_num_masters, &out_num_slaves, &imap, &proc_to_ghost,
@@ -1663,8 +1665,8 @@ mpc_data<T> create_contact_inelastic_condition(
16631665
std::vector<std::int32_t> offsets = {0};
16641666
offsets.reserve(slaves.size() + 1);
16651667

1666-
std::for_each(
1667-
local_blocks.begin(), local_blocks.end(),
1668+
std::ranges::for_each(
1669+
local_blocks,
16681670
[block_size, tdim, &masters, &local_masters, &coeffs_out, &local_coeffs,
16691671
&owners_out, &local_owners, &offsets, &slaves](const std::int32_t block)
16701672
{

cpp/MultiPointConstraint.h

+3-3
Original file line numberDiff line numberDiff line change
@@ -68,7 +68,7 @@ class MultiPointConstraint
6868
// Create adjacency list with all local dofs, where the slave dofs maps to
6969
// its masters
7070
std::vector<std::int32_t> _num_masters(num_dofs_local);
71-
std::fill(_num_masters.begin(), _num_masters.end(), 0);
71+
std::ranges::fill(_num_masters, 0);
7272
for (std::int32_t i = 0; i < slaves.size(); i++)
7373
_num_masters[slaves[i]] = offsets[i + 1] - offsets[i];
7474
std::vector<std::int32_t> masters_offsets(num_dofs_local + 1);
@@ -77,7 +77,7 @@ class MultiPointConstraint
7777
masters_offsets.begin() + 1);
7878

7979
// Reuse num masters as fill position array
80-
std::fill(_num_masters.begin(), _num_masters.end(), 0);
80+
std::ranges::fill(_num_masters, 0);
8181
std::vector<std::int64_t> _master_data(masters.size());
8282
std::vector<T> _coeff_data(masters.size());
8383
std::vector<std::int32_t> _owner_data(masters.size());
@@ -111,7 +111,7 @@ class MultiPointConstraint
111111

112112
const std::int32_t num_local
113113
= dofmap.index_map_bs() * dofmap.index_map->size_local();
114-
auto it = std::lower_bound(_slaves.begin(), _slaves.end(), num_local);
114+
auto it = std::ranges::lower_bound(_slaves, num_local);
115115
_num_local_slaves = std::distance(_slaves.begin(), it);
116116

117117
// Create new function space with extended index map

cpp/PeriodicConstraint.h

+25-24
Original file line numberDiff line numberDiff line change
@@ -33,8 +33,9 @@ dolfinx_mpc::mpc_data<T> _create_periodic_condition(
3333
auto sub_to_parent = [&parent_map](const std::vector<std::int32_t>& sub_dofs)
3434
{
3535
std::vector<std::int32_t> parent_dofs(sub_dofs.size());
36-
std::transform(sub_dofs.cbegin(), sub_dofs.cend(), parent_dofs.begin(),
37-
[&parent_map](auto& dof) { return parent_map(dof); });
36+
std::ranges::transform(sub_dofs, parent_dofs.begin(),
37+
[&parent_map](auto& dof)
38+
{ return parent_map(dof); });
3839
return parent_dofs;
3940
};
4041

@@ -49,13 +50,13 @@ dolfinx_mpc::mpc_data<T> _create_periodic_condition(
4950
parent_rems.reserve(dofs.size());
5051
const auto bs = parent_dofmap->index_map_bs();
5152
// Split parent dofs into blocks and rems
52-
std::for_each(dofs.cbegin(), dofs.cend(),
53-
[&parent_blocks, &parent_rems, &bs](auto dof)
54-
{
55-
std::div_t div = std::div(dof, bs);
56-
parent_blocks.push_back(div.quot);
57-
parent_rems.push_back(div.rem);
58-
});
53+
std::ranges::for_each(dofs,
54+
[&parent_blocks, &parent_rems, &bs](auto dof)
55+
{
56+
std::div_t div = std::div(dof, bs);
57+
parent_blocks.push_back(div.quot);
58+
parent_rems.push_back(div.rem);
59+
});
5960
// Map blocks to global index
6061
std::vector<std::int64_t> parents_glob(dofs.size());
6162
parent_dofmap->index_map->local_to_global(parent_blocks, parents_glob);
@@ -86,12 +87,12 @@ dolfinx_mpc::mpc_data<T> _create_periodic_condition(
8687
// Only work with local blocks
8788
std::vector<std::int32_t> local_blocks;
8889
local_blocks.reserve(slave_blocks.size());
89-
std::for_each(slave_blocks.begin(), slave_blocks.end(),
90-
[&local_blocks, size_local](auto block)
91-
{
92-
if (block < size_local)
93-
local_blocks.push_back(block);
94-
});
90+
std::ranges::for_each(slave_blocks,
91+
[&local_blocks, size_local](auto block)
92+
{
93+
if (block < size_local)
94+
local_blocks.push_back(block);
95+
});
9596

9697
// Create map from slave dof blocks to a cell containing them
9798
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(
301302
const std::int32_t insert_location
302303
= disp_out[dist] + out_placement[dist]++;
303304
// Copy coordinates and dofs to output arrays
304-
std::copy_n(std::next(mapped_T_b.begin(), 3 * i), 3,
305-
std::next(coords_out.begin(), 3 * insert_location));
305+
std::ranges::copy_n(std::next(mapped_T_b.begin(), 3 * i), 3,
306+
std::next(coords_out.begin(), 3 * insert_location));
306307
for (int b = 0; b < bs; b++)
307308
{
308309
searching_dofs[insert_location * bs + b]
@@ -323,10 +324,10 @@ dolfinx_mpc::mpc_data<T> _create_periodic_condition(
323324

324325
// Take into account that we send three values per slave
325326
auto m_3 = [](auto& num) { num *= 3; };
326-
std::for_each(disp_out.begin(), disp_out.end(), m_3);
327-
std::for_each(num_out_slaves.begin(), num_out_slaves.end(), m_3);
328-
std::for_each(disp_in.begin(), disp_in.end(), m_3);
329-
std::for_each(num_recv_slaves.begin(), num_recv_slaves.end(), m_3);
327+
std::ranges::for_each(disp_out, m_3);
328+
std::ranges::for_each(num_out_slaves, m_3);
329+
std::ranges::for_each(disp_in, m_3);
330+
std::ranges::for_each(num_recv_slaves, m_3);
330331

331332
// Communicate coordinates
332333
MPI_Neighbor_alltoallv(
@@ -336,12 +337,12 @@ dolfinx_mpc::mpc_data<T> _create_periodic_condition(
336337

337338
// Reset in_displacements to be per block for later usage
338339
auto d_3 = [](auto& num) { num /= 3; };
339-
std::for_each(disp_in.begin(), disp_in.end(), d_3);
340+
std::ranges::for_each(disp_in, d_3);
340341

341342
// Reset out_displacments to be for every slave
342343
auto m_bs_d_3 = [bs](auto& num) { num = num * bs / 3; };
343-
std::for_each(disp_out.begin(), disp_out.end(), m_bs_d_3);
344-
std::for_each(num_out_slaves.begin(), num_out_slaves.end(), m_bs_d_3);
344+
std::ranges::for_each(disp_out, m_bs_d_3);
345+
std::ranges::for_each(num_out_slaves, m_bs_d_3);
345346

346347
// Create remote arrays
347348
std::vector<std::int64_t> masters_remote;

cpp/SlipConstraint.h

+3-5
Original file line numberDiff line numberDiff line change
@@ -117,9 +117,8 @@ mpc_data<T> create_slip_condition(
117117

118118
// Determine slave dof by component with biggest normal vector (to avoid
119119
// issues with grids aligned with coordiante system)
120-
auto max_el = std::max_element(normal.begin(), normal.end(),
121-
[](T a, T b)
122-
{ return std::norm(a) < std::norm(b); });
120+
auto max_el = std::ranges::max_element(
121+
normal, [](T a, T b) { return std::norm(a) < std::norm(b); });
123122
auto slave_index = std::distance(normal.begin(), max_el);
124123
assert(slave_index < num_normal_components);
125124
std::int32_t parent_slave
@@ -147,8 +146,7 @@ mpc_data<T> create_slip_condition(
147146
}
148147
// Convert local parent dof to local parent block
149148
std::vector<std::int32_t> parent_blocks = parent_masters;
150-
std::for_each(parent_blocks.begin(), parent_blocks.end(),
151-
[W_bs](auto& b) { b /= W_bs; });
149+
std::ranges::for_each(parent_blocks, [W_bs](auto& b) { b /= W_bs; });
152150
// Map blocks from local to global
153151
pair_m.resize(parent_masters.size());
154152
W_imap->local_to_global(parent_blocks, pair_m);

0 commit comments

Comments
 (0)