diff --git a/src/dev/ParallelChecker.hpp b/src/dev/ParallelChecker.hpp index 91b4bc1ab39907d681123387a016086fa3c1ca0e..97729f38a9f5d31356919bcb757b4e120accc38d 100644 --- a/src/dev/ParallelChecker.hpp +++ b/src/dev/ParallelChecker.hpp @@ -292,6 +292,31 @@ class ParallelChecker } } + template <ItemType item_type, ItemType sub_item_type> + Array<const typename ConnectivityMatrix::IndexType> + _getSubItemValues(const std::shared_ptr<const IConnectivity>& i_connectivity) + { + switch (i_connectivity->dimension()) { + case 1: { + const Connectivity<1>& connectivity = dynamic_cast<const Connectivity<1>&>(*i_connectivity); + return connectivity.getMatrix(item_type, sub_item_type).values(); + } + case 2: { + const Connectivity<2>& connectivity = dynamic_cast<const Connectivity<2>&>(*i_connectivity); + return connectivity.getMatrix(item_type, sub_item_type).values(); + } + case 3: { + const Connectivity<3>& connectivity = dynamic_cast<const Connectivity<3>&>(*i_connectivity); + return connectivity.getMatrix(item_type, sub_item_type).values(); + } + // LCOV_EXCL_START + default: { + throw UnexpectedError("unexpected connectivity dimension"); + } + // LCOV_EXCL_STOP + } + } + template <ItemType item_type> Array<const int> _getItemOwner(const std::shared_ptr<const IConnectivity>& i_connectivity) const @@ -371,14 +396,14 @@ class ParallelChecker } HighFive::DataSet item_numbers = file.getDataSet(item_number_path + "/numbers"); - group.createHardLink("numbers", item_numbers); + group.createHardLink(std::string(itemName(item_type)) + "_numbers", item_numbers); } template <typename ItemOfItem> void - _writeSubItemRowsMap(const std::shared_ptr<const IConnectivity> i_connectivity, - HighFive::File file, - HighFive::Group group) + _writeSubItemMatrix(const std::shared_ptr<const IConnectivity> i_connectivity, + HighFive::File file, + HighFive::Group group) { constexpr ItemType item_type = ItemOfItem::item_type; constexpr ItemType sub_item_type = ItemOfItem::sub_item_type; @@ -391,10 +416,14 @@ class ParallelChecker HighFive::Group subitem_of_item_row_map_group = file.createGroup(subitem_of_item_row_map_path); this->_writeArray(subitem_of_item_row_map_group, "rows_map", this->_getSubItemRowsMap<item_type, sub_item_type>(i_connectivity)); + this->_writeArray(subitem_of_item_row_map_group, "sub_item_index", + this->_getSubItemValues<item_type, sub_item_type>(i_connectivity)); } HighFive::DataSet subitem_of_item_row_map = file.getDataSet(subitem_of_item_row_map_path + "/rows_map"); group.createHardLink("rows_map", subitem_of_item_row_map); + HighFive::DataSet subitem_of_item_index = file.getDataSet(subitem_of_item_row_map_path + "/sub_item_index"); + group.createHardLink("sub_item_index", subitem_of_item_index); } template <typename DataType, ItemType item_type> @@ -640,7 +669,8 @@ class ParallelChecker this->_writeArray(group, name, subitem_value_per_item.arrayView()); this->_writeItemNumbers<item_type>(i_connectivity, file, group); - this->_writeSubItemRowsMap<ItemOfItem>(i_connectivity, file, group); + this->_writeItemNumbers<sub_item_type>(i_connectivity, file, group); + this->_writeSubItemMatrix<ItemOfItem>(i_connectivity, file, group); ++m_tag; @@ -685,7 +715,8 @@ class ParallelChecker this->_writeTable(group, name, subitem_value_per_item.tableView()); this->_writeItemNumbers<item_type>(i_connectivity, file, group); - this->_writeSubItemRowsMap<ItemOfItem>(i_connectivity, file, group); + this->_writeItemNumbers<sub_item_type>(i_connectivity, file, group); + this->_writeSubItemMatrix<ItemOfItem>(i_connectivity, file, group); ++m_tag; @@ -720,7 +751,8 @@ class ParallelChecker std::vector<size_t>{item_value.numberOfItems()}, i_connectivity, group); - Array<const int> reference_item_numbers = this->_readArray<int>(group, "numbers"); + Array<const int> reference_item_numbers = + this->_readArray<int>(group, std::string{itemName(item_type)} + "_numbers"); Array<const DataType> reference_item_value = this->_readArray<DataType>(group, reference_name); Array<const int> item_numbers = this->_getItemNumber<item_type>(i_connectivity); @@ -846,7 +878,8 @@ class ParallelChecker item_array.sizeOfArrays()}, i_connectivity, group); - Array<const int> reference_item_numbers = this->_readArray<int>(group, "numbers"); + Array<const int> reference_item_numbers = + this->_readArray<int>(group, std::string{itemName(item_type)} + "_numbers"); Table<const DataType> reference_item_array = this->_readTable<DataType>(group, reference_name); Array<const int> item_numbers = this->_getItemNumber<item_type>(i_connectivity); @@ -980,12 +1013,17 @@ class ParallelChecker constexpr ItemType sub_item_type = ItemOfItem::sub_item_type; using IndexType = typename ConnectivityMatrix::IndexType; - Array<const int> reference_item_numbers = this->_readArray<int>(group, "numbers"); + Array<const int> reference_item_numbers = + this->_readArray<int>(group, std::string{itemName(item_type)} + "_numbers"); + Array<const int> reference_sub_item_numbers = + this->_readArray<int>(group, std::string{itemName(sub_item_type)} + "_numbers"); Array<const IndexType> reference_subitem_rows_map = this->_readArray<IndexType>(group, "rows_map"); + Array<const IndexType> reference_subitem_index = this->_readArray<IndexType>(group, "sub_item_index"); Array<const DataType> reference_subitem_value_per_item = this->_readArray<DataType>(group, reference_name); Array<const int> item_numbers = this->_getItemNumber<item_type>(i_connectivity); + Array<const int> sub_item_numbers = this->_getItemNumber<sub_item_type>(i_connectivity); Array<const IndexType> sub_item_row_map = this->_getSubItemRowsMap<item_type, sub_item_type>(i_connectivity); using ItemId = ItemIdT<item_type>; @@ -1019,6 +1057,8 @@ class ParallelChecker } this->_checkGlobalNumberOfItems<item_type>(i_connectivity, reference_item_numbers.size()); + auto item_to_sub_item_matrix = i_connectivity->getMatrix(item_type, sub_item_type); + Array<const int> owner = this->_getItemOwner<item_type>(i_connectivity); bool has_own_differences = false; @@ -1030,12 +1070,29 @@ class ParallelChecker const size_t index_end_in_reference = reference_subitem_rows_map[reference_item_index + 1]; bool item_is_same = true; - if ((index_end_in_reference - index_begin_in_reference) != subitem_value_per_item[item_id].size()) { - item_is_same = false; + + if ((item_type > sub_item_type) or (static_cast<size_t>(owner[item_id]) == parallel::rank())) { + if ((index_end_in_reference - index_begin_in_reference) != subitem_value_per_item[item_id].size()) { + item_is_same = false; + } else { + for (size_t i_sub_item = 0; i_sub_item < subitem_value_per_item[item_id].size(); ++i_sub_item) { + if (reference_subitem_value_per_item[index_begin_in_reference + i_sub_item] != + subitem_value_per_item[item_id][i_sub_item]) { + item_is_same = false; + } + } + } } else { - for (size_t i_sub_item = 0; i_sub_item < subitem_value_per_item[item_id].size(); ++i_sub_item) { - if (reference_subitem_value_per_item[index_begin_in_reference + i_sub_item] != - subitem_value_per_item[item_id][i_sub_item]) { + std::map<int, size_t> sub_item_number_to_index; + for (size_t index = index_begin_in_reference; index < index_end_in_reference; ++index) { + sub_item_number_to_index[reference_sub_item_numbers[reference_subitem_index[index]]] = index; + } + + auto sub_item_list = item_to_sub_item_matrix[item_id]; + for (size_t i_sub_item = 0; i_sub_item < sub_item_list.size(); ++i_sub_item) { + auto sub_item_id = sub_item_list[i_sub_item]; + auto index = sub_item_number_to_index.at(sub_item_numbers[sub_item_id]); + if (reference_subitem_value_per_item[index] != subitem_value_per_item[item_id][i_sub_item]) { item_is_same = false; } } @@ -1147,12 +1204,17 @@ class ParallelChecker constexpr ItemType sub_item_type = ItemOfItem::sub_item_type; using IndexType = typename ConnectivityMatrix::IndexType; - Array<const int> reference_item_numbers = this->_readArray<int>(group, "numbers"); + Array<const int> reference_item_numbers = + this->_readArray<int>(group, std::string{itemName(item_type)} + "_numbers"); + Array<const int> reference_sub_item_numbers = + this->_readArray<int>(group, std::string{itemName(sub_item_type)} + "_numbers"); Array<const IndexType> reference_subitem_rows_map = this->_readArray<IndexType>(group, "rows_map"); + Array<const IndexType> reference_subitem_index = this->_readArray<IndexType>(group, "sub_item_index"); Table<const DataType> reference_subitem_array_per_item = this->_readTable<DataType>(group, reference_name); Array<const int> item_numbers = this->_getItemNumber<item_type>(i_connectivity); + Array<const int> sub_item_numbers = this->_getItemNumber<sub_item_type>(i_connectivity); Array<const IndexType> sub_item_row_map = this->_getSubItemRowsMap<item_type, sub_item_type>(i_connectivity); using ItemId = ItemIdT<item_type>; @@ -1186,6 +1248,8 @@ class ParallelChecker } this->_checkGlobalNumberOfItems<item_type>(i_connectivity, reference_item_numbers.size()); + auto item_to_sub_item_matrix = i_connectivity->getMatrix(item_type, sub_item_type); + Array<const int> owner = this->_getItemOwner<item_type>(i_connectivity); bool has_own_differences = false; @@ -1197,13 +1261,32 @@ class ParallelChecker const size_t index_end_in_reference = reference_subitem_rows_map[reference_item_index + 1]; bool item_is_same = true; - if ((index_end_in_reference - index_begin_in_reference) != subitem_array_per_item[item_id].numberOfRows()) { - item_is_same = false; + + if ((item_type > sub_item_type) or (static_cast<size_t>(owner[item_id]) == parallel::rank())) { + if ((index_end_in_reference - index_begin_in_reference) != subitem_array_per_item[item_id].numberOfRows()) { + item_is_same = false; + } else { + for (size_t i_sub_item = 0; i_sub_item < subitem_array_per_item[item_id].numberOfRows(); ++i_sub_item) { + for (size_t i = 0; i < subitem_array_per_item.sizeOfArrays(); ++i) { + if (reference_subitem_array_per_item[index_begin_in_reference + i_sub_item][i] != + subitem_array_per_item[item_id][i_sub_item][i]) { + item_is_same = false; + } + } + } + } } else { - for (size_t i_sub_item = 0; i_sub_item < subitem_array_per_item[item_id].numberOfRows(); ++i_sub_item) { + std::map<int, size_t> sub_item_number_to_index; + for (size_t index = index_begin_in_reference; index < index_end_in_reference; ++index) { + sub_item_number_to_index[reference_sub_item_numbers[reference_subitem_index[index]]] = index; + } + + auto sub_item_list = item_to_sub_item_matrix[item_id]; + for (size_t i_sub_item = 0; i_sub_item < sub_item_list.size(); ++i_sub_item) { + auto sub_item_id = sub_item_list[i_sub_item]; + auto index = sub_item_number_to_index.at(sub_item_numbers[sub_item_id]); for (size_t i = 0; i < subitem_array_per_item.sizeOfArrays(); ++i) { - if (reference_subitem_array_per_item[index_begin_in_reference + i_sub_item][i] != - subitem_array_per_item[item_id][i_sub_item][i]) { + if (reference_subitem_array_per_item[index][i] != subitem_array_per_item[item_id][i_sub_item][i]) { item_is_same = false; } } diff --git a/tests/test_ParallelChecker_read.cpp b/tests/test_ParallelChecker_read.cpp index 026cd4063fc0837dcec9a83bac312d4d58619561..40628382f6336517a9e2636d5e65fbe90cb774ab 100644 --- a/tests/test_ParallelChecker_read.cpp +++ b/tests/test_ParallelChecker_read.cpp @@ -181,6 +181,116 @@ TEST_CASE("ParallelChecker_read", "[dev]") } }; + auto get_subitem_index = [&get_item_numbers]<typename ConnectivityT>(const ConnectivityT& connectivity, + ItemType item_type, ItemType subitem_type) + -> Array<const typename ConnectivityMatrix::IndexType> { + auto item_to_subitem_matrix = connectivity.getMatrix(item_type, subitem_type); + + Array sub_item_index = item_to_subitem_matrix.values(); + Array rows_map = connectivity.getMatrix(item_type, subitem_type).rowsMap(); + + if (parallel::size() == 1) { + return sub_item_index; + } else { + Array<const bool> is_owned; + switch (item_type) { + case ItemType::cell: { + is_owned = connectivity.cellIsOwned().arrayView(); + break; + } + case ItemType::face: { + is_owned = connectivity.faceIsOwned().arrayView(); + break; + } + case ItemType::edge: { + is_owned = connectivity.edgeIsOwned().arrayView(); + break; + } + case ItemType::node: { + is_owned = connectivity.nodeIsOwned().arrayView(); + break; + } + } + + Array<const int> subitem_numbers; + switch (subitem_type) { + case ItemType::cell: { + subitem_numbers = connectivity.cellNumber().arrayView(); + break; + } + case ItemType::face: { + subitem_numbers = connectivity.faceNumber().arrayView(); + break; + } + case ItemType::edge: { + subitem_numbers = connectivity.edgeNumber().arrayView(); + break; + } + case ItemType::node: { + subitem_numbers = connectivity.nodeNumber().arrayView(); + break; + } + } + + Array<size_t> nb_subitem_per_item(rows_map.size() - 1); + + for (size_t i = 0; i < nb_subitem_per_item.size(); ++i) { + nb_subitem_per_item[i] = rows_map[i + 1] - rows_map[i]; + } + + const size_t nb_local_item = [is_owned]() { + size_t count = 0; + for (size_t i = 0; i < is_owned.size(); ++i) { + count += is_owned[i]; + } + return count; + }(); + + Array<int> global_subitem_numbers; + { + Array<size_t> owned_nb_subitem_per_item{nb_local_item}; + for (size_t i = 0, l = 0; i < is_owned.size(); ++i) { + if (is_owned[i]) { + owned_nb_subitem_per_item[l++] = nb_subitem_per_item[i]; + } + } + + size_t owned_nb_subitem = sum(owned_nb_subitem_per_item); + + Array<int> owned_subitem_numbers{owned_nb_subitem}; + + size_t l = 0; + for (size_t item_id = 0; item_id < item_to_subitem_matrix.numberOfRows(); ++item_id) { + if (is_owned[item_id]) { + for (size_t i = 0; i < item_to_subitem_matrix[item_id].size(); ++i) { + owned_subitem_numbers[l++] = subitem_numbers[item_to_subitem_matrix[item_id][i]]; + } + } + } + + global_subitem_numbers = parallel::allGatherVariable(owned_subitem_numbers); + } + + Array sub_item_numbers = get_item_numbers(connectivity, subitem_type); + + std::map<typename ConnectivityMatrix::IndexType, int> number_to_id_map; + { + for (size_t i = 0; i < sub_item_numbers.size(); ++i) { + number_to_id_map[sub_item_numbers[i]] = i; + } + REQUIRE(sub_item_numbers.size() == number_to_id_map.size()); + } + + Array<typename ConnectivityMatrix::IndexType> global_values{global_subitem_numbers.size()}; + + for (size_t i = 0; i < global_subitem_numbers.size(); ++i) { + global_values[i] = number_to_id_map.at(global_subitem_numbers[i]); + } + + return global_values; + } + }; + SECTION("check parallel write implementation") { if (parallel::size() == 1) { @@ -207,21 +317,21 @@ TEST_CASE("ParallelChecker_read", "[dev]") SourceLocation source_location; - Array numbers = get_item_numbers(connectivity, ItemType::cell); + Array cell_numbers = get_item_numbers(connectivity, ItemType::cell); int tag = 12; if (parallel::rank() == 0) { HighFive::File file(filename, HighFive::File::Overwrite); HighFive::Group group = file.createGroup("/values/" + std::to_string(tag)); - group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}}) - .write_raw<int>(&(numbers[0])); + group.createDataSet<int>("cell_numbers", HighFive::DataSpace{std::vector<size_t>{cell_numbers.size()}}) + .write_raw<int>(&(cell_numbers[0])); - Array<double> values{numbers.size()}; - for (size_t i = 0; i < numbers.size(); ++i) { - values[i] = std::sin(numbers[i]); + Array<double> values{cell_numbers.size()}; + for (size_t i = 0; i < cell_numbers.size(); ++i) { + values[i] = std::sin(cell_numbers[i]); } - group.createDataSet<double>(name, HighFive::DataSpace{std::vector<size_t>{numbers.size()}}) + group.createDataSet<double>(name, HighFive::DataSpace{std::vector<size_t>{cell_numbers.size()}}) .write_raw<double>(&(values[0])); group.createAttribute("filename", source_location.filename()); @@ -392,7 +502,7 @@ TEST_CASE("ParallelChecker_read", "[dev]") HighFive::File file(filename, HighFive::File::Overwrite); HighFive::Group group = file.createGroup("/values/" + std::to_string(tag)); - group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}}) + group.createDataSet<int>("cell_numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}}) .write_raw<int>(&(numbers[0])); Table<double> double_table{numbers.size(), 2}; @@ -525,7 +635,7 @@ TEST_CASE("ParallelChecker_read", "[dev]") SourceLocation source_location; - Array numbers = get_item_numbers(connectivity, ItemType::node); + Array node_numbers = get_item_numbers(connectivity, ItemType::node); using DataType = TinyVector<3>; @@ -534,17 +644,17 @@ TEST_CASE("ParallelChecker_read", "[dev]") HighFive::File file(filename, HighFive::File::Overwrite); HighFive::Group group = file.createGroup("/values/" + std::to_string(tag)); - group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}}) - .write_raw<int>(&(numbers[0])); + group.createDataSet<int>("node_numbers", HighFive::DataSpace{std::vector<size_t>{node_numbers.size()}}) + .write_raw<int>(&(node_numbers[0])); - Array<DataType> values{numbers.size()}; - for (size_t i = 0; i < numbers.size(); ++i) { + Array<DataType> values{node_numbers.size()}; + for (size_t i = 0; i < node_numbers.size(); ++i) { for (size_t j = 0; j < DataType::Dimension; ++j) { - values[i][j] = std::sin(numbers[i] + j); + values[i][j] = std::sin(node_numbers[i] + j); } } group - .createDataSet(name, HighFive::DataSpace{std::vector<size_t>{numbers.size()}}, + .createDataSet(name, HighFive::DataSpace{std::vector<size_t>{node_numbers.size()}}, test_TinyVectorDataType<DataType>{}) .template write_raw<double>(&(values[0][0]), test_TinyVectorDataType<DataType>{}); @@ -620,22 +730,22 @@ TEST_CASE("ParallelChecker_read", "[dev]") using DataType = TinyMatrix<3, 2>; - Array numbers = get_item_numbers(connectivity, ItemType::face); + Array face_numbers = get_item_numbers(connectivity, ItemType::face); int tag = 12; if (parallel::rank() == 0) { HighFive::File file(filename, HighFive::File::Overwrite); HighFive::Group group = file.createGroup("/values/" + std::to_string(tag)); - group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}}) - .write_raw<int>(&(numbers[0])); + group.createDataSet<int>("face_numbers", HighFive::DataSpace{std::vector<size_t>{face_numbers.size()}}) + .write_raw<int>(&(face_numbers[0])); - Table<DataType> dt_table{numbers.size(), 2}; + Table<DataType> dt_table{face_numbers.size(), 2}; for (size_t i = 0; i < dt_table.numberOfRows(); ++i) { for (size_t j = 0; j < dt_table.numberOfColumns(); ++j) { for (size_t k = 0; k < DataType::NumberOfRows; ++k) { for (size_t l = 0; l < DataType::NumberOfColumns; ++l) { - dt_table[i][j](k, l) = std::sin(2 * numbers[i] + j + 3 * k + 2 * l); + dt_table[i][j](k, l) = std::sin(2 * face_numbers[i] + j + 3 * k + 2 * l); } } } @@ -769,7 +879,7 @@ TEST_CASE("ParallelChecker_read", "[dev]") SourceLocation source_location; - Array numbers = get_item_numbers(connectivity, ItemType::node); + Array node_numbers = get_item_numbers(connectivity, ItemType::node); using DataType = TinyMatrix<2, 3>; @@ -778,19 +888,19 @@ TEST_CASE("ParallelChecker_read", "[dev]") HighFive::File file(filename, HighFive::File::Overwrite); HighFive::Group group = file.createGroup("/values/" + std::to_string(tag)); - group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}}) - .write_raw<int>(&(numbers[0])); + group.createDataSet<int>("node_numbers", HighFive::DataSpace{std::vector<size_t>{node_numbers.size()}}) + .write_raw<int>(&(node_numbers[0])); - Array<DataType> values{numbers.size()}; - for (size_t i = 0; i < numbers.size(); ++i) { + Array<DataType> values{node_numbers.size()}; + for (size_t i = 0; i < node_numbers.size(); ++i) { for (size_t j = 0; j < DataType::NumberOfRows; ++j) { for (size_t k = 0; k < DataType::NumberOfColumns; ++k) { - values[i](j, k) = std::sin(numbers[i] + j + 2 * k); + values[i](j, k) = std::sin(node_numbers[i] + j + 2 * k); } } } group - .createDataSet(name, HighFive::DataSpace{std::vector<size_t>{numbers.size()}}, + .createDataSet(name, HighFive::DataSpace{std::vector<size_t>{node_numbers.size()}}, test_TinyMatrixDataType<DataType>{}) .template write_raw<double>(&(values[0](0, 0)), test_TinyMatrixDataType<DataType>{}); @@ -868,21 +978,21 @@ TEST_CASE("ParallelChecker_read", "[dev]") using DataType = TinyVector<2>; - Array numbers = get_item_numbers(connectivity, ItemType::face); + Array face_numbers = get_item_numbers(connectivity, ItemType::face); int tag = 7; if (parallel::rank() == 0) { HighFive::File file(filename, HighFive::File::Overwrite); HighFive::Group group = file.createGroup("/values/" + std::to_string(tag)); - group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}}) - .write_raw<int>(&(numbers[0])); + group.createDataSet<int>("face_numbers", HighFive::DataSpace{std::vector<size_t>{face_numbers.size()}}) + .write_raw<int>(&(face_numbers[0])); - Table<DataType> dt_table{numbers.size(), 2}; + Table<DataType> dt_table{face_numbers.size(), 2}; for (size_t i = 0; i < dt_table.numberOfRows(); ++i) { for (size_t j = 0; j < dt_table.numberOfColumns(); ++j) { for (size_t k = 0; k < DataType::Dimension; ++k) { - dt_table[i][j][k] = std::sin(2 * numbers[i] + j + 3 * k); + dt_table[i][j][k] = std::sin(2 * face_numbers[i] + j + 3 * k); } } } @@ -1014,27 +1124,37 @@ TEST_CASE("ParallelChecker_read", "[dev]") const std::string name = "sin"; SourceLocation source_location; - Array numbers = get_item_numbers(connectivity, ItemType::node); + Array node_numbers = get_item_numbers(connectivity, ItemType::node); + Array cell_numbers = get_item_numbers(connectivity, ItemType::cell); Array<const typename ConnectivityMatrix::IndexType> rows_map = get_subitem_rows_map(connectivity, ItemType::node, ItemType::cell); + Array<const typename ConnectivityMatrix::IndexType> sub_item_index = + get_subitem_index(connectivity, ItemType::node, ItemType::cell); int tag = 6; if (parallel::rank() == 0) { HighFive::File file(filename, HighFive::File::Overwrite); HighFive::Group group = file.createGroup("/values/" + std::to_string(tag)); - group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}}) - .write_raw<int>(&(numbers[0])); + group.createDataSet<int>("node_numbers", HighFive::DataSpace{std::vector<size_t>{node_numbers.size()}}) + .write_raw<int>(&(node_numbers[0])); + group.createDataSet<int>("cell_numbers", HighFive::DataSpace{std::vector<size_t>{cell_numbers.size()}}) + .write_raw<int>(&(cell_numbers[0])); group .createDataSet<typename ConnectivityMatrix::IndexType>("rows_map", HighFive::DataSpace{std::vector<size_t>{ rows_map.size()}}) .write_raw<typename ConnectivityMatrix::IndexType>(&(rows_map[0])); + group + .createDataSet<typename ConnectivityMatrix::IndexType>("sub_item_index", + HighFive::DataSpace{ + std::vector<size_t>{sub_item_index.size()}}) + .write_raw<typename ConnectivityMatrix::IndexType>(&(sub_item_index[0])); Array<double> values{rows_map[rows_map.size() - 1]}; - for (size_t i = 0; i < numbers.size(); ++i) { + for (size_t i = 0; i < node_numbers.size(); ++i) { for (size_t i_row = rows_map[i]; i_row < rows_map[i + 1]; ++i_row) { const size_t j = i_row - rows_map[i]; - values[i_row] = std::sin(numbers[i] + 2 * j); + values[i_row] = std::sin(node_numbers[i] + 2 * j); } } @@ -1220,28 +1340,38 @@ TEST_CASE("ParallelChecker_read", "[dev]") SourceLocation source_location; - Array numbers = get_item_numbers(connectivity, ItemType::cell); + Array cell_numbers = get_item_numbers(connectivity, ItemType::cell); + Array node_numbers = get_item_numbers(connectivity, ItemType::node); Array<const typename ConnectivityMatrix::IndexType> rows_map = get_subitem_rows_map(connectivity, ItemType::cell, ItemType::node); + Array<const typename ConnectivityMatrix::IndexType> sub_item_index = + get_subitem_index(connectivity, ItemType::cell, ItemType::node); int tag = 12; if (parallel::rank() == 0) { HighFive::File file(filename, HighFive::File::Overwrite); HighFive::Group group = file.createGroup("/values/" + std::to_string(tag)); - group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}}) - .write_raw<int>(&(numbers[0])); + group.createDataSet<int>("cell_numbers", HighFive::DataSpace{std::vector<size_t>{cell_numbers.size()}}) + .write_raw<int>(&(cell_numbers[0])); + group.createDataSet<int>("node_numbers", HighFive::DataSpace{std::vector<size_t>{node_numbers.size()}}) + .write_raw<int>(&(node_numbers[0])); group .createDataSet<typename ConnectivityMatrix::IndexType>("rows_map", HighFive::DataSpace{std::vector<size_t>{ rows_map.size()}}) .write_raw<typename ConnectivityMatrix::IndexType>(&(rows_map[0])); + group + .createDataSet<typename ConnectivityMatrix::IndexType>("sub_item_index", + HighFive::DataSpace{ + std::vector<size_t>{sub_item_index.size()}}) + .write_raw<typename ConnectivityMatrix::IndexType>(&(sub_item_index[0])); Table<double> double_table{rows_map[rows_map.size() - 1], 2}; - for (size_t i = 0; i < numbers.size(); ++i) { + for (size_t i = 0; i < cell_numbers.size(); ++i) { for (size_t i_row = rows_map[i]; i_row < rows_map[i + 1]; ++i_row) { const size_t j = i_row - rows_map[i]; for (size_t k = 0; k < 2; ++k) { - double_table[i_row][k] = std::sin(2 * numbers[i] + (1 + k) * j); + double_table[i_row][k] = std::sin(2 * cell_numbers[i] + (1 + k) * j); } } } @@ -1376,22 +1506,22 @@ TEST_CASE("ParallelChecker_read", "[dev]") using DataType = TinyMatrix<3, 2>; - Array numbers = get_item_numbers(connectivity, ItemType::face); + Array face_numbers = get_item_numbers(connectivity, ItemType::face); int tag = 12; if (parallel::rank() == 0) { HighFive::File file(filename, HighFive::File::Overwrite); HighFive::Group group = file.createGroup("/values/" + std::to_string(tag)); - group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}}) - .write_raw<int>(&(numbers[0])); + group.createDataSet<int>("face_numbers", HighFive::DataSpace{std::vector<size_t>{face_numbers.size()}}) + .write_raw<int>(&(face_numbers[0])); - Table<DataType> dt_table{numbers.size(), 2}; + Table<DataType> dt_table{face_numbers.size(), 2}; for (size_t i = 0; i < dt_table.numberOfRows(); ++i) { for (size_t j = 0; j < dt_table.numberOfColumns(); ++j) { for (size_t k = 0; k < DataType::NumberOfRows; ++k) { for (size_t l = 0; l < DataType::NumberOfColumns; ++l) { - dt_table[i][j](k, l) = std::sin(2 * numbers[i] + j + 3 * k + 2 * l); + dt_table[i][j](k, l) = std::sin(2 * face_numbers[i] + j + 3 * k + 2 * l); } } } @@ -1524,27 +1654,37 @@ TEST_CASE("ParallelChecker_read", "[dev]") const std::string name = "sin"; SourceLocation source_location; - Array numbers = get_item_numbers(connectivity, ItemType::node); + Array node_numbers = get_item_numbers(connectivity, ItemType::node); + Array cell_numbers = get_item_numbers(connectivity, ItemType::cell); Array<const typename ConnectivityMatrix::IndexType> rows_map = get_subitem_rows_map(connectivity, ItemType::node, ItemType::cell); + Array<const typename ConnectivityMatrix::IndexType> sub_item_index = + get_subitem_index(connectivity, ItemType::node, ItemType::cell); int tag = 6; if (parallel::rank() == 0) { HighFive::File file(filename, HighFive::File::Overwrite); HighFive::Group group = file.createGroup("/values/" + std::to_string(tag)); - group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}}) - .write_raw<int>(&(numbers[0])); + group.createDataSet<int>("node_numbers", HighFive::DataSpace{std::vector<size_t>{node_numbers.size()}}) + .write_raw<int>(&(node_numbers[0])); + group.createDataSet<int>("cell_numbers", HighFive::DataSpace{std::vector<size_t>{cell_numbers.size()}}) + .write_raw<int>(&(cell_numbers[0])); group .createDataSet<typename ConnectivityMatrix::IndexType>("rows_map", HighFive::DataSpace{std::vector<size_t>{ rows_map.size()}}) .write_raw<typename ConnectivityMatrix::IndexType>(&(rows_map[0])); + group + .createDataSet<typename ConnectivityMatrix::IndexType>("sub_item_index", + HighFive::DataSpace{ + std::vector<size_t>{sub_item_index.size()}}) + .write_raw<typename ConnectivityMatrix::IndexType>(&(sub_item_index[0])); Array<double> values{rows_map[rows_map.size() - 1]}; - for (size_t i = 0; i < numbers.size(); ++i) { + for (size_t i = 0; i < node_numbers.size(); ++i) { for (size_t i_row = rows_map[i]; i_row < rows_map[i + 1]; ++i_row) { const size_t j = i_row - rows_map[i]; - values[i_row] = std::sin(numbers[i] + 2 * j); + values[i_row] = std::sin(node_numbers[i] + 2 * j); } } @@ -1732,21 +1872,21 @@ TEST_CASE("ParallelChecker_read", "[dev]") using DataType = TinyVector<2>; - Array numbers = get_item_numbers(connectivity, ItemType::face); + Array face_numbers = get_item_numbers(connectivity, ItemType::face); int tag = 7; if (parallel::rank() == 0) { HighFive::File file(filename, HighFive::File::Overwrite); HighFive::Group group = file.createGroup("/values/" + std::to_string(tag)); - group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}}) - .write_raw<int>(&(numbers[0])); + group.createDataSet<int>("face_numbers", HighFive::DataSpace{std::vector<size_t>{face_numbers.size()}}) + .write_raw<int>(&(face_numbers[0])); - Table<DataType> dt_table{numbers.size(), 2}; + Table<DataType> dt_table{face_numbers.size(), 2}; for (size_t i = 0; i < dt_table.numberOfRows(); ++i) { for (size_t j = 0; j < dt_table.numberOfColumns(); ++j) { for (size_t k = 0; k < DataType::Dimension; ++k) { - dt_table[i][j][k] = std::sin(2 * numbers[i] + j + 3 * k); + dt_table[i][j][k] = std::sin(2 * face_numbers[i] + j + 3 * k); } } } @@ -1876,28 +2016,38 @@ TEST_CASE("ParallelChecker_read", "[dev]") SourceLocation source_location; - Array numbers = get_item_numbers(connectivity, ItemType::cell); + Array cell_numbers = get_item_numbers(connectivity, ItemType::cell); + Array node_numbers = get_item_numbers(connectivity, ItemType::node); Array<const typename ConnectivityMatrix::IndexType> rows_map = get_subitem_rows_map(connectivity, ItemType::cell, ItemType::node); + Array<const typename ConnectivityMatrix::IndexType> sub_item_index = + get_subitem_index(connectivity, ItemType::cell, ItemType::node); int tag = 12; if (parallel::rank() == 0) { HighFive::File file(filename, HighFive::File::Overwrite); HighFive::Group group = file.createGroup("/values/" + std::to_string(tag)); - group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}}) - .write_raw<int>(&(numbers[0])); + group.createDataSet<int>("cell_numbers", HighFive::DataSpace{std::vector<size_t>{cell_numbers.size()}}) + .write_raw<int>(&(cell_numbers[0])); + group.createDataSet<int>("node_numbers", HighFive::DataSpace{std::vector<size_t>{node_numbers.size()}}) + .write_raw<int>(&(node_numbers[0])); group .createDataSet<typename ConnectivityMatrix::IndexType>("rows_map", HighFive::DataSpace{std::vector<size_t>{ rows_map.size()}}) .write_raw<typename ConnectivityMatrix::IndexType>(&(rows_map[0])); + group + .createDataSet<typename ConnectivityMatrix::IndexType>("sub_item_index", + HighFive::DataSpace{ + std::vector<size_t>{sub_item_index.size()}}) + .write_raw<typename ConnectivityMatrix::IndexType>(&(sub_item_index[0])); Table<double> double_table{rows_map[rows_map.size() - 1], 2}; - for (size_t i = 0; i < numbers.size(); ++i) { + for (size_t i = 0; i < cell_numbers.size(); ++i) { for (size_t i_row = rows_map[i]; i_row < rows_map[i + 1]; ++i_row) { const size_t j = i_row - rows_map[i]; for (size_t k = 0; k < 2; ++k) { - double_table[i_row][k] = std::sin(2 * numbers[i] + (1 + k) * j); + double_table[i_row][k] = std::sin(2 * cell_numbers[i] + (1 + k) * j); } } } diff --git a/tests/test_ParallelChecker_write.cpp b/tests/test_ParallelChecker_write.cpp index 8ca7ceb50cdd2d2e8c1d4f3f5a2fd2669d9d9806..460d77dadf6f0519c0f0d808071b3933a8d6df33 100644 --- a/tests/test_ParallelChecker_write.cpp +++ b/tests/test_ParallelChecker_write.cpp @@ -108,7 +108,7 @@ TEST_CASE("ParallelChecker_write", "[dev]") HighFive::Group group_var0 = file.getGroup("values/" + std::to_string(tag)); REQUIRE(group_var0.getNumberObjects() == 2); - REQUIRE(group_var0.exist("numbers")); + REQUIRE(group_var0.exist(std::string{itemName(item_type)} + "_numbers")); REQUIRE(group_var0.exist(var_name)); REQUIRE(group_var0.getNumberAttributes() == 7); @@ -366,9 +366,11 @@ TEST_CASE("ParallelChecker_write", "[dev]") HighFive::File file(ParallelChecker::instance().filename(), HighFive::File::ReadOnly); HighFive::Group group_var0 = file.getGroup("values/" + std::to_string(tag)); - REQUIRE(group_var0.getNumberObjects() == 3); + REQUIRE(group_var0.getNumberObjects() == 5); - REQUIRE(group_var0.exist("numbers")); + REQUIRE(group_var0.exist(std::string{itemName(item_type)} + "_numbers")); + REQUIRE(group_var0.exist(std::string{itemName(sub_item_type)} + "_numbers")); + REQUIRE(group_var0.exist("sub_item_index")); REQUIRE(group_var0.exist("rows_map")); REQUIRE(group_var0.exist(var_name));