Improve data transfer from primal to diamond dual mesh

src/mesh/DiamondDualMeshBuilder.cpp

@@ -28,13 +28,20 @@ class MeshToDualDataMapper
   using CellIdToNodeIdMap = Array<std::pair<CellId, NodeId>>;
   CellIdToNodeIdMap m_primal_cell_to_dual_node_map;
 
+  using FaceIdToCellIdMap = Array<std::pair<FaceId, CellId>>;
+  FaceIdToCellIdMap m_primal_face_to_dual_cell_map;
+
  public:
-  template <typename DataType>
+  template <typename OriginDataType1, typename OriginDataType2, typename DestinationDataType>
   void
-  toDualNode(const NodeValue<const DataType>& primal_node_value,
-             const CellValue<const DataType>& primal_cell_value,
-             NodeValue<DataType>& dual_node_value)
+  toDualNode(const NodeValue<OriginDataType1>& primal_node_value,
+             const CellValue<OriginDataType2>& primal_cell_value,
+             const NodeValue<DestinationDataType>& dual_node_value)
   {
+    static_assert(not std::is_const_v<DestinationDataType>, "destination data type must not be constant");
+    static_assert(std::is_same_v<std::remove_const_t<OriginDataType1>, DestinationDataType>, "incompatible types");
+    static_assert(std::is_same_v<std::remove_const_t<OriginDataType2>, DestinationDataType>, "incompatible types");
+
     Assert(m_primal_connectivity == primal_cell_value.connectivity_ptr().get());
     Assert(m_primal_connectivity == primal_node_value.connectivity_ptr().get());
     Assert(m_dual_connectivity == dual_node_value.connectivity_ptr().get());
@@ -53,6 +60,85 @@ class MeshToDualDataMapper
       });
   }
 
+  template <typename OriginDataType, typename DestinationDataType1, typename DestinationDataType2>
+  void
+  fromDualNode(const NodeValue<OriginDataType>& dual_node_value,
+               const NodeValue<DestinationDataType1>& primal_node_value,
+               const CellValue<DestinationDataType2>& primal_cell_value)
+  {
+    static_assert(not std::is_const_v<DestinationDataType1>, "destination data type must not be constant");
+    static_assert(not std::is_const_v<DestinationDataType2>, "destination data type must not be constant");
+    static_assert(std::is_same_v<std::remove_const_t<OriginDataType>, DestinationDataType1>, "incompatible types");
+    static_assert(std::is_same_v<std::remove_const_t<OriginDataType>, DestinationDataType2>, "incompatible types");
+
+    Assert(m_primal_connectivity == primal_cell_value.connectivity_ptr().get());
+    Assert(m_primal_connectivity == primal_node_value.connectivity_ptr().get());
+    Assert(m_dual_connectivity == dual_node_value.connectivity_ptr().get());
+
+    parallel_for(
+      m_primal_node_to_dual_node_map.size(), PUGS_LAMBDA(size_t i) {
+        const auto [primal_node_id, dual_node_id] = m_primal_node_to_dual_node_map[i];
+
+        primal_node_value[primal_node_id] = dual_node_value[dual_node_id];
+      });
+
+    parallel_for(
+      m_primal_cell_to_dual_node_map.size(), PUGS_LAMBDA(size_t i) {
+        const auto [primal_cell_id, dual_node_id] = m_primal_cell_to_dual_node_map[i];
+        primal_cell_value[primal_cell_id]         = dual_node_value[dual_node_id];
+      });
+  }
+
+  template <typename OriginDataType, typename DestinationDataType>
+  void
+  toDualCell(const FaceValue<OriginDataType>& primal_face_value, const CellValue<DestinationDataType>& dual_cell_value)
+  {
+    static_assert(not std::is_const_v<DestinationDataType>, "destination data type must not be constant");
+    static_assert(std::is_same_v<std::remove_const_t<OriginDataType>, DestinationDataType>, "incompatible types");
+
+    Assert(m_primal_connectivity == primal_face_value.connectivity_ptr().get());
+    Assert(m_dual_connectivity == dual_cell_value.connectivity_ptr().get());
+
+    parallel_for(
+      m_primal_face_to_dual_cell_map.size(), PUGS_LAMBDA(size_t i) {
+        const auto [primal_face_id, dual_cell_id] = m_primal_face_to_dual_cell_map[i];
+
+        dual_cell_value[dual_cell_id] = primal_face_value[primal_face_id];
+      });
+
+    parallel_for(
+      m_primal_cell_to_dual_node_map.size(), PUGS_LAMBDA(size_t i) {
+        const auto [primal_face_id, dual_cell_id] = m_primal_face_to_dual_cell_map[i];
+
+        dual_cell_value[dual_cell_id] = primal_face_value[primal_face_id];
+      });
+  }
+
+  template <typename OriginDataType, typename DestinationDataType>
+  void
+  fromDualCell(const CellValue<DestinationDataType>& dual_cell_value,
+               const FaceValue<OriginDataType>& primal_face_value)
+  {
+    static_assert(not std::is_const_v<DestinationDataType>, "destination data type must not be constant");
+    static_assert(std::is_same_v<std::remove_const_t<OriginDataType>, DestinationDataType>, "incompatible types");
+
+    Assert(m_primal_connectivity == primal_face_value.connectivity_ptr().get());
+    Assert(m_dual_connectivity == dual_cell_value.connectivity_ptr().get());
+
+    parallel_for(
+      m_primal_face_to_dual_cell_map.size(), PUGS_LAMBDA(size_t i) {
+        const auto [primal_face_id, dual_cell_id] = m_primal_face_to_dual_cell_map[i];
+
+        primal_face_value[primal_face_id] = dual_cell_value[dual_cell_id];
+      });
+
+    parallel_for(
+      m_primal_cell_to_dual_node_map.size(), PUGS_LAMBDA(size_t i) {
+        const auto [primal_face_id, dual_cell_id] = m_primal_face_to_dual_cell_map[i];
+        primal_face_value[primal_face_id]         = dual_cell_value[dual_cell_id];
+      });
+  }
+
   MeshToDualDataMapper(const Connectivity<Dimension>& primal_connectivity,
                        const Connectivity<Dimension>& dual_connectivity)
     : m_primal_connectivity{&primal_connectivity}, m_dual_connectivity{&dual_connectivity}
