From d3adc9e52b35b883ffc87001fe77937c84424bf1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?St=C3=A9phane=20Del=20Pino?= <stephane.delpino44@gmail.com> Date: Wed, 2 Mar 2022 17:13:44 +0100 Subject: [PATCH] Simplify implementation and add a new access operators[](ItemId) The new operator behaves exactly as the SubItemValuePerItem::itemArray(ItemId) and SubItemArrayPerItem::itemTable(ItemId) functions This convenient change is mainly made in the goal of simplifying item-to-item matrices used in connectivity --- src/mesh/SubItemArrayPerItem.hpp | 24 +- src/mesh/SubItemValuePerItem.hpp | 26 +- tests/test_SubItemValuePerItem.cpp | 531 +++++++++++++++++++++++++++++ 3 files changed, 548 insertions(+), 33 deletions(-) diff --git a/src/mesh/SubItemArrayPerItem.hpp b/src/mesh/SubItemArrayPerItem.hpp index 7b204d219..e0bc1e611 100644 --- a/src/mesh/SubItemArrayPerItem.hpp +++ b/src/mesh/SubItemArrayPerItem.hpp @@ -90,8 +90,14 @@ class SubItemArrayPerItem return m_values[m_host_row_map(size_t{item_id}) + i]; } - // Following Kokkos logic, these classes are view and const view does allow - // changes in data + template <ItemType item_t> + Table<DataType> + operator[](const ItemIdT<item_t>& item_id) const noexcept(NO_ASSERT) + { + static_assert(item_t == item_type, "invalid ItemId type"); + return this->itemTable(item_id); + } + template <typename ArrayIndexType> Array<DataType> operator[](const ArrayIndexType& i) const noexcept(NO_ASSERT) @@ -144,20 +150,6 @@ class SubItemArrayPerItem m_values.fill(data); } - template <typename IndexType> - PUGS_INLINE Table<DataType> - itemTable(IndexType item_id) noexcept(NO_ASSERT) - { - static_assert(std::is_same_v<IndexType, ItemId>, "index must be an ItemId"); - Assert(this->isBuilt()); - Assert(item_id < this->numberOfItems()); - const auto& item_begin = m_host_row_map(size_t{item_id}); - const auto& item_end = m_host_row_map(size_t{item_id} + 1); - return subTable(m_values, item_begin, item_end - item_begin, 0, this->sizeOfArrays()); - } - - // Following Kokkos logic, these classes are view and const view does allow - // changes in data template <typename IndexType> PUGS_INLINE Table<DataType> itemTable(IndexType item_id) const noexcept(NO_ASSERT) diff --git a/src/mesh/SubItemValuePerItem.hpp b/src/mesh/SubItemValuePerItem.hpp index ea0e90068..90ef57b2c 100644 --- a/src/mesh/SubItemValuePerItem.hpp +++ b/src/mesh/SubItemValuePerItem.hpp @@ -88,8 +88,14 @@ class SubItemValuePerItem return m_values[m_host_row_map(size_t{item_id}) + i]; } - // Following Kokkos logic, these classes are view and const view does allow - // changes in data + template <ItemType item_t> + Array<DataType> + operator[](const ItemIdT<item_t>& item_id) const noexcept(NO_ASSERT) + { + static_assert(item_t == item_type, "invalid ItemId type"); + return this->itemArray(item_id); + } + template <typename ArrayIndexType> DataType& operator[](const ArrayIndexType& i) const noexcept(NO_ASSERT) @@ -137,21 +143,7 @@ class SubItemValuePerItem template <typename IndexType> PUGS_INLINE Array<DataType> - itemArray(IndexType item_id) noexcept(NO_ASSERT) - { - static_assert(std::is_same_v<IndexType, ItemId>, "index must be an ItemId"); - Assert(this->isBuilt()); - Assert(item_id < this->numberOfItems()); - const auto& item_begin = m_host_row_map(size_t{item_id}); - const auto& item_end = m_host_row_map(size_t{item_id} + 1); - return subArray(m_values, item_begin, item_end - item_begin); - } - - // Following Kokkos logic, these classes are view and const view does allow - // changes in data - template <typename IndexType> - PUGS_INLINE Array<DataType> - itemArray(IndexType item_id) const noexcept(NO_ASSERT) + itemArray(const IndexType& item_id) const noexcept(NO_ASSERT) { static_assert(std::is_same_v<IndexType, ItemId>, "index must be an ItemId"); Assert(this->isBuilt()); diff --git a/tests/test_SubItemValuePerItem.cpp b/tests/test_SubItemValuePerItem.cpp index dda38918a..8b0e8c5f4 100644 --- a/tests/test_SubItemValuePerItem.cpp +++ b/tests/test_SubItemValuePerItem.cpp @@ -517,6 +517,529 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") } } + SECTION("access functions") + { + SECTION("1D") + { + std::array mesh_list = MeshDataBaseForTests::get().all1DMeshes(); + + for (auto named_mesh : mesh_list) { + SECTION(named_mesh.name()) + { + auto mesh_1d = named_mesh.mesh(); + + const Connectivity<1>& connectivity = mesh_1d->connectivity(); + + SECTION("per cell") + { + { + NodeValuePerCell<int> node_value_per_cell{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { + for (size_t i = 0; i < node_value_per_cell.numberOfSubValues(cell_id); ++i) { + is_valid &= (&(node_value_per_cell[cell_id][i]) == &(node_value_per_cell.itemArray(cell_id)[i])); + is_valid &= (&(node_value_per_cell[cell_id][i]) == &(node_value_per_cell(cell_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == node_value_per_cell.numberOfValues()); + } + + { + EdgeValuePerCell<int> edge_value_per_cell{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { + for (size_t i = 0; i < edge_value_per_cell.numberOfSubValues(cell_id); ++i) { + is_valid &= (&(edge_value_per_cell[cell_id][i]) == &(edge_value_per_cell.itemArray(cell_id)[i])); + is_valid &= (&(edge_value_per_cell[cell_id][i]) == &(edge_value_per_cell(cell_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == edge_value_per_cell.numberOfValues()); + } + + { + FaceValuePerCell<int> face_value_per_cell{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { + for (size_t i = 0; i < face_value_per_cell.numberOfSubValues(cell_id); ++i) { + is_valid &= (&(face_value_per_cell[cell_id][i]) == &(face_value_per_cell.itemArray(cell_id)[i])); + is_valid &= (&(face_value_per_cell[cell_id][i]) == &(face_value_per_cell(cell_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == face_value_per_cell.numberOfValues()); + } + } + + SECTION("per face") + { + CellValuePerFace<int> cell_value_per_face{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { + for (size_t i = 0; i < cell_value_per_face.numberOfSubValues(face_id); ++i) { + is_valid &= (&(cell_value_per_face[face_id][i]) == &(cell_value_per_face.itemArray(face_id)[i])); + is_valid &= (&(cell_value_per_face[face_id][i]) == &(cell_value_per_face(face_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == cell_value_per_face.numberOfValues()); + } + + SECTION("per edge") + { + CellValuePerEdge<int> cell_value_per_edge{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (EdgeId edge_id = 0; edge_id < connectivity.numberOfEdges(); ++edge_id) { + for (size_t i = 0; i < cell_value_per_edge.numberOfSubValues(edge_id); ++i) { + is_valid &= (&(cell_value_per_edge[edge_id][i]) == &(cell_value_per_edge.itemArray(edge_id)[i])); + is_valid &= (&(cell_value_per_edge[edge_id][i]) == &(cell_value_per_edge(edge_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == cell_value_per_edge.numberOfValues()); + } + + SECTION("per node") + { + CellValuePerNode<int> cell_value_per_node{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) { + for (size_t i = 0; i < cell_value_per_node.numberOfSubValues(node_id); ++i) { + is_valid &= (&(cell_value_per_node[node_id][i]) == &(cell_value_per_node.itemArray(node_id)[i])); + is_valid &= (&(cell_value_per_node[node_id][i]) == &(cell_value_per_node(node_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == cell_value_per_node.numberOfValues()); + } + } + } + } + + SECTION("2D") + { + std::array mesh_list = MeshDataBaseForTests::get().all2DMeshes(); + + for (auto named_mesh : mesh_list) { + SECTION(named_mesh.name()) + { + auto mesh_2d = named_mesh.mesh(); + + const Connectivity<2>& connectivity = mesh_2d->connectivity(); + + SECTION("per cell") + { + { + NodeValuePerCell<int> node_value_per_cell{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { + for (size_t i = 0; i < node_value_per_cell.numberOfSubValues(cell_id); ++i) { + is_valid &= (&(node_value_per_cell[cell_id][i]) == &(node_value_per_cell.itemArray(cell_id)[i])); + is_valid &= (&(node_value_per_cell[cell_id][i]) == &(node_value_per_cell(cell_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == node_value_per_cell.numberOfValues()); + } + + { + EdgeValuePerCell<int> edge_value_per_cell{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { + for (size_t i = 0; i < edge_value_per_cell.numberOfSubValues(cell_id); ++i) { + is_valid &= (&(edge_value_per_cell[cell_id][i]) == &(edge_value_per_cell.itemArray(cell_id)[i])); + is_valid &= (&(edge_value_per_cell[cell_id][i]) == &(edge_value_per_cell(cell_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == edge_value_per_cell.numberOfValues()); + } + + { + FaceValuePerCell<int> face_value_per_cell{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { + for (size_t i = 0; i < face_value_per_cell.numberOfSubValues(cell_id); ++i) { + is_valid &= (&(face_value_per_cell[cell_id][i]) == &(face_value_per_cell.itemArray(cell_id)[i])); + is_valid &= (&(face_value_per_cell[cell_id][i]) == &(face_value_per_cell(cell_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == face_value_per_cell.numberOfValues()); + } + } + + SECTION("per face") + { + { + NodeValuePerFace<int> node_value_per_face{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { + for (size_t i = 0; i < node_value_per_face.numberOfSubValues(face_id); ++i) { + is_valid &= (&(node_value_per_face[face_id][i]) == &(node_value_per_face.itemArray(face_id)[i])); + is_valid &= (&(node_value_per_face[face_id][i]) == &(node_value_per_face(face_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == node_value_per_face.numberOfValues()); + } + + { + CellValuePerFace<int> cell_value_per_face{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { + for (size_t i = 0; i < cell_value_per_face.numberOfSubValues(face_id); ++i) { + is_valid &= (&(cell_value_per_face[face_id][i]) == &(cell_value_per_face.itemArray(face_id)[i])); + is_valid &= (&(cell_value_per_face[face_id][i]) == &(cell_value_per_face(face_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == cell_value_per_face.numberOfValues()); + } + } + + SECTION("per edge") + { + { + NodeValuePerEdge<int> node_value_per_edge{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (EdgeId edge_id = 0; edge_id < connectivity.numberOfEdges(); ++edge_id) { + for (size_t i = 0; i < node_value_per_edge.numberOfSubValues(edge_id); ++i) { + is_valid &= (&(node_value_per_edge[edge_id][i]) == &(node_value_per_edge.itemArray(edge_id)[i])); + is_valid &= (&(node_value_per_edge[edge_id][i]) == &(node_value_per_edge(edge_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == node_value_per_edge.numberOfValues()); + } + + { + CellValuePerEdge<int> cell_value_per_edge{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (EdgeId edge_id = 0; edge_id < connectivity.numberOfEdges(); ++edge_id) { + for (size_t i = 0; i < cell_value_per_edge.numberOfSubValues(edge_id); ++i) { + is_valid &= (&(cell_value_per_edge[edge_id][i]) == &(cell_value_per_edge.itemArray(edge_id)[i])); + is_valid &= (&(cell_value_per_edge[edge_id][i]) == &(cell_value_per_edge(edge_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == cell_value_per_edge.numberOfValues()); + } + } + + SECTION("per node") + { + { + EdgeValuePerNode<int> edge_value_per_node{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) { + for (size_t i = 0; i < edge_value_per_node.numberOfSubValues(node_id); ++i) { + is_valid &= (&(edge_value_per_node[node_id][i]) == &(edge_value_per_node.itemArray(node_id)[i])); + is_valid &= (&(edge_value_per_node[node_id][i]) == &(edge_value_per_node(node_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == edge_value_per_node.numberOfValues()); + } + + { + FaceValuePerNode<int> face_value_per_node{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) { + for (size_t i = 0; i < face_value_per_node.numberOfSubValues(node_id); ++i) { + is_valid &= (&(face_value_per_node[node_id][i]) == &(face_value_per_node.itemArray(node_id)[i])); + is_valid &= (&(face_value_per_node[node_id][i]) == &(face_value_per_node(node_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == face_value_per_node.numberOfValues()); + } + + { + CellValuePerNode<int> cell_value_per_node{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) { + for (size_t i = 0; i < cell_value_per_node.numberOfSubValues(node_id); ++i) { + is_valid &= (&(cell_value_per_node[node_id][i]) == &(cell_value_per_node.itemArray(node_id)[i])); + is_valid &= (&(cell_value_per_node[node_id][i]) == &(cell_value_per_node(node_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == cell_value_per_node.numberOfValues()); + } + } + } + } + } + + SECTION("3D") + { + std::array mesh_list = MeshDataBaseForTests::get().all3DMeshes(); + + for (auto named_mesh : mesh_list) { + SECTION(named_mesh.name()) + { + auto mesh_3d = named_mesh.mesh(); + + const Connectivity<3>& connectivity = mesh_3d->connectivity(); + + SECTION("per cell") + { + { + NodeValuePerCell<int> node_value_per_cell{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { + for (size_t i = 0; i < node_value_per_cell.numberOfSubValues(cell_id); ++i) { + is_valid &= (&(node_value_per_cell[cell_id][i]) == &(node_value_per_cell.itemArray(cell_id)[i])); + is_valid &= (&(node_value_per_cell[cell_id][i]) == &(node_value_per_cell(cell_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == node_value_per_cell.numberOfValues()); + } + + { + EdgeValuePerCell<int> edge_value_per_cell{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { + for (size_t i = 0; i < edge_value_per_cell.numberOfSubValues(cell_id); ++i) { + is_valid &= (&(edge_value_per_cell[cell_id][i]) == &(edge_value_per_cell.itemArray(cell_id)[i])); + is_valid &= (&(edge_value_per_cell[cell_id][i]) == &(edge_value_per_cell(cell_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == edge_value_per_cell.numberOfValues()); + } + + { + FaceValuePerCell<int> face_value_per_cell{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { + for (size_t i = 0; i < face_value_per_cell.numberOfSubValues(cell_id); ++i) { + is_valid &= (&(face_value_per_cell[cell_id][i]) == &(face_value_per_cell.itemArray(cell_id)[i])); + is_valid &= (&(face_value_per_cell[cell_id][i]) == &(face_value_per_cell(cell_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == face_value_per_cell.numberOfValues()); + } + } + + SECTION("per face") + { + { + NodeValuePerFace<int> node_value_per_face{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { + for (size_t i = 0; i < node_value_per_face.numberOfSubValues(face_id); ++i) { + is_valid &= (&(node_value_per_face[face_id][i]) == &(node_value_per_face.itemArray(face_id)[i])); + is_valid &= (&(node_value_per_face[face_id][i]) == &(node_value_per_face(face_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == node_value_per_face.numberOfValues()); + } + + { + EdgeValuePerFace<int> edge_value_per_face{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { + for (size_t i = 0; i < edge_value_per_face.numberOfSubValues(face_id); ++i) { + is_valid &= (&(edge_value_per_face[face_id][i]) == &(edge_value_per_face.itemArray(face_id)[i])); + is_valid &= (&(edge_value_per_face[face_id][i]) == &(edge_value_per_face(face_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == edge_value_per_face.numberOfValues()); + } + + { + CellValuePerFace<int> cell_value_per_face{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { + for (size_t i = 0; i < cell_value_per_face.numberOfSubValues(face_id); ++i) { + is_valid &= (&(cell_value_per_face[face_id][i]) == &(cell_value_per_face.itemArray(face_id)[i])); + is_valid &= (&(cell_value_per_face[face_id][i]) == &(cell_value_per_face(face_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == cell_value_per_face.numberOfValues()); + } + } + + SECTION("per edge") + { + { + NodeValuePerEdge<int> node_value_per_edge{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (EdgeId edge_id = 0; edge_id < connectivity.numberOfEdges(); ++edge_id) { + for (size_t i = 0; i < node_value_per_edge.numberOfSubValues(edge_id); ++i) { + is_valid &= (&(node_value_per_edge[edge_id][i]) == &(node_value_per_edge.itemArray(edge_id)[i])); + is_valid &= (&(node_value_per_edge[edge_id][i]) == &(node_value_per_edge(edge_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == node_value_per_edge.numberOfValues()); + } + + { + FaceValuePerEdge<int> face_value_per_edge{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (EdgeId edge_id = 0; edge_id < connectivity.numberOfEdges(); ++edge_id) { + for (size_t i = 0; i < face_value_per_edge.numberOfSubValues(edge_id); ++i) { + is_valid &= (&(face_value_per_edge[edge_id][i]) == &(face_value_per_edge.itemArray(edge_id)[i])); + is_valid &= (&(face_value_per_edge[edge_id][i]) == &(face_value_per_edge(edge_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == face_value_per_edge.numberOfValues()); + } + + { + CellValuePerEdge<int> cell_value_per_edge{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (EdgeId edge_id = 0; edge_id < connectivity.numberOfEdges(); ++edge_id) { + for (size_t i = 0; i < cell_value_per_edge.numberOfSubValues(edge_id); ++i) { + is_valid &= (&(cell_value_per_edge[edge_id][i]) == &(cell_value_per_edge.itemArray(edge_id)[i])); + is_valid &= (&(cell_value_per_edge[edge_id][i]) == &(cell_value_per_edge(edge_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == cell_value_per_edge.numberOfValues()); + } + } + + SECTION("per node") + { + { + EdgeValuePerNode<int> edge_value_per_node{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) { + for (size_t i = 0; i < edge_value_per_node.numberOfSubValues(node_id); ++i) { + is_valid &= (&(edge_value_per_node[node_id][i]) == &(edge_value_per_node.itemArray(node_id)[i])); + is_valid &= (&(edge_value_per_node[node_id][i]) == &(edge_value_per_node(node_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == edge_value_per_node.numberOfValues()); + } + + { + FaceValuePerNode<int> face_value_per_node{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) { + for (size_t i = 0; i < face_value_per_node.numberOfSubValues(node_id); ++i) { + is_valid &= (&(face_value_per_node[node_id][i]) == &(face_value_per_node.itemArray(node_id)[i])); + is_valid &= (&(face_value_per_node[node_id][i]) == &(face_value_per_node(node_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == face_value_per_node.numberOfValues()); + } + + { + CellValuePerNode<int> cell_value_per_node{connectivity}; + + bool is_valid = true; + size_t counter = 0; + for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) { + for (size_t i = 0; i < cell_value_per_node.numberOfSubValues(node_id); ++i) { + is_valid &= (&(cell_value_per_node[node_id][i]) == &(cell_value_per_node.itemArray(node_id)[i])); + is_valid &= (&(cell_value_per_node[node_id][i]) == &(cell_value_per_node(node_id, i))); + counter++; + } + } + REQUIRE(is_valid); + REQUIRE(counter == cell_value_per_node.numberOfValues()); + } + } + } + } + } + } + SECTION("array view") { SECTION("1D") @@ -791,6 +1314,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") CellValuePerNode<int> cell_value_per_node; REQUIRE_THROWS_AS(cell_value_per_node[0], AssertError); REQUIRE_THROWS_AS(cell_value_per_node.itemArray(NodeId{0}), AssertError); + REQUIRE_THROWS_AS(cell_value_per_node[NodeId{0}], AssertError); REQUIRE_THROWS_AS(cell_value_per_node(NodeId{0}, 0), AssertError); REQUIRE_THROWS_AS(cell_value_per_node.numberOfValues(), AssertError); REQUIRE_THROWS_AS(cell_value_per_node.numberOfItems(), AssertError); @@ -799,6 +1323,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") FaceValuePerCell<int> face_value_per_cell; REQUIRE_THROWS_AS(face_value_per_cell[0], AssertError); REQUIRE_THROWS_AS(face_value_per_cell.itemArray(CellId{0}), AssertError); + REQUIRE_THROWS_AS(face_value_per_cell[CellId{0}], AssertError); REQUIRE_THROWS_AS(face_value_per_cell(CellId{0}, 0), AssertError); REQUIRE_THROWS_AS(face_value_per_cell.numberOfValues(), AssertError); REQUIRE_THROWS_AS(face_value_per_cell.numberOfItems(), AssertError); @@ -807,6 +1332,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") CellValuePerEdge<int> cell_value_per_edge; REQUIRE_THROWS_AS(cell_value_per_edge[0], AssertError); REQUIRE_THROWS_AS(cell_value_per_edge.itemArray(EdgeId{0}), AssertError); + REQUIRE_THROWS_AS(cell_value_per_edge[EdgeId{0}], AssertError); REQUIRE_THROWS_AS(cell_value_per_edge(EdgeId{0}, 0), AssertError); REQUIRE_THROWS_AS(cell_value_per_edge.numberOfValues(), AssertError); REQUIRE_THROWS_AS(cell_value_per_edge.numberOfItems(), AssertError); @@ -815,6 +1341,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") NodeValuePerFace<int> node_value_per_face; REQUIRE_THROWS_AS(node_value_per_face[0], AssertError); REQUIRE_THROWS_AS(node_value_per_face.itemArray(FaceId{0}), AssertError); + REQUIRE_THROWS_AS(node_value_per_face[FaceId{0}], AssertError); REQUIRE_THROWS_AS(node_value_per_face(FaceId{0}, 0), AssertError); REQUIRE_THROWS_AS(node_value_per_face.numberOfValues(), AssertError); REQUIRE_THROWS_AS(node_value_per_face.numberOfItems(), AssertError); @@ -843,6 +1370,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE_THROWS_AS(cell_value_per_face(face_id, cell_values.size()), AssertError); REQUIRE_THROWS_AS(cell_values[cell_values.size()], AssertError); REQUIRE_THROWS_AS(cell_value_per_face.itemArray(face_id)[cell_values.size()] = 2, AssertError); + REQUIRE_THROWS_AS(cell_value_per_face[face_id][cell_values.size()] = 2, AssertError); } FaceValuePerNode<int> face_value_per_node{connectivity}; @@ -856,6 +1384,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE_THROWS_AS(face_value_per_node(node_id, face_values.size()), AssertError); REQUIRE_THROWS_AS(face_values[face_values.size()], AssertError); REQUIRE_THROWS_AS(face_value_per_node.itemArray(node_id)[face_values.size()] = 2, AssertError); + REQUIRE_THROWS_AS(face_value_per_node[node_id][face_values.size()] = 2, AssertError); } EdgeValuePerCell<int> edge_value_per_cell{connectivity}; @@ -869,6 +1398,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE_THROWS_AS(edge_value_per_cell(cell_id, edge_values.size()), AssertError); REQUIRE_THROWS_AS(edge_values[edge_values.size()], AssertError); REQUIRE_THROWS_AS(edge_value_per_cell.itemArray(cell_id)[edge_values.size()] = 2, AssertError); + REQUIRE_THROWS_AS(edge_value_per_cell[cell_id][edge_values.size()] = 2, AssertError); } NodeValuePerEdge<int> node_value_per_edge{connectivity}; @@ -882,6 +1412,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]") REQUIRE_THROWS_AS(node_value_per_edge(edge_id, node_values.size()), AssertError); REQUIRE_THROWS_AS(node_values[node_values.size()], AssertError); REQUIRE_THROWS_AS(node_value_per_edge.itemArray(edge_id)[node_values.size()] = 2, AssertError); + REQUIRE_THROWS_AS(node_value_per_edge[edge_id][node_values.size()] = 2, AssertError); } } } -- GitLab