Begin ConnectivityMatrix refactoring

src/mesh/Connectivity.cpp

@@ -106,8 +106,7 @@ void Connectivity<3>::_computeFaceCellConnectivities()
       }
       ++l;
     }
-    m_cell_to_face_matrix
-        = Kokkos::create_staticcrsgraph<ConnectivityMatrix>("cell_to_face_matrix", cell_to_face_vector);
+    m_cell_to_face_matrix = cell_to_face_vector;
   }
 
   {
@@ -125,9 +124,7 @@ void Connectivity<3>::_computeFaceCellConnectivities()
       ++l;
     }
 
-    m_cell_to_face_is_reversed_matrix
-        = Kokkos::create_staticcrsgraph<ConnectivityMatrixShort>("cell_to_face_is_reversed_matrix",
-                                                                 cell_to_face_is_reversed_vector);
+    m_cell_to_face_is_reversed_matrix = cell_to_face_is_reversed_vector;
   }
 
   {
@@ -138,8 +135,7 @@ void Connectivity<3>::_computeFaceCellConnectivities()
       face_to_node_vector[l] = face.nodeIdList();
       ++l;
     }
-    m_face_to_node_matrix
-        = Kokkos::create_staticcrsgraph<ConnectivityMatrix>("face_to_node_matrix", face_to_node_vector);
+    m_face_to_node_matrix = face_to_node_vector;
   }
 
   {
@@ -221,8 +217,7 @@ void Connectivity<2>::_computeFaceCellConnectivities()
       face_to_node_vector[l] = {face.m_node0_id, face.m_node1_id};
       ++l;
     }
-    m_face_to_node_matrix
-        = Kokkos::create_staticcrsgraph<ConnectivityMatrix>("face_to_node_matrix", face_to_node_vector);
+    m_face_to_node_matrix = face_to_node_vector;
   }
 
   {
@@ -235,7 +230,6 @@ void Connectivity<2>::_computeFaceCellConnectivities()
       }
       ++l;
     }
-    m_face_to_cell_matrix
-        = Kokkos::create_staticcrsgraph<ConnectivityMatrix>("face_to_cell_matrix", face_to_cell_vector);
+    m_face_to_cell_matrix = face_to_cell_vector;
   }
 }

src/mesh/Connectivity.hpp

@@ -6,6 +6,7 @@
 
 #include <Kokkos_Core.hpp>
 
+#include <ConnectivityMatrix.hpp>
 #include <ConnectivityComputer.hpp>
 
 #include <vector>
@@ -343,9 +344,7 @@ private:
 
   Connectivity(const std::vector<std::vector<unsigned int>>& cell_by_node_vector)
   {
-    m_cell_to_node_matrix
-        = Kokkos::create_staticcrsgraph<ConnectivityMatrix>("cell_to_node_matrix",
-                                                            cell_by_node_vector);
+    m_cell_to_node_matrix = cell_by_node_vector;
 
     Assert(this->numberOfCells()>0);
 
@@ -369,9 +368,7 @@ private:
           node_id_per_cell[r] = id++;
         }
       }
-      m_node_id_per_cell_matrix
-          = Kokkos::create_staticcrsgraph<ConnectivityMatrix>("node_id_per_cell_matrix",
-                                                              node_id_per_cell_vector);
+      m_node_id_per_cell_matrix = node_id_per_cell_vector;
     }
 
     m_connectivity_computer.computeInverseConnectivityMatrix(m_cell_to_node_matrix,

src/mesh/ConnectivityComputer.cpp

@@ -30,8 +30,7 @@ computeInverseConnectivityMatrix(const ConnectivityMatrix& item_to_child_item_ma
   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);
+  child_item_to_item_matrix = child_item_to_items_vector;
 }
 
 void ConnectivityComputer::
@@ -55,6 +54,5 @@ computeLocalChildItemNumberInItem(const ConnectivityMatrix& item_to_child_items_
       }
     }
   }
