diff --git a/src/mesh/SubItemArrayPerItem.hpp b/src/mesh/SubItemArrayPerItem.hpp
index 7b204d2193aa6cdb450f7e8d8b23f91d0a47e2c3..e0bc1e611c10ccecb088c272c75d1d5e2c7d9d38 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 ea0e900681279b306ee82a9615e843650cfb1ea7..90ef57b2ca0221752a5890f0ede7f481a6fe4f70 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 dda38918acdb156f8a7c5de552d1f82319463c97..8b0e8c5f41a3c238135e5a0c88ce15236ad67b8f 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);
}
}
}