@@ -73,8 +159,8 @@ class MeshToDualDataMapper
 
       m_primal_cell_to_dual_node_map = [&]() {
         CellIdToNodeIdMap primal_cell_to_dual_node_map{primal_connectivity.numberOfCells()};
-        for (CellId cell_id = 0; cell_id < primal_cell_to_dual_node_map.size(); ++cell_id) {
-          primal_cell_to_dual_node_map[cell_id] = std::make_pair(cell_id, dual_node_id++);
+        for (CellId primal_cell_id = 0; primal_cell_id < primal_cell_to_dual_node_map.size(); ++primal_cell_id) {
+          primal_cell_to_dual_node_map[primal_cell_id] = std::make_pair(primal_cell_id, dual_node_id++);
         }
         return primal_cell_to_dual_node_map;
       }();
@@ -82,8 +168,10 @@ class MeshToDualDataMapper
     } else {
       m_primal_node_to_dual_node_map = [&]() {
         NodeIdToNodeIdMap primal_node_to_dual_node_map{primal_connectivity.numberOfNodes()};
-        for (NodeId node_id = 0; node_id < primal_node_to_dual_node_map.size(); ++node_id) {
-          primal_node_to_dual_node_map[node_id] = std::make_pair(node_id, node_id);
+        for (NodeId primal_node_id = 0; primal_node_id < primal_node_to_dual_node_map.size(); ++primal_node_id) {
+          const NodeId dual_node_id = primal_node_id;
+
+          primal_node_to_dual_node_map[primal_node_id] = std::make_pair(primal_node_id, dual_node_id);
         }
         return primal_node_to_dual_node_map;
       }();
@@ -91,12 +179,23 @@ class MeshToDualDataMapper
       m_primal_cell_to_dual_node_map = [&]() {
         CellIdToNodeIdMap primal_cell_to_dual_node_map{primal_connectivity.numberOfCells()};
         NodeId dual_node_id = m_primal_node_to_dual_node_map.size();
-        for (CellId cell_id = 0; cell_id < primal_cell_to_dual_node_map.size(); ++cell_id) {
-          primal_cell_to_dual_node_map[cell_id] = std::make_pair(cell_id, dual_node_id++);
+        for (CellId primal_cell_id = 0; primal_cell_id < primal_cell_to_dual_node_map.size(); ++primal_cell_id) {
+          primal_cell_to_dual_node_map[primal_cell_id] = std::make_pair(primal_cell_id, dual_node_id++);
         }
         return primal_cell_to_dual_node_map;
       }();
     }
+
+    m_primal_face_to_dual_cell_map = [&]() {
+      FaceIdToCellIdMap primal_face_to_dual_cell_map{primal_connectivity.numberOfFaces()};
+      for (size_t id = 0; id < primal_face_to_dual_cell_map.size(); ++id) {
+        const CellId dual_cell_id   = id;
+        const FaceId primal_face_id = id;
+
+        primal_face_to_dual_cell_map[id] = std::make_pair(primal_face_id, dual_cell_id);
+      }
+      return primal_face_to_dual_cell_map;
+    }();
   }
 };