-  child_item_number_in_item_matrix
-      = Kokkos::create_staticcrsgraph<ConnectivityMatrixShort>("child_item_number_in_item_matrix", child_item_number_in_item_vector);
+  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;
+#include <ConnectivityMatrix.hpp>
 
 struct ConnectivityComputer
 {

src/mesh/ConnectivityMatrix.hpp

+#ifndef CONNECTIVITY_MATRIX_HPP
+#define CONNECTIVITY_MATRIX_HPP
+
+#include <Kokkos_Core.hpp>
+#include <Kokkos_StaticCrsGraph.hpp>
+
+
+#if 0
+typedef Kokkos::StaticCrsGraph<unsigned int, Kokkos::HostSpace> ConnectivityMatrix;
+#else
+
+class ConnectivityMatrix
+{
+ private:
+  typedef Kokkos::StaticCrsGraph<unsigned int, Kokkos::HostSpace> HostMatrix;
+  HostMatrix m_host_matrix;
+
+ public:
+  KOKKOS_INLINE_FUNCTION
+  const auto numEntries() const
+  {
+    return m_host_matrix.entries.extent(0);
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  const auto numRows() const
+  {
+    return m_host_matrix.numRows();
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  const auto rowConst(const size_t& j) const
+  {
+    return m_host_matrix.rowConst(j);
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  const auto rowMap(const size_t& j) const
+  {
+    return m_host_matrix.row_map[j];
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  ConnectivityMatrix& operator=(const std::vector<std::vector<unsigned int>>& initializer)
+  {
+    m_host_matrix = Kokkos::create_staticcrsgraph<HostMatrix>("connecticity_matrix", initializer);
+    return *this;
+  }
+
+  [[deprecated("Must only define connectivities so that only unsigned int should be treated")]]
+  KOKKOS_INLINE_FUNCTION
+  ConnectivityMatrix& operator=(const std::vector<std::vector<unsigned short>>& initializer)
+  {
+    m_host_matrix = Kokkos::create_staticcrsgraph<HostMatrix>("connecticity_matrix", initializer);
+    return *this;
+  }
+
+  ConnectivityMatrix& operator=(const ConnectivityMatrix&) = default;
+  ConnectivityMatrix& operator=(ConnectivityMatrix&&) = default;
+
+  ConnectivityMatrix() = default;
+  ConnectivityMatrix(const ConnectivityMatrix&) = default;
+  ConnectivityMatrix(ConnectivityMatrix&&) = default;
+  ~ConnectivityMatrix() = default;
+};
+
+#endif
+
+#warning use right type (unsigned short) instead of a clone of ConnectivityMatrix
+using ConnectivityMatrixShort = ConnectivityMatrix;
+
+
+#endif // CONNECTIVITY_MATRIX_HPP

src/scheme/SubItemValuePerItem.hpp

@@ -6,7 +6,7 @@
 
 #warning should not stand in the scheme directory
 
-typedef Kokkos::StaticCrsGraph<unsigned int, Kokkos::HostSpace> ConnectivityMatrix;
+#include <ConnectivityMatrix.hpp>
 
 template <typename DataType,
           TypeOfItem SubItemType,
@@ -104,13 +104,13 @@ class SubItemValuePerItem
   KOKKOS_FORCEINLINE_FUNCTION
   DataType& operator()(const size_t& j, const size_t& r)
   {
-    return m_values[m_subitem_id_per_item_matrix.row_map[j]+r];
+    return m_values[m_subitem_id_per_item_matrix.rowMap(j)+r];
   }
 
   KOKKOS_FORCEINLINE_FUNCTION
   const DataType& operator()(const size_t& j, const size_t& r) const
   {
-    return m_values[m_subitem_id_per_item_matrix.row_map[j]+r];
+    return m_values[m_subitem_id_per_item_matrix.rowMap(j)+r];
   }
 
   KOKKOS_INLINE_FUNCTION
@@ -140,22 +140,22 @@ class SubItemValuePerItem
   KOKKOS_INLINE_FUNCTION
   size_t numberOfSubValues(const size_t& i_cell) const
   {
-    return m_subitem_id_per_item_matrix.row_map[i_cell+1]-m_subitem_id_per_item_matrix.row_map[i_cell];
+    return m_subitem_id_per_item_matrix.rowMap(i_cell+1)-m_subitem_id_per_item_matrix.rowMap(i_cell);
   }
 
   KOKKOS_INLINE_FUNCTION
   SubView itemValues(const size_t& i_cell)
   {
-    const ConnectivityMatrix::size_type& cell_begin = m_subitem_id_per_item_matrix.row_map[i_cell];
-    const ConnectivityMatrix::size_type& cell_end = m_subitem_id_per_item_matrix.row_map[i_cell+1];
+    const auto& cell_begin = m_subitem_id_per_item_matrix.rowMap(i_cell);
+    const auto& cell_end = m_subitem_id_per_item_matrix.rowMap(i_cell+1);
     return SubView(m_values, cell_begin, cell_end);
   }
 
   KOKKOS_INLINE_FUNCTION
   SubViewConst itemValues(const size_t& i_cell) const
   {
-    const ConnectivityMatrix::size_type& cell_begin = m_subitem_id_per_item_matrix.row_map[i_cell];
-    const ConnectivityMatrix::size_type& cell_end = m_subitem_id_per_item_matrix.row_map[i_cell+1];
+    const auto& cell_begin = m_subitem_id_per_item_matrix.rowMap(i_cell);
+    const auto& cell_end = m_subitem_id_per_item_matrix.rowMap(i_cell+1);
     return SubViewConst(m_values, cell_begin, cell_end);
   }
 
@@ -165,7 +165,7 @@ class SubItemValuePerItem
   SubItemValuePerItem(const ConnectivityType& connectivity)
   {
     m_subitem_id_per_item_matrix = connectivity.template subItemIdPerItemMatrix<SubItemType,ItemType>();
-    m_values = Kokkos::View<DataType*>("values", m_subitem_id_per_item_matrix.entries.extent(0));
+    m_values = Kokkos::View<DataType*>("values", m_subitem_id_per_item_matrix.numEntries());
   }
 
   ~SubItemValuePerItem() = default;