Skip to content
Snippets Groups Projects
Commit d7386ad1 authored by Stéphane Del Pino's avatar Stéphane Del Pino
Browse files

Begin conversion to Connectivity dispatcher 

Actually partitioning is related to the connectivity, not to the mesh. One could
need partitioning of various meshes of the same connectivity for instance...
parent 033af9cb
No related branches found
No related tags found
1 merge request!11Feature/mpi
Show whitespace changes
Inline Side-by-side
src/mesh/MeshDispatcher.cpp
+ 53
− 54
View file @ d7386ad1
...@@ -7,11 +7,11 @@ template <int Dimension> ...@@ -7,11 +7,11 @@ template <int Dimension>
CellValue<int> CellValue<int>
MeshDispatcher<Dimension>::_getCellNewOwner() MeshDispatcher<Dimension>::_getCellNewOwner()
{ {
CSRGraph mesh_graph = m_mesh.cellToCellGraph(); CSRGraph connectivity_graph = m_connectivity.cellToCellGraph();
Partitioner P; Partitioner P;
CellValue<int> cell_new_owner(m_mesh.connectivity()); CellValue<int> cell_new_owner(m_connectivity);
cell_new_owner = P.partition(mesh_graph); cell_new_owner = P.partition(connectivity_graph);
return cell_new_owner; return cell_new_owner;
} }
...@@ -20,11 +20,11 @@ FaceValue<int> ...@@ -20,11 +20,11 @@ FaceValue<int>
MeshDispatcher<Dimension>::_getFaceNewOwner() MeshDispatcher<Dimension>::_getFaceNewOwner()
{ {
const auto& face_to_cell_matrix const auto& face_to_cell_matrix
= m_mesh.connectivity().faceToCellMatrix(); = m_connectivity.faceToCellMatrix();
const auto& cell_number = m_mesh.connectivity().cellNumber(); const auto& cell_number = m_connectivity.cellNumber();
FaceValue<int> face_new_owner(m_mesh.connectivity()); FaceValue<int> face_new_owner(m_connectivity);
parallel_for(m_mesh.numberOfFaces(), PASTIS_LAMBDA(const FaceId& l) { parallel_for(m_connectivity.numberOfFaces(), PASTIS_LAMBDA(const FaceId& l) {
const auto& face_to_cell = face_to_cell_matrix[l]; const auto& face_to_cell = face_to_cell_matrix[l];
CellId Jmin = face_to_cell[0]; CellId Jmin = face_to_cell[0];
...@@ -45,12 +45,11 @@ template <int Dimension> ...@@ -45,12 +45,11 @@ template <int Dimension>
NodeValue<int> NodeValue<int>
MeshDispatcher<Dimension>::_getNodeNewOwner() MeshDispatcher<Dimension>::_getNodeNewOwner()
{ {
const auto& node_to_cell_matrix const auto& node_to_cell_matrix = m_connectivity.nodeToCellMatrix();
= m_mesh.connectivity().nodeToCellMatrix(); const auto& cell_number = m_connectivity.cellNumber();
const auto& cell_number = m_mesh.connectivity().cellNumber();
NodeValue<int> node_new_owner(m_mesh.connectivity()); NodeValue<int> node_new_owner(m_connectivity);
parallel_for(m_mesh.numberOfNodes(), PASTIS_LAMBDA(const NodeId& r) { parallel_for(m_connectivity.numberOfNodes(), PASTIS_LAMBDA(const NodeId& r) {
const auto& node_to_cell = node_to_cell_matrix[r]; const auto& node_to_cell = node_to_cell_matrix[r];
CellId Jmin = node_to_cell[0]; CellId Jmin = node_to_cell[0];
...@@ -72,13 +71,13 @@ const typename MeshDispatcher<Dimension>::CellListToSendByProc ...@@ -72,13 +71,13 @@ const typename MeshDispatcher<Dimension>::CellListToSendByProc
MeshDispatcher<Dimension>::_buildCellListToSend() const MeshDispatcher<Dimension>::_buildCellListToSend() const
{ {
const auto& node_to_cell_matrix const auto& node_to_cell_matrix
= m_mesh.connectivity().nodeToCellMatrix(); = m_connectivity.nodeToCellMatrix();
const auto& cell_to_node_matrix const auto& cell_to_node_matrix
= m_mesh.connectivity().cellToNodeMatrix(); = m_connectivity.cellToNodeMatrix();
std::vector<std::vector<CellId>> cell_vector_to_send_by_proc(parallel::size()); std::vector<std::vector<CellId>> cell_vector_to_send_by_proc(parallel::size());
Array<bool> send_to_rank(parallel::size()); Array<bool> send_to_rank(parallel::size());
for (CellId j=0; j<m_mesh.numberOfCells(); ++j) { for (CellId j=0; j<m_connectivity.numberOfCells(); ++j) {
send_to_rank.fill(false); send_to_rank.fill(false);
const auto& cell_to_node = cell_to_node_matrix[j]; const auto& cell_to_node = cell_to_node_matrix[j];
...@@ -124,9 +123,9 @@ MeshDispatcher<Dimension>::_dispatchFaces() ...@@ -124,9 +123,9 @@ MeshDispatcher<Dimension>::_dispatchFaces()
if constexpr (Dimension>1) { if constexpr (Dimension>1) {
std::vector<Array<int>> recv_number_of_face_per_cell_by_proc = std::vector<Array<int>> recv_number_of_face_per_cell_by_proc =
[&] () { [&] () {
CellValue<int> number_of_face_per_cell(m_mesh.connectivity()); CellValue<int> number_of_face_per_cell(m_connectivity);
const auto& cell_to_face_matrix = m_mesh.connectivity().cellToFaceMatrix(); const auto& cell_to_face_matrix = m_connectivity.cellToFaceMatrix();
parallel_for(m_mesh.numberOfCells(), PASTIS_LAMBDA(const CellId& j){ parallel_for(m_connectivity.numberOfCells(), PASTIS_LAMBDA(const CellId& j){
number_of_face_per_cell[j] = cell_to_face_matrix[j].size(); number_of_face_per_cell[j] = cell_to_face_matrix[j].size();
}); });
...@@ -135,8 +134,8 @@ MeshDispatcher<Dimension>::_dispatchFaces() ...@@ -135,8 +134,8 @@ MeshDispatcher<Dimension>::_dispatchFaces()
std::vector<Array<int>> recv_cell_face_number_by_proc(parallel::size()); std::vector<Array<int>> recv_cell_face_number_by_proc(parallel::size());
{ {
const auto& cell_to_face_matrix = m_mesh.connectivity().cellToFaceMatrix(); const auto& cell_to_face_matrix = m_connectivity.cellToFaceMatrix();
const FaceValue<const int>& face_number = m_mesh.connectivity().faceNumber(); const FaceValue<const int>& face_number = m_connectivity.faceNumber();
std::vector<Array<int>> cell_face_number_to_send_by_proc(parallel::size()); std::vector<Array<int>> cell_face_number_to_send_by_proc(parallel::size());
{ {
...@@ -198,7 +197,7 @@ MeshDispatcher<Dimension>::_dispatchFaces() ...@@ -198,7 +197,7 @@ MeshDispatcher<Dimension>::_dispatchFaces()
{ {
std::vector<Array<bool>> cell_face_is_reversed_to_send_by_proc(parallel::size()); std::vector<Array<bool>> cell_face_is_reversed_to_send_by_proc(parallel::size());
{ {
const auto& cell_face_is_reversed = m_mesh.connectivity().cellFaceIsReversed(); const auto& cell_face_is_reversed = m_connectivity.cellFaceIsReversed();
for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) { for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
std::vector<bool> face_is_reversed_by_cell_vector; std::vector<bool> face_is_reversed_by_cell_vector;
for (size_t j=0; j<m_cell_list_to_send_by_proc[i_rank].size(); ++j) { for (size_t j=0; j<m_cell_list_to_send_by_proc[i_rank].size(); ++j) {
...@@ -234,10 +233,10 @@ MeshDispatcher<Dimension>::_dispatchFaces() ...@@ -234,10 +233,10 @@ MeshDispatcher<Dimension>::_dispatchFaces()
std::vector<Array<const FaceId>> send_face_id_by_proc(parallel::size()); std::vector<Array<const FaceId>> send_face_id_by_proc(parallel::size());
{ {
const auto& cell_to_face_matrix = m_mesh.connectivity().cellToFaceMatrix(); const auto& cell_to_face_matrix = m_connectivity.cellToFaceMatrix();
for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) { for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
Array<bool> tag(m_mesh.numberOfFaces()); Array<bool> tag(m_connectivity.numberOfFaces());
tag.fill(false); tag.fill(false);
std::vector<FaceId> face_id_vector; std::vector<FaceId> face_id_vector;
for (size_t j=0; j<m_cell_list_to_send_by_proc[i_rank].size(); ++j) { for (size_t j=0; j<m_cell_list_to_send_by_proc[i_rank].size(); ++j) {
...@@ -257,7 +256,7 @@ MeshDispatcher<Dimension>::_dispatchFaces() ...@@ -257,7 +256,7 @@ MeshDispatcher<Dimension>::_dispatchFaces()
std::vector<Array<const int>> send_face_number_by_proc(parallel::size()); std::vector<Array<const int>> send_face_number_by_proc(parallel::size());
{ {
const FaceValue<const int>& face_number = m_mesh.connectivity().faceNumber(); const FaceValue<const int>& face_number = m_connectivity.faceNumber();
for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) { for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
Array<int> send_face_number(send_face_id_by_proc[i_rank].size()); Array<int> send_face_number(send_face_id_by_proc[i_rank].size());
...@@ -328,9 +327,9 @@ MeshDispatcher<Dimension>::_dispatchFaces() ...@@ -328,9 +327,9 @@ MeshDispatcher<Dimension>::_dispatchFaces()
std::vector<Array<int>> recv_face_number_of_node_by_proc(parallel::size()); std::vector<Array<int>> recv_face_number_of_node_by_proc(parallel::size());
{ {
const auto& face_to_node_matrix = m_mesh.connectivity().faceToNodeMatrix(); const auto& face_to_node_matrix = m_connectivity.faceToNodeMatrix();
FaceValue<int> number_of_node_per_face(m_mesh.connectivity()); FaceValue<int> number_of_node_per_face(m_connectivity);
parallel_for(m_mesh.numberOfFaces(), PASTIS_LAMBDA(const FaceId& j){ parallel_for(m_connectivity.numberOfFaces(), PASTIS_LAMBDA(const FaceId& j){
number_of_node_per_face[j] = face_to_node_matrix[j].size(); number_of_node_per_face[j] = face_to_node_matrix[j].size();
}); });
...@@ -353,8 +352,8 @@ MeshDispatcher<Dimension>::_dispatchFaces() ...@@ -353,8 +352,8 @@ MeshDispatcher<Dimension>::_dispatchFaces()
std::vector<Array<int>> face_node_number_to_send_by_proc(parallel::size()); std::vector<Array<int>> face_node_number_to_send_by_proc(parallel::size());
{ {
const auto& face_to_node_matrix = m_mesh.connectivity().faceToNodeMatrix(); const auto& face_to_node_matrix = m_connectivity.faceToNodeMatrix();
const NodeValue<const int>& node_number = m_mesh.connectivity().nodeNumber(); const NodeValue<const int>& node_number = m_connectivity.nodeNumber();
for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) { for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
std::vector<int> node_number_by_face_vector; std::vector<int> node_number_by_face_vector;
for (size_t l=0; l<send_face_id_by_proc[i_rank].size(); ++l) { for (size_t l=0; l<send_face_id_by_proc[i_rank].size(); ++l) {
...@@ -394,7 +393,7 @@ MeshDispatcher<Dimension>::_dispatchFaces() ...@@ -394,7 +393,7 @@ MeshDispatcher<Dimension>::_dispatchFaces()
// Getting references // Getting references
Array<const size_t> number_of_ref_face_list_per_proc Array<const size_t> number_of_ref_face_list_per_proc
= parallel::allGather(m_mesh.connectivity().numberOfRefFaceList()); = parallel::allGather(m_connectivity.numberOfRefFaceList());
const size_t number_of_face_list_sender const size_t number_of_face_list_sender
= [&] () { = [&] () {
...@@ -431,9 +430,9 @@ MeshDispatcher<Dimension>::_dispatchFaces() ...@@ -431,9 +430,9 @@ MeshDispatcher<Dimension>::_dispatchFaces()
// sending references tags // sending references tags
Array<RefId::TagNumberType> ref_tag_list{number_of_ref_face_list_per_proc[sender_rank]}; Array<RefId::TagNumberType> ref_tag_list{number_of_ref_face_list_per_proc[sender_rank]};
if (parallel::rank() == sender_rank){ if (parallel::rank() == sender_rank){
for (size_t i_ref_face_list=0; i_ref_face_list<m_mesh.connectivity().numberOfRefFaceList(); for (size_t i_ref_face_list=0; i_ref_face_list<m_connectivity.numberOfRefFaceList();
++i_ref_face_list) { ++i_ref_face_list) {
auto ref_face_list = m_mesh.connectivity().refFaceList(i_ref_face_list); auto ref_face_list = m_connectivity.refFaceList(i_ref_face_list);
ref_tag_list[i_ref_face_list] = ref_face_list.refId().tagNumber(); ref_tag_list[i_ref_face_list] = ref_face_list.refId().tagNumber();
} }
} }
...@@ -442,9 +441,9 @@ MeshDispatcher<Dimension>::_dispatchFaces() ...@@ -442,9 +441,9 @@ MeshDispatcher<Dimension>::_dispatchFaces()
// sending references name size // sending references name size
Array<size_t> ref_name_size_list{number_of_ref_face_list_per_proc[sender_rank]}; Array<size_t> ref_name_size_list{number_of_ref_face_list_per_proc[sender_rank]};
if (parallel::rank() == sender_rank){ if (parallel::rank() == sender_rank){
for (size_t i_ref_face_list=0; i_ref_face_list<m_mesh.connectivity().numberOfRefFaceList(); for (size_t i_ref_face_list=0; i_ref_face_list<m_connectivity.numberOfRefFaceList();
++i_ref_face_list) { ++i_ref_face_list) {
auto ref_face_list = m_mesh.connectivity().refFaceList(i_ref_face_list); auto ref_face_list = m_connectivity.refFaceList(i_ref_face_list);
ref_name_size_list[i_ref_face_list] = ref_face_list.refId().tagName().size(); ref_name_size_list[i_ref_face_list] = ref_face_list.refId().tagName().size();
} }
} }
...@@ -454,9 +453,9 @@ MeshDispatcher<Dimension>::_dispatchFaces() ...@@ -454,9 +453,9 @@ MeshDispatcher<Dimension>::_dispatchFaces()
Array<RefId::TagNameType::value_type> ref_name_cat{sum(ref_name_size_list)}; Array<RefId::TagNameType::value_type> ref_name_cat{sum(ref_name_size_list)};
if (parallel::rank() == sender_rank){ if (parallel::rank() == sender_rank){
size_t i_char=0; size_t i_char=0;
for (size_t i_ref_face_list=0; i_ref_face_list<m_mesh.connectivity().numberOfRefFaceList(); for (size_t i_ref_face_list=0; i_ref_face_list<m_connectivity.numberOfRefFaceList();
++i_ref_face_list) { ++i_ref_face_list) {
auto ref_face_list = m_mesh.connectivity().refFaceList(i_ref_face_list); auto ref_face_list = m_connectivity.refFaceList(i_ref_face_list);
for (auto c : ref_face_list.refId().tagName()) { for (auto c : ref_face_list.refId().tagName()) {
ref_name_cat[i_char++] = c; ref_name_cat[i_char++] = c;
} }
...@@ -482,14 +481,14 @@ MeshDispatcher<Dimension>::_dispatchFaces() ...@@ -482,14 +481,14 @@ MeshDispatcher<Dimension>::_dispatchFaces()
constexpr size_t block_size = sizeof(block_type); constexpr size_t block_size = sizeof(block_type);
const size_t nb_block = ref_id_list.size()/block_size + (ref_id_list.size()%block_size != 0); const size_t nb_block = ref_id_list.size()/block_size + (ref_id_list.size()%block_size != 0);
for (size_t i_block=0; i_block<nb_block; ++i_block) { for (size_t i_block=0; i_block<nb_block; ++i_block) {
FaceValue<block_type> face_references(m_mesh.connectivity()); FaceValue<block_type> face_references(m_connectivity);
face_references.fill(0); face_references.fill(0);
if (m_mesh.connectivity().numberOfRefFaceList() > 0) { if (m_connectivity.numberOfRefFaceList() > 0) {
const size_t max_i_ref = std::min(ref_id_list.size(), block_size*(i_block+1)); const size_t max_i_ref = std::min(ref_id_list.size(), block_size*(i_block+1));
for (size_t i_ref=block_size*i_block, i=0; i_ref<max_i_ref; ++i_ref, ++i) { for (size_t i_ref=block_size*i_block, i=0; i_ref<max_i_ref; ++i_ref, ++i) {
block_type ref_bit{1<<i}; block_type ref_bit{1<<i};
auto ref_face_list = m_mesh.connectivity().refFaceList(i_ref); auto ref_face_list = m_connectivity.refFaceList(i_ref);
const auto& face_list = ref_face_list.faceList(); const auto& face_list = ref_face_list.faceList();
for (size_t i_face=0; i_face<face_list.size(); ++i_face) { for (size_t i_face=0; i_face<face_list.size(); ++i_face) {
...@@ -551,8 +550,8 @@ MeshDispatcher<Dimension>::_dispatchFaces() ...@@ -551,8 +550,8 @@ MeshDispatcher<Dimension>::_dispatchFaces()
template <int Dimension> template <int Dimension>
MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh) MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh_deprecated)
: m_mesh(mesh), : m_connectivity(mesh_deprecated.connectivity()),
m_cell_new_owner(_getCellNewOwner()), m_cell_new_owner(_getCellNewOwner()),
m_face_new_owner(_getFaceNewOwner()), m_face_new_owner(_getFaceNewOwner()),
m_node_new_owner(_getNodeNewOwner()), m_node_new_owner(_getNodeNewOwner()),
...@@ -560,13 +559,13 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh) ...@@ -560,13 +559,13 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
m_nb_cell_to_send_by_proc(_buildNbCellToSend()), m_nb_cell_to_send_by_proc(_buildNbCellToSend()),
m_nb_cell_to_recv_by_proc(parallel::allToAll(m_nb_cell_to_send_by_proc)) m_nb_cell_to_recv_by_proc(parallel::allToAll(m_nb_cell_to_send_by_proc))
{ {
m_recv_cell_number_by_proc = this->exchange(mesh.connectivity().cellNumber()); m_recv_cell_number_by_proc = this->exchange(m_connectivity.cellNumber());
const auto& cell_to_node_matrix = mesh.connectivity().cellToNodeMatrix(); const auto& cell_to_node_matrix = m_connectivity.cellToNodeMatrix();
std::vector<Array<int>> cell_node_number_to_send_by_proc = std::vector<Array<int>> cell_node_number_to_send_by_proc =
[&] () { [&] () {
const NodeValue<const int>& node_number = mesh.connectivity().nodeNumber(); const NodeValue<const int>& node_number = m_connectivity.nodeNumber();
std::vector<Array<int>> cell_node_number_to_send_by_proc(parallel::size()); std::vector<Array<int>> cell_node_number_to_send_by_proc(parallel::size());
for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) { for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
std::vector<int> node_number_by_cell_vector; std::vector<int> node_number_by_cell_vector;
...@@ -585,8 +584,8 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh) ...@@ -585,8 +584,8 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
std::vector<Array<int>> recv_number_of_node_per_cell_by_proc std::vector<Array<int>> recv_number_of_node_per_cell_by_proc
= [&] () { = [&] () {
CellValue<int> number_of_node_per_cell(mesh.connectivity()); CellValue<int> number_of_node_per_cell(m_connectivity);
parallel_for(mesh.numberOfCells(), PASTIS_LAMBDA(const CellId& j){ parallel_for(m_connectivity.numberOfCells(), PASTIS_LAMBDA(const CellId& j){
number_of_node_per_cell[j] = cell_to_node_matrix[j].size(); number_of_node_per_cell[j] = cell_to_node_matrix[j].size();
}); });
return this->exchange(number_of_node_per_cell); return this->exchange(number_of_node_per_cell);
...@@ -652,7 +651,7 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh) ...@@ -652,7 +651,7 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
{ {
std::vector<Array<CellType>> recv_cell_type_by_proc std::vector<Array<CellType>> recv_cell_type_by_proc
= this->exchange(mesh.connectivity().cellType()); = this->exchange(m_connectivity.cellType());
m_new_descriptor.cell_type_vector.resize(cell_number_id_map.size()); m_new_descriptor.cell_type_vector.resize(cell_number_id_map.size());
for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) { for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
for (size_t i=0; i<m_recv_cell_number_by_proc[i_rank].size(); ++i) { for (size_t i=0; i<m_recv_cell_number_by_proc[i_rank].size(); ++i) {
...@@ -666,7 +665,7 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh) ...@@ -666,7 +665,7 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
std::vector<Array<const NodeId>> send_node_id_by_proc(parallel::size()); std::vector<Array<const NodeId>> send_node_id_by_proc(parallel::size());
for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) { for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
Array<bool> tag(mesh.numberOfNodes()); Array<bool> tag(m_connectivity.numberOfNodes());
tag.fill(false); tag.fill(false);
std::vector<NodeId> node_id_vector; std::vector<NodeId> node_id_vector;
for (size_t j=0; j<m_cell_list_to_send_by_proc[i_rank].size(); ++j) { for (size_t j=0; j<m_cell_list_to_send_by_proc[i_rank].size(); ++j) {
...@@ -692,7 +691,7 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh) ...@@ -692,7 +691,7 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
std::vector<Array<const NodeId>> recv_node_id_correspondance_by_proc(parallel::size()); std::vector<Array<const NodeId>> recv_node_id_correspondance_by_proc(parallel::size());
{ {
const NodeValue<const int>& node_number = mesh.connectivity().nodeNumber(); const NodeValue<const int>& node_number = m_connectivity.nodeNumber();
std::vector<Array<const int>> send_node_number_by_proc(parallel::size()); std::vector<Array<const int>> send_node_number_by_proc(parallel::size());
for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) { 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()); Array<int> send_node_number(send_node_id_by_proc[i_rank].size());
...@@ -765,12 +764,12 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh) ...@@ -765,12 +764,12 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
this->_dispatchFaces(); this->_dispatchFaces();
using ConnectivityType = Connectivity<Dimension>; using ConnectivityType = Connectivity<Dimension>;
std::shared_ptr p_connectivity std::shared_ptr m_dispatched_connectivity
= ConnectivityType::build(m_new_descriptor); = ConnectivityType::build(m_new_descriptor);
using Rd = TinyVector<Dimension, double>; using Rd = TinyVector<Dimension, double>;
const NodeValue<const Rd>& xr = m_mesh.xr(); const NodeValue<const Rd>& xr = mesh_deprecated.xr();
std::vector<Array<const Rd>> send_node_coord_by_proc(parallel::size()); std::vector<Array<const Rd>> send_node_coord_by_proc(parallel::size());
for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) { 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]); Array<Rd> send_node_coord(nb_node_to_send_by_proc[i_rank]);
...@@ -789,7 +788,7 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh) ...@@ -789,7 +788,7 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
parallel::exchange(send_node_coord_by_proc, recv_node_coord_by_proc); parallel::exchange(send_node_coord_by_proc, recv_node_coord_by_proc);
Array<const size_t> number_of_ref_node_list_per_proc Array<const size_t> number_of_ref_node_list_per_proc
= parallel::allGather(m_mesh.connectivity().numberOfRefNodeList()); = parallel::allGather(m_connectivity.numberOfRefNodeList());
if (max(number_of_ref_node_list_per_proc) > 0) { if (max(number_of_ref_node_list_per_proc) > 0) {
perr() << __FILE__ << ':' << __LINE__ << ": " perr() << __FILE__ << ':' << __LINE__ << ": "
<< rang::fgB::red << "exchange of node ref list not implemented yet!" << rang::fgB::red << "exchange of node ref list not implemented yet!"
...@@ -797,7 +796,7 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh) ...@@ -797,7 +796,7 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
} }
// Finally build the mesh // Finally build the mesh
NodeValue<Rd> new_xr(*p_connectivity); NodeValue<Rd> new_xr(*m_dispatched_connectivity);
for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) { 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) { 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]; const NodeId& node_id = recv_node_id_correspondance_by_proc[i_rank][r];
...@@ -805,7 +804,7 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh) ...@@ -805,7 +804,7 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
} }
} }
m_dispatched_mesh = std::make_shared<MeshType>(p_connectivity, new_xr); m_dispatched_mesh = std::make_shared<MeshType>(m_dispatched_connectivity, new_xr);
} }
template MeshDispatcher<1>::MeshDispatcher(const MeshType& mesh); template MeshDispatcher<1>::MeshDispatcher(const MeshType& mesh);
......
src/mesh/MeshDispatcher.hpp
+ 14
− 3
View file @ d7386ad1
...@@ -7,19 +7,24 @@ ...@@ -7,19 +7,24 @@
#include <unordered_map> #include <unordered_map>
#warning use MeshType instead of dimension as template parameter?
template <int Dimension> template <int Dimension>
class MeshDispatcher class MeshDispatcher
{ {
public: public:
using MeshType = Mesh<Connectivity<Dimension>>; using ConnectivityType = Connectivity<Dimension>;
using MeshType = Mesh<ConnectivityType>;
private: private:
const MeshType& m_mesh; const ConnectivityType& m_connectivity;
ConnectivityDescriptor m_new_descriptor; ConnectivityDescriptor m_new_descriptor;
[[deprecated]]
std::shared_ptr<MeshType> m_dispatched_mesh; std::shared_ptr<MeshType> m_dispatched_mesh;
std::shared_ptr<ConnectivityType> m_dispatched_connectivity;
CellValue<const int> m_cell_new_owner; CellValue<const int> m_cell_new_owner;
FaceValue<const int> m_face_new_owner; FaceValue<const int> m_face_new_owner;
NodeValue<const int> m_node_new_owner; NodeValue<const int> m_node_new_owner;
...@@ -44,11 +49,17 @@ class MeshDispatcher ...@@ -44,11 +49,17 @@ class MeshDispatcher
void _dispatchFaces(); void _dispatchFaces();
public: public:
const std::shared_ptr<MeshType> dispatchedMesh() const [[deprecated]]
std::shared_ptr<MeshType> dispatchedMesh() const
{ {
return m_dispatched_mesh; return m_dispatched_mesh;
} }
const std::shared_ptr<ConnectivityType>& dispatchedConnectivity() const
{
return m_dispatched_connectivity;
}
PASTIS_INLINE PASTIS_INLINE
const CellValue<const int>& cellNewOwner() const const CellValue<const int>& cellNewOwner() const
{ {
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment