TestLineMesh.cpp
/**
* \file
* \copyright
* Copyright (c) 2012-2021, OpenGeoSys Community (http://www.opengeosys.org)
* Distributed under a Modified BSD License.
* See accompanying file LICENSE.txt or
* http://www.opengeosys.org/project/license
*/
#include <gtest/gtest.h>
#include <ctime>
#include "MeshLib/Elements/Line.h"
#include "MeshLib/Mesh.h"
#include "MeshLib/MeshGenerators/MeshGenerator.h"
class MeshLibLineMesh : public ::testing::Test
{
public:
MeshLibLineMesh()
{
mesh = MeshLib::MeshGenerator::generateLineMesh(extent, mesh_size);
}
~MeshLibLineMesh() override { delete mesh; }
static std::size_t const mesh_size = 9;
double extent = 1.0;
MeshLib::Mesh const* mesh{nullptr};
};
std::size_t const MeshLibLineMesh::mesh_size;
TEST_F(MeshLibLineMesh, Construction)
{
ASSERT_TRUE(mesh != nullptr);
// There are mesh_size elements in the mesh.
ASSERT_EQ(mesh_size, mesh->getNumberOfElements());
// There are mesh_size+1 nodes in the mesh.
ASSERT_EQ(mesh_size + 1, mesh->getNumberOfNodes());
// All elements have maximum two neighbors.
std::vector<MeshLib::Element*> const& elements = mesh->getElements();
for (auto e : elements)
{
ASSERT_EQ(2u, e->getNumberOfNeighbors());
}
ASSERT_NEAR(extent / mesh_size, mesh->getMinEdgeLength(),
std::numeric_limits<double>::epsilon());
ASSERT_NEAR(extent / mesh_size, mesh->getMaxEdgeLength(),
std::numeric_limits<double>::epsilon());
}
TEST_F(MeshLibLineMesh, ElementNeigbors)
{
auto count_neighbors = [](MeshLib::Element const* const e)
{
unsigned count = 0;
for (int i = 0; i < 2; i++)
{
if (e->getNeighbor(i) != nullptr)
{
count++;
}
}
return count;
};
std::vector<MeshLib::Element*> const& elements = mesh->getElements();
// Each element has two neighbors n-1 and n+1 except the first and the last
// elements.
ASSERT_EQ(1u, count_neighbors(elements.front()));
ASSERT_EQ(1u, count_neighbors(elements.back()));
ASSERT_TRUE(areNeighbors(elements.front(), elements[1]));
ASSERT_TRUE(areNeighbors(elements.back(), elements[elements.size() - 2]));
for (std::size_t i = 1; i < elements.size() - 1; ++i)
{
ASSERT_EQ(2u, count_neighbors(elements[i]));
ASSERT_TRUE(areNeighbors(elements[i], elements[i - 1]));
ASSERT_TRUE(areNeighbors(elements[i], elements[i + 1]));
}
}
TEST_F(MeshLibLineMesh, ElementToNodeConnectivity)
{
std::vector<MeshLib::Element*> const& elements = mesh->getElements();
// Each element n of the line mesh is formed by nodes n and n+1.
for (std::size_t i = 0; i < elements.size(); ++i)
{
// An element consists of two nodes n and n+1
ASSERT_EQ(2u, elements[i]->getNumberOfBaseNodes());
ASSERT_EQ(i, elements[i]->getNode(0)->getID());
ASSERT_EQ(i + 1, elements[i]->getNode(1)->getID());
}
}
TEST_F(MeshLibLineMesh, NodeToElementConnectivity)
{
std::vector<MeshLib::Node*> const& nodes = mesh->getNodes();
std::vector<MeshLib::Element*> const& elements = mesh->getElements();
// Each node n of the line mesh is connected to two elements n-1 and n,
// except the first and last nodes.
ASSERT_EQ(1u, mesh->getElementsConnectedToNode(*nodes.front()).size());
ASSERT_EQ(elements[0], mesh->getElementsConnectedToNode(*nodes.front())[0]);
ASSERT_EQ(1u, mesh->getElementsConnectedToNode(*nodes.back()).size());
ASSERT_EQ(elements.back(),
mesh->getElementsConnectedToNode(*nodes.back())[0]);
for (std::size_t i = 1; i < nodes.size() - 1; ++i)
{
ASSERT_EQ(2u, mesh->getElementsConnectedToNode(*nodes[i]).size());
ASSERT_EQ(elements[i - 1],
mesh->getElementsConnectedToNode(*nodes[i])[0]);
ASSERT_EQ(elements[i], mesh->getElementsConnectedToNode(*nodes[i])[1]);
}
}