From 9ca09a0d34f3c8d3e9d32f7d82a7ac185df91ac3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?St=C3=A9phane=20Del=20Pino?= <stephane.delpino44@gmail.com>
Date: Mon, 21 Feb 2022 11:10:17 +0100
Subject: [PATCH] Rename SubItemValuePerItem::itemValues() ->
 SubItemValuePerItem::itemArray()

This change is to make API more consistent. Indeed the equivalent
function for SubItemArrayPerItem is SubItemValuePerItem::itemTable()
---
 src/mesh/ConnectivityDispatcher.cpp     |  2 +-
 src/mesh/MeshData.hpp                   |  2 +-
 src/mesh/SubItemValuePerItem.hpp        |  4 +--
 src/mesh/SubItemValuePerItemUtils.hpp   |  6 ++--
 src/mesh/Synchronizer.hpp               |  4 +--
 src/scheme/AcousticSolver.cpp           |  4 +--
 tests/test_SubItemValuePerItem.cpp      | 40 ++++++++++++-------------
 tests/test_SubItemValuePerItemUtils.cpp | 18 +++++------
 8 files changed, 40 insertions(+), 40 deletions(-)

diff --git a/src/mesh/ConnectivityDispatcher.cpp b/src/mesh/ConnectivityDispatcher.cpp
index 1502bed70..769eb23bc 100644
--- a/src/mesh/ConnectivityDispatcher.cpp
+++ b/src/mesh/ConnectivityDispatcher.cpp
@@ -183,7 +183,7 @@ ConnectivityDispatcher<Dimension>::_gatherFrom(
     std::vector<MutableDataType> data_by_item_vector;
     for (size_t j = 0; j < item_list_to_send_by_proc[i_rank].size(); ++j) {
       const ItemId& item_id = item_list_to_send_by_proc[i_rank][j];
-      const auto& item_data = data_to_gather.itemValues(item_id);
+      const auto& item_data = data_to_gather.itemArray(item_id);
       for (size_t l = 0; l < item_data.size(); ++l) {
         data_by_item_vector.push_back(item_data[l]);
       }
diff --git a/src/mesh/MeshData.hpp b/src/mesh/MeshData.hpp
index 596ab38bd..8842fd8ac 100644
--- a/src/mesh/MeshData.hpp
+++ b/src/mesh/MeshData.hpp
@@ -401,7 +401,7 @@ class MeshData : public IMeshData
           const auto& cell_nodes = cell_to_node_matrix[j];
 
           const auto& cell_faces       = cell_to_face_matrix[j];
-          const auto& face_is_reversed = cell_face_is_reversed.itemValues(j);
+          const auto& face_is_reversed = cell_face_is_reversed.itemArray(j);
 
           for (size_t L = 0; L < cell_faces.size(); ++L) {
             const FaceId& l        = cell_faces[L];
diff --git a/src/mesh/SubItemValuePerItem.hpp b/src/mesh/SubItemValuePerItem.hpp
index f48907baa..ea0e90068 100644
--- a/src/mesh/SubItemValuePerItem.hpp
+++ b/src/mesh/SubItemValuePerItem.hpp
@@ -137,7 +137,7 @@ class SubItemValuePerItem
 
   template <typename IndexType>
   PUGS_INLINE Array<DataType>
-  itemValues(IndexType item_id) noexcept(NO_ASSERT)
+  itemArray(IndexType item_id) noexcept(NO_ASSERT)
   {
     static_assert(std::is_same_v<IndexType, ItemId>, "index must be an ItemId");
     Assert(this->isBuilt());
@@ -151,7 +151,7 @@ class SubItemValuePerItem
   // changes in data
   template <typename IndexType>
   PUGS_INLINE Array<DataType>
-  itemValues(IndexType item_id) const noexcept(NO_ASSERT)
+  itemArray(IndexType item_id) const noexcept(NO_ASSERT)
   {
     static_assert(std::is_same_v<IndexType, ItemId>, "index must be an ItemId");
     Assert(this->isBuilt());
diff --git a/src/mesh/SubItemValuePerItemUtils.hpp b/src/mesh/SubItemValuePerItemUtils.hpp
index 5ff153876..88f36d1cc 100644
--- a/src/mesh/SubItemValuePerItemUtils.hpp
+++ b/src/mesh/SubItemValuePerItemUtils.hpp
@@ -44,7 +44,7 @@ min(const SubItemValuePerItem<DataType, ItemOfItem, ConnectivityPtr>& sub_item_v
     operator()(const index_type& item_id, data_type& data) const
     {
       if (m_is_owned[item_id]) {
-        Array sub_item_array = m_sub_item_value_per_item.itemValues(item_id);
+        Array sub_item_array = m_sub_item_value_per_item.itemArray(item_id);
         for (size_t i = 0; i < sub_item_array.size(); ++i) {
           if (sub_item_array[i] < data) {
             data = sub_item_array[i];
@@ -144,7 +144,7 @@ max(const SubItemValuePerItem<DataType, ItemOfItem, ConnectivityPtr>& sub_item_v
     operator()(const index_type& item_id, data_type& data) const
     {
       if (m_is_owned[item_id]) {
-        Array sub_item_array = m_sub_item_value_per_item.itemValues(item_id);
+        Array sub_item_array = m_sub_item_value_per_item.itemArray(item_id);
         for (size_t i = 0; i < sub_item_array.size(); ++i) {
           if (sub_item_array[i] > data) {
             data = sub_item_array[i];
@@ -243,7 +243,7 @@ sum(const SubItemValuePerItem<DataType, ItemOfItem, ConnectivityPtr>& item_value
     operator()(const index_type& item_id, data_type& data) const
     {
       if (m_is_owned[item_id]) {
-        Array sub_item_array = m_sub_item_value_per_item.itemValues(item_id);
+        Array sub_item_array = m_sub_item_value_per_item.itemArray(item_id);
         for (size_t i = 0; i < sub_item_array.size(); ++i) {
           data += sub_item_array[i];
         }
diff --git a/src/mesh/Synchronizer.hpp b/src/mesh/Synchronizer.hpp
index 4f688e18e..63e4363ef 100644
--- a/src/mesh/Synchronizer.hpp
+++ b/src/mesh/Synchronizer.hpp
@@ -347,7 +347,7 @@ class Synchronizer
         size_t index = 0;
         for (size_t i = 0; i < provided_item_info_to_rank.size(); ++i) {
           const ItemId item_id   = provided_item_info_to_rank[i];
-          const auto item_values = sub_item_value_per_item.itemValues(item_id);
+          const auto item_values = sub_item_value_per_item.itemArray(item_id);
           for (size_t j = 0; j < item_values.size(); ++j) {
             provided_data[index++] = item_values[j];
           }
@@ -369,7 +369,7 @@ class Synchronizer
         size_t index = 0;
         for (size_t i = 0; i < requested_item_info_from_rank.size(); ++i) {
           const ItemId item_id   = requested_item_info_from_rank[i];
-          const auto item_values = sub_item_value_per_item.itemValues(item_id);
+          const auto item_values = sub_item_value_per_item.itemArray(item_id);
           for (size_t j = 0; j < item_values.size(); ++j) {
             item_values[j] = requested_data[index++];
           }
diff --git a/src/scheme/AcousticSolver.cpp b/src/scheme/AcousticSolver.cpp
index 098b146e5..db0a20dca 100644
--- a/src/scheme/AcousticSolver.cpp
+++ b/src/scheme/AcousticSolver.cpp
@@ -195,7 +195,7 @@ class AcousticSolverHandler::AcousticSolver final : public AcousticSolverHandler
       mesh.numberOfNodes(), PUGS_LAMBDA(NodeId r) {
         Rdxd sum                                   = zero;
         const auto& node_to_cell                   = node_to_cell_matrix[r];
-        const auto& node_local_number_in_its_cells = node_local_numbers_in_their_cells.itemValues(r);
+        const auto& node_local_number_in_its_cells = node_local_numbers_in_their_cells.itemArray(r);
 
         for (size_t j = 0; j < node_to_cell.size(); ++j) {
           const CellId J       = node_to_cell[j];
@@ -226,7 +226,7 @@ class AcousticSolverHandler::AcousticSolver final : public AcousticSolverHandler
     parallel_for(
       mesh.numberOfNodes(), PUGS_LAMBDA(NodeId r) {
         const auto& node_to_cell                   = node_to_cell_matrix[r];
-        const auto& node_local_number_in_its_cells = node_local_numbers_in_their_cells.itemValues(r);
+        const auto& node_local_number_in_its_cells = node_local_numbers_in_their_cells.itemArray(r);
 
         Rd br = zero;
         for (size_t j = 0; j < node_to_cell.size(); ++j) {
diff --git a/tests/test_SubItemValuePerItem.cpp b/tests/test_SubItemValuePerItem.cpp
index 4063133a3..dda38918a 100644
--- a/tests/test_SubItemValuePerItem.cpp
+++ b/tests/test_SubItemValuePerItem.cpp
@@ -85,7 +85,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
               for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
                 is_correct &=
                   (cell_to_node_matrix[cell_id].size() == node_value_per_cell.numberOfSubValues(cell_id)) and
-                  (node_value_per_cell.itemValues(cell_id).size() == node_value_per_cell.numberOfSubValues(cell_id));
+                  (node_value_per_cell.itemArray(cell_id).size() == node_value_per_cell.numberOfSubValues(cell_id));
               }
               REQUIRE(is_correct);
             }
@@ -94,7 +94,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
             {
               bool is_correct = true;
               for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
-                is_correct &= (const_node_value_per_cell.itemValues(cell_id).size() ==
+                is_correct &= (const_node_value_per_cell.itemArray(cell_id).size() ==
                                node_value_per_cell.numberOfSubValues(cell_id));
               }
               REQUIRE(is_correct);
@@ -624,7 +624,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
             size_t value = 0;
             for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) {
               for (size_t i_face = 0; i_face < face_values_per_node.numberOfSubValues(node_id); ++i_face) {
-                face_values_per_node.itemValues(node_id)[i_face] = value++;
+                face_values_per_node.itemArray(node_id)[i_face] = value++;
               }
             }
           }
@@ -644,7 +644,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
             size_t i     = 0;
             for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) {
               for (size_t i_face = 0; i_face < face_values_per_node.numberOfSubValues(node_id); ++i_face, ++i) {
-                is_same &= (face_values_per_node.itemValues(node_id)[i_face] == 3 + i * i);
+                is_same &= (face_values_per_node.itemArray(node_id)[i_face] == 3 + i * i);
               }
             }
             REQUIRE(is_same);
@@ -673,7 +673,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
             size_t value = 0;
             for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
               for (size_t i_node = 0; i_node < node_value_per_cell.numberOfSubValues(cell_id); ++i_node) {
-                node_value_per_cell.itemValues(cell_id)[i_node] = value++;
+                node_value_per_cell.itemArray(cell_id)[i_node] = value++;
               }
             }
           }
@@ -692,7 +692,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
           {
             for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
               for (size_t i_node = 0; i_node < node_value_per_cell.numberOfSubValues(cell_id); ++i_node) {
-                node_value_per_cell.itemValues(cell_id)[i_node] = i_node;
+                node_value_per_cell.itemArray(cell_id)[i_node] = i_node;
               }
             }
           }
@@ -715,7 +715,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
             size_t value = 0;
             for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
               for (size_t i_node = 0; i_node < node_value_per_cell.numberOfSubValues(cell_id); ++i_node) {
-                node_value_per_cell.itemValues(cell_id)[i_node] = value++;
+                node_value_per_cell.itemArray(cell_id)[i_node] = value++;
               }
             }
           }
@@ -735,7 +735,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
           {
             for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
               for (size_t i_node = 0; i_node < node_value_per_cell.numberOfSubValues(cell_id); ++i_node) {
-                node_value_per_cell.itemValues(cell_id)[i_node] = i_node;
+                node_value_per_cell.itemArray(cell_id)[i_node] = i_node;
               }
             }
           }
@@ -790,7 +790,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
     {
       CellValuePerNode<int> cell_value_per_node;
       REQUIRE_THROWS_AS(cell_value_per_node[0], AssertError);
-      REQUIRE_THROWS_AS(cell_value_per_node.itemValues(NodeId{0}), AssertError);
+      REQUIRE_THROWS_AS(cell_value_per_node.itemArray(NodeId{0}), AssertError);
       REQUIRE_THROWS_AS(cell_value_per_node(NodeId{0}, 0), AssertError);
       REQUIRE_THROWS_AS(cell_value_per_node.numberOfValues(), AssertError);
       REQUIRE_THROWS_AS(cell_value_per_node.numberOfItems(), AssertError);
@@ -798,7 +798,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
 
       FaceValuePerCell<int> face_value_per_cell;
       REQUIRE_THROWS_AS(face_value_per_cell[0], AssertError);
-      REQUIRE_THROWS_AS(face_value_per_cell.itemValues(CellId{0}), AssertError);
+      REQUIRE_THROWS_AS(face_value_per_cell.itemArray(CellId{0}), AssertError);
       REQUIRE_THROWS_AS(face_value_per_cell(CellId{0}, 0), AssertError);
       REQUIRE_THROWS_AS(face_value_per_cell.numberOfValues(), AssertError);
       REQUIRE_THROWS_AS(face_value_per_cell.numberOfItems(), AssertError);
@@ -806,7 +806,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
 
       CellValuePerEdge<int> cell_value_per_edge;
       REQUIRE_THROWS_AS(cell_value_per_edge[0], AssertError);
-      REQUIRE_THROWS_AS(cell_value_per_edge.itemValues(EdgeId{0}), AssertError);
+      REQUIRE_THROWS_AS(cell_value_per_edge.itemArray(EdgeId{0}), AssertError);
       REQUIRE_THROWS_AS(cell_value_per_edge(EdgeId{0}, 0), AssertError);
       REQUIRE_THROWS_AS(cell_value_per_edge.numberOfValues(), AssertError);
       REQUIRE_THROWS_AS(cell_value_per_edge.numberOfItems(), AssertError);
@@ -814,7 +814,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
 
       NodeValuePerFace<int> node_value_per_face;
       REQUIRE_THROWS_AS(node_value_per_face[0], AssertError);
-      REQUIRE_THROWS_AS(node_value_per_face.itemValues(FaceId{0}), AssertError);
+      REQUIRE_THROWS_AS(node_value_per_face.itemArray(FaceId{0}), AssertError);
       REQUIRE_THROWS_AS(node_value_per_face(FaceId{0}, 0), AssertError);
       REQUIRE_THROWS_AS(node_value_per_face.numberOfValues(), AssertError);
       REQUIRE_THROWS_AS(node_value_per_face.numberOfItems(), AssertError);
@@ -839,10 +839,10 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
           }
           if (connectivity.numberOfFaces() > 0) {
             FaceId face_id          = 0;
-            const auto& cell_values = cell_value_per_face.itemValues(face_id);
+            const auto& cell_values = cell_value_per_face.itemArray(face_id);
             REQUIRE_THROWS_AS(cell_value_per_face(face_id, cell_values.size()), AssertError);
             REQUIRE_THROWS_AS(cell_values[cell_values.size()], AssertError);
-            REQUIRE_THROWS_AS(cell_value_per_face.itemValues(face_id)[cell_values.size()] = 2, AssertError);
+            REQUIRE_THROWS_AS(cell_value_per_face.itemArray(face_id)[cell_values.size()] = 2, AssertError);
           }
 
           FaceValuePerNode<int> face_value_per_node{connectivity};
@@ -852,10 +852,10 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
           }
           if (connectivity.numberOfNodes() > 0) {
             NodeId node_id          = 0;
-            const auto& face_values = face_value_per_node.itemValues(node_id);
+            const auto& face_values = face_value_per_node.itemArray(node_id);
             REQUIRE_THROWS_AS(face_value_per_node(node_id, face_values.size()), AssertError);
             REQUIRE_THROWS_AS(face_values[face_values.size()], AssertError);
-            REQUIRE_THROWS_AS(face_value_per_node.itemValues(node_id)[face_values.size()] = 2, AssertError);
+            REQUIRE_THROWS_AS(face_value_per_node.itemArray(node_id)[face_values.size()] = 2, AssertError);
           }
 
           EdgeValuePerCell<int> edge_value_per_cell{connectivity};
@@ -865,10 +865,10 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
           }
           if (connectivity.numberOfCells() > 0) {
             CellId cell_id          = 0;
-            const auto& edge_values = edge_value_per_cell.itemValues(cell_id);
+            const auto& edge_values = edge_value_per_cell.itemArray(cell_id);
             REQUIRE_THROWS_AS(edge_value_per_cell(cell_id, edge_values.size()), AssertError);
             REQUIRE_THROWS_AS(edge_values[edge_values.size()], AssertError);
-            REQUIRE_THROWS_AS(edge_value_per_cell.itemValues(cell_id)[edge_values.size()] = 2, AssertError);
+            REQUIRE_THROWS_AS(edge_value_per_cell.itemArray(cell_id)[edge_values.size()] = 2, AssertError);
           }
 
           NodeValuePerEdge<int> node_value_per_edge{connectivity};
@@ -878,10 +878,10 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
           }
           if (connectivity.numberOfEdges() > 0) {
             EdgeId edge_id          = 0;
-            const auto& node_values = node_value_per_edge.itemValues(edge_id);
+            const auto& node_values = node_value_per_edge.itemArray(edge_id);
             REQUIRE_THROWS_AS(node_value_per_edge(edge_id, node_values.size()), AssertError);
             REQUIRE_THROWS_AS(node_values[node_values.size()], AssertError);
-            REQUIRE_THROWS_AS(node_value_per_edge.itemValues(edge_id)[node_values.size()] = 2, AssertError);
+            REQUIRE_THROWS_AS(node_value_per_edge.itemArray(edge_id)[node_values.size()] = 2, AssertError);
           }
         }
       }
diff --git a/tests/test_SubItemValuePerItemUtils.cpp b/tests/test_SubItemValuePerItemUtils.cpp
index c93f5cb7c..ccda4722d 100644
--- a/tests/test_SubItemValuePerItemUtils.cpp
+++ b/tests/test_SubItemValuePerItemUtils.cpp
@@ -28,7 +28,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
         NodeValuePerFace<int> weak_node_value_per_face{connectivity};
 
         for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
-          auto face_array = weak_node_value_per_face.itemValues(face_id);
+          auto face_array = weak_node_value_per_face.itemArray(face_id);
           for (size_t i_node = 0; i_node < face_array.size(); ++i_node) {
             face_array[i_node] = parallel::rank() + 2 * i_node;
           }
@@ -44,7 +44,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
 
           bool is_synchronized = true;
           for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
-            auto face_array = node_value_per_face.itemValues(face_id);
+            auto face_array = node_value_per_face.itemArray(face_id);
             for (size_t i_node = 0; i_node < face_array.size(); ++i_node) {
               if (face_array[i_node] != static_cast<int>(face_owner[face_id] + 2 * i_node)) {
                 is_synchronized = false;
@@ -64,7 +64,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
 
           bool is_synchronized = true;
           for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
-            auto face_array = node_value_per_face.itemValues(face_id);
+            auto face_array = node_value_per_face.itemArray(face_id);
             for (size_t i_node = 0; i_node < face_array.size(); ++i_node) {
               if (face_array[i_node] != static_cast<int>(face_owner[face_id] + 2 * i_node)) {
                 is_synchronized = false;
@@ -99,7 +99,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
           parallel_for(
             connectivity.numberOfCells(), PUGS_LAMBDA(CellId cell_id) {
               if (cell_is_owned[cell_id]) {
-                auto cell_array = node_value_per_cell.itemValues(cell_id);
+                auto cell_array = node_value_per_cell.itemArray(cell_id);
                 for (size_t i = 0; i < cell_array.size(); ++i) {
                   cell_array[i] = 10 + parallel::rank() + i;
                 }
@@ -129,7 +129,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
           parallel_for(
             connectivity.numberOfCells(), PUGS_LAMBDA(CellId cell_id) {
               if (cell_is_owned[cell_id]) {
-                auto cell_array = face_value_per_cell.itemValues(cell_id);
+                auto cell_array = face_value_per_cell.itemArray(cell_id);
                 for (size_t i = 0; i < cell_array.size(); ++i) {
                   cell_array[i] = 10 + parallel::rank() + i;
                 }
@@ -159,7 +159,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
           parallel_for(
             connectivity.numberOfFaces(), PUGS_LAMBDA(FaceId face_id) {
               if (face_is_owned[face_id]) {
-                auto face_array = edge_value_per_face.itemValues(face_id);
+                auto face_array = edge_value_per_face.itemArray(face_id);
                 for (size_t i = 0; i < face_array.size(); ++i) {
                   face_array[i] = 10 + parallel::rank() + i;
                 }
@@ -192,7 +192,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
           parallel_for(
             connectivity.numberOfCells(), PUGS_LAMBDA(CellId cell_id) {
               if (cell_is_owned[cell_id]) {
-                auto cell_array = edge_value_per_cell.itemValues(cell_id);
+                auto cell_array = edge_value_per_cell.itemArray(cell_id);
                 for (size_t i = 0; i < cell_array.size(); ++i) {
                   cell_array[i] = 10 + parallel::rank() - i;
                 }
@@ -222,7 +222,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
           parallel_for(
             connectivity.numberOfCells(), PUGS_LAMBDA(CellId cell_id) {
               if (cell_is_owned[cell_id]) {
-                auto cell_array = edge_value_per_cell.itemValues(cell_id);
+                auto cell_array = edge_value_per_cell.itemArray(cell_id);
                 for (size_t i = 0; i < cell_array.size(); ++i) {
                   cell_array[i] = 10 + parallel::rank() - i;
                 }
@@ -254,7 +254,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
           parallel_for(
             connectivity.numberOfEdges(), PUGS_LAMBDA(EdgeId edge_id) {
               if (edge_is_owned[edge_id]) {
-                auto edge_array = node_value_per_edge.itemValues(edge_id);
+                auto edge_array = node_value_per_edge.itemArray(edge_id);
                 for (size_t i = 0; i < edge_array.size(); ++i) {
                   edge_array[i] = 10 + parallel::rank() - i;
                 }
-- 
GitLab