diff --git a/src/mesh/CMakeLists.txt b/src/mesh/CMakeLists.txt
index 9c232ea60db552e1f032a8b4a1b45cf199c33d4a..ad245fb038c4a09e451591ff44098da80cb22106 100644
--- a/src/mesh/CMakeLists.txt
+++ b/src/mesh/CMakeLists.txt
@@ -8,7 +8,7 @@ add_library(
Connectivity.cpp
ConnectivityComputer.cpp
GmshReader.cpp
- MeshDispatcher.cpp
+ ConnectivityDispatcher.cpp
SynchronizerManager.cpp)
include_directories(${PASTIS_BINARY_DIR}/src/utils)
diff --git a/src/mesh/MeshDispatcher.cpp b/src/mesh/ConnectivityDispatcher.cpp
similarity index 84%
rename from src/mesh/MeshDispatcher.cpp
rename to src/mesh/ConnectivityDispatcher.cpp
index a5201895f3dbae6426fa9fafec088f207918d02a..c0a7b7776d05b64dc4c2c82ad05a92bb4077f0c6 100644
--- a/src/mesh/MeshDispatcher.cpp
+++ b/src/mesh/ConnectivityDispatcher.cpp
@@ -1,11 +1,11 @@
-#include <MeshDispatcher.hpp>
+#include <ConnectivityDispatcher.hpp>
#include <Partitioner.hpp>
#include <unordered_map>
template <int Dimension>
CellValue<int>
-MeshDispatcher<Dimension>::_getCellNewOwner()
+ConnectivityDispatcher<Dimension>::_getCellNewOwner()
{
CSRGraph connectivity_graph = m_connectivity.cellToCellGraph();
Partitioner P;
@@ -17,7 +17,7 @@ MeshDispatcher<Dimension>::_getCellNewOwner()
template <int Dimension>
FaceValue<int>
-MeshDispatcher<Dimension>::_getFaceNewOwner()
+ConnectivityDispatcher<Dimension>::_getFaceNewOwner()
{
const auto& face_to_cell_matrix
= m_connectivity.faceToCellMatrix();
@@ -37,13 +37,14 @@ MeshDispatcher<Dimension>::_getFaceNewOwner()
face_new_owner[l] = m_cell_new_owner[Jmin];
});
- synchronize(face_new_owner);
+#warning Add missing synchronize (fix it!)
+ // synchronize(face_new_owner);
return face_new_owner;
}
template <int Dimension>
NodeValue<int>
-MeshDispatcher<Dimension>::_getNodeNewOwner()
+ConnectivityDispatcher<Dimension>::_getNodeNewOwner()
{
const auto& node_to_cell_matrix = m_connectivity.nodeToCellMatrix();
const auto& cell_number = m_connectivity.cellNumber();
@@ -62,13 +63,14 @@ MeshDispatcher<Dimension>::_getNodeNewOwner()
node_new_owner[r] = m_cell_new_owner[Jmin];
});
- synchronize(node_new_owner);
+#warning Add missing synchronize (fix it!)
+ // synchronize(node_new_owner);
return node_new_owner;
}
template <int Dimension>
-const typename MeshDispatcher<Dimension>::CellListToSendByProc
-MeshDispatcher<Dimension>::_buildCellListToSend() const
+std::vector<Array<const CellId>>
+ConnectivityDispatcher<Dimension>::_buildCellListToSend() const
{
const auto& node_to_cell_matrix
= m_connectivity.nodeToCellMatrix();
@@ -107,7 +109,7 @@ MeshDispatcher<Dimension>::_buildCellListToSend() const
template <int Dimension>
Array<int>
-MeshDispatcher<Dimension>::_buildNbCellToSend()
+ConnectivityDispatcher<Dimension>::_buildNbCellToSend()
{
Array<int> nb_cell_to_send_by_proc(parallel::size());
for (size_t i=0; i<parallel::size(); ++i) {
@@ -118,7 +120,7 @@ MeshDispatcher<Dimension>::_buildNbCellToSend()
template <int Dimension>
void
-MeshDispatcher<Dimension>::_dispatchFaces()
+ConnectivityDispatcher<Dimension>::_dispatchFaces()
{
if constexpr (Dimension>1) {
std::vector<Array<int>> recv_number_of_face_per_cell_by_proc =
@@ -550,8 +552,8 @@ MeshDispatcher<Dimension>::_dispatchFaces()
template <int Dimension>
-MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh_deprecated)
- : m_connectivity(mesh_deprecated.connectivity()),
+ConnectivityDispatcher<Dimension>::ConnectivityDispatcher(const ConnectivityType& connectivity)
+ : m_connectivity(connectivity),
m_cell_new_owner(_getCellNewOwner()),
m_face_new_owner(_getFaceNewOwner()),
m_node_new_owner(_getNodeNewOwner()),
@@ -663,62 +665,67 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh_deprecated)
}
}
- std::vector<Array<const NodeId>> send_node_id_by_proc(parallel::size());
- for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
- Array<bool> tag(m_connectivity.numberOfNodes());
- tag.fill(false);
- std::vector<NodeId> node_id_vector;
- for (size_t j=0; j<m_cell_list_to_send_by_proc[i_rank].size(); ++j) {
- const CellId& cell_id = m_cell_list_to_send_by_proc[i_rank][j];
- const auto& cell_node_list = cell_to_node_matrix[cell_id];
- for (size_t r=0; r<cell_node_list.size(); ++r) {
- const NodeId& node_id = cell_node_list[r];
- if (not tag[node_id]) {
- node_id_vector.push_back(node_id);
- tag[node_id] = true;
+ m_node_list_to_send_by_proc =
+ [&] () {
+ std::vector<Array<const NodeId>> node_list_to_send_by_proc(parallel::size());
+ for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
+ Array<bool> tag(m_connectivity.numberOfNodes());
+ tag.fill(false);
+ std::vector<NodeId> node_id_vector;
+ for (size_t j=0; j<m_cell_list_to_send_by_proc[i_rank].size(); ++j) {
+ const CellId& cell_id = m_cell_list_to_send_by_proc[i_rank][j];
+ const auto& cell_node_list = cell_to_node_matrix[cell_id];
+ for (size_t r=0; r<cell_node_list.size(); ++r) {
+ const NodeId& node_id = cell_node_list[r];
+ if (not tag[node_id]) {
+ node_id_vector.push_back(node_id);
+ tag[node_id] = true;
+ }
+ }
+ }
+ node_list_to_send_by_proc[i_rank] = convert_to_array(node_id_vector);
}
- }
- }
- send_node_id_by_proc[i_rank] = convert_to_array(node_id_vector);
- }
+ return node_list_to_send_by_proc;
+ } ();
Array<unsigned int> nb_node_to_send_by_proc(parallel::size());
for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
- nb_node_to_send_by_proc[i_rank] = send_node_id_by_proc[i_rank].size();
+ nb_node_to_send_by_proc[i_rank] = m_node_list_to_send_by_proc[i_rank].size();
}
- Array<const unsigned int> nb_node_to_recv_by_proc
- = parallel::allToAll(nb_node_to_send_by_proc);
+ m_nb_node_to_recv_by_proc = parallel::allToAll(nb_node_to_send_by_proc);
- std::vector<Array<const NodeId>> recv_node_id_correspondance_by_proc(parallel::size());
- {
- const NodeValue<const int>& node_number = m_connectivity.nodeNumber();
- std::vector<Array<const int>> send_node_number_by_proc(parallel::size());
- for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
- Array<int> send_node_number(send_node_id_by_proc[i_rank].size());
- const Array<const NodeId> send_node_id = send_node_id_by_proc[i_rank];
- parallel_for(send_node_number.size(), PASTIS_LAMBDA(const size_t& j){
- send_node_number[j] = node_number[send_node_id[j]];
- });
- send_node_number_by_proc[i_rank] = send_node_number;
- }
+ m_recv_node_id_correspondance_by_proc =
+ [&] () {
+ std::vector<Array<const NodeId>> recv_node_id_correspondance_by_proc(parallel::size());
+ const NodeValue<const int>& node_number = m_connectivity.nodeNumber();
+ std::vector<Array<const int>> send_node_number_by_proc(parallel::size());
+ for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
+ Array<int> send_node_number(m_node_list_to_send_by_proc[i_rank].size());
+ const Array<const NodeId> send_node_id = m_node_list_to_send_by_proc[i_rank];
+ parallel_for(send_node_number.size(), PASTIS_LAMBDA(const size_t& j){
+ send_node_number[j] = node_number[send_node_id[j]];
+ });
+ send_node_number_by_proc[i_rank] = send_node_number;
+ }
- std::vector<Array<int>> recv_node_number_by_proc(parallel::size());
- for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
- recv_node_number_by_proc[i_rank] = Array<int>(nb_node_to_recv_by_proc[i_rank]);
- }
- parallel::exchange(send_node_number_by_proc, recv_node_number_by_proc);
+ std::vector<Array<int>> recv_node_number_by_proc(parallel::size());
+ for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
+ recv_node_number_by_proc[i_rank] = Array<int>(m_nb_node_to_recv_by_proc[i_rank]);
+ }
+ parallel::exchange(send_node_number_by_proc, recv_node_number_by_proc);
- for (size_t i_rank=0; i_rank<nb_node_to_recv_by_proc.size(); ++i_rank) {
- Array<NodeId> node_id_correspondace(nb_node_to_recv_by_proc[i_rank]);
- for (size_t l=0; l<nb_node_to_recv_by_proc[i_rank]; ++l) {
- const int& node_number = recv_node_number_by_proc[i_rank][l];
- const auto& searched_node_id = m_node_number_id_map.find(node_number);
- Assert(searched_node_id != m_node_number_id_map.end());
- node_id_correspondace[l] = searched_node_id->second;
- }
- recv_node_id_correspondance_by_proc[i_rank] = node_id_correspondace;
- }
- }
+ for (size_t i_rank=0; i_rank<m_nb_node_to_recv_by_proc.size(); ++i_rank) {
+ Array<NodeId> node_id_correspondace(m_nb_node_to_recv_by_proc[i_rank]);
+ for (size_t l=0; l<m_nb_node_to_recv_by_proc[i_rank]; ++l) {
+ const int& node_number = recv_node_number_by_proc[i_rank][l];
+ const auto& searched_node_id = m_node_number_id_map.find(node_number);
+ Assert(searched_node_id != m_node_number_id_map.end());
+ node_id_correspondace[l] = searched_node_id->second;
+ }
+ recv_node_id_correspondance_by_proc[i_rank] = node_id_correspondace;
+ }
+ return recv_node_id_correspondance_by_proc;
+ } ();
{
std::vector<Array<int>> recv_cell_new_owner_by_proc
@@ -738,7 +745,7 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh_deprecated)
std::vector<Array<const int>> send_node_owner_by_proc(parallel::size());
for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
Array<int> send_node_owner(nb_node_to_send_by_proc[i_rank]);
- const Array<const NodeId> send_node_id = send_node_id_by_proc[i_rank];
+ const Array<const NodeId> send_node_id = m_node_list_to_send_by_proc[i_rank];
parallel_for(send_node_id.size(), PASTIS_LAMBDA(const size_t& r) {
const NodeId& node_id = send_node_id[r];
send_node_owner[r] = m_node_new_owner[node_id];
@@ -748,14 +755,14 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh_deprecated)
std::vector<Array<int>> recv_node_owner_by_proc(parallel::size());
for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
- recv_node_owner_by_proc[i_rank] = Array<int>(nb_node_to_recv_by_proc[i_rank]);
+ recv_node_owner_by_proc[i_rank] = Array<int>(m_nb_node_to_recv_by_proc[i_rank]);
}
parallel::exchange(send_node_owner_by_proc, recv_node_owner_by_proc);
m_new_descriptor.node_owner_vector.resize(m_new_descriptor.node_number_vector.size());
for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
for (size_t r=0; r<recv_node_owner_by_proc[i_rank].size(); ++r) {
- const NodeId& node_id = recv_node_id_correspondance_by_proc[i_rank][r];
+ const NodeId& node_id = m_recv_node_id_correspondance_by_proc[i_rank][r];
m_new_descriptor.node_owner_vector[node_id] = recv_node_owner_by_proc[i_rank][r];
}
}
@@ -763,52 +770,9 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh_deprecated)
this->_dispatchFaces();
- using ConnectivityType = Connectivity<Dimension>;
- std::shared_ptr m_dispatched_connectivity
- = ConnectivityType::build(m_new_descriptor);
-
- using Rd = TinyVector<Dimension, double>;
-
- const NodeValue<const Rd>& xr = mesh_deprecated.xr();
- std::vector<Array<const Rd>> send_node_coord_by_proc(parallel::size());
- for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
- Array<Rd> send_node_coord(nb_node_to_send_by_proc[i_rank]);
- const Array<const NodeId> send_node_id = send_node_id_by_proc[i_rank];
- parallel_for(send_node_id.size(), PASTIS_LAMBDA(const size_t& r) {
- const NodeId& node_id = send_node_id[r];
- send_node_coord[r] = xr[node_id];
- });
- send_node_coord_by_proc[i_rank] = send_node_coord;
- }
-
- std::vector<Array<Rd>> recv_node_coord_by_proc(parallel::size());
- for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
- recv_node_coord_by_proc[i_rank] = Array<Rd>(nb_node_to_recv_by_proc[i_rank]);
- }
- parallel::exchange(send_node_coord_by_proc, recv_node_coord_by_proc);
-
- Array<const size_t> number_of_ref_node_list_per_proc
- = parallel::allGather(m_connectivity.numberOfRefNodeList());
- if (max(number_of_ref_node_list_per_proc) > 0) {
- perr() << __FILE__ << ':' << __LINE__ << ": "
- << rang::fgB::red << "exchange of node ref list not implemented yet!"
- << rang::fg::reset << '\n';
- }
-
- // Finally build the mesh
- NodeValue<Rd> new_xr(*m_dispatched_connectivity);
- for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
- for (size_t r=0; r<recv_node_coord_by_proc[i_rank].size(); ++r) {
- const NodeId& node_id = recv_node_id_correspondance_by_proc[i_rank][r];
- new_xr[node_id] = recv_node_coord_by_proc[i_rank][r];
- }
- }
-
- m_dispatched_mesh = std::make_shared<MeshType>(m_dispatched_connectivity, new_xr);
+ m_dispatched_connectivity = ConnectivityType::build(m_new_descriptor);
}
-template MeshDispatcher<1>::MeshDispatcher(const MeshType& mesh);
-
-template MeshDispatcher<2>::MeshDispatcher(const MeshType& mesh);
-
-template MeshDispatcher<3>::MeshDispatcher(const MeshType& mesh);
+template ConnectivityDispatcher<1>::ConnectivityDispatcher(const ConnectivityType&);
+template ConnectivityDispatcher<2>::ConnectivityDispatcher(const ConnectivityType&);
+template ConnectivityDispatcher<3>::ConnectivityDispatcher(const ConnectivityType&);
diff --git a/src/mesh/ConnectivityDispatcher.hpp b/src/mesh/ConnectivityDispatcher.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..67556eef459ac62f32e99de3ea2ae424ff09b49e
--- /dev/null
+++ b/src/mesh/ConnectivityDispatcher.hpp
@@ -0,0 +1,140 @@
+#ifndef CONNECTIVITY_DISPATCHER_HPP
+#define CONNECTIVITY_DISPATCHER_HPP
+
+#include <Mesh.hpp>
+#include <ItemValue.hpp>
+#include <ItemValueUtils.hpp>
+
+#include <unordered_map>
+
+template <int Dimension>
+class ConnectivityDispatcher
+{
+ public:
+ using ConnectivityType = Connectivity<Dimension>;
+
+ private:
+ const ConnectivityType& m_connectivity;
+
+ ConnectivityDescriptor m_new_descriptor;
+
+ std::shared_ptr<ConnectivityType> m_dispatched_connectivity;
+
+ CellValue<const int> m_cell_new_owner;
+ FaceValue<const int> m_face_new_owner;
+ NodeValue<const int> m_node_new_owner;
+
+ const std::vector<Array<const CellId>> m_cell_list_to_send_by_proc;
+#warning use a const sementic too
+ std::vector<Array<const NodeId>> m_node_list_to_send_by_proc;
+
+ Array<const int> m_nb_cell_to_send_by_proc;
+ Array<const int> m_nb_cell_to_recv_by_proc;
+
+ Array<const unsigned int> m_nb_node_to_recv_by_proc;
+
+ std::vector<Array<const NodeId>> m_recv_node_id_correspondance_by_proc;
+
+ std::vector<Array<int>> m_recv_cell_number_by_proc;
+ std::unordered_map<int, int> m_node_number_id_map;
+
+ CellValue<int> _getCellNewOwner();
+ FaceValue<int> _getFaceNewOwner();
+ NodeValue<int> _getNodeNewOwner();
+
+ std::vector<Array<const CellId>> _buildCellListToSend() const;
+
+ Array<int> _buildNbCellToSend();
+
+ void _dispatchFaces();
+ public:
+ std::shared_ptr<const ConnectivityType>
+ dispatchedConnectivity() const
+ {
+ return m_dispatched_connectivity;
+ }
+
+ PASTIS_INLINE
+ const CellValue<const int>& cellNewOwner() const
+ {
+ return m_cell_new_owner;
+ }
+
+ PASTIS_INLINE
+ const FaceValue<const int>& faceNewOwner() const
+ {
+ return m_face_new_owner;
+ }
+
+ PASTIS_INLINE
+ const NodeValue<const int>& nodeNewOwner() const
+ {
+ return m_node_new_owner;
+ }
+
+ template<typename DataType, typename ConnectivityPtr>
+ std::vector<Array<std::remove_const_t<DataType>>>
+ exchange(ItemValue<DataType, ItemType::cell, ConnectivityPtr> cell_value) const
+ {
+ using MutableDataType = std::remove_const_t<DataType>;
+ std::vector<Array<DataType>> cell_value_to_send_by_proc(parallel::size());
+ for (size_t i=0; i<parallel::size(); ++i) {
+ const Array<const CellId>& cell_list = m_cell_list_to_send_by_proc[i];
+ Array<MutableDataType> cell_value_list(cell_list.size());
+ parallel_for (cell_list.size(), PASTIS_LAMBDA(const CellId& cell_id) {
+ cell_value_list[cell_id] = cell_value[cell_list[cell_id]];
+ });
+ cell_value_to_send_by_proc[i] = cell_value_list;
+ }
+
+ std::vector<Array<MutableDataType>> recv_cell_value_by_proc(parallel::size());
+ for (size_t i=0; i<parallel::size(); ++i) {
+ recv_cell_value_by_proc[i] = Array<MutableDataType>(m_nb_cell_to_recv_by_proc[i]);
+ }
+
+ parallel::exchange(cell_value_to_send_by_proc, recv_cell_value_by_proc);
+ return recv_cell_value_by_proc;
+ }
+
+#warning Should write this function generically w.r. to the item type
+ template<typename DataType, typename ConnectivityPtr>
+ ItemValue<DataType, ItemType::node, ConnectivityPtr>
+ dispatch(ItemValue<DataType, ItemType::node, ConnectivityPtr> node_value) const
+ {
+ Assert(m_dispatched_connectivity.use_count()> 0,
+ "cannot dispatch quantity before connectivity");
+ using MutableDataType = std::remove_const_t<DataType>;
+ std::vector<Array<DataType>> node_value_to_send_by_proc(parallel::size());
+ for (size_t i=0; i<parallel::size(); ++i) {
+ const Array<const NodeId>& node_list = m_node_list_to_send_by_proc[i];
+ Array<MutableDataType> node_value_list(node_list.size());
+ parallel_for (node_list.size(), PASTIS_LAMBDA(const NodeId& node_id) {
+ node_value_list[node_id] = node_value[node_list[node_id]];
+ });
+ node_value_to_send_by_proc[i] = node_value_list;
+ }
+
+ std::vector<Array<MutableDataType>> recv_node_value_by_proc(parallel::size());
+ for (size_t i=0; i<parallel::size(); ++i) {
+ recv_node_value_by_proc[i] = Array<MutableDataType>(m_nb_node_to_recv_by_proc[i]);
+ }
+
+ parallel::exchange(node_value_to_send_by_proc, recv_node_value_by_proc);
+
+ NodeValue<MutableDataType> new_node_value(*m_dispatched_connectivity);
+ for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
+ for (size_t r=0; r<recv_node_value_by_proc[i_rank].size(); ++r) {
+ const NodeId& node_id = m_recv_node_id_correspondance_by_proc[i_rank][r];
+ new_node_value[node_id] = recv_node_value_by_proc[i_rank][r];
+ }
+ }
+ return new_node_value;
+ }
+
+ ConnectivityDispatcher(const ConnectivityType& mesh);
+ ConnectivityDispatcher(const ConnectivityDispatcher&) = delete;
+ ~ConnectivityDispatcher() = default;
+};
+
+
+#endif // CONNECTIVITY_DISPATCHER_HPP
diff --git a/src/mesh/GmshReader.cpp b/src/mesh/GmshReader.cpp
index 29b6e4ebe81d6e9b14c4042232f11fdc3f9dcb22..d19fc8d34260aa9c41ad8fcf8ff7833bfc3176d7 100644
--- a/src/mesh/GmshReader.cpp
+++ b/src/mesh/GmshReader.cpp
@@ -18,7 +18,7 @@
#include <ArrayUtils.hpp>
#include <ItemValueUtils.hpp>
-#include <MeshDispatcher.hpp>
+#include <ConnectivityDispatcher.hpp>
#include <unordered_map>
#include <map>
@@ -146,8 +146,12 @@ void GmshReader::_dispatch()
}
const MeshType& mesh = static_cast<const MeshType&>(*m_mesh);
- MeshDispatcher<Dimension> dispatcher(mesh);
- m_mesh = dispatcher.dispatchedMesh();
+ ConnectivityDispatcher<Dimension> dispatcher(mesh.connectivity());
+
+ std::shared_ptr dispatched_connectivity = dispatcher.dispatchedConnectivity();
+ NodeValue<Rd> dispatched_xr = dispatcher.dispatch(mesh.mutableXr());
+
+ m_mesh = std::make_shared<MeshType>(dispatched_connectivity, dispatched_xr);
}
diff --git a/src/mesh/Mesh.hpp b/src/mesh/Mesh.hpp
index 3136f90ba28c94c1ce3f8d2a8d81c28409c8f657..e111d14531c050961ee581841cc3ffedf936e966 100644
--- a/src/mesh/Mesh.hpp
+++ b/src/mesh/Mesh.hpp
@@ -11,7 +11,7 @@
struct IMesh
{
virtual size_t dimension() const = 0;
- virtual CSRGraph cellToCellGraph() const = 0;
+ // virtual CSRGraph cellToCellGraph() const = 0;
~IMesh() = default;
};
@@ -30,12 +30,6 @@ private:
NodeValue<Rd> m_mutable_xr;
public:
- PASTIS_INLINE
- CSRGraph cellToCellGraph() const final
- {
- return m_connectivity->cellToCellGraph();
- }
-
PASTIS_INLINE
size_t dimension() const
{
@@ -80,7 +74,7 @@ public:
}
PASTIS_INLINE
- Mesh(const std::shared_ptr<Connectivity>& connectivity,
+ Mesh(const std::shared_ptr<const Connectivity>& connectivity,
NodeValue<Rd>& xr)
: m_connectivity{connectivity},
m_xr{xr},
diff --git a/src/mesh/MeshDispatcher.hpp b/src/mesh/MeshDispatcher.hpp
deleted file mode 100644
index 878a5a70775134c98db2d608a803770a16df6f2a..0000000000000000000000000000000000000000
--- a/src/mesh/MeshDispatcher.hpp
+++ /dev/null
@@ -1,112 +0,0 @@
-#ifndef MESH_DISPATCHER_HPP
-#define MESH_DISPATCHER_HPP
-
-#include <Mesh.hpp>
-#include <ItemValue.hpp>
-#include <ItemValueUtils.hpp>
-
-#include <unordered_map>
-
-#warning use MeshType instead of dimension as template parameter?
-template <int Dimension>
-class MeshDispatcher
-{
- public:
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
-
- private:
- const ConnectivityType& m_connectivity;
-
- ConnectivityDescriptor m_new_descriptor;
-
- [[deprecated]]
- std::shared_ptr<MeshType> m_dispatched_mesh;
-
- std::shared_ptr<ConnectivityType> m_dispatched_connectivity;
-
- CellValue<const int> m_cell_new_owner;
- FaceValue<const int> m_face_new_owner;
- NodeValue<const int> m_node_new_owner;
-
- using CellListToSendByProc = std::vector<Array<const CellId>>;
- const CellListToSendByProc m_cell_list_to_send_by_proc;
-
- Array<int> m_nb_cell_to_send_by_proc;
- Array<int> m_nb_cell_to_recv_by_proc;
-
- std::vector<Array<int>> m_recv_cell_number_by_proc;
- std::unordered_map<int, int> m_node_number_id_map;
-
- CellValue<int> _getCellNewOwner();
- FaceValue<int> _getFaceNewOwner();
- NodeValue<int> _getNodeNewOwner();
-
- const CellListToSendByProc _buildCellListToSend() const;
-
- Array<int> _buildNbCellToSend();
-
- void _dispatchFaces();
- public:
-
- [[deprecated]]
- std::shared_ptr<MeshType> dispatchedMesh() const
- {
- return m_dispatched_mesh;
- }
-
- const std::shared_ptr<ConnectivityType>& dispatchedConnectivity() const
- {
- return m_dispatched_connectivity;
- }
-
- PASTIS_INLINE
- const CellValue<const int>& cellNewOwner() const
- {
- return m_cell_new_owner;
- }
-
- PASTIS_INLINE
- const FaceValue<const int>& faceNewOwner() const
- {
- return m_face_new_owner;
- }
-
- PASTIS_INLINE
- const NodeValue<const int>& nodeNewOwner() const
- {
- return m_node_new_owner;
- }
-
- template<typename DataType, typename ConnectivityPtr>
- std::vector<Array<std::remove_const_t<DataType>>>
- exchange(ItemValue<DataType, ItemType::cell, ConnectivityPtr> cell_value) const
- {
- using MutableDataType = std::remove_const_t<DataType>;
- std::vector<Array<DataType>> cell_value_to_send_by_proc(parallel::size());
- for (size_t i=0; i<parallel::size(); ++i) {
- const Array<const CellId>& cell_list = m_cell_list_to_send_by_proc[i];
- Array<MutableDataType> cell_value_list(cell_list.size());
- parallel_for (cell_list.size(), PASTIS_LAMBDA(const CellId& cell_id) {
- cell_value_list[cell_id] = cell_value[cell_list[cell_id]];
- });
- cell_value_to_send_by_proc[i] = cell_value_list;
- }
-
- std::vector<Array<MutableDataType>> recv_cell_value_by_proc(parallel::size());
- for (size_t i=0; i<parallel::size(); ++i) {
- recv_cell_value_by_proc[i] = Array<MutableDataType>(m_nb_cell_to_recv_by_proc[i]);
- }
-
- parallel::exchange(cell_value_to_send_by_proc, recv_cell_value_by_proc);
- return recv_cell_value_by_proc;
- }
-
- MeshDispatcher(const MeshType& mesh);
-
- MeshDispatcher(const MeshDispatcher&) = delete;
- ~MeshDispatcher() = default;
-};
-
-
-#endif // MESH_DISPATCHER_HPP