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

Add tests for SubItemValuePerItem

parent fe1b47d9
No related branches found
No related tags found
1 merge request!84Add SubArray class
Show whitespace changes
Inline Side-by-side
src/mesh/SubItemValuePerItem.hpp
+ 28
− 16
View file @ e8b20dee
...@@ -55,7 +55,8 @@ class SubItemValuePerItem ...@@ -55,7 +55,8 @@ class SubItemValuePerItem
public: public:
template <typename IndexType> template <typename IndexType>
PUGS_INLINE const DataType& operator[](IndexType i) const noexcept(NO_ASSERT) PUGS_INLINE const DataType&
operator[](IndexType i) const noexcept(NO_ASSERT)
{ {
static_assert(std::is_integral_v<IndexType>, "SubView is indexed by integral values"); static_assert(std::is_integral_v<IndexType>, "SubView is indexed by integral values");
Assert(i < m_size); Assert(i < m_size);
...@@ -63,7 +64,8 @@ class SubItemValuePerItem ...@@ -63,7 +64,8 @@ class SubItemValuePerItem
} }
template <typename IndexType> template <typename IndexType>
PUGS_FORCEINLINE DataType& operator[](IndexType i) noexcept(NO_ASSERT) PUGS_FORCEINLINE DataType&
operator[](IndexType i) noexcept(NO_ASSERT)
{ {
static_assert(std::is_integral_v<IndexType>, "SubView is indexed by integral values"); static_assert(std::is_integral_v<IndexType>, "SubView is indexed by integral values");
Assert(i < m_size); Assert(i < m_size);
...@@ -91,6 +93,15 @@ class SubItemValuePerItem ...@@ -91,6 +93,15 @@ class SubItemValuePerItem
} }
}; };
friend PUGS_INLINE SubItemValuePerItem<std::remove_const_t<DataType>, ItemOfItem, ConnectivityPtr>
copy(SubItemValuePerItem<DataType, ItemOfItem, ConnectivityPtr>& source)
{
SubItemValuePerItem<std::remove_const_t<DataType>, ItemOfItem, ConnectivityPtr> image(*source.m_connectivity_ptr);
image.m_values = copy(source.m_values);
return image;
}
PUGS_INLINE PUGS_INLINE
bool bool
isBuilt() const noexcept isBuilt() const noexcept
...@@ -109,18 +120,11 @@ class SubItemValuePerItem ...@@ -109,18 +120,11 @@ class SubItemValuePerItem
return m_values[m_host_row_map(size_t{item_id}) + i]; return m_values[m_host_row_map(size_t{item_id}) + i];
} }
PUGS_INLINE
size_t
numberOfValues() const noexcept(NO_ASSERT)
{
Assert(this->isBuilt());
return m_values.size();
}
// Following Kokkos logic, these classes are view and const view does allow // Following Kokkos logic, these classes are view and const view does allow
// changes in data // changes in data
template <typename ArrayIndexType> template <typename ArrayIndexType>
DataType& operator[](const ArrayIndexType& i) const noexcept(NO_ASSERT) DataType&
operator[](const ArrayIndexType& i) const noexcept(NO_ASSERT)
{ {
static_assert(std::is_integral_v<ArrayIndexType>, "index must be an integral type"); static_assert(std::is_integral_v<ArrayIndexType>, "index must be an integral type");
Assert(this->isBuilt()); Assert(this->isBuilt());
...@@ -128,13 +132,21 @@ class SubItemValuePerItem ...@@ -128,13 +132,21 @@ class SubItemValuePerItem
return m_values[i]; return m_values[i];
} }
PUGS_INLINE
size_t
numberOfValues() const noexcept(NO_ASSERT)
{
Assert(this->isBuilt());
return m_values.size();
}
PUGS_INLINE PUGS_INLINE
size_t size_t
numberOfItems() const noexcept(NO_ASSERT) numberOfItems() const noexcept(NO_ASSERT)
{ {
Assert(this->isBuilt()); Assert(this->isBuilt());
Assert(m_host_row_map.extent(0) != 0); Assert(m_host_row_map.extent(0) > 0);
return m_host_row_map.extent(0); return m_host_row_map.extent(0) - 1;
} }
template <typename IndexType> template <typename IndexType>
...@@ -143,7 +155,7 @@ class SubItemValuePerItem ...@@ -143,7 +155,7 @@ class SubItemValuePerItem
{ {
static_assert(std::is_same_v<IndexType, ItemId>, "index must be an ItemId"); static_assert(std::is_same_v<IndexType, ItemId>, "index must be an ItemId");
Assert(this->isBuilt()); Assert(this->isBuilt());
Assert(item_id < m_host_row_map.extent(0)); Assert(item_id < this->numberOfItems());
return m_host_row_map(size_t{item_id} + 1) - m_host_row_map(size_t{item_id}); return m_host_row_map(size_t{item_id} + 1) - m_host_row_map(size_t{item_id});
} }
...@@ -153,7 +165,7 @@ class SubItemValuePerItem ...@@ -153,7 +165,7 @@ class SubItemValuePerItem
{ {
static_assert(std::is_same_v<IndexType, ItemId>, "index must be an ItemId"); static_assert(std::is_same_v<IndexType, ItemId>, "index must be an ItemId");
Assert(this->isBuilt()); Assert(this->isBuilt());
Assert(item_id < m_host_row_map.extent(0)); Assert(item_id < this->numberOfItems());
const auto& item_begin = m_host_row_map(size_t{item_id}); 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); const auto& item_end = m_host_row_map(size_t{item_id} + 1);
return SubView(m_values, item_begin, item_end); return SubView(m_values, item_begin, item_end);
...@@ -167,7 +179,7 @@ class SubItemValuePerItem ...@@ -167,7 +179,7 @@ class SubItemValuePerItem
{ {
static_assert(std::is_same_v<IndexType, ItemId>, "index must be an ItemId"); static_assert(std::is_same_v<IndexType, ItemId>, "index must be an ItemId");
Assert(this->isBuilt()); Assert(this->isBuilt());
Assert(item_id < m_host_row_map.extent(0)); Assert(item_id < this->numberOfItems());
const auto& item_begin = m_host_row_map(size_t{item_id}); 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); const auto& item_end = m_host_row_map(size_t{item_id} + 1);
return SubView(m_values, item_begin, item_end); return SubView(m_values, item_begin, item_end);
......
tests/CMakeLists.txt
+ 1
− 0
View file @ e8b20dee
...@@ -102,6 +102,7 @@ add_executable (mpi_unit_tests ...@@ -102,6 +102,7 @@ add_executable (mpi_unit_tests
test_Partitioner.cpp test_Partitioner.cpp
test_ItemValue.cpp test_ItemValue.cpp
test_ItemValueUtils.cpp test_ItemValueUtils.cpp
test_SubItemValuePerItem.cpp
) )
add_library(test_Pugs_MeshDataBase add_library(test_Pugs_MeshDataBase
......
tests/test_SubItemValuePerItem.cpp 0 → 100644
+ 595
− 0
View file @ e8b20dee
#include <catch2/catch_test_macros.hpp>
#include <catch2/matchers/catch_matchers_all.hpp>
#include <MeshDataBaseForTests.hpp>
#include <mesh/Connectivity.hpp>
#include <mesh/Mesh.hpp>
#include <mesh/SubItemValuePerItem.hpp>
#include <utils/Messenger.hpp>
// Instantiate to ensure full coverage is performed
template class SubItemValuePerItem<size_t, NodeOfCell>;
// clazy:excludeall=non-pod-global-static
TEST_CASE("SubItemValuePerItem", "[mesh]")
{
SECTION("default constructors")
{
REQUIRE_NOTHROW(NodeValuePerEdge<int>{});
REQUIRE_NOTHROW(NodeValuePerFace<int>{});
REQUIRE_NOTHROW(NodeValuePerCell<int>{});
REQUIRE_NOTHROW(EdgeValuePerNode<int>{});
REQUIRE_NOTHROW(EdgeValuePerFace<int>{});
REQUIRE_NOTHROW(EdgeValuePerCell<int>{});
REQUIRE_NOTHROW(FaceValuePerNode<int>{});
REQUIRE_NOTHROW(FaceValuePerEdge<int>{});
REQUIRE_NOTHROW(FaceValuePerCell<int>{});
REQUIRE_NOTHROW(CellValuePerNode<int>{});
REQUIRE_NOTHROW(CellValuePerEdge<int>{});
REQUIRE_NOTHROW(CellValuePerFace<int>{});
REQUIRE(not NodeValuePerEdge<int>{}.isBuilt());
REQUIRE(not NodeValuePerFace<int>{}.isBuilt());
REQUIRE(not NodeValuePerCell<int>{}.isBuilt());
REQUIRE(not EdgeValuePerNode<int>{}.isBuilt());
REQUIRE(not EdgeValuePerFace<int>{}.isBuilt());
REQUIRE(not EdgeValuePerCell<int>{}.isBuilt());
REQUIRE(not FaceValuePerNode<int>{}.isBuilt());
REQUIRE(not FaceValuePerEdge<int>{}.isBuilt());
REQUIRE(not FaceValuePerCell<int>{}.isBuilt());
REQUIRE(not CellValuePerNode<int>{}.isBuilt());
REQUIRE(not CellValuePerEdge<int>{}.isBuilt());
REQUIRE(not CellValuePerFace<int>{}.isBuilt());
}
SECTION("dimensions")
{
auto number_of_values = [](const auto& sub_item_value_per_item) -> size_t {
using SubItemValuePerItemType = std::decay_t<decltype(sub_item_value_per_item)>;
using ItemId = typename SubItemValuePerItemType::ItemId;
size_t number = 0;
for (ItemId item_id = 0; item_id < sub_item_value_per_item.numberOfItems(); ++item_id) {
number += sub_item_value_per_item.numberOfSubValues(item_id);
}
return number;
};
SECTION("1D")
{
const Mesh<Connectivity<1>>& mesh_1d = MeshDataBaseForTests::get().cartesianMesh<1>();
const Connectivity<1>& connectivity = mesh_1d.connectivity();
SECTION("per cell")
{
NodeValuePerCell<int> node_value_per_cell{connectivity};
REQUIRE(node_value_per_cell.numberOfItems() == connectivity.numberOfCells());
REQUIRE(node_value_per_cell.numberOfValues() == number_of_values(node_value_per_cell));
auto cell_to_node_matrix = connectivity.cellToNodeMatrix();
for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
REQUIRE(cell_to_node_matrix[cell_id].size() == node_value_per_cell.numberOfSubValues(cell_id));
REQUIRE(node_value_per_cell.itemValues(cell_id).size() == node_value_per_cell.numberOfSubValues(cell_id));
}
const NodeValuePerCell<const int> const_node_value_per_cell = node_value_per_cell;
for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
REQUIRE(const_node_value_per_cell.itemValues(cell_id).size() ==
node_value_per_cell.numberOfSubValues(cell_id));
}
EdgeValuePerCell<int> edge_value_per_cell{connectivity};
REQUIRE(edge_value_per_cell.numberOfItems() == connectivity.numberOfCells());
REQUIRE(edge_value_per_cell.numberOfValues() == number_of_values(edge_value_per_cell));
auto cell_to_edge_matrix = connectivity.cellToEdgeMatrix();
for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
REQUIRE(cell_to_edge_matrix[cell_id].size() == edge_value_per_cell.numberOfSubValues(cell_id));
}
FaceValuePerCell<int> face_value_per_cell{connectivity};
REQUIRE(face_value_per_cell.numberOfItems() == connectivity.numberOfCells());
REQUIRE(face_value_per_cell.numberOfValues() == number_of_values(face_value_per_cell));
auto cell_to_face_matrix = connectivity.cellToFaceMatrix();
for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
REQUIRE(cell_to_face_matrix[cell_id].size() == face_value_per_cell.numberOfSubValues(cell_id));
}
}
SECTION("per face")
{
CellValuePerFace<int> cell_value_per_face{connectivity};
REQUIRE(cell_value_per_face.numberOfItems() == connectivity.numberOfFaces());
REQUIRE(cell_value_per_face.numberOfValues() == number_of_values(cell_value_per_face));
auto face_to_cell_matrix = connectivity.faceToCellMatrix();
for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
REQUIRE(face_to_cell_matrix[face_id].size() == cell_value_per_face.numberOfSubValues(face_id));
}
}
SECTION("per edge")
{
CellValuePerEdge<int> cell_value_per_edge{connectivity};
REQUIRE(cell_value_per_edge.numberOfItems() == connectivity.numberOfEdges());
REQUIRE(cell_value_per_edge.numberOfValues() == number_of_values(cell_value_per_edge));
auto edge_to_cell_matrix = connectivity.edgeToCellMatrix();
for (EdgeId edge_id = 0; edge_id < connectivity.numberOfEdges(); ++edge_id) {
REQUIRE(edge_to_cell_matrix[edge_id].size() == cell_value_per_edge.numberOfSubValues(edge_id));
}
}
SECTION("per node")
{
CellValuePerNode<int> cell_value_per_node{connectivity};
REQUIRE(cell_value_per_node.numberOfItems() == connectivity.numberOfNodes());
REQUIRE(cell_value_per_node.numberOfValues() == number_of_values(cell_value_per_node));
auto node_to_cell_matrix = connectivity.nodeToCellMatrix();
for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) {
REQUIRE(node_to_cell_matrix[node_id].size() == cell_value_per_node.numberOfSubValues(node_id));
}
}
}
SECTION("2D")
{
const Mesh<Connectivity<2>>& mesh_2d = MeshDataBaseForTests::get().cartesianMesh<2>();
const Connectivity<2>& connectivity = mesh_2d.connectivity();
SECTION("per cell")
{
NodeValuePerCell<int> node_value_per_cell{connectivity};
REQUIRE(node_value_per_cell.numberOfItems() == connectivity.numberOfCells());
REQUIRE(node_value_per_cell.numberOfValues() == number_of_values(node_value_per_cell));
auto cell_to_node_matrix = connectivity.cellToNodeMatrix();
for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
REQUIRE(cell_to_node_matrix[cell_id].size() == node_value_per_cell.numberOfSubValues(cell_id));
}
EdgeValuePerCell<int> edge_value_per_cell{connectivity};
REQUIRE(edge_value_per_cell.numberOfItems() == connectivity.numberOfCells());
REQUIRE(edge_value_per_cell.numberOfValues() == number_of_values(edge_value_per_cell));
auto cell_to_edge_matrix = connectivity.cellToEdgeMatrix();
for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
REQUIRE(cell_to_edge_matrix[cell_id].size() == edge_value_per_cell.numberOfSubValues(cell_id));
}
FaceValuePerCell<int> face_value_per_cell{connectivity};
REQUIRE(face_value_per_cell.numberOfItems() == connectivity.numberOfCells());
REQUIRE(face_value_per_cell.numberOfValues() == number_of_values(face_value_per_cell));
auto cell_to_face_matrix = connectivity.cellToFaceMatrix();
for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
REQUIRE(cell_to_face_matrix[cell_id].size() == face_value_per_cell.numberOfSubValues(cell_id));
}
}
SECTION("per face")
{
CellValuePerFace<int> cell_value_per_face{connectivity};
REQUIRE(cell_value_per_face.numberOfItems() == connectivity.numberOfFaces());
REQUIRE(cell_value_per_face.numberOfValues() == number_of_values(cell_value_per_face));
auto face_to_cell_matrix = connectivity.faceToCellMatrix();
for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
REQUIRE(face_to_cell_matrix[face_id].size() == cell_value_per_face.numberOfSubValues(face_id));
}
NodeValuePerFace<int> node_value_per_face{connectivity};
REQUIRE(node_value_per_face.numberOfItems() == connectivity.numberOfFaces());
REQUIRE(node_value_per_face.numberOfValues() == number_of_values(node_value_per_face));
auto face_to_node_matrix = connectivity.faceToNodeMatrix();
for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
REQUIRE(face_to_node_matrix[face_id].size() == node_value_per_face.numberOfSubValues(face_id));
}
}
SECTION("per edge")
{
CellValuePerEdge<int> cell_value_per_edge{connectivity};
REQUIRE(cell_value_per_edge.numberOfItems() == connectivity.numberOfEdges());
REQUIRE(cell_value_per_edge.numberOfValues() == number_of_values(cell_value_per_edge));
auto edge_to_cell_matrix = connectivity.edgeToCellMatrix();
for (EdgeId edge_id = 0; edge_id < connectivity.numberOfEdges(); ++edge_id) {
REQUIRE(edge_to_cell_matrix[edge_id].size() == cell_value_per_edge.numberOfSubValues(edge_id));
}
NodeValuePerEdge<int> node_value_per_edge{connectivity};
REQUIRE(node_value_per_edge.numberOfItems() == connectivity.numberOfEdges());
REQUIRE(node_value_per_edge.numberOfValues() == number_of_values(node_value_per_edge));
auto edge_to_node_matrix = connectivity.edgeToNodeMatrix();
for (EdgeId edge_id = 0; edge_id < connectivity.numberOfEdges(); ++edge_id) {
REQUIRE(edge_to_node_matrix[edge_id].size() == node_value_per_edge.numberOfSubValues(edge_id));
}
}
SECTION("per node")
{
EdgeValuePerNode<int> edge_value_per_node{connectivity};
REQUIRE(edge_value_per_node.numberOfItems() == connectivity.numberOfNodes());
REQUIRE(edge_value_per_node.numberOfValues() == number_of_values(edge_value_per_node));
auto node_to_edge_matrix = connectivity.nodeToEdgeMatrix();
for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) {
REQUIRE(node_to_edge_matrix[node_id].size() == edge_value_per_node.numberOfSubValues(node_id));
}
FaceValuePerNode<int> face_value_per_node{connectivity};
REQUIRE(face_value_per_node.numberOfItems() == connectivity.numberOfNodes());
REQUIRE(face_value_per_node.numberOfValues() == number_of_values(face_value_per_node));
auto node_to_face_matrix = connectivity.nodeToFaceMatrix();
for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) {
REQUIRE(node_to_face_matrix[node_id].size() == face_value_per_node.numberOfSubValues(node_id));
}
CellValuePerNode<int> cell_value_per_node{connectivity};
REQUIRE(cell_value_per_node.numberOfItems() == connectivity.numberOfNodes());
REQUIRE(cell_value_per_node.numberOfValues() == number_of_values(cell_value_per_node));
auto node_to_cell_matrix = connectivity.nodeToCellMatrix();
for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) {
REQUIRE(node_to_cell_matrix[node_id].size() == cell_value_per_node.numberOfSubValues(node_id));
}
}
}
SECTION("3D")
{
const Mesh<Connectivity<3>>& mesh_3d = MeshDataBaseForTests::get().cartesianMesh<3>();
const Connectivity<3>& connectivity = mesh_3d.connectivity();
SECTION("per cell")
{
NodeValuePerCell<int> node_value_per_cell{connectivity};
REQUIRE(node_value_per_cell.numberOfItems() == connectivity.numberOfCells());
REQUIRE(node_value_per_cell.numberOfValues() == number_of_values(node_value_per_cell));
auto cell_to_node_matrix = connectivity.cellToNodeMatrix();
for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
REQUIRE(cell_to_node_matrix[cell_id].size() == node_value_per_cell.numberOfSubValues(cell_id));
}
EdgeValuePerCell<int> edge_value_per_cell{connectivity};
REQUIRE(edge_value_per_cell.numberOfItems() == connectivity.numberOfCells());
REQUIRE(edge_value_per_cell.numberOfValues() == number_of_values(edge_value_per_cell));
auto cell_to_edge_matrix = connectivity.cellToEdgeMatrix();
for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
REQUIRE(cell_to_edge_matrix[cell_id].size() == edge_value_per_cell.numberOfSubValues(cell_id));
}
FaceValuePerCell<int> face_value_per_cell{connectivity};
REQUIRE(face_value_per_cell.numberOfItems() == connectivity.numberOfCells());
REQUIRE(face_value_per_cell.numberOfValues() == number_of_values(face_value_per_cell));
auto cell_to_face_matrix = connectivity.cellToFaceMatrix();
for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
REQUIRE(cell_to_face_matrix[cell_id].size() == face_value_per_cell.numberOfSubValues(cell_id));
}
}
SECTION("per face")
{
CellValuePerFace<int> cell_value_per_face{connectivity};
REQUIRE(cell_value_per_face.numberOfItems() == connectivity.numberOfFaces());
REQUIRE(cell_value_per_face.numberOfValues() == number_of_values(cell_value_per_face));
auto face_to_cell_matrix = connectivity.faceToCellMatrix();
for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
REQUIRE(face_to_cell_matrix[face_id].size() == cell_value_per_face.numberOfSubValues(face_id));
}
EdgeValuePerFace<int> edge_value_per_face{connectivity};
REQUIRE(edge_value_per_face.numberOfItems() == connectivity.numberOfFaces());
REQUIRE(edge_value_per_face.numberOfValues() == number_of_values(edge_value_per_face));
auto face_to_edge_matrix = connectivity.faceToEdgeMatrix();
for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
REQUIRE(face_to_edge_matrix[face_id].size() == edge_value_per_face.numberOfSubValues(face_id));
}
NodeValuePerFace<int> node_value_per_face{connectivity};
REQUIRE(node_value_per_face.numberOfItems() == connectivity.numberOfFaces());
REQUIRE(node_value_per_face.numberOfValues() == number_of_values(node_value_per_face));
auto face_to_node_matrix = connectivity.faceToNodeMatrix();
for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
REQUIRE(face_to_node_matrix[face_id].size() == node_value_per_face.numberOfSubValues(face_id));
}
}
SECTION("per edge")
{
CellValuePerEdge<int> cell_value_per_edge{connectivity};
REQUIRE(cell_value_per_edge.numberOfItems() == connectivity.numberOfEdges());
REQUIRE(cell_value_per_edge.numberOfValues() == number_of_values(cell_value_per_edge));
auto edge_to_cell_matrix = connectivity.edgeToCellMatrix();
for (EdgeId edge_id = 0; edge_id < connectivity.numberOfEdges(); ++edge_id) {
REQUIRE(edge_to_cell_matrix[edge_id].size() == cell_value_per_edge.numberOfSubValues(edge_id));
}
FaceValuePerEdge<int> face_value_per_edge{connectivity};
REQUIRE(face_value_per_edge.numberOfItems() == connectivity.numberOfEdges());
REQUIRE(face_value_per_edge.numberOfValues() == number_of_values(face_value_per_edge));
auto edge_to_face_matrix = connectivity.edgeToFaceMatrix();
for (EdgeId edge_id = 0; edge_id < connectivity.numberOfEdges(); ++edge_id) {
REQUIRE(edge_to_face_matrix[edge_id].size() == face_value_per_edge.numberOfSubValues(edge_id));
}
NodeValuePerEdge<int> node_value_per_edge{connectivity};
REQUIRE(node_value_per_edge.numberOfItems() == connectivity.numberOfEdges());
REQUIRE(node_value_per_edge.numberOfValues() == number_of_values(node_value_per_edge));
auto edge_to_node_matrix = connectivity.edgeToNodeMatrix();
for (EdgeId edge_id = 0; edge_id < connectivity.numberOfEdges(); ++edge_id) {
REQUIRE(edge_to_node_matrix[edge_id].size() == node_value_per_edge.numberOfSubValues(edge_id));
}
}
SECTION("per node")
{
EdgeValuePerNode<int> edge_value_per_node{connectivity};
REQUIRE(edge_value_per_node.numberOfItems() == connectivity.numberOfNodes());
REQUIRE(edge_value_per_node.numberOfValues() == number_of_values(edge_value_per_node));
auto node_to_edge_matrix = connectivity.nodeToEdgeMatrix();
for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) {
REQUIRE(node_to_edge_matrix[node_id].size() == edge_value_per_node.numberOfSubValues(node_id));
}
FaceValuePerNode<int> face_value_per_node{connectivity};
REQUIRE(face_value_per_node.numberOfItems() == connectivity.numberOfNodes());
REQUIRE(face_value_per_node.numberOfValues() == number_of_values(face_value_per_node));
auto node_to_face_matrix = connectivity.nodeToFaceMatrix();
for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) {
REQUIRE(node_to_face_matrix[node_id].size() == face_value_per_node.numberOfSubValues(node_id));
}
CellValuePerNode<int> cell_value_per_node{connectivity};
REQUIRE(cell_value_per_node.numberOfItems() == connectivity.numberOfNodes());
REQUIRE(cell_value_per_node.numberOfValues() == number_of_values(cell_value_per_node));
auto node_to_cell_matrix = connectivity.nodeToCellMatrix();
for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) {
REQUIRE(node_to_cell_matrix[node_id].size() == cell_value_per_node.numberOfSubValues(node_id));
}
}
}
}
SECTION("array view")
{
SECTION("1D")
{
const Mesh<Connectivity<1>>& mesh_1d = MeshDataBaseForTests::get().cartesianMesh<1>();
const Connectivity<1>& connectivity = mesh_1d.connectivity();
EdgeValuePerCell<size_t> edge_values_per_cell{connectivity};
{
size_t value = 0;
for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
for (size_t i_edge = 0; i_edge < edge_values_per_cell.numberOfSubValues(cell_id); ++i_edge) {
edge_values_per_cell(cell_id, i_edge) = value++;
}
}
}
for (size_t i = 0; i < edge_values_per_cell.numberOfValues(); ++i) {
REQUIRE(edge_values_per_cell[i] == i);
}
for (size_t i = 0; i < edge_values_per_cell.numberOfValues(); ++i) {
edge_values_per_cell[i] = i * i + 1;
}
{
size_t i = 0;
for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
for (size_t i_edge = 0; i_edge < edge_values_per_cell.numberOfSubValues(cell_id); ++i_edge, ++i) {
REQUIRE(edge_values_per_cell(cell_id, i_edge) == i * i + 1);
}
}
}
}
SECTION("2D")
{
const Mesh<Connectivity<2>>& mesh_2d = MeshDataBaseForTests::get().cartesianMesh<2>();
const Connectivity<2>& connectivity = mesh_2d.connectivity();
CellValuePerFace<size_t> cell_values_per_face{connectivity};
{
size_t value = 0;
for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
for (size_t i_cell = 0; i_cell < cell_values_per_face.numberOfSubValues(face_id); ++i_cell) {
cell_values_per_face(face_id, i_cell) = value++;
}
}
}
for (size_t i = 0; i < cell_values_per_face.numberOfValues(); ++i) {
REQUIRE(cell_values_per_face[i] == i);
}
for (size_t i = 0; i < cell_values_per_face.numberOfValues(); ++i) {
cell_values_per_face[i] = 3 * i + 1;
}
{
size_t i = 0;
for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
for (size_t i_cell = 0; i_cell < cell_values_per_face.numberOfSubValues(face_id); ++i_cell, ++i) {
REQUIRE(cell_values_per_face(face_id, i_cell) == 3 * i + 1);
}
}
}
}
SECTION("3D")
{
const Mesh<Connectivity<3>>& mesh_3d = MeshDataBaseForTests::get().cartesianMesh<3>();
const Connectivity<3>& connectivity = mesh_3d.connectivity();
FaceValuePerNode<size_t> face_values_per_node{connectivity};
{
size_t value = 0;
for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) {
for (size_t i_face = 0; i_face < face_values_per_node.numberOfSubValues(node_id); ++i_face) {
face_values_per_node.itemValues(node_id)[i_face] = value++;
}
}
}
for (size_t i = 0; i < face_values_per_node.numberOfValues(); ++i) {
REQUIRE(face_values_per_node[i] == i);
}
for (size_t i = 0; i < face_values_per_node.numberOfValues(); ++i) {
face_values_per_node[i] = 3 + i * i;
}
{
size_t i = 0;
for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) {
for (size_t i_face = 0; i_face < face_values_per_node.numberOfSubValues(node_id); ++i_face, ++i) {
face_values_per_node(node_id, i_face) = 3 + i * i;
}
}
}
{
size_t i = 0;
for (NodeId node_id = 0; node_id < connectivity.numberOfNodes(); ++node_id) {
for (size_t i_face = 0; i_face < face_values_per_node.numberOfSubValues(node_id); ++i_face, ++i) {
face_values_per_node.itemValues(node_id)[i_face] = 3 + i * i;
}
}
}
}
}
SECTION("copy")
{
const Mesh<Connectivity<3>>& mesh_3d = MeshDataBaseForTests::get().cartesianMesh<3>();
const Connectivity<3>& connectivity = mesh_3d.connectivity();
NodeValuePerCell<size_t> node_value_per_cell{connectivity};
{
size_t value = 0;
for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
for (size_t i_node = 0; i_node < node_value_per_cell.numberOfSubValues(cell_id); ++i_node) {
node_value_per_cell.itemValues(cell_id)[i_node] = value++;
}
}
}
NodeValuePerCell<size_t> copy_node_value_per_cell = copy(node_value_per_cell);
{
bool is_same = true;
for (size_t i = 0; i < copy_node_value_per_cell.numberOfValues(); ++i) {
is_same &= (copy_node_value_per_cell[i] == node_value_per_cell[i]);
}
REQUIRE(is_same);
}
{
for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
for (size_t i_node = 0; i_node < node_value_per_cell.numberOfSubValues(cell_id); ++i_node) {
node_value_per_cell.itemValues(cell_id)[i_node] = i_node;
}
}
}
{
bool is_same = true;
for (size_t i = 0; i < copy_node_value_per_cell.numberOfValues(); ++i) {
is_same &= (copy_node_value_per_cell[i] == node_value_per_cell[i]);
}
REQUIRE(not is_same);
}
}
SECTION("WeakItemValue")
{
// const Mesh<Connectivity<2>>& mesh_2d = MeshDataBaseForTests::get().cartesianMesh<2>();
// const Connectivity<2>& connectivity = mesh_2d.connectivity();
// WeakFaceValue<int> weak_face_value{connectivity};
// weak_face_value.fill(parallel::rank());
// FaceValue<const int> face_value{weak_face_value};
// REQUIRE(face_value.connectivity_ptr() == weak_face_value.connectivity_ptr());
}
#ifndef NDEBUG
SECTION("error")
{
SECTION("checking for build ItemValue")
{
// CellValue<int> cell_value;
// REQUIRE_THROWS_AS(cell_value[CellId{0}], AssertError);
// FaceValue<int> face_value;
// REQUIRE_THROWS_AS(face_value[FaceId{0}], AssertError);
// EdgeValue<int> edge_value;
// REQUIRE_THROWS_AS(edge_value[EdgeId{0}], AssertError);
// NodeValue<int> node_value;
// REQUIRE_THROWS_AS(node_value[NodeId{0}], AssertError);
}
SECTION("checking for bounds violation")
{
// const Mesh<Connectivity<3>>& mesh_3d = MeshDataBaseForTests::get().cartesianMesh<3>();
// const Connectivity<3>& connectivity = mesh_3d.connectivity();
// CellValue<int> cell_value{connectivity};
// CellId invalid_cell_id = connectivity.numberOfCells();
// REQUIRE_THROWS_AS(cell_value[invalid_cell_id], AssertError);
// FaceValue<int> face_value{connectivity};
// FaceId invalid_face_id = connectivity.numberOfFaces();
// REQUIRE_THROWS_AS(face_value[invalid_face_id], AssertError);
// EdgeValue<int> edge_value{connectivity};
// EdgeId invalid_edge_id = connectivity.numberOfEdges();
// REQUIRE_THROWS_AS(edge_value[invalid_edge_id], AssertError);
// NodeValue<int> node_value{connectivity};
// NodeId invalid_node_id = connectivity.numberOfNodes();
// REQUIRE_THROWS_AS(node_value[invalid_node_id], AssertError);
}
SECTION("set values from invalid array size")
{
// const Mesh<Connectivity<3>>& mesh_3d = MeshDataBaseForTests::get().cartesianMesh<3>();
// const Connectivity<3>& connectivity = mesh_3d.connectivity();
// CellValue<size_t> cell_value{connectivity};
// Array<size_t> values{3 + cell_value.size()};
// REQUIRE_THROWS_AS(cell_value = values, AssertError);
}
}
#endif // NDEBUG
}
tests/test_SubItemValuePerItem.hpp 0 → 100644
+ 1
− 0
View file @ e8b20dee
edge_values_per_faceedge_values_per_faceedge_values_per_faceedge_values_per_faceedge_values_per_face
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment