Add ConnectivityComputer utility

src/mesh/CMakeLists.txt

@@ -6,6 +6,7 @@ include_directories(${CMAKE_CURRENT_BINARY_DIR})
 add_library(
   PastisMesh
   Connectivity.cpp
+  ConnectivityComputer.cpp
   GmshReader.cpp)
 
 #include_directories(${PASTIS_SOURCE_DIR}/utils)

src/mesh/Connectivity.cpp

 #include <Connectivity.hpp>
+#include <map>
 
 template<>
 void Connectivity<3>::_computeFaceCellConnectivities()
@@ -150,10 +151,10 @@ void Connectivity<3>::_computeFaceCellConnectivities()
     }
   }
 
-  this->_computeInverseConnectivityMatrix(m_cell_to_face_matrix,
+  m_connectivity_computer.computeInverseConnectivityMatrix(m_cell_to_face_matrix,
                                                            m_face_to_cell_matrix);
 
-  this->_computeLocalChildItemNumberInItem(m_cell_to_face_matrix,
+  m_connectivity_computer.computeLocalChildItemNumberInItem(m_cell_to_face_matrix,
                                                             m_face_to_cell_matrix,
                                                             m_face_to_cell_local_face_matrix);
 

src/mesh/Connectivity.hpp

-#ifndef CONNECTIVITY_3D_HPP
-#define CONNECTIVITY_3D_HPP
+#ifndef CONNECTIVITY_HPP
+#define CONNECTIVITY_HPP
 
-#include <Kokkos_Core.hpp>
 #include <PastisAssert.hpp>
 #include <TinyVector.hpp>
 
-#include <Kokkos_StaticCrsGraph.hpp>
+#include <Kokkos_Core.hpp>
 
-typedef Kokkos::StaticCrsGraph<unsigned int, Kokkos::HostSpace> ConnectivityMatrix;
-#warning use right type (unsigned short)
-typedef Kokkos::StaticCrsGraph<unsigned int, Kokkos::HostSpace> ConnectivityMatrixShort;
+#include <ConnectivityComputer.hpp>
 
 #include <vector>
-#include <map>
 #include <unordered_map>
 #include <algorithm>
 
@@ -254,6 +250,8 @@ public:
   const ConnectivityMatrix& subItemIdPerItemMatrix() const = delete;
 
 private:
+  ConnectivityComputer m_connectivity_computer;
+
   // Stores numbering of nodes of each cell.
   // gives an id to each node of each cell. (j,r) -> id
   //
@@ -274,12 +272,6 @@ private:
   std::unordered_map<Face, unsigned int, typename Face::Hash> m_face_number_map;
 
   void _computeFaceCellConnectivities();
-  void _computeInverseConnectivityMatrix(const ConnectivityMatrix& cell_to_node_matrix,
-                                         ConnectivityMatrix& node_to_cell_matrix);
-
-  void _computeLocalChildItemNumberInItem(const ConnectivityMatrix& cell_to_node_matrix,
-                                          const ConnectivityMatrix& node_to_cell_matrix,
-                                          ConnectivityMatrixShort& node_to_cell_local_node_matrix);
 
  public:
   void addRefFaceList(const RefFaceList& ref_face_list)
@@ -382,10 +374,10 @@ private:
                                                               node_id_per_cell_vector);
     }
 
-    this->_computeInverseConnectivityMatrix(m_cell_to_node_matrix,
+    m_connectivity_computer.computeInverseConnectivityMatrix(m_cell_to_node_matrix,
                                                              m_node_to_cell_matrix);
 
-    this->_computeLocalChildItemNumberInItem(m_cell_to_node_matrix,
+    m_connectivity_computer.computeLocalChildItemNumberInItem(m_cell_to_node_matrix,
                                                               m_node_to_cell_matrix,
                                                               m_node_to_cell_local_node_matrix);
     if constexpr (Dimension>1) {
@@ -399,65 +391,6 @@ private:
   }
 };
 
-template<size_t Dimension>
-inline void Connectivity<Dimension>::
-_computeInverseConnectivityMatrix(const ConnectivityMatrix& item_to_child_item_matrix,
-                                  ConnectivityMatrix& child_item_to_item_matrix)
-{
-  std::map<unsigned int, std::vector<unsigned int>> child_item_to_item_vector_map;
-  const size_t& number_of_items = item_to_child_item_matrix.numRows();
-
-  for (unsigned int j=0; j<number_of_items; ++j) {
-    const auto& item_to_child_items = item_to_child_item_matrix.rowConst(j);
-    for (unsigned int r=0; r<item_to_child_items.length; ++r) {
-      child_item_to_item_vector_map[item_to_child_items(r)].push_back(j);
-    }
-  }
-
-  {
-    size_t i=0;
-    for (const auto& [child_item_id, item_vector] : child_item_to_item_vector_map) {
-      if (child_item_id != i) {
-        std::cerr << "sparse item numerotation NIY\n";
-        std::exit(0);
-      }
-      ++i;
-    }
-  }
-
-  std::vector<std::vector<unsigned int>> child_item_to_items_vector(child_item_to_item_vector_map.size());
-  for (const auto& [child_item_id, item_vector] : child_item_to_item_vector_map) {
-    child_item_to_items_vector[child_item_id] = item_vector;
-  }
-  child_item_to_item_matrix
-      = Kokkos::create_staticcrsgraph<ConnectivityMatrix>("child_item_to_item_matrix", child_item_to_items_vector);
-}
-
-template<size_t Dimension>
-inline void Connectivity<Dimension>::
-_computeLocalChildItemNumberInItem(const ConnectivityMatrix& item_to_child_items_matrix,
-                                   const ConnectivityMatrix& child_item_to_items_matrix,
-                                   ConnectivityMatrixShort&  child_item_number_in_item_matrix)
-{
-  std::vector<std::vector<unsigned int>> child_item_number_in_item_vector(child_item_to_items_matrix.numRows());
-  for (unsigned int r=0; r<child_item_to_items_matrix.numRows(); ++r) {
-    const auto& child_item_to_items = child_item_to_items_matrix.rowConst(r);
-    child_item_number_in_item_vector[r].resize(child_item_to_items.length);
-    for (unsigned short J=0; J<child_item_to_items.length; ++J) {
-      const unsigned int j = child_item_to_items(J);
-      const auto& item_to_child_items = item_to_child_items_matrix.rowConst(j);
-
-      for (unsigned int R=0; R<item_to_child_items.length; ++R) {
-        if (item_to_child_items(R) == r) {
-          child_item_number_in_item_vector[r][J] = R;
-          break;
-        }
-      }
-    }
-  }
-  child_item_number_in_item_matrix
-      = Kokkos::create_staticcrsgraph<ConnectivityMatrixShort>("child_item_number_in_item_matrix", child_item_number_in_item_vector);
-}
 
 using Connectivity3D = Connectivity<3>;
 
@@ -492,4 +425,4 @@ Connectivity<1>::subItemIdPerItemMatrix<TypeOfItem::node,
   return m_node_id_per_cell_matrix;
 }
 
