Forked from
ogs / ogs
23591 commits behind the upstream repository.
-
Tom Fischer authored
Moved functionality of FixedSearchLength to SearchLength.
Tom Fischer authoredMoved functionality of FixedSearchLength to SearchLength.
Code owners
Assign users and groups as approvers for specific file changes. Learn more.
TestMeshNodeSearch.cpp 12.24 KiB
/**
* @file TestMeshNodeSearch.cpp
* @author git blame TestMeshNodeSearch.cpp
* @date Oct 28, 2013
* @brief Test the implementation of class MeshNodeSearch.
*
* @copyright
* Copyright (c) 2012-2014, OpenGeoSys Community (http://www.opengeosys.org)
* Distributed under a Modified BSD License.
* See accompanying file LICENSE.txt or
* http://www.opengeosys.org/LICENSE.txt
*/
#include "gtest/gtest.h"
#include <memory>
#include "Mesh.h"
#include "MeshGenerators/MeshGenerator.h"
#include "MeshGeoToolsLib/MeshNodeSearcher.h"
#include "MeshGeoToolsLib/HeuristicSearchLength.h"
using namespace MeshLib;
class MeshLibMeshNodeSearchInSimpleQuadMesh : public testing::Test
{
public:
MeshLibMeshNodeSearchInSimpleQuadMesh() :
_geometric_size(10.0), _number_of_subdivisions_per_direction(99),
_quad_mesh(MeshGenerator::generateRegularQuadMesh(_geometric_size, _number_of_subdivisions_per_direction))
{}
~MeshLibMeshNodeSearchInSimpleQuadMesh()
{
delete _quad_mesh;
}
protected:
const double _geometric_size;
const std::size_t _number_of_subdivisions_per_direction;
Mesh* _quad_mesh;
};
class MeshLibMeshNodeSearchInSimpleHexMesh : public testing::Test
{
public:
MeshLibMeshNodeSearchInSimpleHexMesh() :
_geometric_size(10.0), _number_of_subdivisions_per_direction(10),
_hex_mesh(MeshGenerator::generateRegularHexMesh(_geometric_size, _number_of_subdivisions_per_direction))
{}
~MeshLibMeshNodeSearchInSimpleHexMesh()
{
delete _hex_mesh;
}
protected:
const double _geometric_size;
const std::size_t _number_of_subdivisions_per_direction;
Mesh* _hex_mesh;
};
TEST_F(MeshLibMeshNodeSearchInSimpleQuadMesh, PointSearch)
{
ASSERT_TRUE(_quad_mesh != nullptr);
// 1 create a geometry
GeoLib::Point pnt(0.0, 0.0, 0.0);
// 2 perform search and compare results with expected vals
MeshGeoToolsLib::SearchLength search_length; MeshGeoToolsLib::MeshNodeSearcher mesh_node_searcher(*_quad_mesh,
search_length);
// find ORIGIN
ASSERT_EQ(0u, *mesh_node_searcher.getMeshNodeIDForPoint(pnt));
pnt[0] = 0.049;
pnt[1] = 0.049;
ASSERT_EQ(0u, *mesh_node_searcher.getMeshNodeIDForPoint(pnt));
pnt[0] = 0.051;
pnt[1] = 0.049;
ASSERT_EQ(1u, *mesh_node_searcher.getMeshNodeIDForPoint(pnt));
pnt[0] = 0.049;
pnt[1] = 0.051;
ASSERT_EQ(100u, *mesh_node_searcher.getMeshNodeIDForPoint(pnt));
pnt[0] = 0.051;
pnt[1] = 0.051;
ASSERT_EQ(101u, *mesh_node_searcher.getMeshNodeIDForPoint(pnt));
pnt[0] = 9.951;
pnt[1] = 9.951;
ASSERT_EQ((_number_of_subdivisions_per_direction+1) * (_number_of_subdivisions_per_direction+1) - 1, *mesh_node_searcher.getMeshNodeIDForPoint(pnt));
}
TEST_F(MeshLibMeshNodeSearchInSimpleQuadMesh, PolylineSearch)
{
ASSERT_TRUE(_quad_mesh != nullptr);
// create geometry
std::vector<GeoLib::Point*> pnts;
pnts.push_back(new GeoLib::Point(0.0, 0.0, 0.0));
pnts.push_back(new GeoLib::Point(_geometric_size, 0.0, 0.0));
pnts.push_back(new GeoLib::Point(0.0, 0.049, 0.0));
pnts.push_back(new GeoLib::Point(_geometric_size, 0.049, 0.0));
pnts.push_back(new GeoLib::Point(0.0, _geometric_size, 0.0));
pnts.push_back(new GeoLib::Point(_geometric_size, _geometric_size, 0.0));
pnts.push_back(new GeoLib::Point(0.0, _geometric_size - 0.049, 0.0));
pnts.push_back(new GeoLib::Point(_geometric_size, _geometric_size - 0.049, 0.0));
GeoLib::Polyline ply0(pnts);
ply0.addPoint(0);
ply0.addPoint(1);
// perform search and compare results with expected vals
MeshGeoToolsLib::HeuristicSearchLength search_length(*_quad_mesh);
MeshGeoToolsLib::MeshNodeSearcher mesh_node_searcher(*_quad_mesh,
search_length);
std::vector<std::size_t> const& found_ids_ply0(mesh_node_searcher.getMeshNodeIDsAlongPolyline(ply0));
ASSERT_EQ(100u, found_ids_ply0.size());
for (std::size_t k(0); k<found_ids_ply0.size(); k++)
ASSERT_EQ(k, found_ids_ply0[k]);
GeoLib::Polyline ply1(pnts);
ply1.addPoint(2);
ply1.addPoint(3);
std::vector<std::size_t> const& found_ids_ply1(mesh_node_searcher.getMeshNodeIDsAlongPolyline(ply1));
ASSERT_EQ(100u, found_ids_ply1.size());
for (std::size_t k(0); k<found_ids_ply1.size(); k++)
ASSERT_EQ(k, found_ids_ply1[k]);
GeoLib::Polyline ply2(pnts);
ply2.addPoint(4);
ply2.addPoint(5);
std::vector<std::size_t> const& found_ids_ply2(mesh_node_searcher.getMeshNodeIDsAlongPolyline(ply2));
std::size_t offset((_number_of_subdivisions_per_direction+1)*_number_of_subdivisions_per_direction); ASSERT_EQ(100u, found_ids_ply2.size());
for (std::size_t k(0); k<found_ids_ply2.size(); k++)
ASSERT_EQ(offset + k, found_ids_ply2[k]);
GeoLib::Polyline ply3(pnts);
ply3.addPoint(6);
ply3.addPoint(7);
std::vector<std::size_t> const& found_ids_ply3(mesh_node_searcher.getMeshNodeIDsAlongPolyline(ply3));
ASSERT_EQ(100u, found_ids_ply3.size());
for (std::size_t k(0); k<found_ids_ply3.size(); k++)
ASSERT_EQ(offset + k, found_ids_ply3[k]);
// left border
GeoLib::Polyline ply4(pnts);
ply4.addPoint(0);
ply4.addPoint(6);
std::vector<std::size_t> const& found_ids_ply4(mesh_node_searcher.getMeshNodeIDsAlongPolyline(ply4));
ASSERT_EQ(100u, found_ids_ply4.size());
for (std::size_t k(0); k<found_ids_ply4.size(); k++)
ASSERT_EQ(k*(_number_of_subdivisions_per_direction+1), found_ids_ply4[k]);
// right border
GeoLib::Polyline ply5(pnts);
ply5.addPoint(1);
ply5.addPoint(7);
std::vector<std::size_t> const& found_ids_ply5(mesh_node_searcher.getMeshNodeIDsAlongPolyline(ply5));
ASSERT_EQ(100u, found_ids_ply5.size());
for (std::size_t k(0); k<found_ids_ply5.size(); k++)
ASSERT_EQ(k*(_number_of_subdivisions_per_direction+1)+_number_of_subdivisions_per_direction, found_ids_ply5[k]);
// diagonal
GeoLib::Polyline ply6(pnts);
ply6.addPoint(0);
ply6.addPoint(5);
std::vector<std::size_t> const& found_ids_ply6(mesh_node_searcher.getMeshNodeIDsAlongPolyline(ply6));
ASSERT_EQ(100u, found_ids_ply6.size());
for (std::size_t k(0); k<found_ids_ply6.size(); k++)
ASSERT_EQ(k*(_number_of_subdivisions_per_direction+1)+k, found_ids_ply6[k]);
std::for_each(pnts.begin(), pnts.end(), [](GeoLib::Point* pnt) { delete pnt; });
}
TEST_F(MeshLibMeshNodeSearchInSimpleQuadMesh, SurfaceSearch)
{
ASSERT_TRUE(_quad_mesh != nullptr);
// create geometry
std::vector<GeoLib::Point*> pnts;
pnts.push_back(new GeoLib::Point(0.0, 0.0, 0.0));
pnts.push_back(new GeoLib::Point(_geometric_size, 0.0, 0.0));
pnts.push_back(new GeoLib::Point(_geometric_size, _geometric_size, 0.0));
pnts.push_back(new GeoLib::Point(0.0, _geometric_size, 0.0));
pnts.push_back(new GeoLib::Point(_geometric_size, 0.5*_geometric_size, 0.0));
pnts.push_back(new GeoLib::Point(0.0, 0.5*_geometric_size, 0.0));
MeshGeoToolsLib::SearchLength search_length;
MeshGeoToolsLib::MeshNodeSearcher mesh_node_searcher(*_quad_mesh,
search_length);
// entire domain
GeoLib::Polyline ply0(pnts);
ply0.addPoint(0);
ply0.addPoint(1);
ply0.addPoint(2);
ply0.addPoint(3);
ply0.addPoint(0);
std::unique_ptr<GeoLib::Surface> sfc0(GeoLib::Surface::createSurface(ply0));
std::vector<std::size_t> const& found_ids_sfc0(mesh_node_searcher.getMeshNodeIDsAlongSurface(*sfc0));
ASSERT_EQ(_quad_mesh->getNNodes(), found_ids_sfc0.size());
for (std::size_t k(0); k<found_ids_sfc0.size(); k++)
ASSERT_EQ(k, found_ids_sfc0[k]);
// bottom half domain
GeoLib::Polyline ply1(pnts);
ply1.addPoint(0);
ply1.addPoint(1);
ply1.addPoint(4);
ply1.addPoint(5);
ply1.addPoint(0);
std::unique_ptr<GeoLib::Surface> sfc1(GeoLib::Surface::createSurface(ply1));
std::vector<std::size_t> const& found_ids_sfc1(mesh_node_searcher.getMeshNodeIDsAlongSurface(*sfc1));
ASSERT_EQ(_quad_mesh->getNNodes()/2, found_ids_sfc1.size());
for (std::size_t k(0); k<found_ids_sfc1.size(); k++)
ASSERT_EQ(k, found_ids_sfc1[k]);
std::for_each(pnts.begin(), pnts.end(), [](GeoLib::Point* pnt) { delete pnt; });
}
TEST_F(MeshLibMeshNodeSearchInSimpleHexMesh, SurfaceSearch)
{
ASSERT_TRUE(_hex_mesh != nullptr);
// create geometry
std::vector<GeoLib::Point*> pnts;
pnts.push_back(new GeoLib::Point(0.0, 0.0, 0.0));
pnts.push_back(new GeoLib::Point(_geometric_size, 0.0, 0.0));
pnts.push_back(new GeoLib::Point(_geometric_size, _geometric_size, 0.0));
pnts.push_back(new GeoLib::Point(0.0, _geometric_size, 0.0));
pnts.push_back(new GeoLib::Point(0.0, 0.0, _geometric_size));
pnts.push_back(new GeoLib::Point(_geometric_size, 0.0, _geometric_size));
pnts.push_back(new GeoLib::Point(_geometric_size, _geometric_size, _geometric_size));
pnts.push_back(new GeoLib::Point(0.0, _geometric_size, _geometric_size));
MeshGeoToolsLib::SearchLength search_length;
MeshGeoToolsLib::MeshNodeSearcher mesh_node_searcher(*_hex_mesh,
search_length);
const std::size_t n_nodes_1d = _number_of_subdivisions_per_direction + 1;
const std::size_t n_nodes_2d = n_nodes_1d * n_nodes_1d;
const std::size_t n_nodes_3d = n_nodes_1d * n_nodes_1d * n_nodes_1d;
// bottom surface
GeoLib::Polyline ply_bottom(pnts);
ply_bottom.addPoint(0);
ply_bottom.addPoint(1);
ply_bottom.addPoint(2);
ply_bottom.addPoint(3);
ply_bottom.addPoint(0);
std::unique_ptr<GeoLib::Surface> sfc_bottom(GeoLib::Surface::createSurface(ply_bottom));
std::vector<std::size_t> const& found_ids_sfc_b(mesh_node_searcher.getMeshNodeIDsAlongSurface(*sfc_bottom));
ASSERT_EQ(n_nodes_2d, found_ids_sfc_b.size());
for (std::size_t k(0); k<found_ids_sfc_b.size(); k++)
ASSERT_EQ(k, found_ids_sfc_b[k]);
// top surface
GeoLib::Polyline ply_top(pnts);
ply_top.addPoint(4);
ply_top.addPoint(5);
ply_top.addPoint(6);
ply_top.addPoint(7);
ply_top.addPoint(4);
std::unique_ptr<GeoLib::Surface> sfc_top(GeoLib::Surface::createSurface(ply_top));
std::vector<std::size_t> const& found_ids_sfc_t(mesh_node_searcher.getMeshNodeIDsAlongSurface(*sfc_top));
ASSERT_EQ(n_nodes_2d, found_ids_sfc_t.size());
const std::size_t offset_t = n_nodes_3d - n_nodes_2d;
for (std::size_t k(0); k<found_ids_sfc_t.size(); k++)
ASSERT_EQ(offset_t + k, found_ids_sfc_t[k]);
// front
GeoLib::Polyline ply_front(pnts);
ply_front.addPoint(0);
ply_front.addPoint(1);
ply_front.addPoint(5);
ply_front.addPoint(4);
ply_front.addPoint(0);
std::unique_ptr<GeoLib::Surface> sfc_front(GeoLib::Surface::createSurface(ply_front));
std::vector<std::size_t> const& found_ids_sfc_f(mesh_node_searcher.getMeshNodeIDsAlongSurface(*sfc_front));
ASSERT_EQ(n_nodes_2d, found_ids_sfc_f.size());
std::size_t cnt=0;
for (std::size_t k(0); k<n_nodes_1d; k++) {
for (std::size_t i(0); i<n_nodes_1d; i++)
ASSERT_EQ(k*n_nodes_2d+i, found_ids_sfc_f[cnt++]);
}
// back
GeoLib::Polyline ply_back(pnts);
ply_back.addPoint(3);
ply_back.addPoint(2);
ply_back.addPoint(6);
ply_back.addPoint(7);
ply_back.addPoint(3);
std::unique_ptr<GeoLib::Surface> sfc_back(GeoLib::Surface::createSurface(ply_back));
std::vector<std::size_t> const& found_ids_sfc_back(mesh_node_searcher.getMeshNodeIDsAlongSurface(*sfc_back));
ASSERT_EQ(n_nodes_2d, found_ids_sfc_back.size());
cnt = 0;
const std::size_t y_offset = n_nodes_1d*(n_nodes_1d-1);
for (std::size_t k(0); k<n_nodes_1d; k++) {
const std::size_t z_offset = n_nodes_2d*k;
for (std::size_t i(0); i<n_nodes_1d; i++)
ASSERT_EQ(z_offset + y_offset + i, found_ids_sfc_back[cnt++]);
}
// left
GeoLib::Polyline ply_left(pnts);
ply_left.addPoint(0);
ply_left.addPoint(3);
ply_left.addPoint(7);
ply_left.addPoint(4);
ply_left.addPoint(0);
std::unique_ptr<GeoLib::Surface> sfc_left(GeoLib::Surface::createSurface(ply_left));
std::vector<std::size_t> const& found_ids_sfc_left(mesh_node_searcher.getMeshNodeIDsAlongSurface(*sfc_left));
ASSERT_EQ(n_nodes_2d, found_ids_sfc_left.size());
cnt = 0;
for (std::size_t k(0); k<n_nodes_1d; k++) {
const std::size_t z_offset = n_nodes_2d*k;
for (std::size_t j(0); j<n_nodes_1d; j++)
ASSERT_EQ(z_offset + j*n_nodes_1d, found_ids_sfc_left[cnt++]);
}
// right
GeoLib::Polyline ply_right(pnts);
ply_right.addPoint(1);
ply_right.addPoint(2);
ply_right.addPoint(6);
ply_right.addPoint(5);
ply_right.addPoint(1);
std::unique_ptr<GeoLib::Surface> sfc_right(GeoLib::Surface::createSurface(ply_right));
std::vector<std::size_t> const& found_ids_sfc_right(mesh_node_searcher.getMeshNodeIDsAlongSurface(*sfc_right));
ASSERT_EQ(n_nodes_2d, found_ids_sfc_right.size());
cnt = 0;
for (std::size_t k(0); k<n_nodes_1d; k++) { const std::size_t z_offset = n_nodes_2d*k;
for (std::size_t j(0); j<n_nodes_1d; j++)
ASSERT_EQ(z_offset + (j+1)*n_nodes_1d-1, found_ids_sfc_right[cnt++]);
}
std::for_each(pnts.begin(), pnts.end(), [](GeoLib::Point* pnt) { delete pnt; });
}