FIx clang11 compilation

And continue fixing ConnectivityDispatcher issues when called in
parallel

src/mesh/ConnectivityDispatcher.cpp

@@ -5,7 +5,6 @@
 #include <utils/Partitioner.hpp>
 
 #include <iostream>
-#include <unordered_map>
 
 template <size_t Dimension>
 template <ItemType item_type>
@@ -16,7 +15,12 @@ ConnectivityDispatcher<Dimension>::_buildNewOwner()
     CRSGraph connectivity_graph = m_connectivity.ownCellToCellGraph();
     Partitioner P;
     Array new_owner_array = P.partition(connectivity_graph);
-    CellValue cell_is_owned = m_connectivity.cellIsOwned();
+
+    std::cout << "new_owner_array = " << new_owner_array << '\n';
+
+    const auto& cell_is_owned = m_connectivity.cellIsOwned();
+
+    std::cout << "cell_is_owned = " << cell_is_owned << '\n';
 
     CellValue<int> cell_new_owner(m_connectivity);
 
@@ -28,6 +32,9 @@ ConnectivityDispatcher<Dimension>::_buildNewOwner()
     }
     synchronize(cell_new_owner);
 
+    std::cout << "cell_new_owner = " << cell_new_owner << '\n';
+    std::cout << "cell_number    = " << m_connectivity.cellNumber() << '\n';
+
     this->_dispatchedInfo<ItemType::cell>().m_new_owner = cell_new_owner;
   } else {
     const auto& item_to_cell_matrix = m_connectivity.template getItemToItemMatrix<item_type, ItemType::cell>();
@@ -77,27 +84,30 @@ ConnectivityDispatcher<Dimension>::_buildItemListToSend()
   if constexpr (item_type == ItemType::cell) {
     const auto& node_to_cell_matrix = m_connectivity.nodeToCellMatrix();
     const auto& cell_to_node_matrix = m_connectivity.cellToNodeMatrix();
+    const auto& cell_is_owned       = m_connectivity.cellIsOwned();
 
     const auto& cell_new_owner = this->_dispatchedInfo<ItemType::cell>().m_new_owner;
 
     std::vector<std::vector<CellId>> cell_vector_to_send_by_proc(parallel::size());
     Array<bool> send_to_rank(parallel::size());
-    for (CellId j = 0; j < m_connectivity.numberOfCells(); ++j) {
+    for (CellId cell_id = 0; cell_id < m_connectivity.numberOfCells(); ++cell_id) {
       send_to_rank.fill(false);
-      const auto& cell_to_node = cell_to_node_matrix[j];
+      const auto& cell_to_node = cell_to_node_matrix[cell_id];
 
-      for (size_t R = 0; R < cell_to_node.size(); ++R) {
-        const NodeId& r          = cell_to_node[R];
-        const auto& node_to_cell = node_to_cell_matrix[r];
-        for (size_t K = 0; K < node_to_cell.size(); ++K) {
-          const CellId& k                 = node_to_cell[K];
-          send_to_rank[cell_new_owner[k]] = true;
+      for (size_t i_node = 0; i_node < cell_to_node.size(); ++i_node) {
+        const NodeId& node_id    = cell_to_node[i_node];
+        const auto& node_to_cell = node_to_cell_matrix[node_id];
+        for (size_t i_node_cell = 0; i_node_cell < node_to_cell.size(); ++i_node_cell) {
+          const CellId& node_cell = node_to_cell[i_node_cell];
+          if (cell_is_owned[node_cell]) {
+            send_to_rank[cell_new_owner[node_cell]] = true;
+          }
         }
       }
 
       for (size_t k = 0; k < send_to_rank.size(); ++k) {
         if (send_to_rank[k]) {
-          cell_vector_to_send_by_proc[k].push_back(j);
+          cell_vector_to_send_by_proc[k].push_back(cell_id);
         }
       }
     }
@@ -107,9 +117,15 @@ ConnectivityDispatcher<Dimension>::_buildItemListToSend()
     for (size_t i = 0; i < parallel::size(); ++i) {
       cell_list_to_send_by_proc[i] = convert_to_array(cell_vector_to_send_by_proc[i]);
     }
+
+    for (size_t i = 0; i < parallel::size(); ++i) {
+      std::cout << parallel::rank() << ": send to " << i << ": " << cell_list_to_send_by_proc[i] << '\n';
+    }
   } else {
     const auto& cell_list_to_send_by_proc = this->_dispatchedInfo<ItemType::cell>().m_list_to_send_by_proc;
 
+    const auto& item_is_owned = m_connectivity.template isOwned<item_type>();
+
     using ItemId                        = ItemIdT<item_type>;
     const auto& cell_to_sub_item_matrix = m_connectivity.template getItemToItemMatrix<ItemType::cell, item_type>();
 
@@ -125,7 +141,7 @@ ConnectivityDispatcher<Dimension>::_buildItemListToSend()
         const auto& cell_sub_item_list = cell_to_sub_item_matrix[cell_id];
         for (size_t r = 0; r < cell_sub_item_list.size(); ++r) {
           const ItemId& item_id = cell_sub_item_list[r];
-          if (not tag[item_id]) {
+          if (item_is_owned[item_id] and (not tag[item_id])) {
             item_id_vector.push_back(item_id);
             tag[item_id] = true;
           }
@@ -761,6 +777,24 @@ ConnectivityDispatcher<Dimension>::ConnectivityDispatcher(const ConnectivityType
 
   this->_buildItemReferenceList<ItemType::node>();
 
+  std::cout << "m_new_descriptor.nodeNumberVector() = " << m_new_descriptor.nodeNumberVector() << '\n';
+  std::cout << "m_new_descriptor.nodeOwnerVector()  = " << m_new_descriptor.nodeOwnerVector() << '\n';
+
+  std::cout << "m_new_descriptor.cellOwnerVector().size()          = " << m_new_descriptor.cellOwnerVector().size()
+            << '\n';
+  std::cout << "m_new_descriptor.cellTypeVector().size()           = " << m_new_descriptor.cellTypeVector().size()
+            << '\n';
+  std::cout << "m_new_descriptor.cellToNodeMatrix().numberOfRows() = "
+            << m_new_descriptor.cellToNodeMatrix().numberOfRows() << '\n';
+
+  for (CellId cell_id = 0; cell_id < m_new_descriptor.cellToNodeMatrix().numberOfRows(); ++cell_id) {
+    std::cout << "- cell [" << cell_id << "]("   // << m_new_descriptor.cellNumberVector()[cell_id]
+              << ")" << m_new_descriptor.cellToNodeMatrix()[cell_id] << '\n';
+  }
+
+  std::cout.flush();
+  parallel::barrier();
+
   m_dispatched_connectivity = ConnectivityType::build(m_new_descriptor);
 
   {