-#endif // CONNECTIVITY_3D_HPP
+#endif // CONNECTIVITY_HPP

src/mesh/ConnectivityComputer.cpp

+#include <ConnectivityComputer.hpp>
+#include <map>
+
+void ConnectivityComputer::
+computeInverseConnectivityMatrix(const ConnectivityMatrix& item_to_child_item_matrix,
+                                 ConnectivityMatrix& child_item_to_item_matrix) const
+{
+  std::map<unsigned int, std::vector<unsigned int>> child_item_to_item_vector_map;
+  const size_t& number_of_items = item_to_child_item_matrix.numRows();
+
+  for (unsigned int j=0; j<number_of_items; ++j) {
+    const auto& item_to_child_items = item_to_child_item_matrix.rowConst(j);
+    for (unsigned int r=0; r<item_to_child_items.length; ++r) {
+      child_item_to_item_vector_map[item_to_child_items(r)].push_back(j);
+    }
+  }
+
+  {
+    size_t i=0;
+    for (const auto& [child_item_id, item_vector] : child_item_to_item_vector_map) {
+      if (child_item_id != i) {
+        std::cerr << "sparse item numerotation NIY\n";
+        std::exit(0);
+      }
+      ++i;
+    }
+  }
+
+  std::vector<std::vector<unsigned int>> child_item_to_items_vector(child_item_to_item_vector_map.size());
+  for (const auto& [child_item_id, item_vector] : child_item_to_item_vector_map) {
+    child_item_to_items_vector[child_item_id] = item_vector;
+  }
+  child_item_to_item_matrix
+      = Kokkos::create_staticcrsgraph<ConnectivityMatrix>("child_item_to_item_matrix", child_item_to_items_vector);
+}
+
+void ConnectivityComputer::
+computeLocalChildItemNumberInItem(const ConnectivityMatrix& item_to_child_items_matrix,
+                                  const ConnectivityMatrix& child_item_to_items_matrix,
+                                  ConnectivityMatrixShort&  child_item_number_in_item_matrix) const
+{
+  std::vector<std::vector<unsigned int>> child_item_number_in_item_vector(child_item_to_items_matrix.numRows());
+  for (unsigned int r=0; r<child_item_to_items_matrix.numRows(); ++r) {
+    const auto& child_item_to_items = child_item_to_items_matrix.rowConst(r);
+    child_item_number_in_item_vector[r].resize(child_item_to_items.length);
+    for (unsigned short J=0; J<child_item_to_items.length; ++J) {
+      const unsigned int j = child_item_to_items(J);
+      const auto& item_to_child_items = item_to_child_items_matrix.rowConst(j);
+
+      for (unsigned int R=0; R<item_to_child_items.length; ++R) {
+        if (item_to_child_items(R) == r) {
+          child_item_number_in_item_vector[r][J] = R;
+          break;
+        }
+      }
+    }
+  }
+  child_item_number_in_item_matrix
+      = Kokkos::create_staticcrsgraph<ConnectivityMatrixShort>("child_item_number_in_item_matrix", child_item_number_in_item_vector);
+}

src/mesh/ConnectivityComputer.hpp

+#ifndef CONNECTIVITY_COMPUTER_HPP
+#define CONNECTIVITY_COMPUTER_HPP
+
+#include <Kokkos_Core.hpp>
+#include <Kokkos_StaticCrsGraph.hpp>
+
+typedef Kokkos::StaticCrsGraph<unsigned int, Kokkos::HostSpace> ConnectivityMatrix;
+#warning use right type (unsigned short)
+typedef Kokkos::StaticCrsGraph<unsigned int, Kokkos::HostSpace> ConnectivityMatrixShort;
+
+struct ConnectivityComputer
+{
+  void computeInverseConnectivityMatrix(const ConnectivityMatrix& item_to_child_item_matrix,
+                                        ConnectivityMatrix& child_item_to_item_matrix) const;
+
+  void computeLocalChildItemNumberInItem(const ConnectivityMatrix& item_to_child_items_matrix,
+                                         const ConnectivityMatrix& child_item_to_items_matrix,
+                                         ConnectivityMatrixShort&  child_item_number_in_item_matrix) const;
+};
+
+#endif // CONNECTIVITY_COMPUTER_HPP