diff --git a/Tests/ApplicationsLib/TestProjectData.cpp b/Tests/ApplicationsLib/TestProjectData.cpp
index 04228b096866b4e5584b7a13f049db67a0fae786..3e21a76d000bd5da590aa09b88a05a1bf5dbd357 100644
--- a/Tests/ApplicationsLib/TestProjectData.cpp
+++ b/Tests/ApplicationsLib/TestProjectData.cpp
@@ -16,8 +16,8 @@
TEST(ApplicationsLib, ProjectData)
{
- ProjectData project;
- GeoLib::GEOObjects *geo_objects = project.getGEOObjects();
+ ProjectData project;
+ GeoLib::GEOObjects *geo_objects = project.getGEOObjects();
- ASSERT_TRUE(geo_objects != nullptr);
+ ASSERT_TRUE(geo_objects != nullptr);
}
diff --git a/Tests/AssemblerLib/LocalToGlobalIndexMapMultiComponent.cpp b/Tests/AssemblerLib/LocalToGlobalIndexMapMultiComponent.cpp
index 90cb9dfcbaa73e00c47b886e2f4608c6910c3ece..53e657449aee621f40c0c372fdea7e70d769b8a7 100644
--- a/Tests/AssemblerLib/LocalToGlobalIndexMapMultiComponent.cpp
+++ b/Tests/AssemblerLib/LocalToGlobalIndexMapMultiComponent.cpp
@@ -32,115 +32,115 @@ namespace MGTL = MeshGeoToolsLib;
class AssemblerLibLocalToGlobalIndexMapMultiDOFTest : public ::testing::Test
{
public:
- static const std::size_t mesh_subdivs = 4;
- AssemblerLibLocalToGlobalIndexMapMultiDOFTest()
- {
- mesh.reset(MeL::MeshGenerator::generateRegularQuadMesh(2.0, mesh_subdivs));
- mesh_items_all_nodes.reset(new MeL::MeshSubset(*mesh, &mesh->getNodes()));
+ static const std::size_t mesh_subdivs = 4;
+ AssemblerLibLocalToGlobalIndexMapMultiDOFTest()
+ {
+ mesh.reset(MeL::MeshGenerator::generateRegularQuadMesh(2.0, mesh_subdivs));
+ mesh_items_all_nodes.reset(new MeL::MeshSubset(*mesh, &mesh->getNodes()));
- std::unique_ptr<std::vector<GeoLib::Point*>> ply_pnts(
- new std::vector<GeoLib::Point*>);
- ply_pnts->push_back(new GeoLib::Point(0.0, 0.0, 0.0));
- ply_pnts->push_back(new GeoLib::Point(1.0, 0.0, 0.0));
+ std::unique_ptr<std::vector<GeoLib::Point*>> ply_pnts(
+ new std::vector<GeoLib::Point*>);
+ ply_pnts->push_back(new GeoLib::Point(0.0, 0.0, 0.0));
+ ply_pnts->push_back(new GeoLib::Point(1.0, 0.0, 0.0));
- std::string geometry_0("GeometryWithPntsAndPolyline");
- geo_objs.addPointVec(std::move(ply_pnts), geometry_0, nullptr);
+ std::string geometry_0("GeometryWithPntsAndPolyline");
+ geo_objs.addPointVec(std::move(ply_pnts), geometry_0, nullptr);
- auto ply = new GeoLib::Polyline(*geo_objs.getPointVec(geometry_0));
+ auto ply = new GeoLib::Polyline(*geo_objs.getPointVec(geometry_0));
- ply->addPoint(0);
- ply->addPoint(1);
+ ply->addPoint(0);
+ ply->addPoint(1);
- std::unique_ptr<std::vector<GeoLib::Polyline*>> plys(
- new std::vector<GeoLib::Polyline*>);
- plys->push_back(ply);
+ std::unique_ptr<std::vector<GeoLib::Polyline*>> plys(
+ new std::vector<GeoLib::Polyline*>);
+ plys->push_back(ply);
- geo_objs.addPolylineVec(std::move(plys), geometry_0, nullptr);
+ geo_objs.addPolylineVec(std::move(plys), geometry_0, nullptr);
- MGTL::MeshNodeSearcher& searcher_nodes = MGTL::MeshNodeSearcher::getMeshNodeSearcher(*mesh);
- MGTL::BoundaryElementsSearcher searcher_elements(*mesh, searcher_nodes);
+ MGTL::MeshNodeSearcher& searcher_nodes = MGTL::MeshNodeSearcher::getMeshNodeSearcher(*mesh);
+ MGTL::BoundaryElementsSearcher searcher_elements(*mesh, searcher_nodes);
- auto elems = searcher_elements.getBoundaryElements(*ply);
+ auto elems = searcher_elements.getBoundaryElements(*ply);
- // deep copy because the searcher destroys the elements.
- std::transform(elems.cbegin(), elems.cend(),
- std::back_inserter(boundary_elements),
- std::mem_fn(&MeL::Element::clone));
+ // deep copy because the searcher destroys the elements.
+ std::transform(elems.cbegin(), elems.cend(),
+ std::back_inserter(boundary_elements),
+ std::mem_fn(&MeL::Element::clone));
- std::vector<MeL::Node*> nodes = MeL::getUniqueNodes(boundary_elements);
+ std::vector<MeL::Node*> nodes = MeL::getUniqueNodes(boundary_elements);
- mesh_items_boundary.reset(
- mesh_items_all_nodes->getIntersectionByNodes(nodes));
- }
+ mesh_items_boundary.reset(
+ mesh_items_all_nodes->getIntersectionByNodes(nodes));
+ }
- ~AssemblerLibLocalToGlobalIndexMapMultiDOFTest()
- {
- for (auto e : boundary_elements)
- delete e;
- }
+ ~AssemblerLibLocalToGlobalIndexMapMultiDOFTest()
+ {
+ for (auto e : boundary_elements)
+ delete e;
+ }
- void initComponents(const unsigned num_components, const unsigned selected_component,
- const AL::ComponentOrder order)
- {
- assert(selected_component < num_components);
+ void initComponents(const unsigned num_components, const unsigned selected_component,
+ const AL::ComponentOrder order)
+ {
+ assert(selected_component < num_components);
- std::vector<std::unique_ptr<MeshLib::MeshSubsets>> components;
- for (unsigned i=0; i<num_components; ++i)
- {
- components.emplace_back(
- new MeL::MeshSubsets{mesh_items_all_nodes.get()});
- }
- dof_map.reset(
- new AL::LocalToGlobalIndexMap(std::move(components), order));
+ std::vector<std::unique_ptr<MeshLib::MeshSubsets>> components;
+ for (unsigned i=0; i<num_components; ++i)
+ {
+ components.emplace_back(
+ new MeL::MeshSubsets{mesh_items_all_nodes.get()});
+ }
+ dof_map.reset(
+ new AL::LocalToGlobalIndexMap(std::move(components), order));
- auto components_boundary = std::unique_ptr<MeshLib::MeshSubsets>{
- new MeL::MeshSubsets{mesh_items_boundary.get()}};
+ auto components_boundary = std::unique_ptr<MeshLib::MeshSubsets>{
+ new MeL::MeshSubsets{mesh_items_boundary.get()}};
- dof_map_boundary.reset(dof_map->deriveBoundaryConstrainedMap(
- 0, // variable id
- selected_component,
- std::move(components_boundary),
- boundary_elements));
- }
+ dof_map_boundary.reset(dof_map->deriveBoundaryConstrainedMap(
+ 0, // variable id
+ selected_component,
+ std::move(components_boundary),
+ boundary_elements));
+ }
- template <AL::ComponentOrder order>
- void test(const unsigned num_components, const unsigned selected_component,
- std::function<std::size_t(std::size_t, std::size_t)> const
- compute_global_index);
+ template <AL::ComponentOrder order>
+ void test(const unsigned num_components, const unsigned selected_component,
+ std::function<std::size_t(std::size_t, std::size_t)> const
+ compute_global_index);
- std::unique_ptr<const MeshLib::Mesh> mesh;
- std::unique_ptr<const MeL::MeshSubset> mesh_items_all_nodes;
+ std::unique_ptr<const MeshLib::Mesh> mesh;
+ std::unique_ptr<const MeL::MeshSubset> mesh_items_all_nodes;
- GeoLib::GEOObjects geo_objs;
+ GeoLib::GEOObjects geo_objs;
- std::unique_ptr<AL::LocalToGlobalIndexMap> dof_map;
- std::unique_ptr<AL::LocalToGlobalIndexMap> dof_map_boundary;
+ std::unique_ptr<AL::LocalToGlobalIndexMap> dof_map;
+ std::unique_ptr<AL::LocalToGlobalIndexMap> dof_map_boundary;
- std::unique_ptr<MeL::MeshSubset const> mesh_items_boundary;
- std::vector<MeL::Element*> boundary_elements;
+ std::unique_ptr<MeL::MeshSubset const> mesh_items_boundary;
+ std::vector<MeL::Element*> boundary_elements;
};
struct ComputeGlobalIndexByComponent
{
- std::size_t num_nodes;
+ std::size_t num_nodes;
- std::size_t operator()(std::size_t const node,
- std::size_t const component) const
- {
- return node + component * num_nodes;
- }
+ std::size_t operator()(std::size_t const node,
+ std::size_t const component) const
+ {
+ return node + component * num_nodes;
+ }
};
struct ComputeGlobalIndexByLocation
{
- std::size_t num_components;
+ std::size_t num_components;
- std::size_t operator()(std::size_t const node,
- std::size_t const component) const
- {
- return node * num_components + component;
- }
+ std::size_t operator()(std::size_t const node,
+ std::size_t const component) const
+ {
+ return node * num_components + component;
+ }
};
@@ -151,54 +151,54 @@ void AssemblerLibLocalToGlobalIndexMapMultiDOFTest::test(
std::function<std::size_t(std::size_t, std::size_t)> const
compute_global_index)
{
- initComponents(num_components, selected_component, ComponentOrder);
-
- ASSERT_EQ(dof_map->getNumComponents(), num_components);
- ASSERT_EQ(dof_map->size(), mesh->getNElements());
-
- ASSERT_EQ(dof_map_boundary->getNumComponents(), 1);
- ASSERT_EQ(dof_map_boundary->size(), boundary_elements.size());
-
- // check mesh elements
- for (unsigned e=0; e<dof_map->size(); ++e)
- {
- auto const element_nodes_size = mesh->getElement(e)->getNNodes();
- auto const ptr_element_nodes = mesh->getElement(e)->getNodes();
-
- for (unsigned c=0; c<dof_map->getNumComponents(); ++c)
- {
- auto const& global_idcs = (*dof_map)(e, c).rows;
- ASSERT_EQ(element_nodes_size, global_idcs.size());
-
- for (unsigned n = 0; n < element_nodes_size; ++n)
- {
- auto const node_id = ptr_element_nodes[n]->getID();
- auto const glob_idx = compute_global_index(node_id, c);
- EXPECT_EQ(glob_idx, global_idcs[n]);
- }
- }
- }
-
- // check boundary elements
- for (unsigned e=0; e<dof_map_boundary->size(); ++e)
- {
- ASSERT_EQ(1, dof_map_boundary->getNumComponents());
-
- for (unsigned c=0; c<1; ++c)
- {
- auto const& global_idcs = (*dof_map_boundary)(e, c).rows;
-
- ASSERT_EQ(2, global_idcs.size()); // boundary of quad is line with two nodes
-
- for (unsigned n=0; n<2; ++n) // boundary of quad is line with two nodes
- {
- auto const node = e + n;
- auto const glob_idx =
- compute_global_index(node, selected_component);
- EXPECT_EQ(glob_idx, global_idcs[n]);
- }
- }
- }
+ initComponents(num_components, selected_component, ComponentOrder);
+
+ ASSERT_EQ(dof_map->getNumComponents(), num_components);
+ ASSERT_EQ(dof_map->size(), mesh->getNElements());
+
+ ASSERT_EQ(dof_map_boundary->getNumComponents(), 1);
+ ASSERT_EQ(dof_map_boundary->size(), boundary_elements.size());
+
+ // check mesh elements
+ for (unsigned e=0; e<dof_map->size(); ++e)
+ {
+ auto const element_nodes_size = mesh->getElement(e)->getNNodes();
+ auto const ptr_element_nodes = mesh->getElement(e)->getNodes();
+
+ for (unsigned c=0; c<dof_map->getNumComponents(); ++c)
+ {
+ auto const& global_idcs = (*dof_map)(e, c).rows;
+ ASSERT_EQ(element_nodes_size, global_idcs.size());
+
+ for (unsigned n = 0; n < element_nodes_size; ++n)
+ {
+ auto const node_id = ptr_element_nodes[n]->getID();
+ auto const glob_idx = compute_global_index(node_id, c);
+ EXPECT_EQ(glob_idx, global_idcs[n]);
+ }
+ }
+ }
+
+ // check boundary elements
+ for (unsigned e=0; e<dof_map_boundary->size(); ++e)
+ {
+ ASSERT_EQ(1, dof_map_boundary->getNumComponents());
+
+ for (unsigned c=0; c<1; ++c)
+ {
+ auto const& global_idcs = (*dof_map_boundary)(e, c).rows;
+
+ ASSERT_EQ(2, global_idcs.size()); // boundary of quad is line with two nodes
+
+ for (unsigned n=0; n<2; ++n) // boundary of quad is line with two nodes
+ {
+ auto const node = e + n;
+ auto const glob_idx =
+ compute_global_index(node, selected_component);
+ EXPECT_EQ(glob_idx, global_idcs[n]);
+ }
+ }
+ }
}
@@ -206,17 +206,17 @@ void AssemblerLibLocalToGlobalIndexMapMultiDOFTest::test(
void assert_equal(AL::LocalToGlobalIndexMap const& dof1, AL::LocalToGlobalIndexMap const& dof2)
{
- ASSERT_EQ(dof1.size(), dof2.size());
- ASSERT_EQ(dof1.getNumComponents(), dof2.getNumComponents());
-
- for (unsigned e=0; e<dof1.size(); ++e)
- {
- for (unsigned c=0; c<dof1.getNumComponents(); ++c)
- {
- EXPECT_EQ(dof1(e, c).rows, dof2(e, c).rows);
- EXPECT_EQ(dof1(e, c).columns, dof2(e, c).columns);
- }
- }
+ ASSERT_EQ(dof1.size(), dof2.size());
+ ASSERT_EQ(dof1.getNumComponents(), dof2.getNumComponents());
+
+ for (unsigned e=0; e<dof1.size(); ++e)
+ {
+ for (unsigned c=0; c<dof1.getNumComponents(); ++c)
+ {
+ EXPECT_EQ(dof1(e, c).rows, dof2(e, c).rows);
+ EXPECT_EQ(dof1(e, c).columns, dof2(e, c).columns);
+ }
+ }
}
#ifndef USE_PETSC
@@ -225,20 +225,20 @@ TEST_F(AssemblerLibLocalToGlobalIndexMapMultiDOFTest, Test1Comp)
TEST_F(AssemblerLibLocalToGlobalIndexMapMultiDOFTest, DISABLED_Test1Comp)
#endif
{
- unsigned const num_components = 1;
+ unsigned const num_components = 1;
- test<AL::ComponentOrder::BY_LOCATION>(
- num_components, 0, ComputeGlobalIndexByComponent{num_components});
+ test<AL::ComponentOrder::BY_LOCATION>(
+ num_components, 0, ComputeGlobalIndexByComponent{num_components});
- auto dof_map_bc = std::move(dof_map);
- auto dof_map_boundary_bc = std::move(dof_map_boundary);
+ auto dof_map_bc = std::move(dof_map);
+ auto dof_map_boundary_bc = std::move(dof_map_boundary);
- test<AL::ComponentOrder::BY_COMPONENT>(
- num_components, 0,
- ComputeGlobalIndexByComponent{(mesh_subdivs + 1) * (mesh_subdivs + 1)});
+ test<AL::ComponentOrder::BY_COMPONENT>(
+ num_components, 0,
+ ComputeGlobalIndexByComponent{(mesh_subdivs + 1) * (mesh_subdivs + 1)});
- assert_equal(*dof_map, *dof_map_bc);
- assert_equal(*dof_map_boundary, *dof_map_boundary_bc);
+ assert_equal(*dof_map, *dof_map_bc);
+ assert_equal(*dof_map_boundary, *dof_map_boundary_bc);
}
#ifndef USE_PETSC
@@ -247,11 +247,11 @@ TEST_F(AssemblerLibLocalToGlobalIndexMapMultiDOFTest, TestMultiCompByComponent)
TEST_F(AssemblerLibLocalToGlobalIndexMapMultiDOFTest, DISABLED_TestMultiCompByComponent)
#endif
{
- unsigned const num_components = 5;
- for (unsigned c = 0; c < num_components; ++c)
- test<AL::ComponentOrder::BY_COMPONENT>(
- num_components, c, ComputeGlobalIndexByComponent{
- (mesh_subdivs + 1) * (mesh_subdivs + 1)});
+ unsigned const num_components = 5;
+ for (unsigned c = 0; c < num_components; ++c)
+ test<AL::ComponentOrder::BY_COMPONENT>(
+ num_components, c, ComputeGlobalIndexByComponent{
+ (mesh_subdivs + 1) * (mesh_subdivs + 1)});
}
#ifndef USE_PETSC
@@ -260,8 +260,8 @@ TEST_F(AssemblerLibLocalToGlobalIndexMapMultiDOFTest, TestMultiCompByLocation)
TEST_F(AssemblerLibLocalToGlobalIndexMapMultiDOFTest, DISABLED_TestMultiCompByLocation)
#endif
{
- unsigned const num_components = 5;
- for (unsigned c = 0; c < num_components; ++c)
- test<AL::ComponentOrder::BY_LOCATION>(
- num_components, c, ComputeGlobalIndexByLocation{num_components});
+ unsigned const num_components = 5;
+ for (unsigned c = 0; c < num_components; ++c)
+ test<AL::ComponentOrder::BY_LOCATION>(
+ num_components, c, ComputeGlobalIndexByLocation{num_components});
}
diff --git a/Tests/AssemblerLib/SteadyDiffusion2DExample1.h b/Tests/AssemblerLib/SteadyDiffusion2DExample1.h
index ca4a83a72f85ed81ef2805d5040fa7c59618d9fd..e5a4737c35e369a5b99e588cd33ecf5bbe54eafa 100644
--- a/Tests/AssemblerLib/SteadyDiffusion2DExample1.h
+++ b/Tests/AssemblerLib/SteadyDiffusion2DExample1.h
@@ -25,127 +25,127 @@
template<typename IndexType>struct SteadyDiffusion2DExample1
{
- using LocalMatrixType =
- Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
- using LocalVectorType = Eigen::VectorXd;
-
- template <typename GlobalMatrix, typename GlobalVector>
- class LocalAssemblerData
- {
- public:
- void init(MeshLib::Element const&,
- std::size_t const /*local_matrix_size*/,
- LocalMatrixType const& localA,
- LocalVectorType const& localRhs)
- {
- _localA = &localA;
- _localRhs = &localRhs;
- }
-
- void assemble(double const, std::vector<double> const&)
- {
- // The local contributions are computed here, usually, but for this
- // particular test all contributions are equal for all elements and are
- // already stored in the _localA matrix.
- }
-
- void addToGlobal(AssemblerLib::LocalToGlobalIndexMap::RowColumnIndices const& indices,
- GlobalMatrix& /*M*/, GlobalMatrix& K, GlobalVector& b) const
- {
- K.add(indices, *_localA);
- b.add(indices.rows, *_localRhs);
- }
-
-
- LocalMatrixType const& getLocalMatrix() const
- {
- return *_localA;
- }
-
- LocalVectorType const& getLocalVector() const
- {
- return *_localRhs;
- }
-
- private:
- LocalMatrixType const* _localA = nullptr;
- LocalVectorType const* _localRhs = nullptr;
- };
-
- template <typename GlobalMatrix, typename GlobalVector>
- static
- void initializeLocalData(const MeshLib::Element& e,
- LocalAssemblerData<GlobalMatrix, GlobalVector>*& data_ptr,
- std::size_t const local_matrix_size,
- SteadyDiffusion2DExample1 const& example)
- {
- data_ptr = new LocalAssemblerData<GlobalMatrix, GlobalVector>;
- data_ptr->init(e, local_matrix_size, example._localA, example._localRhs);
- }
-
- SteadyDiffusion2DExample1()
- : _localA(4, 4), _localRhs(4)
- {
- msh = MeshLib::MeshGenerator::generateRegularQuadMesh(2.0, mesh_subdivs);
- for (auto* node : msh->getNodes())
- vec_nodeIDs.push_back(node->getID());
- vec_DirichletBC_id.resize(2 * mesh_stride);
- for (std::size_t i = 0; i < mesh_stride; i++)
- {
- // left side
- vec_DirichletBC_id[i] = i * mesh_stride;
-
- // right side
- vec_DirichletBC_id[mesh_stride + i] = i * mesh_stride + mesh_subdivs;
- }
-
- // Local assembler matrix and vector are equal for all quad elements.
- {
- _localA(0,0) = 4.0; _localA(0,1) = -1.0; _localA(0,2) = -2.0; _localA(0,3) = -1.0;
- _localA(1,1) = 4.0; _localA(1,2) = -1.0; _localA(1,3) = -2.0;
- _localA(2,2) = 4.0; _localA(2,3) = -1.0;
- _localA(3,3) = 4.0;
-
- // copy upper triangle to lower to localA for symmetry
- for (std::size_t i = 0; i < 4; i++)
- for (std::size_t j = 0; j < i; j++)
- _localA(i,j) = _localA(j,i);
-
- //_localA *= 1.e-11/6.0;
- for (std::size_t i = 0; i < 4; i++)
- for (std::size_t j = 0; j < 4; j++)
- _localA(i,j) *= 1.e-11 / 6.0;
-
- // Fill rhs with zero;
- for (std::size_t i = 0; i < 4; i++)
- _localRhs[i] = 0;
- }
-
- vec_DirichletBC_value.resize(2 * mesh_stride);
- std::fill_n(vec_DirichletBC_value.begin(), mesh_stride, 0);
- std::fill_n(vec_DirichletBC_value.begin() + mesh_stride, mesh_stride, 1);
- exact_solutions.resize(dim_eqs);
- for (std::size_t i = 0; i < mesh_stride; i++)
- for (std::size_t j = 0; j < mesh_stride; j++)
- exact_solutions[i*mesh_stride + j] = j * 1./mesh_subdivs;
- }
-
- ~SteadyDiffusion2DExample1()
- {
- delete msh;
- }
-
- static const std::size_t mesh_subdivs = 10;
- static const std::size_t mesh_stride = mesh_subdivs + 1;
- static const std::size_t dim_eqs = mesh_stride * mesh_stride;
- MeshLib::Mesh* msh;
- std::vector<IndexType> vec_DirichletBC_id;
- std::vector<double> vec_DirichletBC_value;
- std::vector<double> exact_solutions;
- std::vector<std::size_t> vec_nodeIDs;
-
- LocalMatrixType _localA;
- LocalVectorType _localRhs;
+ using LocalMatrixType =
+ Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
+ using LocalVectorType = Eigen::VectorXd;
+
+ template <typename GlobalMatrix, typename GlobalVector>
+ class LocalAssemblerData
+ {
+ public:
+ void init(MeshLib::Element const&,
+ std::size_t const /*local_matrix_size*/,
+ LocalMatrixType const& localA,
+ LocalVectorType const& localRhs)
+ {
+ _localA = &localA;
+ _localRhs = &localRhs;
+ }
+
+ void assemble(double const, std::vector<double> const&)
+ {
+ // The local contributions are computed here, usually, but for this
+ // particular test all contributions are equal for all elements and are
+ // already stored in the _localA matrix.
+ }
+
+ void addToGlobal(AssemblerLib::LocalToGlobalIndexMap::RowColumnIndices const& indices,
+ GlobalMatrix& /*M*/, GlobalMatrix& K, GlobalVector& b) const
+ {
+ K.add(indices, *_localA);
+ b.add(indices.rows, *_localRhs);
+ }
+
+
+ LocalMatrixType const& getLocalMatrix() const
+ {
+ return *_localA;
+ }
+
+ LocalVectorType const& getLocalVector() const
+ {
+ return *_localRhs;
+ }
+
+ private:
+ LocalMatrixType const* _localA = nullptr;
+ LocalVectorType const* _localRhs = nullptr;
+ };
+
+ template <typename GlobalMatrix, typename GlobalVector>
+ static
+ void initializeLocalData(const MeshLib::Element& e,
+ LocalAssemblerData<GlobalMatrix, GlobalVector>*& data_ptr,
+ std::size_t const local_matrix_size,
+ SteadyDiffusion2DExample1 const& example)
+ {
+ data_ptr = new LocalAssemblerData<GlobalMatrix, GlobalVector>;
+ data_ptr->init(e, local_matrix_size, example._localA, example._localRhs);
+ }
+
+ SteadyDiffusion2DExample1()
+ : _localA(4, 4), _localRhs(4)
+ {
+ msh = MeshLib::MeshGenerator::generateRegularQuadMesh(2.0, mesh_subdivs);
+ for (auto* node : msh->getNodes())
+ vec_nodeIDs.push_back(node->getID());
+ vec_DirichletBC_id.resize(2 * mesh_stride);
+ for (std::size_t i = 0; i < mesh_stride; i++)
+ {
+ // left side
+ vec_DirichletBC_id[i] = i * mesh_stride;
+
+ // right side
+ vec_DirichletBC_id[mesh_stride + i] = i * mesh_stride + mesh_subdivs;
+ }
+
+ // Local assembler matrix and vector are equal for all quad elements.
+ {
+ _localA(0,0) = 4.0; _localA(0,1) = -1.0; _localA(0,2) = -2.0; _localA(0,3) = -1.0;
+ _localA(1,1) = 4.0; _localA(1,2) = -1.0; _localA(1,3) = -2.0;
+ _localA(2,2) = 4.0; _localA(2,3) = -1.0;
+ _localA(3,3) = 4.0;
+
+ // copy upper triangle to lower to localA for symmetry
+ for (std::size_t i = 0; i < 4; i++)
+ for (std::size_t j = 0; j < i; j++)
+ _localA(i,j) = _localA(j,i);
+
+ //_localA *= 1.e-11/6.0;
+ for (std::size_t i = 0; i < 4; i++)
+ for (std::size_t j = 0; j < 4; j++)
+ _localA(i,j) *= 1.e-11 / 6.0;
+
+ // Fill rhs with zero;
+ for (std::size_t i = 0; i < 4; i++)
+ _localRhs[i] = 0;
+ }
+
+ vec_DirichletBC_value.resize(2 * mesh_stride);
+ std::fill_n(vec_DirichletBC_value.begin(), mesh_stride, 0);
+ std::fill_n(vec_DirichletBC_value.begin() + mesh_stride, mesh_stride, 1);
+ exact_solutions.resize(dim_eqs);
+ for (std::size_t i = 0; i < mesh_stride; i++)
+ for (std::size_t j = 0; j < mesh_stride; j++)
+ exact_solutions[i*mesh_stride + j] = j * 1./mesh_subdivs;
+ }
+
+ ~SteadyDiffusion2DExample1()
+ {
+ delete msh;
+ }
+
+ static const std::size_t mesh_subdivs = 10;
+ static const std::size_t mesh_stride = mesh_subdivs + 1;
+ static const std::size_t dim_eqs = mesh_stride * mesh_stride;
+ MeshLib::Mesh* msh;
+ std::vector<IndexType> vec_DirichletBC_id;
+ std::vector<double> vec_DirichletBC_value;
+ std::vector<double> exact_solutions;
+ std::vector<std::size_t> vec_nodeIDs;
+
+ LocalMatrixType _localA;
+ LocalVectorType _localRhs;
};
diff --git a/Tests/BaseLib/TestFilePathStringManipulation.cpp b/Tests/BaseLib/TestFilePathStringManipulation.cpp
index 404071db495ce3eba6ed890801151783f52da995..a4e59b51e6213554ae0bae2a113d00c975835fea 100644
--- a/Tests/BaseLib/TestFilePathStringManipulation.cpp
+++ b/Tests/BaseLib/TestFilePathStringManipulation.cpp
@@ -20,383 +20,383 @@
TEST(BaseLib, FindLastPathSeparatorWin)
{
- ASSERT_EQ ( BaseLib::findLastPathSeparator("file"), std::string::npos );
- ASSERT_EQ ( BaseLib::findLastPathSeparator("\\file"), 0U );
- ASSERT_EQ ( BaseLib::findLastPathSeparator("path\\"), 4U );
- ASSERT_EQ ( BaseLib::findLastPathSeparator("\\path\\"), 5U );
- ASSERT_EQ ( BaseLib::findLastPathSeparator("path\\file"), 4U );
- ASSERT_EQ ( BaseLib::findLastPathSeparator("\\path\\file"), 5U );
- ASSERT_EQ ( BaseLib::findLastPathSeparator("\\path\\path\\file"), 10U );
- ASSERT_EQ ( BaseLib::findLastPathSeparator("\\path\\path\\path\\"), 15U );
+ ASSERT_EQ ( BaseLib::findLastPathSeparator("file"), std::string::npos );
+ ASSERT_EQ ( BaseLib::findLastPathSeparator("\\file"), 0U );
+ ASSERT_EQ ( BaseLib::findLastPathSeparator("path\\"), 4U );
+ ASSERT_EQ ( BaseLib::findLastPathSeparator("\\path\\"), 5U );
+ ASSERT_EQ ( BaseLib::findLastPathSeparator("path\\file"), 4U );
+ ASSERT_EQ ( BaseLib::findLastPathSeparator("\\path\\file"), 5U );
+ ASSERT_EQ ( BaseLib::findLastPathSeparator("\\path\\path\\file"), 10U );
+ ASSERT_EQ ( BaseLib::findLastPathSeparator("\\path\\path\\path\\"), 15U );
}
TEST(BaseLib, FindLastPathSeparatorUnix)
{
- ASSERT_EQ ( BaseLib::findLastPathSeparator("file"), std::string::npos );
- ASSERT_EQ ( BaseLib::findLastPathSeparator("/file"), 0U );
- ASSERT_EQ ( BaseLib::findLastPathSeparator("path/"), 4U );
- ASSERT_EQ ( BaseLib::findLastPathSeparator("/path/"), 5U );
- ASSERT_EQ ( BaseLib::findLastPathSeparator("path/file"), 4U );
- ASSERT_EQ ( BaseLib::findLastPathSeparator("/path/file"), 5U );
- ASSERT_EQ ( BaseLib::findLastPathSeparator("/path/path/file"), 10U );
- ASSERT_EQ ( BaseLib::findLastPathSeparator("/path/path/path/"), 15U );
+ ASSERT_EQ ( BaseLib::findLastPathSeparator("file"), std::string::npos );
+ ASSERT_EQ ( BaseLib::findLastPathSeparator("/file"), 0U );
+ ASSERT_EQ ( BaseLib::findLastPathSeparator("path/"), 4U );
+ ASSERT_EQ ( BaseLib::findLastPathSeparator("/path/"), 5U );
+ ASSERT_EQ ( BaseLib::findLastPathSeparator("path/file"), 4U );
+ ASSERT_EQ ( BaseLib::findLastPathSeparator("/path/file"), 5U );
+ ASSERT_EQ ( BaseLib::findLastPathSeparator("/path/path/file"), 10U );
+ ASSERT_EQ ( BaseLib::findLastPathSeparator("/path/path/path/"), 15U );
}
TEST(BaseLib, DropFileExtensionWin)
{
- ASSERT_EQ ( BaseLib::dropFileExtension("file"), "file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("\\file"), "\\file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("path\\"), "path\\" );
- ASSERT_EQ ( BaseLib::dropFileExtension("\\path\\"), "\\path\\" );
- ASSERT_EQ ( BaseLib::dropFileExtension("path\\file"), "path\\file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("\\path\\file"), "\\path\\file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("\\path\\path\\file"), "\\path\\path\\file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("\\path\\path\\path\\"), "\\path\\path\\path\\" );
-
- ASSERT_EQ ( BaseLib::dropFileExtension("file.ext"), "file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("\\file.ext"), "\\file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("path.ext\\"), "path.ext\\" );
- ASSERT_EQ ( BaseLib::dropFileExtension("\\path.ext\\"), "\\path.ext\\" );
- ASSERT_EQ ( BaseLib::dropFileExtension("path\\file.ext"), "path\\file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("\\path\\file.ext"), "\\path\\file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("\\path\\path\\file.ext"), "\\path\\path\\file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("\\path\\path\\path.ext\\"), "\\path\\path\\path.ext\\" );
-
- ASSERT_EQ ( BaseLib::dropFileExtension("path.wrong\\file.ext"), "path.wrong\\file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("\\path.wrong\\file.ext"), "\\path.wrong\\file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("\\path.wrong0\\path.wrong\\file.ext"), "\\path.wrong0\\path.wrong\\file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("\\path.wrong0\\path.wrong\\path.ext\\"), "\\path.wrong0\\path.wrong\\path.ext\\" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("file"), "file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("\\file"), "\\file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("path\\"), "path\\" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("\\path\\"), "\\path\\" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("path\\file"), "path\\file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("\\path\\file"), "\\path\\file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("\\path\\path\\file"), "\\path\\path\\file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("\\path\\path\\path\\"), "\\path\\path\\path\\" );
+
+ ASSERT_EQ ( BaseLib::dropFileExtension("file.ext"), "file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("\\file.ext"), "\\file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("path.ext\\"), "path.ext\\" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("\\path.ext\\"), "\\path.ext\\" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("path\\file.ext"), "path\\file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("\\path\\file.ext"), "\\path\\file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("\\path\\path\\file.ext"), "\\path\\path\\file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("\\path\\path\\path.ext\\"), "\\path\\path\\path.ext\\" );
+
+ ASSERT_EQ ( BaseLib::dropFileExtension("path.wrong\\file.ext"), "path.wrong\\file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("\\path.wrong\\file.ext"), "\\path.wrong\\file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("\\path.wrong0\\path.wrong\\file.ext"), "\\path.wrong0\\path.wrong\\file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("\\path.wrong0\\path.wrong\\path.ext\\"), "\\path.wrong0\\path.wrong\\path.ext\\" );
}
TEST(BaseLib, DropFileExtensionUnix)
{
- ASSERT_EQ ( BaseLib::dropFileExtension("file"), "file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("/file"), "/file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("path/"), "path/" );
- ASSERT_EQ ( BaseLib::dropFileExtension("/path/"), "/path/" );
- ASSERT_EQ ( BaseLib::dropFileExtension("path/file"), "path/file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("/path/file"), "/path/file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("/path/path/file"), "/path/path/file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("/path/path/path/"), "/path/path/path/" );
-
- ASSERT_EQ ( BaseLib::dropFileExtension("file.ext"), "file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("/file.ext"), "/file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("path.ext/"), "path.ext/" );
- ASSERT_EQ ( BaseLib::dropFileExtension("/path.ext/"), "/path.ext/" );
- ASSERT_EQ ( BaseLib::dropFileExtension("path/file.ext"), "path/file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("/path/file.ext"), "/path/file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("/path/path/file.ext"), "/path/path/file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("/path/path/path.ext/"), "/path/path/path.ext/" );
-
- ASSERT_EQ ( BaseLib::dropFileExtension("path.wrong/file.ext"), "path.wrong/file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("/path.wrong/file.ext"), "/path.wrong/file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("/path.wrong0/path.wrong/file.ext"), "/path.wrong0/path.wrong/file" );
- ASSERT_EQ ( BaseLib::dropFileExtension("/path.wrong0/path.wrong/path.ext/"), "/path.wrong0/path.wrong/path.ext/" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("file"), "file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("/file"), "/file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("path/"), "path/" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("/path/"), "/path/" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("path/file"), "path/file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("/path/file"), "/path/file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("/path/path/file"), "/path/path/file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("/path/path/path/"), "/path/path/path/" );
+
+ ASSERT_EQ ( BaseLib::dropFileExtension("file.ext"), "file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("/file.ext"), "/file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("path.ext/"), "path.ext/" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("/path.ext/"), "/path.ext/" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("path/file.ext"), "path/file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("/path/file.ext"), "/path/file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("/path/path/file.ext"), "/path/path/file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("/path/path/path.ext/"), "/path/path/path.ext/" );
+
+ ASSERT_EQ ( BaseLib::dropFileExtension("path.wrong/file.ext"), "path.wrong/file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("/path.wrong/file.ext"), "/path.wrong/file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("/path.wrong0/path.wrong/file.ext"), "/path.wrong0/path.wrong/file" );
+ ASSERT_EQ ( BaseLib::dropFileExtension("/path.wrong0/path.wrong/path.ext/"), "/path.wrong0/path.wrong/path.ext/" );
}
TEST(BaseLib, GetFileExtensionWin)
{
- ASSERT_EQ ( BaseLib::getFileExtension("file"), "" );
- ASSERT_EQ ( BaseLib::getFileExtension("\\file"), "" );
- ASSERT_EQ ( BaseLib::getFileExtension("path\\"), "" );
- ASSERT_EQ ( BaseLib::getFileExtension("\\path\\"), "" );
- ASSERT_EQ ( BaseLib::getFileExtension("path\\file"), "" );
- ASSERT_EQ ( BaseLib::getFileExtension("\\path\\file"), "" );
- ASSERT_EQ ( BaseLib::getFileExtension("\\path\\path\\file"), "" );
- ASSERT_EQ ( BaseLib::getFileExtension("\\path\\path\\path\\"), "" );
-
- ASSERT_EQ ( BaseLib::getFileExtension("file.ext"), "ext" );
- ASSERT_EQ ( BaseLib::getFileExtension("\\file.ext"), "ext" );
- ASSERT_EQ ( BaseLib::getFileExtension("path.ext\\"), "" );
- ASSERT_EQ ( BaseLib::getFileExtension("\\path.ext\\"), "" );
- ASSERT_EQ ( BaseLib::getFileExtension("path\\file.ext"), "ext" );
- ASSERT_EQ ( BaseLib::getFileExtension("\\path\\file.ext"), "ext" );
- ASSERT_EQ ( BaseLib::getFileExtension("\\path\\path\\file.ext"), "ext" );
- ASSERT_EQ ( BaseLib::getFileExtension("\\path\\path\\path.ext\\"), "" );
-
- ASSERT_EQ ( BaseLib::getFileExtension("path.wrong\\file.ext"), "ext" );
- ASSERT_EQ ( BaseLib::getFileExtension("\\path.wrong\\file.ext"), "ext" );
- ASSERT_EQ ( BaseLib::getFileExtension("\\path.wrong0\\path.wrong\\file.ext"), "ext" );
- ASSERT_EQ ( BaseLib::getFileExtension("\\path.wrong0\\path.wrong\\path.ext\\"), "" );
+ ASSERT_EQ ( BaseLib::getFileExtension("file"), "" );
+ ASSERT_EQ ( BaseLib::getFileExtension("\\file"), "" );
+ ASSERT_EQ ( BaseLib::getFileExtension("path\\"), "" );
+ ASSERT_EQ ( BaseLib::getFileExtension("\\path\\"), "" );
+ ASSERT_EQ ( BaseLib::getFileExtension("path\\file"), "" );
+ ASSERT_EQ ( BaseLib::getFileExtension("\\path\\file"), "" );
+ ASSERT_EQ ( BaseLib::getFileExtension("\\path\\path\\file"), "" );
+ ASSERT_EQ ( BaseLib::getFileExtension("\\path\\path\\path\\"), "" );
+
+ ASSERT_EQ ( BaseLib::getFileExtension("file.ext"), "ext" );
+ ASSERT_EQ ( BaseLib::getFileExtension("\\file.ext"), "ext" );
+ ASSERT_EQ ( BaseLib::getFileExtension("path.ext\\"), "" );
+ ASSERT_EQ ( BaseLib::getFileExtension("\\path.ext\\"), "" );
+ ASSERT_EQ ( BaseLib::getFileExtension("path\\file.ext"), "ext" );
+ ASSERT_EQ ( BaseLib::getFileExtension("\\path\\file.ext"), "ext" );
+ ASSERT_EQ ( BaseLib::getFileExtension("\\path\\path\\file.ext"), "ext" );
+ ASSERT_EQ ( BaseLib::getFileExtension("\\path\\path\\path.ext\\"), "" );
+
+ ASSERT_EQ ( BaseLib::getFileExtension("path.wrong\\file.ext"), "ext" );
+ ASSERT_EQ ( BaseLib::getFileExtension("\\path.wrong\\file.ext"), "ext" );
+ ASSERT_EQ ( BaseLib::getFileExtension("\\path.wrong0\\path.wrong\\file.ext"), "ext" );
+ ASSERT_EQ ( BaseLib::getFileExtension("\\path.wrong0\\path.wrong\\path.ext\\"), "" );
}
TEST(BaseLib, getFileExtensionUnix)
{
- ASSERT_EQ ( BaseLib::getFileExtension("file"), "" );
- ASSERT_EQ ( BaseLib::getFileExtension("/file"), "" );
- ASSERT_EQ ( BaseLib::getFileExtension("path/"), "" );
- ASSERT_EQ ( BaseLib::getFileExtension("/path/"), "" );
- ASSERT_EQ ( BaseLib::getFileExtension("path/file"), "" );
- ASSERT_EQ ( BaseLib::getFileExtension("/path/file"), "" );
- ASSERT_EQ ( BaseLib::getFileExtension("/path/path/file"), "" );
- ASSERT_EQ ( BaseLib::getFileExtension("/path/path/path/"), "" );
-
- ASSERT_EQ ( BaseLib::getFileExtension("file.ext"), "ext" );
- ASSERT_EQ ( BaseLib::getFileExtension("/file.ext"), "ext" );
- ASSERT_EQ ( BaseLib::getFileExtension("path.ext/"), "" );
- ASSERT_EQ ( BaseLib::getFileExtension("/path.ext/"), "" );
- ASSERT_EQ ( BaseLib::getFileExtension("path/file.ext"), "ext" );
- ASSERT_EQ ( BaseLib::getFileExtension("/path/file.ext"), "ext" );
- ASSERT_EQ ( BaseLib::getFileExtension("/path/path/file.ext"), "ext" );
- ASSERT_EQ ( BaseLib::getFileExtension("/path/path/path.ext/"), "" );
-
- ASSERT_EQ ( BaseLib::getFileExtension("path.wrong/file.ext"), "ext" );
- ASSERT_EQ ( BaseLib::getFileExtension("/path.wrong/file.ext"), "ext" );
- ASSERT_EQ ( BaseLib::getFileExtension("/path.wrong0/path.wrong/file.ext"), "ext" );
- ASSERT_EQ ( BaseLib::getFileExtension("/path.wrong0/path.wrong/path.ext/"), "" );
+ ASSERT_EQ ( BaseLib::getFileExtension("file"), "" );
+ ASSERT_EQ ( BaseLib::getFileExtension("/file"), "" );
+ ASSERT_EQ ( BaseLib::getFileExtension("path/"), "" );
+ ASSERT_EQ ( BaseLib::getFileExtension("/path/"), "" );
+ ASSERT_EQ ( BaseLib::getFileExtension("path/file"), "" );
+ ASSERT_EQ ( BaseLib::getFileExtension("/path/file"), "" );
+ ASSERT_EQ ( BaseLib::getFileExtension("/path/path/file"), "" );
+ ASSERT_EQ ( BaseLib::getFileExtension("/path/path/path/"), "" );
+
+ ASSERT_EQ ( BaseLib::getFileExtension("file.ext"), "ext" );
+ ASSERT_EQ ( BaseLib::getFileExtension("/file.ext"), "ext" );
+ ASSERT_EQ ( BaseLib::getFileExtension("path.ext/"), "" );
+ ASSERT_EQ ( BaseLib::getFileExtension("/path.ext/"), "" );
+ ASSERT_EQ ( BaseLib::getFileExtension("path/file.ext"), "ext" );
+ ASSERT_EQ ( BaseLib::getFileExtension("/path/file.ext"), "ext" );
+ ASSERT_EQ ( BaseLib::getFileExtension("/path/path/file.ext"), "ext" );
+ ASSERT_EQ ( BaseLib::getFileExtension("/path/path/path.ext/"), "" );
+
+ ASSERT_EQ ( BaseLib::getFileExtension("path.wrong/file.ext"), "ext" );
+ ASSERT_EQ ( BaseLib::getFileExtension("/path.wrong/file.ext"), "ext" );
+ ASSERT_EQ ( BaseLib::getFileExtension("/path.wrong0/path.wrong/file.ext"), "ext" );
+ ASSERT_EQ ( BaseLib::getFileExtension("/path.wrong0/path.wrong/path.ext/"), "" );
}
TEST(BaseLib, CopyPathToFileNameWin)
{
- ASSERT_EQ ( BaseLib::copyPathToFileName("file", "extend"), "file" );
- ASSERT_EQ ( BaseLib::copyPathToFileName("path\\file", "extend"), "path\\file" );
+ ASSERT_EQ ( BaseLib::copyPathToFileName("file", "extend"), "file" );
+ ASSERT_EQ ( BaseLib::copyPathToFileName("path\\file", "extend"), "path\\file" );
- ASSERT_EQ ( BaseLib::copyPathToFileName("file", "extend\\"), "extend\\file" );
- ASSERT_EQ ( BaseLib::copyPathToFileName("path\\file", "extend\\"), "path\\file" );
+ ASSERT_EQ ( BaseLib::copyPathToFileName("file", "extend\\"), "extend\\file" );
+ ASSERT_EQ ( BaseLib::copyPathToFileName("path\\file", "extend\\"), "path\\file" );
- ASSERT_EQ ( BaseLib::copyPathToFileName("file", "extend\\smth"), "extend\\file" );
- ASSERT_EQ ( BaseLib::copyPathToFileName("path\\file", "extend\\smth"), "path\\file" );
+ ASSERT_EQ ( BaseLib::copyPathToFileName("file", "extend\\smth"), "extend\\file" );
+ ASSERT_EQ ( BaseLib::copyPathToFileName("path\\file", "extend\\smth"), "path\\file" );
}
TEST(BaseLib, CopyPathToFileNameUnix)
{
- ASSERT_EQ ( BaseLib::copyPathToFileName("file", "extend"), "file" );
- ASSERT_EQ ( BaseLib::copyPathToFileName("path/file", "extend"), "path/file" );
+ ASSERT_EQ ( BaseLib::copyPathToFileName("file", "extend"), "file" );
+ ASSERT_EQ ( BaseLib::copyPathToFileName("path/file", "extend"), "path/file" );
- ASSERT_EQ ( BaseLib::copyPathToFileName("file", "extend/"), "extend/file" );
- ASSERT_EQ ( BaseLib::copyPathToFileName("path/file", "extend/"), "path/file" );
+ ASSERT_EQ ( BaseLib::copyPathToFileName("file", "extend/"), "extend/file" );
+ ASSERT_EQ ( BaseLib::copyPathToFileName("path/file", "extend/"), "path/file" );
- ASSERT_EQ ( BaseLib::copyPathToFileName("file", "extend/smth"), "extend/file" );
- ASSERT_EQ ( BaseLib::copyPathToFileName("path/file", "extend/smth"), "path/file" );
+ ASSERT_EQ ( BaseLib::copyPathToFileName("file", "extend/smth"), "extend/file" );
+ ASSERT_EQ ( BaseLib::copyPathToFileName("path/file", "extend/smth"), "path/file" );
}
TEST(BaseLib, ExtractPathWin)
{
- ASSERT_EQ ( BaseLib::extractPath("file"), "" );
- ASSERT_EQ ( BaseLib::extractPath("/file"), "/" );
- ASSERT_EQ ( BaseLib::extractPath("path/"), "path/" );
- ASSERT_EQ ( BaseLib::extractPath("/path/"), "/path/" );
- ASSERT_EQ ( BaseLib::extractPath("path/file"), "path/" );
- ASSERT_EQ ( BaseLib::extractPath("/path/file"), "/path/" );
- ASSERT_EQ ( BaseLib::extractPath("/path/path/file"), "/path/path/" );
- ASSERT_EQ ( BaseLib::extractPath("/path/path/path/"), "/path/path/path/" );
-
- ASSERT_EQ ( BaseLib::extractPath("file.ext"), "" );
- ASSERT_EQ ( BaseLib::extractPath("/file.ext"), "/" );
- ASSERT_EQ ( BaseLib::extractPath("path.ext/"), "path.ext/" );
- ASSERT_EQ ( BaseLib::extractPath("/path.ext/"), "/path.ext/" );
- ASSERT_EQ ( BaseLib::extractPath("path/file.ext"), "path/" );
- ASSERT_EQ ( BaseLib::extractPath("/path/file.ext"), "/path/" );
- ASSERT_EQ ( BaseLib::extractPath("/path/path/file.ext"), "/path/path/" );
- ASSERT_EQ ( BaseLib::extractPath("/path/path/path.ext/"), "/path/path/path.ext/" );
+ ASSERT_EQ ( BaseLib::extractPath("file"), "" );
+ ASSERT_EQ ( BaseLib::extractPath("/file"), "/" );
+ ASSERT_EQ ( BaseLib::extractPath("path/"), "path/" );
+ ASSERT_EQ ( BaseLib::extractPath("/path/"), "/path/" );
+ ASSERT_EQ ( BaseLib::extractPath("path/file"), "path/" );
+ ASSERT_EQ ( BaseLib::extractPath("/path/file"), "/path/" );
+ ASSERT_EQ ( BaseLib::extractPath("/path/path/file"), "/path/path/" );
+ ASSERT_EQ ( BaseLib::extractPath("/path/path/path/"), "/path/path/path/" );
+
+ ASSERT_EQ ( BaseLib::extractPath("file.ext"), "" );
+ ASSERT_EQ ( BaseLib::extractPath("/file.ext"), "/" );
+ ASSERT_EQ ( BaseLib::extractPath("path.ext/"), "path.ext/" );
+ ASSERT_EQ ( BaseLib::extractPath("/path.ext/"), "/path.ext/" );
+ ASSERT_EQ ( BaseLib::extractPath("path/file.ext"), "path/" );
+ ASSERT_EQ ( BaseLib::extractPath("/path/file.ext"), "/path/" );
+ ASSERT_EQ ( BaseLib::extractPath("/path/path/file.ext"), "/path/path/" );
+ ASSERT_EQ ( BaseLib::extractPath("/path/path/path.ext/"), "/path/path/path.ext/" );
}
TEST(BaseLib, ExtractBaseNameWithoutExtensionWin)
{
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("file"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\file"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("path\\"), "" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\path\\"), "" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("path\\file"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\path\\file"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\path\\path\\file"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\path\\path\\path\\"), "" );
-
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("file.ext"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\file.ext"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("path.ext\\"), "" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\path.ext\\"), "" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("path\\file.ext"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\path\\file.ext"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\path\\path\\file.ext"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\path\\path\\path.ext\\"), "" );
-
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("path.wrong\\file.ext"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\path.wrong\\file.ext"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\path.wrong0\\path.wrong\\file.ext"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\path.wrong0\\path.wrong\\path.ext\\"), "" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("file"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\file"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("path\\"), "" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\path\\"), "" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("path\\file"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\path\\file"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\path\\path\\file"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\path\\path\\path\\"), "" );
+
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("file.ext"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\file.ext"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("path.ext\\"), "" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\path.ext\\"), "" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("path\\file.ext"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\path\\file.ext"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\path\\path\\file.ext"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\path\\path\\path.ext\\"), "" );
+
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("path.wrong\\file.ext"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\path.wrong\\file.ext"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\path.wrong0\\path.wrong\\file.ext"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("\\path.wrong0\\path.wrong\\path.ext\\"), "" );
}
TEST(BaseLib, ExtractBaseNameWithoutExtensionUnix)
{
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("file"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/file"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("path/"), "" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/path/"), "" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("path/file"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/path/file"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/path/path/file"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/path/path/path/"), "" );
-
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("file.ext"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/file.ext"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("path.ext/"), "" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/path.ext/"), "" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("path/file.ext"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/path/file.ext"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/path/path/file.ext"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/path/path/path.ext/"), "" );
-
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("path.wrong/file.ext"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/path.wrong/file.ext"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/path.wrong0/path.wrong/file.ext"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/path.wrong0/path.wrong/path.ext/"), "" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("file"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/file"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("path/"), "" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/path/"), "" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("path/file"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/path/file"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/path/path/file"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/path/path/path/"), "" );
+
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("file.ext"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/file.ext"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("path.ext/"), "" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/path.ext/"), "" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("path/file.ext"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/path/file.ext"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/path/path/file.ext"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/path/path/path.ext/"), "" );
+
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("path.wrong/file.ext"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/path.wrong/file.ext"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/path.wrong0/path.wrong/file.ext"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseNameWithoutExtension("/path.wrong0/path.wrong/path.ext/"), "" );
}
TEST(BaseLib, ExtractBaseNameWin)
{
- ASSERT_EQ ( BaseLib::extractBaseName("file"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseName("\\file"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseName("path\\"), "" );
- ASSERT_EQ ( BaseLib::extractBaseName("\\path\\"), "" );
- ASSERT_EQ ( BaseLib::extractBaseName("path\\file"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseName("\\path\\file"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseName("\\path\\path\\file"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseName("\\path\\path\\path\\"), "" );
-
- ASSERT_EQ ( BaseLib::extractBaseName("file.ext"), "file.ext" );
- ASSERT_EQ ( BaseLib::extractBaseName("\\file.ext"), "file.ext" );
- ASSERT_EQ ( BaseLib::extractBaseName("path.ext\\"), "" );
- ASSERT_EQ ( BaseLib::extractBaseName("\\path.ext\\"), "" );
- ASSERT_EQ ( BaseLib::extractBaseName("path\\file.ext"), "file.ext" );
- ASSERT_EQ ( BaseLib::extractBaseName("\\path\\file.ext"), "file.ext" );
- ASSERT_EQ ( BaseLib::extractBaseName("\\path\\path\\file.ext"), "file.ext" );
- ASSERT_EQ ( BaseLib::extractBaseName("\\path\\path\\path.ext\\"), "" );
-
- ASSERT_EQ ( BaseLib::extractBaseName("path.wrong\\file.ext"), "file.ext" );
- ASSERT_EQ ( BaseLib::extractBaseName("\\path.wrong\\file.ext"), "file.ext" );
- ASSERT_EQ ( BaseLib::extractBaseName("\\path.wrong0\\path.wrong\\file.ext"), "file.ext" );
- ASSERT_EQ ( BaseLib::extractBaseName("\\path.wrong0\\path.wrong\\path.ext\\"), "" );
+ ASSERT_EQ ( BaseLib::extractBaseName("file"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseName("\\file"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseName("path\\"), "" );
+ ASSERT_EQ ( BaseLib::extractBaseName("\\path\\"), "" );
+ ASSERT_EQ ( BaseLib::extractBaseName("path\\file"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseName("\\path\\file"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseName("\\path\\path\\file"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseName("\\path\\path\\path\\"), "" );
+
+ ASSERT_EQ ( BaseLib::extractBaseName("file.ext"), "file.ext" );
+ ASSERT_EQ ( BaseLib::extractBaseName("\\file.ext"), "file.ext" );
+ ASSERT_EQ ( BaseLib::extractBaseName("path.ext\\"), "" );
+ ASSERT_EQ ( BaseLib::extractBaseName("\\path.ext\\"), "" );
+ ASSERT_EQ ( BaseLib::extractBaseName("path\\file.ext"), "file.ext" );
+ ASSERT_EQ ( BaseLib::extractBaseName("\\path\\file.ext"), "file.ext" );
+ ASSERT_EQ ( BaseLib::extractBaseName("\\path\\path\\file.ext"), "file.ext" );
+ ASSERT_EQ ( BaseLib::extractBaseName("\\path\\path\\path.ext\\"), "" );
+
+ ASSERT_EQ ( BaseLib::extractBaseName("path.wrong\\file.ext"), "file.ext" );
+ ASSERT_EQ ( BaseLib::extractBaseName("\\path.wrong\\file.ext"), "file.ext" );
+ ASSERT_EQ ( BaseLib::extractBaseName("\\path.wrong0\\path.wrong\\file.ext"), "file.ext" );
+ ASSERT_EQ ( BaseLib::extractBaseName("\\path.wrong0\\path.wrong\\path.ext\\"), "" );
}
TEST(BaseLib, HasFileExtensionWin)
{
- ASSERT_TRUE ( BaseLib::hasFileExtension("", "file"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("", "\\file"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("", "path\\"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("", "\\path\\"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("", "path\\file"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("", "\\path\\file"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("", "\\path\\path\\file"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("", "\\path\\path\\path\\"));
-
- ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "file.ext"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "\\file.ext"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("", "path.ext\\"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("", "\\path.ext\\"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "path\\file.ext"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "\\path\\file.ext"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "\\path\\path\\file.ext"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("", "\\path\\path\\path.ext\\"));
-
- ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "path.wrong\\file.ext"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "\\path.wrong\\file.ext"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "\\path.wrong0\\path.wrong\\file.ext"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("", "\\path.wrong0\\path.wrong\\path.ext\\"));
-
- ASSERT_TRUE ( BaseLib::hasFileExtension("EXT", "file.ext"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("EXT", "file.EXT"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "file.EXT"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("Ext", "file.exT"));
-
- ASSERT_TRUE ( BaseLib::hasFileExtension("EXT", "path\\file.ext"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("EXT", "path\\file.EXT"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "path\\file.EXT"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("Ext", "path\\file.exT"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("", "file"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("", "\\file"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("", "path\\"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("", "\\path\\"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("", "path\\file"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("", "\\path\\file"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("", "\\path\\path\\file"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("", "\\path\\path\\path\\"));
+
+ ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "file.ext"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "\\file.ext"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("", "path.ext\\"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("", "\\path.ext\\"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "path\\file.ext"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "\\path\\file.ext"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "\\path\\path\\file.ext"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("", "\\path\\path\\path.ext\\"));
+
+ ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "path.wrong\\file.ext"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "\\path.wrong\\file.ext"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "\\path.wrong0\\path.wrong\\file.ext"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("", "\\path.wrong0\\path.wrong\\path.ext\\"));
+
+ ASSERT_TRUE ( BaseLib::hasFileExtension("EXT", "file.ext"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("EXT", "file.EXT"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "file.EXT"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("Ext", "file.exT"));
+
+ ASSERT_TRUE ( BaseLib::hasFileExtension("EXT", "path\\file.ext"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("EXT", "path\\file.EXT"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "path\\file.EXT"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("Ext", "path\\file.exT"));
}
TEST(BaseLib, HasFileExtensionUnix)
{
- ASSERT_TRUE ( BaseLib::hasFileExtension("", "file"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("", "/file"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("", "path/"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("", "/path/"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("", "path/file"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("", "/path/file"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("", "/path/path/file"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("", "/path/path/path/"));
-
- ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "file.ext"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "/file.ext"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("", "path.ext/"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("", "/path.ext/"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "path/file.ext"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "/path/file.ext"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "/path/path/file.ext"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("", "/path/path/path.ext/"));
-
- ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "path.wrong/file.ext"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "/path.wrong/file.ext"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "/path.wrong0/path.wrong/file.ext"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("", "/path.wrong0/path.wrong/path.ext/"));
-
- ASSERT_TRUE ( BaseLib::hasFileExtension("EXT", "file.ext"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("EXT", "file.EXT"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "file.EXT"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("Ext", "file.exT"));
-
- ASSERT_TRUE ( BaseLib::hasFileExtension("EXT", "path/file.ext"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("EXT", "path/file.EXT"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "path/file.EXT"));
- ASSERT_TRUE ( BaseLib::hasFileExtension("Ext", "path/file.exT"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("", "file"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("", "/file"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("", "path/"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("", "/path/"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("", "path/file"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("", "/path/file"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("", "/path/path/file"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("", "/path/path/path/"));
+
+ ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "file.ext"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "/file.ext"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("", "path.ext/"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("", "/path.ext/"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "path/file.ext"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "/path/file.ext"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "/path/path/file.ext"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("", "/path/path/path.ext/"));
+
+ ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "path.wrong/file.ext"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "/path.wrong/file.ext"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "/path.wrong0/path.wrong/file.ext"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("", "/path.wrong0/path.wrong/path.ext/"));
+
+ ASSERT_TRUE ( BaseLib::hasFileExtension("EXT", "file.ext"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("EXT", "file.EXT"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "file.EXT"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("Ext", "file.exT"));
+
+ ASSERT_TRUE ( BaseLib::hasFileExtension("EXT", "path/file.ext"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("EXT", "path/file.EXT"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("ext", "path/file.EXT"));
+ ASSERT_TRUE ( BaseLib::hasFileExtension("Ext", "path/file.exT"));
}
TEST(BaseLib, ExtractBaseNameUnix)
{
- ASSERT_EQ ( BaseLib::extractBaseName("file"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseName("/file"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseName("path/"), "" );
- ASSERT_EQ ( BaseLib::extractBaseName("/path/"), "" );
- ASSERT_EQ ( BaseLib::extractBaseName("path/file"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseName("/path/file"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseName("/path/path/file"), "file" );
- ASSERT_EQ ( BaseLib::extractBaseName("/path/path/path/"), "" );
-
- ASSERT_EQ ( BaseLib::extractBaseName("file.ext"), "file.ext" );
- ASSERT_EQ ( BaseLib::extractBaseName("/file.ext"), "file.ext" );
- ASSERT_EQ ( BaseLib::extractBaseName("path.ext/"), "" );
- ASSERT_EQ ( BaseLib::extractBaseName("/path.ext/"), "" );
- ASSERT_EQ ( BaseLib::extractBaseName("path/file.ext"), "file.ext" );
- ASSERT_EQ ( BaseLib::extractBaseName("/path/file.ext"), "file.ext" );
- ASSERT_EQ ( BaseLib::extractBaseName("/path/path/file.ext"), "file.ext" );
- ASSERT_EQ ( BaseLib::extractBaseName("/path/path/path.ext/"), "" );
-
- ASSERT_EQ ( BaseLib::extractBaseName("path.wrong/file.ext"), "file.ext" );
- ASSERT_EQ ( BaseLib::extractBaseName("/path.wrong/file.ext"), "file.ext" );
- ASSERT_EQ ( BaseLib::extractBaseName("/path.wrong0/path.wrong/file.ext"), "file.ext" );
- ASSERT_EQ ( BaseLib::extractBaseName("/path.wrong0/path.wrong/path.ext/"), "" );
+ ASSERT_EQ ( BaseLib::extractBaseName("file"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseName("/file"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseName("path/"), "" );
+ ASSERT_EQ ( BaseLib::extractBaseName("/path/"), "" );
+ ASSERT_EQ ( BaseLib::extractBaseName("path/file"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseName("/path/file"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseName("/path/path/file"), "file" );
+ ASSERT_EQ ( BaseLib::extractBaseName("/path/path/path/"), "" );
+
+ ASSERT_EQ ( BaseLib::extractBaseName("file.ext"), "file.ext" );
+ ASSERT_EQ ( BaseLib::extractBaseName("/file.ext"), "file.ext" );
+ ASSERT_EQ ( BaseLib::extractBaseName("path.ext/"), "" );
+ ASSERT_EQ ( BaseLib::extractBaseName("/path.ext/"), "" );
+ ASSERT_EQ ( BaseLib::extractBaseName("path/file.ext"), "file.ext" );
+ ASSERT_EQ ( BaseLib::extractBaseName("/path/file.ext"), "file.ext" );
+ ASSERT_EQ ( BaseLib::extractBaseName("/path/path/file.ext"), "file.ext" );
+ ASSERT_EQ ( BaseLib::extractBaseName("/path/path/path.ext/"), "" );
+
+ ASSERT_EQ ( BaseLib::extractBaseName("path.wrong/file.ext"), "file.ext" );
+ ASSERT_EQ ( BaseLib::extractBaseName("/path.wrong/file.ext"), "file.ext" );
+ ASSERT_EQ ( BaseLib::extractBaseName("/path.wrong0/path.wrong/file.ext"), "file.ext" );
+ ASSERT_EQ ( BaseLib::extractBaseName("/path.wrong0/path.wrong/path.ext/"), "" );
}
TEST(BaseLib, ExtractPathUnix)
{
- ASSERT_EQ ( BaseLib::extractPath("file"), "" );
- ASSERT_EQ ( BaseLib::extractPath("/file"), "/" );
- ASSERT_EQ ( BaseLib::extractPath("path/"), "path/" );
- ASSERT_EQ ( BaseLib::extractPath("/path/"), "/path/" );
- ASSERT_EQ ( BaseLib::extractPath("path/file"), "path/" );
- ASSERT_EQ ( BaseLib::extractPath("/path/file"), "/path/" );
- ASSERT_EQ ( BaseLib::extractPath("/path/path/file"), "/path/path/" );
- ASSERT_EQ ( BaseLib::extractPath("/path/path/path/"), "/path/path/path/" );
-
- ASSERT_EQ ( BaseLib::extractPath("file.ext"), "" );
- ASSERT_EQ ( BaseLib::extractPath("/file.ext"), "/" );
- ASSERT_EQ ( BaseLib::extractPath("path.ext/"), "path.ext/" );
- ASSERT_EQ ( BaseLib::extractPath("/path.ext/"), "/path.ext/" );
- ASSERT_EQ ( BaseLib::extractPath("path/file.ext"), "path/" );
- ASSERT_EQ ( BaseLib::extractPath("/path/file.ext"), "/path/" );
- ASSERT_EQ ( BaseLib::extractPath("/path/path/file.ext"), "/path/path/" );
- ASSERT_EQ ( BaseLib::extractPath("/path/path/path.ext/"), "/path/path/path.ext/" );
+ ASSERT_EQ ( BaseLib::extractPath("file"), "" );
+ ASSERT_EQ ( BaseLib::extractPath("/file"), "/" );
+ ASSERT_EQ ( BaseLib::extractPath("path/"), "path/" );
+ ASSERT_EQ ( BaseLib::extractPath("/path/"), "/path/" );
+ ASSERT_EQ ( BaseLib::extractPath("path/file"), "path/" );
+ ASSERT_EQ ( BaseLib::extractPath("/path/file"), "/path/" );
+ ASSERT_EQ ( BaseLib::extractPath("/path/path/file"), "/path/path/" );
+ ASSERT_EQ ( BaseLib::extractPath("/path/path/path/"), "/path/path/path/" );
+
+ ASSERT_EQ ( BaseLib::extractPath("file.ext"), "" );
+ ASSERT_EQ ( BaseLib::extractPath("/file.ext"), "/" );
+ ASSERT_EQ ( BaseLib::extractPath("path.ext/"), "path.ext/" );
+ ASSERT_EQ ( BaseLib::extractPath("/path.ext/"), "/path.ext/" );
+ ASSERT_EQ ( BaseLib::extractPath("path/file.ext"), "path/" );
+ ASSERT_EQ ( BaseLib::extractPath("/path/file.ext"), "/path/" );
+ ASSERT_EQ ( BaseLib::extractPath("/path/path/file.ext"), "/path/path/" );
+ ASSERT_EQ ( BaseLib::extractPath("/path/path/path.ext/"), "/path/path/path.ext/" );
}
TEST(BaseLib, JoinPaths)
{
#if _WIN32
- ASSERT_EQ ( "\\path\\path", BaseLib::joinPaths("\\path", "path") );
- ASSERT_EQ ( "\\path\\path", BaseLib::joinPaths("\\path", "\\path") );
- ASSERT_EQ ( "\\path\\path", BaseLib::joinPaths("\\path", ".\\path") );
+ ASSERT_EQ ( "\\path\\path", BaseLib::joinPaths("\\path", "path") );
+ ASSERT_EQ ( "\\path\\path", BaseLib::joinPaths("\\path", "\\path") );
+ ASSERT_EQ ( "\\path\\path", BaseLib::joinPaths("\\path", ".\\path") );
#else
- ASSERT_EQ ( "/path/path", BaseLib::joinPaths("/path", "path") );
- ASSERT_EQ ( "/path/path", BaseLib::joinPaths("/path", "/path") );
- ASSERT_EQ ( "/path/path", BaseLib::joinPaths("/path", "./path") );
+ ASSERT_EQ ( "/path/path", BaseLib::joinPaths("/path", "path") );
+ ASSERT_EQ ( "/path/path", BaseLib::joinPaths("/path", "/path") );
+ ASSERT_EQ ( "/path/path", BaseLib::joinPaths("/path", "./path") );
#endif
}
diff --git a/Tests/BaseLib/TestSwap.cpp b/Tests/BaseLib/TestSwap.cpp
index 2e9dda1849b86440858d670507679864a88ae189..1b89e0c25083dd98bb115bde0004117287f3fdf5 100644
--- a/Tests/BaseLib/TestSwap.cpp
+++ b/Tests/BaseLib/TestSwap.cpp
@@ -16,25 +16,25 @@
#include "gtest/gtest.h"
TEST(BaseLib, SwapInt) {
- int arg0 = 5;
- int arg1 = 10;
- std::swap(arg0, arg1);
- ASSERT_EQ ( arg0, 10 );
- ASSERT_EQ ( arg1, 5 );
+ int arg0 = 5;
+ int arg1 = 10;
+ std::swap(arg0, arg1);
+ ASSERT_EQ ( arg0, 10 );
+ ASSERT_EQ ( arg1, 5 );
}
TEST(BaseLib, SwapDouble) {
- double arg0 = 5.0;
- double arg1 = 10.0;
- std::swap(arg0, arg1);
- ASSERT_EQ ( arg0, 10.0 );
- ASSERT_EQ ( arg1, 5.0 );
+ double arg0 = 5.0;
+ double arg1 = 10.0;
+ std::swap(arg0, arg1);
+ ASSERT_EQ ( arg0, 10.0 );
+ ASSERT_EQ ( arg1, 5.0 );
}
TEST(BaseLib, SwapString) {
- std::string arg0 = "5";
- std::string arg1 = "10";
- std::swap(arg0, arg1);
- ASSERT_EQ ( arg0, std::string("10") );
- ASSERT_EQ ( arg1, std::string("5") );
+ std::string arg0 = "5";
+ std::string arg1 = "10";
+ std::swap(arg0, arg1);
+ ASSERT_EQ ( arg0, std::string("10") );
+ ASSERT_EQ ( arg1, std::string("5") );
}
diff --git a/Tests/BaseLib/TestSystemTools.cpp b/Tests/BaseLib/TestSystemTools.cpp
index 9b161dbee53560bcf2833153f6fa1343690818e9..00f37ac618046c15dab007f4efed7ad6668ec88c 100644
--- a/Tests/BaseLib/TestSystemTools.cpp
+++ b/Tests/BaseLib/TestSystemTools.cpp
@@ -23,6 +23,6 @@ TEST(BaseLib, EndianLittle) {
if (*(char*)&x)
isLittle = true; //am little
- ASSERT_EQ (isLittle, BaseLib::IsLittleEndian());
+ ASSERT_EQ (isLittle, BaseLib::IsLittleEndian());
}
diff --git a/Tests/BaseLib/excludeObjectCopy.cpp b/Tests/BaseLib/excludeObjectCopy.cpp
index ef8d58cf5d1e155da22ff18d62256305d6087d67..11700b74674f58cf87e89321571ceefb52a3554b 100644
--- a/Tests/BaseLib/excludeObjectCopy.cpp
+++ b/Tests/BaseLib/excludeObjectCopy.cpp
@@ -22,40 +22,40 @@
TEST(BaseLib, excludeObjectCopy)
{
- // create and fill vector
- std::size_t const size(100);
- std::vector<std::size_t> v(size);
- std::iota(v.begin(), v.end(), 0);
+ // create and fill vector
+ std::size_t const size(100);
+ std::vector<std::size_t> v(size);
+ std::iota(v.begin(), v.end(), 0);
- std::vector<std::size_t> ex_positions(size/10);
- // do not copy first 10 elements
- std::iota(ex_positions.begin(), ex_positions.end(), 0);
+ std::vector<std::size_t> ex_positions(size/10);
+ // do not copy first 10 elements
+ std::iota(ex_positions.begin(), ex_positions.end(), 0);
- std::vector<std::size_t> c1(BaseLib::excludeObjectCopy(v,ex_positions));
- ASSERT_EQ(size-ex_positions.size(), c1.size());
+ std::vector<std::size_t> c1(BaseLib::excludeObjectCopy(v,ex_positions));
+ ASSERT_EQ(size-ex_positions.size(), c1.size());
- for (std::size_t i(0); i<c1.size(); i++)
- ASSERT_EQ(c1[i], v[size/10+i]);
+ for (std::size_t i(0); i<c1.size(); i++)
+ ASSERT_EQ(c1[i], v[size/10+i]);
- // do not copy element 0, 2, 4, 6, 8, 10, 12, 14, 16, 18
- std::transform(ex_positions.begin(), ex_positions.end(),
- ex_positions.begin(), std::bind1st(std::multiplies<std::size_t>(),2));
+ // do not copy element 0, 2, 4, 6, 8, 10, 12, 14, 16, 18
+ std::transform(ex_positions.begin(), ex_positions.end(),
+ ex_positions.begin(), std::bind1st(std::multiplies<std::size_t>(),2));
- std::vector<std::size_t> c2(BaseLib::excludeObjectCopy(v,ex_positions));
- ASSERT_EQ(size-ex_positions.size(), c2.size());
+ std::vector<std::size_t> c2(BaseLib::excludeObjectCopy(v,ex_positions));
+ ASSERT_EQ(size-ex_positions.size(), c2.size());
- for (std::size_t i(0); i<ex_positions.size(); i++)
- ASSERT_EQ(c2[i], v[2*i+1]);
- for (std::size_t i(ex_positions.size()); i<c2.size(); i++)
- ASSERT_EQ(c2[i], v[ex_positions.size()+i]);
+ for (std::size_t i(0); i<ex_positions.size(); i++)
+ ASSERT_EQ(c2[i], v[2*i+1]);
+ for (std::size_t i(ex_positions.size()); i<c2.size(); i++)
+ ASSERT_EQ(c2[i], v[ex_positions.size()+i]);
- // do not copy the last element
- ex_positions.clear();
- ex_positions.push_back(99);
+ // do not copy the last element
+ ex_positions.clear();
+ ex_positions.push_back(99);
- std::vector<std::size_t> c3(BaseLib::excludeObjectCopy(v,ex_positions));
- ASSERT_EQ(size-ex_positions.size(), c3.size());
+ std::vector<std::size_t> c3(BaseLib::excludeObjectCopy(v,ex_positions));
+ ASSERT_EQ(size-ex_positions.size(), c3.size());
- for (std::size_t i(0); i<c3.size(); i++)
- ASSERT_EQ(c3[i], v[i]);
+ for (std::size_t i(0); i<c3.size(); i++)
+ ASSERT_EQ(c3[i], v[i]);
}
diff --git a/Tests/CMakeLists.txt b/Tests/CMakeLists.txt
index bcc9f942baeab3fac7012440348a322b076714fa..3b6a680ad231bf1a0653a9460360689a8fc5c703 100644
--- a/Tests/CMakeLists.txt
+++ b/Tests/CMakeLists.txt
@@ -3,7 +3,7 @@ include(${PROJECT_SOURCE_DIR}/scripts/cmake/OGSEnabledElements.cmake)
# VS2012 doesn't support correctly the tuples yet
# See http://code.google.com/p/googletest/issues/detail?id=412
if(MSVC)
- add_definitions(/D_VARIADIC_MAX=10)
+ add_definitions(/D_VARIADIC_MAX=10)
endif()
APPEND_SOURCE_FILES(TEST_SOURCES)
@@ -20,83 +20,83 @@ APPEND_SOURCE_FILES(TEST_SOURCES MeshGeoToolsLib)
APPEND_SOURCE_FILES(TEST_SOURCES NumLib)
if(QT4_FOUND)
- APPEND_SOURCE_FILES(TEST_SOURCES FileIO_Qt)
+ APPEND_SOURCE_FILES(TEST_SOURCES FileIO_Qt)
endif()
if(OGS_USE_PETSC OR OGS_USE_MPI)
- list(REMOVE_ITEM TEST_SOURCES AssemblerLib/TestSerialLinearSolver.cpp)
+ list(REMOVE_ITEM TEST_SOURCES AssemblerLib/TestSerialLinearSolver.cpp)
endif()
add_executable(testrunner ${TEST_SOURCES})
set_target_properties(testrunner PROPERTIES FOLDER Testing)
target_link_libraries(testrunner
- ApplicationsLib
- AssemblerLib
- FileIO
- GTest
- InSituLib
- MeshGeoToolsLib
- MeshLib
- NumLib
- Threads::Threads
+ ApplicationsLib
+ AssemblerLib
+ FileIO
+ GTest
+ InSituLib
+ MeshGeoToolsLib
+ MeshLib
+ NumLib
+ Threads::Threads
)
ADD_VTK_DEPENDENCY(testrunner)
if(OGS_USE_PETSC)
- target_link_libraries(testrunner ${PETSC_LIBRARIES})
+ target_link_libraries(testrunner ${PETSC_LIBRARIES})
endif()
if(OGS_USE_MPI)
- target_link_libraries(testrunner ${MPI_CXX_LIBRARIES})
+ target_link_libraries(testrunner ${MPI_CXX_LIBRARIES})
endif()
if(OGS_BUILD_GUI)
- target_link_libraries(testrunner
- QtDataView
- QtStratView
- VtkVis
- )
+ target_link_libraries(testrunner
+ QtDataView
+ QtStratView
+ VtkVis
+ )
endif()
if(QT4_FOUND)
- target_link_libraries(testrunner Qt4::QtCore Qt4::QtGui Qt4::QtXml Qt4::QtNetwork)
- if(CMAKE_CROSSCOMPILING)
- target_link_libraries(testrunner
- ${QT_XML_DEPS_LIBRARIES}
- ${QT_GUI_DEPS_LIBRARIES}
- ${QT_NETWORK_DEPS_LIBRARIES})
- endif()
+ target_link_libraries(testrunner Qt4::QtCore Qt4::QtGui Qt4::QtXml Qt4::QtNetwork)
+ if(CMAKE_CROSSCOMPILING)
+ target_link_libraries(testrunner
+ ${QT_XML_DEPS_LIBRARIES}
+ ${QT_GUI_DEPS_LIBRARIES}
+ ${QT_NETWORK_DEPS_LIBRARIES})
+ endif()
endif()
ADD_VTK_DEPENDENCY(testrunner)
# Add make-target tests which runs the testrunner
if(DEFINED ENV{CI})
- set(TESTRUNNER_ADDITIONAL_ARGUMENTS ${TESTRUNNER_ADDITIONAL_ARGUMENTS}
- --gtest_shuffle --gtest_repeat=3)
+ set(TESTRUNNER_ADDITIONAL_ARGUMENTS ${TESTRUNNER_ADDITIONAL_ARGUMENTS}
+ --gtest_shuffle --gtest_repeat=3)
endif()
set(TESTRUNNER_ADDITIONAL_ARGUMENTS ${TESTRUNNER_ADDITIONAL_ARGUMENTS}
- -l warn
- --gtest_output=xml:./testrunner.xml)
+ -l warn
+ --gtest_output=xml:./testrunner.xml)
add_custom_target(tests-cleanup ${CMAKE_COMMAND} -E remove testrunner.xml)
if(OGS_USE_PETSC)
- set(TEST_FILTER_MPI --gtest_filter=-MPITest_Math.*)
- add_custom_target(tests
- mpirun -np 1 $<TARGET_FILE:testrunner> ${TESTRUNNER_ADDITIONAL_ARGUMENTS} ${TEST_FILTER_MPI}
- DEPENDS testrunner tests-cleanup
- )
- add_custom_target(tests_mpi
- mpirun -np 3 $<TARGET_FILE:testrunner> --gtest_filter=MPITest*
- DEPENDS testrunner
- )
+ set(TEST_FILTER_MPI --gtest_filter=-MPITest_Math.*)
+ add_custom_target(tests
+ mpirun -np 1 $<TARGET_FILE:testrunner> ${TESTRUNNER_ADDITIONAL_ARGUMENTS} ${TEST_FILTER_MPI}
+ DEPENDS testrunner tests-cleanup
+ )
+ add_custom_target(tests_mpi
+ mpirun -np 3 $<TARGET_FILE:testrunner> --gtest_filter=MPITest*
+ DEPENDS testrunner
+ )
else()
- add_custom_target(tests
- $<TARGET_FILE:testrunner> ${TESTRUNNER_ADDITIONAL_ARGUMENTS}
- DEPENDS testrunner tests-cleanup
- )
+ add_custom_target(tests
+ $<TARGET_FILE:testrunner> ${TESTRUNNER_ADDITIONAL_ARGUMENTS}
+ DEPENDS testrunner tests-cleanup
+ )
endif()
# Creates one ctest entry for every googletest
diff --git a/Tests/FileIO/TestBoostGmlInterface.cpp b/Tests/FileIO/TestBoostGmlInterface.cpp
index fcb4d3023e7aaedd792550f155628e004c0e46d2..df87ddecc038368b221506e1b842626fd29f9fa9 100644
--- a/Tests/FileIO/TestBoostGmlInterface.cpp
+++ b/Tests/FileIO/TestBoostGmlInterface.cpp
@@ -24,29 +24,29 @@
TEST_F(TestGmlInterface, BoostXmlGmlWriterReaderTest)
{
- // Writer test
- std::string test_data_file(BaseLib::BuildInfo::tests_tmp_path
- + "TestXmlGmlReader.gml");
-
- GeoLib::IO::BoostXmlGmlInterface xml(geo_objects);
- xml.setNameForExport(geo_name);
- int result = xml.writeToFile(test_data_file);
- EXPECT_EQ(result, 1);
-
- // remove the written data from the data structures
- geo_objects.removeSurfaceVec(geo_name);
- geo_objects.removePolylineVec(geo_name);
- geo_objects.removePointVec(geo_name);
-
- // Reader test
- result = xml.readFile(test_data_file);
- EXPECT_EQ(1, result);
-
- std::remove(test_data_file.c_str());
- test_data_file += ".md5";
- std::remove(test_data_file.c_str());
-
- checkPointProperties();
- checkPolylineProperties();
- checkSurfaceProperties();
+ // Writer test
+ std::string test_data_file(BaseLib::BuildInfo::tests_tmp_path
+ + "TestXmlGmlReader.gml");
+
+ GeoLib::IO::BoostXmlGmlInterface xml(geo_objects);
+ xml.setNameForExport(geo_name);
+ int result = xml.writeToFile(test_data_file);
+ EXPECT_EQ(result, 1);
+
+ // remove the written data from the data structures
+ geo_objects.removeSurfaceVec(geo_name);
+ geo_objects.removePolylineVec(geo_name);
+ geo_objects.removePointVec(geo_name);
+
+ // Reader test
+ result = xml.readFile(test_data_file);
+ EXPECT_EQ(1, result);
+
+ std::remove(test_data_file.c_str());
+ test_data_file += ".md5";
+ std::remove(test_data_file.c_str());
+
+ checkPointProperties();
+ checkPolylineProperties();
+ checkSurfaceProperties();
}
diff --git a/Tests/FileIO/TestCsvReader.cpp b/Tests/FileIO/TestCsvReader.cpp
index 01572744eee46eccc20fd58c7cea0128e95d6fa1..57eea7588ac5bade825c160476767879e9e1ca38 100644
--- a/Tests/FileIO/TestCsvReader.cpp
+++ b/Tests/FileIO/TestCsvReader.cpp
@@ -23,169 +23,169 @@
class CsvInterfaceTest : public ::testing::Test
{
public:
- CsvInterfaceTest()
- : _file_name(BaseLib::BuildInfo::tests_tmp_path+"test.csv")
- {
- std::ofstream out(_file_name);
- out << "id x y z name value1 value_two\n";
- out << "0 642015.538 5724666.445 391.759 test_a 11.05303121 436.913 133\n";
- out << "1 642015.49 5724667.426 391.85 test_b 51.65503659\n";
- out << "2 642015.379 5724668.424 391.914 test_c 437.068 135 2\n";
- out << "3 642015.318 5724669.411 392.033 test_d 51.65505447 11.05302923\n";
- out << "4 642015.275 5724670.403 392.172 test_e 437.326 137 392.172\n";
- out << "5 642015.288 5724671.407 392.232 test_f\n";
- out << "6 642015.231 5724672.403 392.281 test_g 437.435\n";
- out << "7 642015.232 5724673.384 392.385 test_h 11.05302961 437.539\n";
- out << "8 642015.153 5724674.372 392.428 test_i 51.65509909 11.05302887\n";
- out << "9 642015.137 5724675.377 392.485 test_j 51.65510812 11.05302905\n";
- out.close();
- }
-
- ~CsvInterfaceTest()
- {
- std::remove(_file_name.c_str());
- }
+ CsvInterfaceTest()
+ : _file_name(BaseLib::BuildInfo::tests_tmp_path+"test.csv")
+ {
+ std::ofstream out(_file_name);
+ out << "id\tx\ty\tz\tname\tvalue1\tvalue_two\n";
+ out << "0\t642015.538\t5724666.445\t391.759\ttest_a\t11.05303121\t436.913\t133\n";
+ out << "1\t642015.49\t724667.426\t391.85\ttest_b\t51.65503659\n";
+ out << "2\t642015.379\t5724668.424\t391.914\ttest_c\t437.068\t135\t2\n";
+ out << "3\t642015.318\t5724669.411\t392.033\ttest_d\t51.65505447\t11.05302923\n";
+ out << "4\t642015.275\t5724670.403\t392.172\ttest_e\t437.326\t137\t392.172\n";
+ out << "5\t642015.288\t5724671.407\t392.232\ttest_f\n";
+ out << "6\t642015.231\t5724672.403\t392.281\ttest_g\t\t437.435\n";
+ out << "7\t642015.232\t5724673.384\t392.385\ttest_h\t11.05302961\t437.539\n";
+ out << "8\t642015.153\t5724674.372\t392.428\ttest_i\t51.65509909\t11.05302887\n";
+ out << "9\t642015.137\t5724675.377\t392.485\ttest_j\t51.65510812\t11.05302905\n";
+ out.close();
+ }
+
+ ~CsvInterfaceTest()
+ {
+ std::remove(_file_name.c_str());
+ }
protected:
- int _result;
- std::string _file_name;
+ int _result;
+ std::string _file_name;
};
/// Reading 3D points
TEST_F(CsvInterfaceTest, SimpleReadPoints)
{
- std::vector<GeoLib::Point*> points;
- std::vector<GeoLib::Point*> points2;
- _result = FileIO::CsvInterface::readPoints(_file_name, '\t', points);
- ASSERT_EQ(0, _result);
- _result = FileIO::CsvInterface::readPoints(_file_name, '\t', points2, "x", "y", "z");
- ASSERT_EQ(0, _result);
- ASSERT_TRUE(points.size() == 10);
- ASSERT_TRUE(points2.size() == 10);
- for (std::size_t i=0; i<points.size(); ++i)
- {
- ASSERT_TRUE((*points[i])[1] == (*points2[i])[0]);
- ASSERT_TRUE((*points[i])[2] == (*points2[i])[1]);
- }
- for (auto p : points)
- delete p;
- for (auto p : points2)
- delete p;
+ std::vector<GeoLib::Point*> points;
+ std::vector<GeoLib::Point*> points2;
+ _result = FileIO::CsvInterface::readPoints(_file_name, '\t', points);
+ ASSERT_EQ(0, _result);
+ _result = FileIO::CsvInterface::readPoints(_file_name, '\t', points2, "x", "y", "z");
+ ASSERT_EQ(0, _result);
+ ASSERT_TRUE(points.size() == 10);
+ ASSERT_TRUE(points2.size() == 10);
+ for (std::size_t i=0; i<points.size(); ++i)
+ {
+ ASSERT_TRUE((*points[i])[1] == (*points2[i])[0]);
+ ASSERT_TRUE((*points[i])[2] == (*points2[i])[1]);
+ }
+ for (auto p : points)
+ delete p;
+ for (auto p : points2)
+ delete p;
}
/// Dealing with unconvertable data types
TEST_F(CsvInterfaceTest, StringInPointColumn)
{
- std::vector<GeoLib::Point*> points;
- _result = FileIO::CsvInterface::readPoints(_file_name, '\t', points, "x", "y", "name");
- ASSERT_EQ(10, _result);
- ASSERT_TRUE(points.empty());
+ std::vector<GeoLib::Point*> points;
+ _result = FileIO::CsvInterface::readPoints(_file_name, '\t', points, "x", "y", "name");
+ ASSERT_EQ(10, _result);
+ ASSERT_TRUE(points.empty());
}
/// Dealing with not existing columns
TEST_F(CsvInterfaceTest, WrongColumnName)
{
- std::vector<GeoLib::Point*> points;
- _result = FileIO::CsvInterface::readPoints(_file_name, '\t', points, "x", "y", "wrong_column_name");
- ASSERT_EQ(-1, _result);
- ASSERT_TRUE(points.empty());
-
- _result = FileIO::CsvInterface::readPoints(_file_name, '\t', points, "wrong_column_name", "y", "id");
- ASSERT_EQ(-1, _result);
- ASSERT_TRUE(points.empty());
+ std::vector<GeoLib::Point*> points;
+ _result = FileIO::CsvInterface::readPoints(_file_name, '\t', points, "x", "y", "wrong_column_name");
+ ASSERT_EQ(-1, _result);
+ ASSERT_TRUE(points.empty());
+
+ _result = FileIO::CsvInterface::readPoints(_file_name, '\t', points, "wrong_column_name", "y", "id");
+ ASSERT_EQ(-1, _result);
+ ASSERT_TRUE(points.empty());
}
/// Dealing with missing values
TEST_F(CsvInterfaceTest, MissingValues)
{
- std::vector<GeoLib::Point*> points;
- _result = FileIO::CsvInterface::readPoints(_file_name, '\t', points, "z", "value1", "value_two");
- ASSERT_EQ(3, _result);
- ASSERT_EQ(7, points.size());
- ASSERT_NEAR(437.539, (*points[4])[2], std::numeric_limits<double>::epsilon());
- for (auto p : points)
- delete p;
+ std::vector<GeoLib::Point*> points;
+ _result = FileIO::CsvInterface::readPoints(_file_name, '\t', points, "z", "value1", "value_two");
+ ASSERT_EQ(3, _result);
+ ASSERT_EQ(7, points.size());
+ ASSERT_NEAR(437.539, (*points[4])[2], std::numeric_limits<double>::epsilon());
+ for (auto p : points)
+ delete p;
}
/// Reading 2D points
TEST_F(CsvInterfaceTest, Points2D)
{
- std::vector<GeoLib::Point*> points;
- _result = FileIO::CsvInterface::readPoints(_file_name, '\t', points, "x", "y");
- ASSERT_EQ(0, _result);
- ASSERT_EQ(10, points.size());
- for (std::size_t i=0; i<points.size(); ++i)
- ASSERT_NEAR(0, (*points[i])[2], std::numeric_limits<double>::epsilon());
- for (auto p : points)
- delete p;
+ std::vector<GeoLib::Point*> points;
+ _result = FileIO::CsvInterface::readPoints(_file_name, '\t', points, "x", "y");
+ ASSERT_EQ(0, _result);
+ ASSERT_EQ(10, points.size());
+ for (std::size_t i=0; i<points.size(); ++i)
+ ASSERT_NEAR(0, (*points[i])[2], std::numeric_limits<double>::epsilon());
+ for (auto p : points)
+ delete p;
}
/// Dealing with non-sequential column order
TEST_F(CsvInterfaceTest, CoordinateOrder)
{
- std::vector<GeoLib::Point*> points1;
- std::vector<GeoLib::Point*> points2;
- std::vector<GeoLib::Point*> points3;
- _result = FileIO::CsvInterface::readPoints(_file_name, '\t', points1, "id", "y", "z");
- ASSERT_EQ(0, _result);
- _result = FileIO::CsvInterface::readPoints(_file_name, '\t', points2, "id", "z", "y");
- ASSERT_EQ(0, _result);
- _result = FileIO::CsvInterface::readPoints(_file_name, '\t', points3, "y", "id", "z");
- ASSERT_EQ(0, _result);
- ASSERT_EQ(10, points1.size());
- ASSERT_EQ(10, points2.size());
- ASSERT_EQ(10, points3.size());
- for (std::size_t i=0; i<points1.size(); ++i)
- {
- ASSERT_EQ((*points1[i])[1], (*points2[i])[2]);
- ASSERT_EQ((*points1[i])[2], (*points2[i])[1]);
- ASSERT_EQ((*points3[i])[0], (*points2[i])[2]);
- ASSERT_EQ((*points3[i])[1], (*points2[i])[0]);
- ASSERT_EQ((*points1[i])[0], (*points3[i])[1]);
- ASSERT_EQ((*points1[i])[1], (*points3[i])[0]);
- }
- for (auto p : points1)
- delete p;
- for (auto p : points2)
- delete p;
- for (auto p : points3)
- delete p;
+ std::vector<GeoLib::Point*> points1;
+ std::vector<GeoLib::Point*> points2;
+ std::vector<GeoLib::Point*> points3;
+ _result = FileIO::CsvInterface::readPoints(_file_name, '\t', points1, "id", "y", "z");
+ ASSERT_EQ(0, _result);
+ _result = FileIO::CsvInterface::readPoints(_file_name, '\t', points2, "id", "z", "y");
+ ASSERT_EQ(0, _result);
+ _result = FileIO::CsvInterface::readPoints(_file_name, '\t', points3, "y", "id", "z");
+ ASSERT_EQ(0, _result);
+ ASSERT_EQ(10, points1.size());
+ ASSERT_EQ(10, points2.size());
+ ASSERT_EQ(10, points3.size());
+ for (std::size_t i=0; i<points1.size(); ++i)
+ {
+ ASSERT_EQ((*points1[i])[1], (*points2[i])[2]);
+ ASSERT_EQ((*points1[i])[2], (*points2[i])[1]);
+ ASSERT_EQ((*points3[i])[0], (*points2[i])[2]);
+ ASSERT_EQ((*points3[i])[1], (*points2[i])[0]);
+ ASSERT_EQ((*points1[i])[0], (*points3[i])[1]);
+ ASSERT_EQ((*points1[i])[1], (*points3[i])[0]);
+ }
+ for (auto p : points1)
+ delete p;
+ for (auto p : points2)
+ delete p;
+ for (auto p : points3)
+ delete p;
}
/// Getting single columns
TEST_F(CsvInterfaceTest, GetColumn)
{
- std::vector<std::string> names;
- _result = FileIO::CsvInterface::readColumn<std::string>(_file_name, '\t', names, "name");
- ASSERT_EQ(0, _result);
- ASSERT_EQ(10, names.size());
-
- std::vector<double> values;
- _result = FileIO::CsvInterface::readColumn<double>(_file_name, '\t', values, "value_two");
- ASSERT_EQ(2, _result);
- ASSERT_EQ(8, values.size());
+ std::vector<std::string> names;
+ _result = FileIO::CsvInterface::readColumn<std::string>(_file_name, '\t', names, "name");
+ ASSERT_EQ(0, _result);
+ ASSERT_EQ(10, names.size());
+
+ std::vector<double> values;
+ _result = FileIO::CsvInterface::readColumn<double>(_file_name, '\t', values, "value_two");
+ ASSERT_EQ(2, _result);
+ ASSERT_EQ(8, values.size());
}
/// Dealing with non-existing column
TEST_F(CsvInterfaceTest, NonExistingColumn)
{
- std::vector<double> values;
- _result = FileIO::CsvInterface::readColumn<double>(_file_name, '\t', values, "value2");
- ASSERT_EQ(-1, _result);
- ASSERT_TRUE(values.empty());
+ std::vector<double> values;
+ _result = FileIO::CsvInterface::readColumn<double>(_file_name, '\t', values, "value2");
+ ASSERT_EQ(-1, _result);
+ ASSERT_TRUE(values.empty());
}
/// Dealing with wrong data type
TEST_F(CsvInterfaceTest, WrongDataType)
{
- std::vector<double> values;
- _result = FileIO::CsvInterface::readColumn<double>(_file_name, '\t', values, "name");
- ASSERT_EQ(10, _result);
- ASSERT_TRUE(values.empty());
-
- std::vector<std::string> names;
- _result = FileIO::CsvInterface::readColumn<std::string>(_file_name, '\t', names, "value1");
- ASSERT_EQ(2, _result);
- ASSERT_EQ(8, names.size());
+ std::vector<double> values;
+ _result = FileIO::CsvInterface::readColumn<double>(_file_name, '\t', values, "name");
+ ASSERT_EQ(10, _result);
+ ASSERT_TRUE(values.empty());
+
+ std::vector<std::string> names;
+ _result = FileIO::CsvInterface::readColumn<std::string>(_file_name, '\t', names, "value1");
+ ASSERT_EQ(2, _result);
+ ASSERT_EQ(8, names.size());
}
diff --git a/Tests/FileIO/TestGmlInterface.h b/Tests/FileIO/TestGmlInterface.h
index d02df29fe13e3ae15b645be60df124d7cacb07ed..4b384c864837143a7e2a4a85b05fae91ee9f7c34 100644
--- a/Tests/FileIO/TestGmlInterface.h
+++ b/Tests/FileIO/TestGmlInterface.h
@@ -25,182 +25,182 @@
class TestGmlInterface : public testing::Test
{
public:
- GeoLib::GEOObjects geo_objects;
- std::string geo_name = "TestData";
-
- std::vector<GeoLib::Point> test_pnts;
- std::map<std::string, std::size_t> pnt_name_id_map;
-
- TestGmlInterface()
- {
- createPoints();
- createPolylines();
- createSurfaces();
- }
-
- void createPoints()
- {
- test_pnts.emplace_back(1,1,0,0);
- test_pnts.emplace_back(1,2,0,1);
- test_pnts.emplace_back(1,3,0,2);
- test_pnts.emplace_back(2,1,0,3);
- test_pnts.emplace_back(2,2,0,4);
- test_pnts.emplace_back(2,3,0,5);
- test_pnts.emplace_back(3,1,0,6);
- test_pnts.emplace_back(3,2,0,7);
- test_pnts.emplace_back(3,3,0,8);
- auto points = std::unique_ptr<std::vector<GeoLib::Point*>>(
- new std::vector<GeoLib::Point*>(9));
-
- auto cpy_name_id_map = new std::map<std::string, std::size_t>;
- std::size_t pos(0);
- for (auto p : test_pnts) {
- (*points)[pos] = new GeoLib::Point(p);
- pnt_name_id_map["p"+std::to_string(pos)] = pos;
- (*cpy_name_id_map)["p"+std::to_string(pos)] = pos;
- pos++;
- }
-
- geo_objects.addPointVec(std::move(points), geo_name, cpy_name_id_map);
- }
-
- void checkPointProperties()
- {
- auto const& pointvec(*geo_objects.getPointVecObj(geo_name));
- auto const& read_points(*pointvec.getVector());
- EXPECT_EQ(test_pnts.size(), read_points.size());
- for (std::size_t k(0); k<test_pnts.size(); ++k) {
- GeoLib::Point const& read_pnt = *read_points[k];
- // compare the coordinates
- EXPECT_EQ(test_pnts[k][0], read_pnt[0]);
- EXPECT_EQ(test_pnts[k][1], read_pnt[1]);
- EXPECT_EQ(test_pnts[k][2], read_pnt[2]);
- // compare the ids
- EXPECT_EQ(test_pnts[k].getID(), read_pnt.getID());
- }
-
- for (auto p : read_points) {
- // fetch name of read point
- std::string read_name;
- pointvec.getNameOfElementByID(p->getID(), read_name);
- // compare the id of the original point fetched by using the
- // read_name and the id of the read point
- EXPECT_EQ(p->getID(), pnt_name_id_map[read_name]);
- }
- }
-
- void createPolylines()
- {
- auto createPolyline = [](GeoLib::PointVec const& pnt_vec,
- std::vector<GeoLib::Polyline*> & lines, std::size_t line_id,
- std::vector<std::size_t> pnt_ids,
- std::map<std::string,std::size_t> & line_name_map,
- std::string const& name)
- {
- auto const & pnt_id_map(pnt_vec.getIDMap());
- lines[line_id] = new GeoLib::Polyline(*(pnt_vec.getVector()));
- for (std::size_t k(0); k<pnt_ids.size(); ++k) {
- lines[line_id]->addPoint(pnt_id_map[pnt_ids[k]]);
- }
-
- if (!name.empty())
- line_name_map.insert(std::make_pair(name, line_id));
- };
-
- auto const& pnt_vec = *(geo_objects.getPointVecObj(geo_name));
-
- auto lines = std::unique_ptr<std::vector<GeoLib::Polyline*>>(
- new std::vector<GeoLib::Polyline*>(5));
- std::map<std::string, std::size_t>* name_map =
- new std::map<std::string, std::size_t>;
-
- createPolyline(pnt_vec, *(lines.get()), 0, {0, 1, 2}, *name_map, "left");
- createPolyline(pnt_vec, *(lines.get()), 1, {3, 4, 5}, *name_map, "center");
- createPolyline(pnt_vec, *(lines.get()), 2, {0, 3}, *name_map, "line1");
- createPolyline(pnt_vec, *(lines.get()), 3, {3, 6}, *name_map, "line2");
- createPolyline(pnt_vec, *(lines.get()), 4, {6, 7, 8}, *name_map, "right");
- geo_objects.addPolylineVec(std::move(lines), geo_name, name_map);
- }
-
- void checkPolylineProperties()
- {
- const GeoLib::PolylineVec *line_vec = geo_objects.getPolylineVecObj(geo_name);
- auto const readerLines = geo_objects.getPolylineVec(geo_name);
- EXPECT_EQ(5u, readerLines->size());
-
- auto checkPolylineProperty = [this](GeoLib::PolylineVec const* line_vec,
- std::size_t ply_id, std::vector<std::size_t> pnt_ids,
- std::string const& name)
- {
- auto const lines = geo_objects.getPolylineVec(geo_name);
- GeoLib::Polyline* line = (*lines)[ply_id];
- EXPECT_EQ(pnt_ids.size(), line->getNumberOfPoints());
- for (std::size_t k(0); k<pnt_ids.size(); ++k)
- EXPECT_EQ(pnt_ids[k], line->getPointID(k));
- std::string line_name;
- line_vec->getNameOfElementByID(ply_id, line_name);
- EXPECT_EQ(name, line_name);
- };
-
- checkPolylineProperty(line_vec, 0, {0, 1, 2}, "left");
- checkPolylineProperty(line_vec, 1, {3, 4, 5}, "center");
- checkPolylineProperty(line_vec, 2, {0, 3}, "line1");
- checkPolylineProperty(line_vec, 3, {3, 6}, "line2");
- checkPolylineProperty(line_vec, 4, {6, 7, 8}, "right");
- }
-
- void createSurfaces()
- {
- auto const points = geo_objects.getPointVec(geo_name);
- const std::vector<std::size_t> pnt_id_map(
- geo_objects.getPointVecObj(geo_name)->getIDMap());
-
- auto sfcs = std::unique_ptr<std::vector<GeoLib::Surface*>>(
- new std::vector<GeoLib::Surface*>(2));
- std::map<std::string, std::size_t>* sfc_names =
- new std::map<std::string, std::size_t>;
- (*sfcs)[0] = new GeoLib::Surface(*points);
- (*sfcs)[0]->addTriangle(pnt_id_map[0], pnt_id_map[3], pnt_id_map[1]);
- (*sfcs)[0]->addTriangle(pnt_id_map[1], pnt_id_map[3], pnt_id_map[4]);
- (*sfcs)[0]->addTriangle(pnt_id_map[1], pnt_id_map[4], pnt_id_map[2]);
- (*sfcs)[0]->addTriangle(pnt_id_map[2], pnt_id_map[4], pnt_id_map[5]);
- (*sfc_names)["FirstSurface"] = 0;
- (*sfcs)[1] = new GeoLib::Surface(*points);
- (*sfcs)[1]->addTriangle(pnt_id_map[3], pnt_id_map[6], pnt_id_map[8]);
- (*sfcs)[1]->addTriangle(pnt_id_map[3], pnt_id_map[8], pnt_id_map[5]);
- (*sfc_names)["SecondSurface"] = 1;
- geo_objects.addSurfaceVec(std::move(sfcs), geo_name, sfc_names);
- }
-
- void checkSurfaceProperties()
- {
- auto checkTriangleIDs = [](
- GeoLib::Triangle const& tri, std::array<std::size_t,3> ids)
- {
- EXPECT_EQ(ids[0], tri[0]);
- EXPECT_EQ(ids[1], tri[1]);
- EXPECT_EQ(ids[2], tri[2]);
- };
-
- auto checkSurface = [&checkTriangleIDs](GeoLib::SurfaceVec const& sfcs,
- std::size_t sfc_id, std::vector<std::array<std::size_t,3>> tri_ids,
- std::string const& name)
- {
- auto const& sfc_vec = *(sfcs.getVector());
- auto const& sfc = *(sfc_vec[sfc_id]);
- EXPECT_EQ(tri_ids.size(), sfc.getNTriangles());
- for (std::size_t k(0); k<tri_ids.size(); ++k)
- checkTriangleIDs(*(sfc[k]), tri_ids[k]);
-
- std::string sfc_name;
- sfcs.getNameOfElementByID(sfc_id, sfc_name);
- EXPECT_EQ(0u, name.compare(sfc_name));
- };
-
- auto const read_sfcs = geo_objects.getSurfaceVecObj(geo_name);
- EXPECT_EQ(2u, read_sfcs->size());
- checkSurface(*read_sfcs, 0,
- {{{0,3,1}}, {{1,3,4}}, {{1,4,2}}, {{2,4,5}}}, "FirstSurface");
- checkSurface(*read_sfcs, 1, {{{3,6,8}}, {{3,8,5}}}, "SecondSurface");
- }
+ GeoLib::GEOObjects geo_objects;
+ std::string geo_name = "TestData";
+
+ std::vector<GeoLib::Point> test_pnts;
+ std::map<std::string, std::size_t> pnt_name_id_map;
+
+ TestGmlInterface()
+ {
+ createPoints();
+ createPolylines();
+ createSurfaces();
+ }
+
+ void createPoints()
+ {
+ test_pnts.emplace_back(1,1,0,0);
+ test_pnts.emplace_back(1,2,0,1);
+ test_pnts.emplace_back(1,3,0,2);
+ test_pnts.emplace_back(2,1,0,3);
+ test_pnts.emplace_back(2,2,0,4);
+ test_pnts.emplace_back(2,3,0,5);
+ test_pnts.emplace_back(3,1,0,6);
+ test_pnts.emplace_back(3,2,0,7);
+ test_pnts.emplace_back(3,3,0,8);
+ auto points = std::unique_ptr<std::vector<GeoLib::Point*>>(
+ new std::vector<GeoLib::Point*>(9));
+
+ auto cpy_name_id_map = new std::map<std::string, std::size_t>;
+ std::size_t pos(0);
+ for (auto p : test_pnts) {
+ (*points)[pos] = new GeoLib::Point(p);
+ pnt_name_id_map["p"+std::to_string(pos)] = pos;
+ (*cpy_name_id_map)["p"+std::to_string(pos)] = pos;
+ pos++;
+ }
+
+ geo_objects.addPointVec(std::move(points), geo_name, cpy_name_id_map);
+ }
+
+ void checkPointProperties()
+ {
+ auto const& pointvec(*geo_objects.getPointVecObj(geo_name));
+ auto const& read_points(*pointvec.getVector());
+ EXPECT_EQ(test_pnts.size(), read_points.size());
+ for (std::size_t k(0); k<test_pnts.size(); ++k) {
+ GeoLib::Point const& read_pnt = *read_points[k];
+ // compare the coordinates
+ EXPECT_EQ(test_pnts[k][0], read_pnt[0]);
+ EXPECT_EQ(test_pnts[k][1], read_pnt[1]);
+ EXPECT_EQ(test_pnts[k][2], read_pnt[2]);
+ // compare the ids
+ EXPECT_EQ(test_pnts[k].getID(), read_pnt.getID());
+ }
+
+ for (auto p : read_points) {
+ // fetch name of read point
+ std::string read_name;
+ pointvec.getNameOfElementByID(p->getID(), read_name);
+ // compare the id of the original point fetched by using the
+ // read_name and the id of the read point
+ EXPECT_EQ(p->getID(), pnt_name_id_map[read_name]);
+ }
+ }
+
+ void createPolylines()
+ {
+ auto createPolyline = [](GeoLib::PointVec const& pnt_vec,
+ std::vector<GeoLib::Polyline*> & lines, std::size_t line_id,
+ std::vector<std::size_t> pnt_ids,
+ std::map<std::string,std::size_t> & line_name_map,
+ std::string const& name)
+ {
+ auto const & pnt_id_map(pnt_vec.getIDMap());
+ lines[line_id] = new GeoLib::Polyline(*(pnt_vec.getVector()));
+ for (std::size_t k(0); k<pnt_ids.size(); ++k) {
+ lines[line_id]->addPoint(pnt_id_map[pnt_ids[k]]);
+ }
+
+ if (!name.empty())
+ line_name_map.insert(std::make_pair(name, line_id));
+ };
+
+ auto const& pnt_vec = *(geo_objects.getPointVecObj(geo_name));
+
+ auto lines = std::unique_ptr<std::vector<GeoLib::Polyline*>>(
+ new std::vector<GeoLib::Polyline*>(5));
+ std::map<std::string, std::size_t>* name_map =
+ new std::map<std::string, std::size_t>;
+
+ createPolyline(pnt_vec, *(lines.get()), 0, {0, 1, 2}, *name_map, "left");
+ createPolyline(pnt_vec, *(lines.get()), 1, {3, 4, 5}, *name_map, "center");
+ createPolyline(pnt_vec, *(lines.get()), 2, {0, 3}, *name_map, "line1");
+ createPolyline(pnt_vec, *(lines.get()), 3, {3, 6}, *name_map, "line2");
+ createPolyline(pnt_vec, *(lines.get()), 4, {6, 7, 8}, *name_map, "right");
+ geo_objects.addPolylineVec(std::move(lines), geo_name, name_map);
+ }
+
+ void checkPolylineProperties()
+ {
+ const GeoLib::PolylineVec *line_vec = geo_objects.getPolylineVecObj(geo_name);
+ auto const readerLines = geo_objects.getPolylineVec(geo_name);
+ EXPECT_EQ(5u, readerLines->size());
+
+ auto checkPolylineProperty = [this](GeoLib::PolylineVec const* line_vec,
+ std::size_t ply_id, std::vector<std::size_t> pnt_ids,
+ std::string const& name)
+ {
+ auto const lines = geo_objects.getPolylineVec(geo_name);
+ GeoLib::Polyline* line = (*lines)[ply_id];
+ EXPECT_EQ(pnt_ids.size(), line->getNumberOfPoints());
+ for (std::size_t k(0); k<pnt_ids.size(); ++k)
+ EXPECT_EQ(pnt_ids[k], line->getPointID(k));
+ std::string line_name;
+ line_vec->getNameOfElementByID(ply_id, line_name);
+ EXPECT_EQ(name, line_name);
+ };
+
+ checkPolylineProperty(line_vec, 0, {0, 1, 2}, "left");
+ checkPolylineProperty(line_vec, 1, {3, 4, 5}, "center");
+ checkPolylineProperty(line_vec, 2, {0, 3}, "line1");
+ checkPolylineProperty(line_vec, 3, {3, 6}, "line2");
+ checkPolylineProperty(line_vec, 4, {6, 7, 8}, "right");
+ }
+
+ void createSurfaces()
+ {
+ auto const points = geo_objects.getPointVec(geo_name);
+ const std::vector<std::size_t> pnt_id_map(
+ geo_objects.getPointVecObj(geo_name)->getIDMap());
+
+ auto sfcs = std::unique_ptr<std::vector<GeoLib::Surface*>>(
+ new std::vector<GeoLib::Surface*>(2));
+ std::map<std::string, std::size_t>* sfc_names =
+ new std::map<std::string, std::size_t>;
+ (*sfcs)[0] = new GeoLib::Surface(*points);
+ (*sfcs)[0]->addTriangle(pnt_id_map[0], pnt_id_map[3], pnt_id_map[1]);
+ (*sfcs)[0]->addTriangle(pnt_id_map[1], pnt_id_map[3], pnt_id_map[4]);
+ (*sfcs)[0]->addTriangle(pnt_id_map[1], pnt_id_map[4], pnt_id_map[2]);
+ (*sfcs)[0]->addTriangle(pnt_id_map[2], pnt_id_map[4], pnt_id_map[5]);
+ (*sfc_names)["FirstSurface"] = 0;
+ (*sfcs)[1] = new GeoLib::Surface(*points);
+ (*sfcs)[1]->addTriangle(pnt_id_map[3], pnt_id_map[6], pnt_id_map[8]);
+ (*sfcs)[1]->addTriangle(pnt_id_map[3], pnt_id_map[8], pnt_id_map[5]);
+ (*sfc_names)["SecondSurface"] = 1;
+ geo_objects.addSurfaceVec(std::move(sfcs), geo_name, sfc_names);
+ }
+
+ void checkSurfaceProperties()
+ {
+ auto checkTriangleIDs = [](
+ GeoLib::Triangle const& tri, std::array<std::size_t,3> ids)
+ {
+ EXPECT_EQ(ids[0], tri[0]);
+ EXPECT_EQ(ids[1], tri[1]);
+ EXPECT_EQ(ids[2], tri[2]);
+ };
+
+ auto checkSurface = [&checkTriangleIDs](GeoLib::SurfaceVec const& sfcs,
+ std::size_t sfc_id, std::vector<std::array<std::size_t,3>> tri_ids,
+ std::string const& name)
+ {
+ auto const& sfc_vec = *(sfcs.getVector());
+ auto const& sfc = *(sfc_vec[sfc_id]);
+ EXPECT_EQ(tri_ids.size(), sfc.getNTriangles());
+ for (std::size_t k(0); k<tri_ids.size(); ++k)
+ checkTriangleIDs(*(sfc[k]), tri_ids[k]);
+
+ std::string sfc_name;
+ sfcs.getNameOfElementByID(sfc_id, sfc_name);
+ EXPECT_EQ(0u, name.compare(sfc_name));
+ };
+
+ auto const read_sfcs = geo_objects.getSurfaceVecObj(geo_name);
+ EXPECT_EQ(2u, read_sfcs->size());
+ checkSurface(*read_sfcs, 0,
+ {{{0,3,1}}, {{1,3,4}}, {{1,4,2}}, {{2,4,5}}}, "FirstSurface");
+ checkSurface(*read_sfcs, 1, {{{3,6,8}}, {{3,8,5}}}, "SecondSurface");
+ }
};
diff --git a/Tests/FileIO/TestGmsInterface.cpp b/Tests/FileIO/TestGmsInterface.cpp
index 6d0831c7cf0a19935cba2a90936e961b23b9b309..39695bdea31aceb1088b4a8050bda5c73d9aed5b 100644
--- a/Tests/FileIO/TestGmsInterface.cpp
+++ b/Tests/FileIO/TestGmsInterface.cpp
@@ -19,18 +19,18 @@
TEST(FileIO, TestGmsInterface)
{
- std::string const file_name (BaseLib::BuildInfo::data_path + "/FileIO/3DMeshData.3dm");
- std::unique_ptr<MeshLib::Mesh> mesh (FileIO::GMSInterface::readGMS3DMMesh(file_name));
- ASSERT_TRUE(mesh != nullptr);
- ASSERT_EQ(11795, mesh->getNNodes());
- ASSERT_EQ(19885, mesh->getNElements());
+ std::string const file_name (BaseLib::BuildInfo::data_path + "/FileIO/3DMeshData.3dm");
+ std::unique_ptr<MeshLib::Mesh> mesh (FileIO::GMSInterface::readGMS3DMMesh(file_name));
+ ASSERT_TRUE(mesh != nullptr);
+ ASSERT_EQ(11795, mesh->getNNodes());
+ ASSERT_EQ(19885, mesh->getNElements());
- std::array<unsigned, 7> types (MeshLib::MeshInformation::getNumberOfElementTypes(*mesh));
- ASSERT_EQ(1456, types[3]); // tets
- ASSERT_EQ(1355, types[5]); // pyramids
- ASSERT_EQ(17074, types[6]); // prism
- std::pair<int, int> bounds (MeshLib::MeshInformation::getValueBounds<int>(*mesh, "MaterialIDs"));
- ASSERT_EQ(1, bounds.first);
- ASSERT_EQ(63, bounds.second);
+ std::array<unsigned, 7> types (MeshLib::MeshInformation::getNumberOfElementTypes(*mesh));
+ ASSERT_EQ(1456, types[3]); // tets
+ ASSERT_EQ(1355, types[5]); // pyramids
+ ASSERT_EQ(17074, types[6]); // prism
+ std::pair<int, int> bounds (MeshLib::MeshInformation::getValueBounds<int>(*mesh, "MaterialIDs"));
+ ASSERT_EQ(1, bounds.first);
+ ASSERT_EQ(63, bounds.second);
}
diff --git a/Tests/FileIO/TestTetGenInterface.cpp b/Tests/FileIO/TestTetGenInterface.cpp
index ea7d45479ccf897635c95b56f38759873be47977..8e9f8f314a8e6cb43cbaca2130c9f81624ccec42 100644
--- a/Tests/FileIO/TestTetGenInterface.cpp
+++ b/Tests/FileIO/TestTetGenInterface.cpp
@@ -29,18 +29,18 @@
// read TetGen geometry
TEST(FileIO, TetGenSmeshReader)
{
- std::string const file_name (BaseLib::BuildInfo::data_path + "/FileIO/twolayermdl.smesh");
- GeoLib::GEOObjects geo_objects;
- FileIO::TetGenInterface tgi;
- bool const result (tgi.readTetGenGeometry(file_name, geo_objects));
- ASSERT_TRUE(result);
-
- std::vector<GeoLib::Point*> const& pnts (*geo_objects.getPointVec("twolayermdl"));
- ASSERT_EQ(744, pnts.size());
- std::vector<GeoLib::Surface*> const& sfcs (*geo_objects.getSurfaceVec("twolayermdl"));
- ASSERT_EQ(5, sfcs.size());
- ASSERT_EQ(468, sfcs[2]->getNTriangles());
- ASSERT_EQ(191, sfcs[3]->getNTriangles());
+ std::string const file_name (BaseLib::BuildInfo::data_path + "/FileIO/twolayermdl.smesh");
+ GeoLib::GEOObjects geo_objects;
+ FileIO::TetGenInterface tgi;
+ bool const result (tgi.readTetGenGeometry(file_name, geo_objects));
+ ASSERT_TRUE(result);
+
+ std::vector<GeoLib::Point*> const& pnts (*geo_objects.getPointVec("twolayermdl"));
+ ASSERT_EQ(744, pnts.size());
+ std::vector<GeoLib::Surface*> const& sfcs (*geo_objects.getSurfaceVec("twolayermdl"));
+ ASSERT_EQ(5, sfcs.size());
+ ASSERT_EQ(468, sfcs[2]->getNTriangles());
+ ASSERT_EQ(191, sfcs[3]->getNTriangles());
}
// existing mesh to TetGen geometry
@@ -50,65 +50,65 @@ TEST(FileIO, TetGenSmeshInterface)
TEST(FileIO, DISABLED_TetGenSmeshInterface)
#endif
{
- std::string const file_name (BaseLib::BuildInfo::data_path + "/FileIO/AmmerSubsurfaceCoarse.vtu");
- std::unique_ptr<MeshLib::Mesh const> const mesh (MeshLib::IO::readMeshFromFile(file_name));
-
- std::string const tg_new_name ("TestSmeshWriter");
- std::string const output_name(BaseLib::BuildInfo::tests_tmp_path + tg_new_name + ".smesh");
- std::vector<MeshLib::Node> attr_pnts;
- FileIO::TetGenInterface tgi;
- bool result (tgi.writeTetGenSmesh(output_name, *mesh, attr_pnts));
- ASSERT_TRUE(result);
-
- GeoLib::GEOObjects geo_objects;
- result = tgi.readTetGenGeometry(output_name, geo_objects);
- ASSERT_TRUE(result);
- std::string const ref_name(BaseLib::BuildInfo::data_path + "/FileIO/AmmerSubsurfaceCoarse.smesh");
- result = tgi.readTetGenGeometry(ref_name, geo_objects);
- ASSERT_TRUE(result);
-
- std::vector<GeoLib::Point*> const& ref_pnts (*geo_objects.getPointVec("AmmerSubsurfaceCoarse"));
- std::vector<GeoLib::Point*> const& new_pnts (*geo_objects.getPointVec(tg_new_name));
- ASSERT_EQ(ref_pnts.size(), new_pnts.size());
-
- std::vector<GeoLib::Surface*> const& ref_sfc (*geo_objects.getSurfaceVec("AmmerSubsurfaceCoarse"));
- std::vector<GeoLib::Surface*> const& new_sfc (*geo_objects.getSurfaceVec(tg_new_name));
- ASSERT_EQ(ref_sfc.size(), new_sfc.size());
-
- for (std::size_t i=0; i<ref_sfc.size(); ++i)
- ASSERT_EQ(ref_sfc[i]->getNTriangles(), new_sfc[i]->getNTriangles());
-
- std::remove(output_name.c_str());
+ std::string const file_name (BaseLib::BuildInfo::data_path + "/FileIO/AmmerSubsurfaceCoarse.vtu");
+ std::unique_ptr<MeshLib::Mesh const> const mesh (MeshLib::IO::readMeshFromFile(file_name));
+
+ std::string const tg_new_name ("TestSmeshWriter");
+ std::string const output_name(BaseLib::BuildInfo::tests_tmp_path + tg_new_name + ".smesh");
+ std::vector<MeshLib::Node> attr_pnts;
+ FileIO::TetGenInterface tgi;
+ bool result (tgi.writeTetGenSmesh(output_name, *mesh, attr_pnts));
+ ASSERT_TRUE(result);
+
+ GeoLib::GEOObjects geo_objects;
+ result = tgi.readTetGenGeometry(output_name, geo_objects);
+ ASSERT_TRUE(result);
+ std::string const ref_name(BaseLib::BuildInfo::data_path + "/FileIO/AmmerSubsurfaceCoarse.smesh");
+ result = tgi.readTetGenGeometry(ref_name, geo_objects);
+ ASSERT_TRUE(result);
+
+ std::vector<GeoLib::Point*> const& ref_pnts (*geo_objects.getPointVec("AmmerSubsurfaceCoarse"));
+ std::vector<GeoLib::Point*> const& new_pnts (*geo_objects.getPointVec(tg_new_name));
+ ASSERT_EQ(ref_pnts.size(), new_pnts.size());
+
+ std::vector<GeoLib::Surface*> const& ref_sfc (*geo_objects.getSurfaceVec("AmmerSubsurfaceCoarse"));
+ std::vector<GeoLib::Surface*> const& new_sfc (*geo_objects.getSurfaceVec(tg_new_name));
+ ASSERT_EQ(ref_sfc.size(), new_sfc.size());
+
+ for (std::size_t i=0; i<ref_sfc.size(); ++i)
+ ASSERT_EQ(ref_sfc[i]->getNTriangles(), new_sfc[i]->getNTriangles());
+
+ std::remove(output_name.c_str());
}
// TetGen mesh with material array
TEST(FileIO, TetGenMeshReaderWithMaterials)
{
- std::string const node_name (BaseLib::BuildInfo::data_path + "/FileIO/twolayermdl.node");
- std::string const ele_name (BaseLib::BuildInfo::data_path + "/FileIO/twolayermdl.ele");
- FileIO::TetGenInterface tgi;
- std::unique_ptr<MeshLib::Mesh> mesh (tgi.readTetGenMesh(node_name, ele_name));
- ASSERT_TRUE(mesh != nullptr);
- ASSERT_EQ(1378, mesh->getNNodes());
- ASSERT_EQ(5114, mesh->getNElements());
-
- std::pair<int, int> bounds (MeshLib::MeshInformation::getValueBounds<int>(*mesh, "MaterialIDs"));
- ASSERT_EQ(-20, bounds.first);
- ASSERT_EQ(-10, bounds.second);
+ std::string const node_name (BaseLib::BuildInfo::data_path + "/FileIO/twolayermdl.node");
+ std::string const ele_name (BaseLib::BuildInfo::data_path + "/FileIO/twolayermdl.ele");
+ FileIO::TetGenInterface tgi;
+ std::unique_ptr<MeshLib::Mesh> mesh (tgi.readTetGenMesh(node_name, ele_name));
+ ASSERT_TRUE(mesh != nullptr);
+ ASSERT_EQ(1378, mesh->getNNodes());
+ ASSERT_EQ(5114, mesh->getNElements());
+
+ std::pair<int, int> bounds (MeshLib::MeshInformation::getValueBounds<int>(*mesh, "MaterialIDs"));
+ ASSERT_EQ(-20, bounds.first);
+ ASSERT_EQ(-10, bounds.second);
}
// TetGen mesh without additional information
TEST(FileIO, TetGenMeshReaderWithoutMaterials)
{
- std::string const node_name (BaseLib::BuildInfo::data_path + "/FileIO/tetgen_example.node");
- std::string const ele_name (BaseLib::BuildInfo::data_path + "/FileIO/tetgen_example.ele");
- FileIO::TetGenInterface tgi;
- std::unique_ptr<MeshLib::Mesh> mesh (tgi.readTetGenMesh(node_name, ele_name));
- ASSERT_TRUE(mesh != nullptr);
- ASSERT_EQ(202, mesh->getNNodes());
- ASSERT_EQ(650, mesh->getNElements());
-
- std::pair<int, int> bounds (MeshLib::MeshInformation::getValueBounds<int>(*mesh, "MaterialIDs"));
- ASSERT_EQ(std::numeric_limits<int>::max(), bounds.first);
- ASSERT_EQ(std::numeric_limits<int>::max(), bounds.second);
+ std::string const node_name (BaseLib::BuildInfo::data_path + "/FileIO/tetgen_example.node");
+ std::string const ele_name (BaseLib::BuildInfo::data_path + "/FileIO/tetgen_example.ele");
+ FileIO::TetGenInterface tgi;
+ std::unique_ptr<MeshLib::Mesh> mesh (tgi.readTetGenMesh(node_name, ele_name));
+ ASSERT_TRUE(mesh != nullptr);
+ ASSERT_EQ(202, mesh->getNNodes());
+ ASSERT_EQ(650, mesh->getNElements());
+
+ std::pair<int, int> bounds (MeshLib::MeshInformation::getValueBounds<int>(*mesh, "MaterialIDs"));
+ ASSERT_EQ(std::numeric_limits<int>::max(), bounds.first);
+ ASSERT_EQ(std::numeric_limits<int>::max(), bounds.second);
}
diff --git a/Tests/FileIO_Qt/TestQtGmlInterface.cpp b/Tests/FileIO_Qt/TestQtGmlInterface.cpp
index 3941a3846db87cdfb8bfb1429a81de496b1782eb..390d72bdd427e3344d331d80a70613cd2989d86d 100644
--- a/Tests/FileIO_Qt/TestQtGmlInterface.cpp
+++ b/Tests/FileIO_Qt/TestQtGmlInterface.cpp
@@ -24,29 +24,29 @@
TEST_F(TestGmlInterface, QtXmlGmlWriterReaderTest)
{
- // Writer test
- std::string test_data_file(BaseLib::BuildInfo::tests_tmp_path
- + "TestXmlGmlReader.gml");
-
- GeoLib::IO::XmlGmlInterface xml(geo_objects);
- xml.setNameForExport(geo_name);
- int result = xml.writeToFile(test_data_file);
- EXPECT_EQ(result, 1);
-
- // remove the written data from the data structures
- geo_objects.removeSurfaceVec(geo_name);
- geo_objects.removePolylineVec(geo_name);
- geo_objects.removePointVec(geo_name);
-
- // Reader test
- result = xml.readFile(QString::fromStdString(test_data_file));
- EXPECT_EQ(1, result);
-
- std::remove(test_data_file.c_str());
- test_data_file += ".md5";
- std::remove(test_data_file.c_str());
-
- checkPointProperties();
- checkPolylineProperties();
- checkSurfaceProperties();
+ // Writer test
+ std::string test_data_file(BaseLib::BuildInfo::tests_tmp_path
+ + "TestXmlGmlReader.gml");
+
+ GeoLib::IO::XmlGmlInterface xml(geo_objects);
+ xml.setNameForExport(geo_name);
+ int result = xml.writeToFile(test_data_file);
+ EXPECT_EQ(result, 1);
+
+ // remove the written data from the data structures
+ geo_objects.removeSurfaceVec(geo_name);
+ geo_objects.removePolylineVec(geo_name);
+ geo_objects.removePointVec(geo_name);
+
+ // Reader test
+ result = xml.readFile(QString::fromStdString(test_data_file));
+ EXPECT_EQ(1, result);
+
+ std::remove(test_data_file.c_str());
+ test_data_file += ".md5";
+ std::remove(test_data_file.c_str());
+
+ checkPointProperties();
+ checkPolylineProperties();
+ checkSurfaceProperties();
}
diff --git a/Tests/GeoLib/AutoCheckGenerators.h b/Tests/GeoLib/AutoCheckGenerators.h
index c707137f53a97d1ac5d7a5f444d308443f427c9f..617fb2bdca2311b520816571500c4badc19cdb72 100644
--- a/Tests/GeoLib/AutoCheckGenerators.h
+++ b/Tests/GeoLib/AutoCheckGenerators.h
@@ -1,9 +1,9 @@
/**
* \copyright
* Copyright (c) 2012-2016, OpenGeoSys Community (http://www.opengeosys.org)
- * Distributed under a Modified BSD License.
- * See accompanying file LICENSE.txt or
- * http://www.opengeosys.org/LICENSE.txt
+ * Distributed under a Modified BSD License.
+ * See accompanying file LICENSE.txt or
+ * http://www.opengeosys.org/LICENSE.txt
*/
#ifndef TESTS_GEOLIB_AUTOCHECKGENERATORS_H_
@@ -24,33 +24,33 @@ namespace autocheck
template <typename Gen = generator<double>>
struct RandomCirclePointGeneratorXY
{
- RandomCirclePointGeneratorXY(
- MathLib::Point3d const& c = MathLib::Point3d{std::array<double, 3>{{0, 0, 0}}},
- double r = 1.0)
- : center(c), radius(r)
- {}
-
- using result_type = MathLib::Point3d;
-
- result_type operator()(std::size_t /*size*/ = 0)
- {
- // generates uniformly distributed values in the interval [-4, 4]
- auto const angle(generator(4));
- return MathLib::Point3d{
- std::array<double, 3>{{center[0] + radius * std::cos(angle),
- center[1] + radius * std::sin(angle), 0.0}}};
- }
-
- Gen generator;
- MathLib::Point3d const center;
- double const radius;
+ RandomCirclePointGeneratorXY(
+ MathLib::Point3d const& c = MathLib::Point3d{std::array<double, 3>{{0, 0, 0}}},
+ double r = 1.0)
+ : center(c), radius(r)
+ {}
+
+ using result_type = MathLib::Point3d;
+
+ result_type operator()(std::size_t /*size*/ = 0)
+ {
+ // generates uniformly distributed values in the interval [-4, 4]
+ auto const angle(generator(4));
+ return MathLib::Point3d{
+ std::array<double, 3>{{center[0] + radius * std::cos(angle),
+ center[1] + radius * std::sin(angle), 0.0}}};
+ }
+
+ Gen generator;
+ MathLib::Point3d const center;
+ double const radius;
};
// reflect point p on the point c in x-y plane
MathLib::Point3d reflect(MathLib::Point3d const& c, MathLib::Point3d const& p)
{
- return MathLib::Point3d(
- std::array<double, 3>{{2 * c[0] - p[0], 2 * c[1] - p[1], 0.0}});
+ return MathLib::Point3d(
+ std::array<double, 3>{{2 * c[0] - p[0], 2 * c[1] - p[1], 0.0}});
}
// generates line segments that are special chords of a circle, i.e. the chords
@@ -58,58 +58,58 @@ MathLib::Point3d reflect(MathLib::Point3d const& c, MathLib::Point3d const& p)
template <typename Gen = RandomCirclePointGeneratorXY<generator<double>>>
struct SymmSegmentGeneratorXY
{
- SymmSegmentGeneratorXY(
- Gen s,
- std::function<MathLib::Point3d(MathLib::Point3d const&)> f)
- : source(s), function(f)
- {}
-
- using result_type = GeoLib::LineSegment;
-
- result_type operator()(std::size_t /*size*/ = 0)
- {
- std::unique_ptr<GeoLib::Point> a{new GeoLib::Point{source(), 0}};
- std::unique_ptr<GeoLib::Point> b{new GeoLib::Point{function(*a), 1}};
- return result_type{a.release(), b.release(), true};
- }
-
- Gen source;
- std::function<MathLib::Point3d(MathLib::Point3d const&)> function;
+ SymmSegmentGeneratorXY(
+ Gen s,
+ std::function<MathLib::Point3d(MathLib::Point3d const&)> f)
+ : source(s), function(f)
+ {}
+
+ using result_type = GeoLib::LineSegment;
+
+ result_type operator()(std::size_t /*size*/ = 0)
+ {
+ std::unique_ptr<GeoLib::Point> a{new GeoLib::Point{source(), 0}};
+ std::unique_ptr<GeoLib::Point> b{new GeoLib::Point{function(*a), 1}};
+ return result_type{a.release(), b.release(), true};
+ }
+
+ Gen source;
+ std::function<MathLib::Point3d(MathLib::Point3d const&)> function;
};
GeoLib::LineSegment translate(MathLib::Vector3 const& translation,
GeoLib::LineSegment const& line_seg)
{
- std::unique_ptr<GeoLib::Point> a{new GeoLib::Point{line_seg.getBeginPoint()}};
- std::unique_ptr<GeoLib::Point> b{new GeoLib::Point{line_seg.getEndPoint()}};
- for (std::size_t k(0); k<3; ++k)
- (*a)[k] += translation[k];
- for (std::size_t k(0); k<3; ++k)
- (*b)[k] += translation[k];
- return GeoLib::LineSegment{a.release(), b.release(), true};
+ std::unique_ptr<GeoLib::Point> a{new GeoLib::Point{line_seg.getBeginPoint()}};
+ std::unique_ptr<GeoLib::Point> b{new GeoLib::Point{line_seg.getEndPoint()}};
+ for (std::size_t k(0); k<3; ++k)
+ (*a)[k] += translation[k];
+ for (std::size_t k(0); k<3; ++k)
+ (*b)[k] += translation[k];
+ return GeoLib::LineSegment{a.release(), b.release(), true};
}
template <typename Gen = SymmSegmentGeneratorXY<
RandomCirclePointGeneratorXY<generator<double>>>>
struct PairSegmentGeneratorXY
{
- PairSegmentGeneratorXY(
- Gen s, std::function<GeoLib::LineSegment(GeoLib::LineSegment const&)> f)
- : segment_generator(s), function(f)
- {
- }
-
- using result_type = std::pair<GeoLib::LineSegment, GeoLib::LineSegment>;
-
- result_type operator()(std::size_t /*size*/ = 0)
- {
- auto first = segment_generator();
- auto second = function(first);
- return result_type{first, second};
- }
-
- Gen segment_generator;
- std::function<GeoLib::LineSegment(GeoLib::LineSegment const&)> function;
+ PairSegmentGeneratorXY(
+ Gen s, std::function<GeoLib::LineSegment(GeoLib::LineSegment const&)> f)
+ : segment_generator(s), function(f)
+ {
+ }
+
+ using result_type = std::pair<GeoLib::LineSegment, GeoLib::LineSegment>;
+
+ result_type operator()(std::size_t /*size*/ = 0)
+ {
+ auto first = segment_generator();
+ auto second = function(first);
+ return result_type{first, second};
+ }
+
+ Gen segment_generator;
+ std::function<GeoLib::LineSegment(GeoLib::LineSegment const&)> function;
};
} // namespace autocheck
diff --git a/Tests/GeoLib/IO/TestGLIReader.cpp b/Tests/GeoLib/IO/TestGLIReader.cpp
index 9f26262c7fc6b08aa111c3f92b13daee23811641..e25c6c2246e14ed60203bfbe65308a03a1a6a107 100644
--- a/Tests/GeoLib/IO/TestGLIReader.cpp
+++ b/Tests/GeoLib/IO/TestGLIReader.cpp
@@ -22,181 +22,181 @@
class OGSIOVer4InterfaceTest : public ::testing::Test
{
public:
- OGSIOVer4InterfaceTest()
- : _gli_fname(BaseLib::BuildInfo::tests_tmp_path+"test.gli")
- {
- std::ofstream gli_out(_gli_fname);
- gli_out << "#POINTS\n";
- gli_out << "0 0 0 0\n";
- gli_out << "#SURFACE\n";
- gli_out << " $NAME\n";
- gli_out << " Surface\n";
- gli_out << " $TIN\n";
- gli_out << " Surface.tin\n";
- gli_out << "#STOP\n";
- gli_out.close();
- }
-
- ~OGSIOVer4InterfaceTest()
- {
- std::remove(_gli_fname.c_str());
- }
+ OGSIOVer4InterfaceTest()
+ : _gli_fname(BaseLib::BuildInfo::tests_tmp_path+"test.gli")
+ {
+ std::ofstream gli_out(_gli_fname);
+ gli_out << "#POINTS\n";
+ gli_out << "0 0 0 0\n";
+ gli_out << "#SURFACE\n";
+ gli_out << " $NAME\n";
+ gli_out << " Surface\n";
+ gli_out << " $TIN\n";
+ gli_out << " Surface.tin\n";
+ gli_out << "#STOP\n";
+ gli_out.close();
+ }
+
+ ~OGSIOVer4InterfaceTest()
+ {
+ std::remove(_gli_fname.c_str());
+ }
protected:
- std::string _gli_fname;
+ std::string _gli_fname;
};
TEST_F(OGSIOVer4InterfaceTest, SimpleTIN)
{
- std::string tin_fname(BaseLib::BuildInfo::tests_tmp_path+"Surface.tin");
- std::ofstream tin_out (tin_fname);
- tin_out << "0 0.0 0.0 0.0 1.0 0.0.0 0.0 0.0 1.0\n";
- tin_out << "1 0.0 0.0 0.0 1.0 0.0.0 0.0 1.0 1.0\n";
- tin_out.close();
-
- // read geometry
- GeoLib::GEOObjects geometries;
- std::vector<std::string> errors;
- std::string geometry_name("TestGeometry");
- GeoLib::IO::Legacy::readGLIFileV4(_gli_fname, geometries, geometry_name, errors);
-
- std::vector<GeoLib::Surface*> const*
- sfcs(geometries.getSurfaceVec(geometry_name));
- ASSERT_TRUE(sfcs != nullptr);
- ASSERT_EQ(1u, geometries.getSurfaceVec(geometry_name)->size());
- ASSERT_EQ(2u, (*geometries.getSurfaceVec(geometry_name))[0]->getNTriangles());
-
- std::remove(tin_fname.c_str());
+ std::string tin_fname(BaseLib::BuildInfo::tests_tmp_path+"Surface.tin");
+ std::ofstream tin_out (tin_fname);
+ tin_out << "0 0.0 0.0 0.0 1.0 0.0.0 0.0 0.0 1.0\n";
+ tin_out << "1 0.0 0.0 0.0 1.0 0.0.0 0.0 1.0 1.0\n";
+ tin_out.close();
+
+ // read geometry
+ GeoLib::GEOObjects geometries;
+ std::vector<std::string> errors;
+ std::string geometry_name("TestGeometry");
+ GeoLib::IO::Legacy::readGLIFileV4(_gli_fname, geometries, geometry_name, errors);
+
+ std::vector<GeoLib::Surface*> const*
+ sfcs(geometries.getSurfaceVec(geometry_name));
+ ASSERT_TRUE(sfcs != nullptr);
+ ASSERT_EQ(1u, geometries.getSurfaceVec(geometry_name)->size());
+ ASSERT_EQ(2u, (*geometries.getSurfaceVec(geometry_name))[0]->getNTriangles());
+
+ std::remove(tin_fname.c_str());
}
TEST_F(OGSIOVer4InterfaceTest, StillCorrectTINWihtAdditionalValueAtEndOfLine)
{
- std::string tin_fname(BaseLib::BuildInfo::tests_tmp_path+"Surface.tin");
- std::ofstream tin_out (tin_fname);
- tin_out << "0 0.0 0.0 0.0 1.0 0.0.0 0.0 0.0 1.0 10\n";
- tin_out << "1 0.0 0.0 0.0 1.0 0.0.0 0.0 0.0 1.0\n";
- tin_out.close();
-
- // read geometry
- GeoLib::GEOObjects geometries;
- std::vector<std::string> errors;
- std::string geometry_name("TestGeometry");
- GeoLib::IO::Legacy::readGLIFileV4(_gli_fname, geometries, geometry_name, errors);
-
- std::vector<GeoLib::Surface*> const*
- sfcs(geometries.getSurfaceVec(geometry_name));
- ASSERT_TRUE(sfcs != nullptr);
- ASSERT_EQ(1u, geometries.getSurfaceVec(geometry_name)->size());
- ASSERT_EQ(2u, (*geometries.getSurfaceVec(geometry_name))[0]->getNTriangles());
-
- std::remove(tin_fname.c_str());
+ std::string tin_fname(BaseLib::BuildInfo::tests_tmp_path+"Surface.tin");
+ std::ofstream tin_out (tin_fname);
+ tin_out << "0 0.0 0.0 0.0 1.0 0.0.0 0.0 0.0 1.0 10\n";
+ tin_out << "1 0.0 0.0 0.0 1.0 0.0.0 0.0 0.0 1.0\n";
+ tin_out.close();
+
+ // read geometry
+ GeoLib::GEOObjects geometries;
+ std::vector<std::string> errors;
+ std::string geometry_name("TestGeometry");
+ GeoLib::IO::Legacy::readGLIFileV4(_gli_fname, geometries, geometry_name, errors);
+
+ std::vector<GeoLib::Surface*> const*
+ sfcs(geometries.getSurfaceVec(geometry_name));
+ ASSERT_TRUE(sfcs != nullptr);
+ ASSERT_EQ(1u, geometries.getSurfaceVec(geometry_name)->size());
+ ASSERT_EQ(2u, (*geometries.getSurfaceVec(geometry_name))[0]->getNTriangles());
+
+ std::remove(tin_fname.c_str());
}
TEST_F(OGSIOVer4InterfaceTest, InvalidTIN_ZeroAreaTri)
{
- std::string tin_fname(BaseLib::BuildInfo::tests_tmp_path+"Surface.tin");
- std::ofstream tin_out (tin_fname);
- tin_out << "0 0.0 0.0 0.0 1.0 0.0.0 0.0 0.0 0.0\n";
- tin_out.close();
-
- // read geometry
- GeoLib::GEOObjects geometries;
- std::vector<std::string> errors;
- std::string geometry_name("TestGeometry");
- GeoLib::IO::Legacy::readGLIFileV4(_gli_fname, geometries, geometry_name, errors);
-
- std::vector<GeoLib::Surface*> const*
- sfcs(geometries.getSurfaceVec(geometry_name));
- ASSERT_TRUE(sfcs == nullptr);
-
- std::remove(tin_fname.c_str());
+ std::string tin_fname(BaseLib::BuildInfo::tests_tmp_path+"Surface.tin");
+ std::ofstream tin_out (tin_fname);
+ tin_out << "0 0.0 0.0 0.0 1.0 0.0.0 0.0 0.0 0.0\n";
+ tin_out.close();
+
+ // read geometry
+ GeoLib::GEOObjects geometries;
+ std::vector<std::string> errors;
+ std::string geometry_name("TestGeometry");
+ GeoLib::IO::Legacy::readGLIFileV4(_gli_fname, geometries, geometry_name, errors);
+
+ std::vector<GeoLib::Surface*> const*
+ sfcs(geometries.getSurfaceVec(geometry_name));
+ ASSERT_TRUE(sfcs == nullptr);
+
+ std::remove(tin_fname.c_str());
}
TEST_F(OGSIOVer4InterfaceTest, InvalidTIN_LineDoesNotStartWithID)
{
- std::string tin_fname(BaseLib::BuildInfo::tests_tmp_path+"Surface.tin");
- std::ofstream tin_out (tin_fname);
- tin_out << "0 0.0 0.0 0.0 1.0 0.0.0 0.0 0.0 1.0\n";
- tin_out << "a\n";
- tin_out << "1 0.0 0.0 0.0 1.0 0.0.0 0.0 0.0 1.0\n";
- tin_out.close();
-
- // read geometry
- GeoLib::GEOObjects geometries;
- std::vector<std::string> errors;
- std::string geometry_name("TestGeometry");
- GeoLib::IO::Legacy::readGLIFileV4(_gli_fname, geometries, geometry_name, errors);
-
- std::vector<GeoLib::Surface*> const*
- sfcs(geometries.getSurfaceVec(geometry_name));
- ASSERT_TRUE(sfcs == nullptr);
-
- std::remove(tin_fname.c_str());
+ std::string tin_fname(BaseLib::BuildInfo::tests_tmp_path+"Surface.tin");
+ std::ofstream tin_out (tin_fname);
+ tin_out << "0 0.0 0.0 0.0 1.0 0.0.0 0.0 0.0 1.0\n";
+ tin_out << "a\n";
+ tin_out << "1 0.0 0.0 0.0 1.0 0.0.0 0.0 0.0 1.0\n";
+ tin_out.close();
+
+ // read geometry
+ GeoLib::GEOObjects geometries;
+ std::vector<std::string> errors;
+ std::string geometry_name("TestGeometry");
+ GeoLib::IO::Legacy::readGLIFileV4(_gli_fname, geometries, geometry_name, errors);
+
+ std::vector<GeoLib::Surface*> const*
+ sfcs(geometries.getSurfaceVec(geometry_name));
+ ASSERT_TRUE(sfcs == nullptr);
+
+ std::remove(tin_fname.c_str());
}
TEST_F(OGSIOVer4InterfaceTest, InvalidTIN_PointIsMissing)
{
- std::string tin_fname(BaseLib::BuildInfo::tests_tmp_path+"Surface.tin");
- std::ofstream tin_out (tin_fname);
- tin_out << "0 0.0 0.0 0.0 1.0 0.0.0 0.0 0.0 1.0\n";
- tin_out << "1 0.0 0.0 0.0 1.0 0.0.0\n";
- tin_out.close();
-
- // read geometry
- GeoLib::GEOObjects geometries;
- std::vector<std::string> errors;
- std::string geometry_name("TestGeometry");
- GeoLib::IO::Legacy::readGLIFileV4(_gli_fname, geometries, geometry_name, errors);
-
- std::vector<GeoLib::Surface*> const*
- sfcs(geometries.getSurfaceVec(geometry_name));
- ASSERT_TRUE(sfcs == nullptr);
-
- std::remove(tin_fname.c_str());
+ std::string tin_fname(BaseLib::BuildInfo::tests_tmp_path+"Surface.tin");
+ std::ofstream tin_out (tin_fname);
+ tin_out << "0 0.0 0.0 0.0 1.0 0.0.0 0.0 0.0 1.0\n";
+ tin_out << "1 0.0 0.0 0.0 1.0 0.0.0\n";
+ tin_out.close();
+
+ // read geometry
+ GeoLib::GEOObjects geometries;
+ std::vector<std::string> errors;
+ std::string geometry_name("TestGeometry");
+ GeoLib::IO::Legacy::readGLIFileV4(_gli_fname, geometries, geometry_name, errors);
+
+ std::vector<GeoLib::Surface*> const*
+ sfcs(geometries.getSurfaceVec(geometry_name));
+ ASSERT_TRUE(sfcs == nullptr);
+
+ std::remove(tin_fname.c_str());
}
TEST_F(OGSIOVer4InterfaceTest, InvalidTIN_CoordOfPointIsMissing)
{
- std::string tin_fname(BaseLib::BuildInfo::tests_tmp_path+"Surface.tin");
- std::ofstream tin_out (tin_fname);
- tin_out << "0 0.0 0.0 0.0 1.0 0.0.0 0.0\n";
- tin_out << "1 0.0 0.0 0.0 1.0 0.0.0\n";
- tin_out.close();
-
- // read geometry
- GeoLib::GEOObjects geometries;
- std::vector<std::string> errors;
- std::string geometry_name("TestGeometry");
- GeoLib::IO::Legacy::readGLIFileV4(_gli_fname, geometries, geometry_name, errors);
-
- std::vector<GeoLib::Surface*> const*
- sfcs(geometries.getSurfaceVec(geometry_name));
- ASSERT_TRUE(sfcs == nullptr);
-
- std::remove(tin_fname.c_str());
+ std::string tin_fname(BaseLib::BuildInfo::tests_tmp_path+"Surface.tin");
+ std::ofstream tin_out (tin_fname);
+ tin_out << "0 0.0 0.0 0.0 1.0 0.0.0 0.0\n";
+ tin_out << "1 0.0 0.0 0.0 1.0 0.0.0\n";
+ tin_out.close();
+
+ // read geometry
+ GeoLib::GEOObjects geometries;
+ std::vector<std::string> errors;
+ std::string geometry_name("TestGeometry");
+ GeoLib::IO::Legacy::readGLIFileV4(_gli_fname, geometries, geometry_name, errors);
+
+ std::vector<GeoLib::Surface*> const*
+ sfcs(geometries.getSurfaceVec(geometry_name));
+ ASSERT_TRUE(sfcs == nullptr);
+
+ std::remove(tin_fname.c_str());
}
TEST_F(OGSIOVer4InterfaceTest, SimpleTIN_AdditionalEmptyLinesAtEnd)
{
- std::string tin_fname(BaseLib::BuildInfo::tests_tmp_path+"Surface.tin");
- std::ofstream tin_out (tin_fname);
- tin_out << "0 0.0 0.0 0.0 1.0 0.0.0 0.0 0.0 1.0 10\n";
- tin_out << "1 0.0 0.0 0.0 1.0 0.0.0 0.0 0.0 1.0\n\n\n";
- tin_out.close();
-
- // read geometry
- GeoLib::GEOObjects geometries;
- std::vector<std::string> errors;
- std::string geometry_name("TestGeometry");
- GeoLib::IO::Legacy::readGLIFileV4(_gli_fname, geometries, geometry_name, errors);
-
- std::vector<GeoLib::Surface*> const*
- sfcs(geometries.getSurfaceVec(geometry_name));
- ASSERT_TRUE(sfcs != nullptr);
- ASSERT_EQ(1u, geometries.getSurfaceVec(geometry_name)->size());
- ASSERT_EQ(2u, (*geometries.getSurfaceVec(geometry_name))[0]->getNTriangles());
-
- std::remove(tin_fname.c_str());
+ std::string tin_fname(BaseLib::BuildInfo::tests_tmp_path+"Surface.tin");
+ std::ofstream tin_out (tin_fname);
+ tin_out << "0 0.0 0.0 0.0 1.0 0.0.0 0.0 0.0 1.0 10\n";
+ tin_out << "1 0.0 0.0 0.0 1.0 0.0.0 0.0 0.0 1.0\n\n\n";
+ tin_out.close();
+
+ // read geometry
+ GeoLib::GEOObjects geometries;
+ std::vector<std::string> errors;
+ std::string geometry_name("TestGeometry");
+ GeoLib::IO::Legacy::readGLIFileV4(_gli_fname, geometries, geometry_name, errors);
+
+ std::vector<GeoLib::Surface*> const*
+ sfcs(geometries.getSurfaceVec(geometry_name));
+ ASSERT_TRUE(sfcs != nullptr);
+ ASSERT_EQ(1u, geometries.getSurfaceVec(geometry_name)->size());
+ ASSERT_EQ(2u, (*geometries.getSurfaceVec(geometry_name))[0]->getNTriangles());
+
+ std::remove(tin_fname.c_str());
}
diff --git a/Tests/GeoLib/TestAABB.cpp b/Tests/GeoLib/TestAABB.cpp
index ab80aa0810f0a603019ef589878ab7fa63519450..4e435ab5e4ea128defc63c5bedea76f827c32721 100644
--- a/Tests/GeoLib/TestAABB.cpp
+++ b/Tests/GeoLib/TestAABB.cpp
@@ -26,216 +26,216 @@
TEST(GeoLibAABB, RandomNumberOfPointersToRandomPoints)
{
- /* initialize random seed: */
- srand ( static_cast<unsigned>(time(nullptr)) );
- int n (rand() % 100000);
- int box_size (rand());
- double half_box_size(box_size/2);
- double minus_half_box_size(-half_box_size);
-
- // fill list with points
- std::list<GeoLib::Point*> pnts_list;
- for (int k(0); k<n; k++) {
- pnts_list.push_back(new GeoLib::Point(rand() % box_size - half_box_size, rand() % box_size - half_box_size, rand() % box_size - half_box_size));
- }
-
- // construct from list points a axis algined bounding box
- GeoLib::AABB aabb(pnts_list.begin(), pnts_list.end());
-
- MathLib::Point3d const& min_pnt(aabb.getMinPoint());
- MathLib::Point3d const& max_pnt(aabb.getMaxPoint());
-
- ASSERT_LE(minus_half_box_size, min_pnt[0]) << "coordinate 0 of min_pnt is smaller than " << minus_half_box_size;
- ASSERT_LE(minus_half_box_size, min_pnt[1]) << "coordinate 1 of min_pnt is smaller than " << minus_half_box_size;
- ASSERT_LE(minus_half_box_size, min_pnt[2]) << "coordinate 2 of min_pnt is smaller than " << minus_half_box_size;
-
- // since the interval is half-open we have to move the upper bound also
- half_box_size = std::nexttoward(half_box_size, std::numeric_limits<double>::max());
- ASSERT_GE(half_box_size, max_pnt[0]) << "coordinate 0 of max_pnt is greater than " << half_box_size;
- ASSERT_GE(half_box_size, max_pnt[1]) << "coordinate 1 of max_pnt is greater than " << half_box_size;
- ASSERT_GE(half_box_size, max_pnt[2]) << "coordinate 2 of max_pnt is greater than " << half_box_size;
-
- for (std::list<GeoLib::Point*>::iterator it(pnts_list.begin()); it != pnts_list.end(); it++) {
- delete *it;
- }
+ /* initialize random seed: */
+ srand ( static_cast<unsigned>(time(nullptr)) );
+ int n (rand() % 100000);
+ int box_size (rand());
+ double half_box_size(box_size/2);
+ double minus_half_box_size(-half_box_size);
+
+ // fill list with points
+ std::list<GeoLib::Point*> pnts_list;
+ for (int k(0); k<n; k++) {
+ pnts_list.push_back(new GeoLib::Point(rand() % box_size - half_box_size, rand() % box_size - half_box_size, rand() % box_size - half_box_size));
+ }
+
+ // construct from list points a axis algined bounding box
+ GeoLib::AABB aabb(pnts_list.begin(), pnts_list.end());
+
+ MathLib::Point3d const& min_pnt(aabb.getMinPoint());
+ MathLib::Point3d const& max_pnt(aabb.getMaxPoint());
+
+ ASSERT_LE(minus_half_box_size, min_pnt[0]) << "coordinate 0 of min_pnt is smaller than " << minus_half_box_size;
+ ASSERT_LE(minus_half_box_size, min_pnt[1]) << "coordinate 1 of min_pnt is smaller than " << minus_half_box_size;
+ ASSERT_LE(minus_half_box_size, min_pnt[2]) << "coordinate 2 of min_pnt is smaller than " << minus_half_box_size;
+
+ // since the interval is half-open we have to move the upper bound also
+ half_box_size = std::nexttoward(half_box_size, std::numeric_limits<double>::max());
+ ASSERT_GE(half_box_size, max_pnt[0]) << "coordinate 0 of max_pnt is greater than " << half_box_size;
+ ASSERT_GE(half_box_size, max_pnt[1]) << "coordinate 1 of max_pnt is greater than " << half_box_size;
+ ASSERT_GE(half_box_size, max_pnt[2]) << "coordinate 2 of max_pnt is greater than " << half_box_size;
+
+ for (std::list<GeoLib::Point*>::iterator it(pnts_list.begin()); it != pnts_list.end(); it++) {
+ delete *it;
+ }
}
TEST(GeoLibAABB, RandomNumberOfPointsRandomPointInAList)
{
- /* initialize random seed: */
- srand ( static_cast<unsigned>(time(nullptr)) );
- int n (rand() % 1000000);
- int box_size (rand());
- double half_box_size(box_size/2);
- double minus_half_box_size(-half_box_size);
-
- // fill list with points
- std::list<GeoLib::Point> pnts_list;
- for (int k(0); k<n; k++) {
- pnts_list.push_back(GeoLib::Point(rand() % box_size - half_box_size, rand() % box_size - half_box_size, rand() % box_size - half_box_size));
- }
-
- // construct from list points a axis algined bounding box
- GeoLib::AABB aabb(pnts_list.begin(), pnts_list.end());
-
- MathLib::Point3d const& min_pnt(aabb.getMinPoint());
- MathLib::Point3d const& max_pnt(aabb.getMaxPoint());
-
- ASSERT_LE(minus_half_box_size, min_pnt[0]) << "coordinate 0 of min_pnt is smaller than " << minus_half_box_size;
- ASSERT_LE(minus_half_box_size, min_pnt[1]) << "coordinate 1 of min_pnt is smaller than " << minus_half_box_size;
- ASSERT_LE(minus_half_box_size, min_pnt[2]) << "coordinate 2 of min_pnt is smaller than " << minus_half_box_size;
-
- // since the interval is half-open we have to move the upper bound also
- half_box_size = std::nexttoward(half_box_size, std::numeric_limits<double>::max());
- ASSERT_GE(half_box_size, max_pnt[0]) << "coordinate 0 of max_pnt is greater than " << half_box_size;
- ASSERT_GE(half_box_size, max_pnt[1]) << "coordinate 1 of max_pnt is greater than " << half_box_size;
- ASSERT_GE(half_box_size, max_pnt[2]) << "coordinate 2 of max_pnt is greater than " << half_box_size;
+ /* initialize random seed: */
+ srand ( static_cast<unsigned>(time(nullptr)) );
+ int n (rand() % 1000000);
+ int box_size (rand());
+ double half_box_size(box_size/2);
+ double minus_half_box_size(-half_box_size);
+
+ // fill list with points
+ std::list<GeoLib::Point> pnts_list;
+ for (int k(0); k<n; k++) {
+ pnts_list.push_back(GeoLib::Point(rand() % box_size - half_box_size, rand() % box_size - half_box_size, rand() % box_size - half_box_size));
+ }
+
+ // construct from list points a axis algined bounding box
+ GeoLib::AABB aabb(pnts_list.begin(), pnts_list.end());
+
+ MathLib::Point3d const& min_pnt(aabb.getMinPoint());
+ MathLib::Point3d const& max_pnt(aabb.getMaxPoint());
+
+ ASSERT_LE(minus_half_box_size, min_pnt[0]) << "coordinate 0 of min_pnt is smaller than " << minus_half_box_size;
+ ASSERT_LE(minus_half_box_size, min_pnt[1]) << "coordinate 1 of min_pnt is smaller than " << minus_half_box_size;
+ ASSERT_LE(minus_half_box_size, min_pnt[2]) << "coordinate 2 of min_pnt is smaller than " << minus_half_box_size;
+
+ // since the interval is half-open we have to move the upper bound also
+ half_box_size = std::nexttoward(half_box_size, std::numeric_limits<double>::max());
+ ASSERT_GE(half_box_size, max_pnt[0]) << "coordinate 0 of max_pnt is greater than " << half_box_size;
+ ASSERT_GE(half_box_size, max_pnt[1]) << "coordinate 1 of max_pnt is greater than " << half_box_size;
+ ASSERT_GE(half_box_size, max_pnt[2]) << "coordinate 2 of max_pnt is greater than " << half_box_size;
}
TEST(GeoLibAABB, RandomNumberOfPointersToRandomPointsInAVector)
{
- /* initialize random seed: */
- srand ( static_cast<unsigned>(time(nullptr)) );
- int n (rand() % 100000);
- int box_size (rand());
- double half_box_size(box_size/2);
- double minus_half_box_size(-half_box_size);
-
- // fill list with points
- std::vector<GeoLib::Point*> pnts;
- for (int k(0); k<n; k++) {
- pnts.push_back(new GeoLib::Point(rand() % box_size - half_box_size, rand() % box_size - half_box_size, rand() % box_size - half_box_size));
- }
-
- // construct from list points a axis aligned bounding box
- GeoLib::AABB aabb(pnts.begin(), pnts.end());
-
- MathLib::Point3d const& min_pnt(aabb.getMinPoint());
- MathLib::Point3d const& max_pnt(aabb.getMaxPoint());
-
- ASSERT_LE(minus_half_box_size, min_pnt[0]) << "coordinate 0 of min_pnt is smaller than " << minus_half_box_size;
- ASSERT_LE(minus_half_box_size, min_pnt[1]) << "coordinate 1 of min_pnt is smaller than " << minus_half_box_size;
- ASSERT_LE(minus_half_box_size, min_pnt[2]) << "coordinate 2 of min_pnt is smaller than " << minus_half_box_size;
-
- // since the interval is half-open we have to move the upper bound also
- half_box_size = std::nexttoward(half_box_size, std::numeric_limits<double>::max());
- ASSERT_GE(half_box_size, max_pnt[0]) << "coordinate 0 of max_pnt is greater than " << half_box_size;
- ASSERT_GE(half_box_size, max_pnt[1]) << "coordinate 1 of max_pnt is greater than " << half_box_size;
- ASSERT_GE(half_box_size, max_pnt[2]) << "coordinate 2 of max_pnt is greater than " << half_box_size;
-
- for (std::vector<GeoLib::Point*>::iterator it(pnts.begin()); it != pnts.end(); it++) {
- delete *it;
- }
+ /* initialize random seed: */
+ srand ( static_cast<unsigned>(time(nullptr)) );
+ int n (rand() % 100000);
+ int box_size (rand());
+ double half_box_size(box_size/2);
+ double minus_half_box_size(-half_box_size);
+
+ // fill list with points
+ std::vector<GeoLib::Point*> pnts;
+ for (int k(0); k<n; k++) {
+ pnts.push_back(new GeoLib::Point(rand() % box_size - half_box_size, rand() % box_size - half_box_size, rand() % box_size - half_box_size));
+ }
+
+ // construct from list points a axis aligned bounding box
+ GeoLib::AABB aabb(pnts.begin(), pnts.end());
+
+ MathLib::Point3d const& min_pnt(aabb.getMinPoint());
+ MathLib::Point3d const& max_pnt(aabb.getMaxPoint());
+
+ ASSERT_LE(minus_half_box_size, min_pnt[0]) << "coordinate 0 of min_pnt is smaller than " << minus_half_box_size;
+ ASSERT_LE(minus_half_box_size, min_pnt[1]) << "coordinate 1 of min_pnt is smaller than " << minus_half_box_size;
+ ASSERT_LE(minus_half_box_size, min_pnt[2]) << "coordinate 2 of min_pnt is smaller than " << minus_half_box_size;
+
+ // since the interval is half-open we have to move the upper bound also
+ half_box_size = std::nexttoward(half_box_size, std::numeric_limits<double>::max());
+ ASSERT_GE(half_box_size, max_pnt[0]) << "coordinate 0 of max_pnt is greater than " << half_box_size;
+ ASSERT_GE(half_box_size, max_pnt[1]) << "coordinate 1 of max_pnt is greater than " << half_box_size;
+ ASSERT_GE(half_box_size, max_pnt[2]) << "coordinate 2 of max_pnt is greater than " << half_box_size;
+
+ for (std::vector<GeoLib::Point*>::iterator it(pnts.begin()); it != pnts.end(); it++) {
+ delete *it;
+ }
}
TEST(GeoLibAABB, RandomNumberOfPointsRandomPointInAVector)
{
- /* initialize random seed: */
- srand ( static_cast<unsigned>(time(nullptr)) );
- int n (rand() % 1000000);
- int box_size (rand());
- double half_box_size(box_size/2);
- double minus_half_box_size(-half_box_size);
-
- // fill list with points
- std::list<GeoLib::Point> pnts;
- for (int k(0); k<n; k++) {
- pnts.push_back(GeoLib::Point(rand() % box_size - half_box_size, rand() % box_size - half_box_size, rand() % box_size - half_box_size));
- }
-
- // construct from list points a axis algined bounding box
- GeoLib::AABB aabb(pnts.begin(), pnts.end());
-
- MathLib::Point3d const& min_pnt(aabb.getMinPoint());
- MathLib::Point3d const& max_pnt(aabb.getMaxPoint());
-
- ASSERT_LE(minus_half_box_size, min_pnt[0]) << "coordinate 0 of min_pnt is smaller than " << minus_half_box_size;
- ASSERT_LE(minus_half_box_size, min_pnt[1]) << "coordinate 1 of min_pnt is smaller than " << minus_half_box_size;
- ASSERT_LE(minus_half_box_size, min_pnt[2]) << "coordinate 2 of min_pnt is smaller than " << minus_half_box_size;
-
- // since the interval is half-open we have to move the upper bound also
- half_box_size = std::nexttoward(half_box_size, std::numeric_limits<double>::max());
- ASSERT_GE(half_box_size, max_pnt[0]) << "coordinate 0 of max_pnt is greater than " << half_box_size;
- ASSERT_GE(half_box_size, max_pnt[1]) << "coordinate 1 of max_pnt is greater than " << half_box_size;
- ASSERT_GE(half_box_size, max_pnt[2]) << "coordinate 2 of max_pnt is greater than " << half_box_size;
+ /* initialize random seed: */
+ srand ( static_cast<unsigned>(time(nullptr)) );
+ int n (rand() % 1000000);
+ int box_size (rand());
+ double half_box_size(box_size/2);
+ double minus_half_box_size(-half_box_size);
+
+ // fill list with points
+ std::list<GeoLib::Point> pnts;
+ for (int k(0); k<n; k++) {
+ pnts.push_back(GeoLib::Point(rand() % box_size - half_box_size, rand() % box_size - half_box_size, rand() % box_size - half_box_size));
+ }
+
+ // construct from list points a axis algined bounding box
+ GeoLib::AABB aabb(pnts.begin(), pnts.end());
+
+ MathLib::Point3d const& min_pnt(aabb.getMinPoint());
+ MathLib::Point3d const& max_pnt(aabb.getMaxPoint());
+
+ ASSERT_LE(minus_half_box_size, min_pnt[0]) << "coordinate 0 of min_pnt is smaller than " << minus_half_box_size;
+ ASSERT_LE(minus_half_box_size, min_pnt[1]) << "coordinate 1 of min_pnt is smaller than " << minus_half_box_size;
+ ASSERT_LE(minus_half_box_size, min_pnt[2]) << "coordinate 2 of min_pnt is smaller than " << minus_half_box_size;
+
+ // since the interval is half-open we have to move the upper bound also
+ half_box_size = std::nexttoward(half_box_size, std::numeric_limits<double>::max());
+ ASSERT_GE(half_box_size, max_pnt[0]) << "coordinate 0 of max_pnt is greater than " << half_box_size;
+ ASSERT_GE(half_box_size, max_pnt[1]) << "coordinate 1 of max_pnt is greater than " << half_box_size;
+ ASSERT_GE(half_box_size, max_pnt[2]) << "coordinate 2 of max_pnt is greater than " << half_box_size;
}
TEST(GeoLibAABB, RandomNumberOfPointsRandomBox)
{
- /* initialize random seed: */
- srand (static_cast<unsigned>(time(nullptr)));
- int n (rand() % 1000000);
- int box_size_x (rand());
- int box_size_y (rand());
- int box_size_z (rand());
- double half_box_size_x(box_size_x/2);
- double half_box_size_y(box_size_y/2);
- double half_box_size_z(box_size_z/2);
- int minus_half_box_size_x(-half_box_size_x);
- int minus_half_box_size_y(-half_box_size_y);
- int minus_half_box_size_z(-half_box_size_z);
-
- // fill list with points
- std::list<GeoLib::Point> pnts;
- for (int k(0); k<n; k++) {
- pnts.push_back(GeoLib::Point(rand() % box_size_x - half_box_size_x, rand() % box_size_y - half_box_size_y, rand() % box_size_z - half_box_size_z));
- }
-
- // construct from list points a axis aligned bounding box
- GeoLib::AABB aabb(pnts.begin(), pnts.end());
-
- MathLib::Point3d const& min_pnt(aabb.getMinPoint());
- MathLib::Point3d const& max_pnt(aabb.getMaxPoint());
-
- ASSERT_LE(minus_half_box_size_x, min_pnt[0]) << "coordinate 0 of min_pnt is smaller than " << minus_half_box_size_x;
- ASSERT_LE(minus_half_box_size_y, min_pnt[1]) << "coordinate 1 of min_pnt is smaller than " << minus_half_box_size_y;
- ASSERT_LE(minus_half_box_size_z, min_pnt[2]) << "coordinate 2 of min_pnt is smaller than " << minus_half_box_size_z;
-
- // since the interval is half-open we have to move the upper bound also
- half_box_size_x = std::nexttoward(half_box_size_x, std::numeric_limits<double>::max());
- half_box_size_y = std::nexttoward(half_box_size_y, std::numeric_limits<double>::max());
- half_box_size_z = std::nexttoward(half_box_size_z, std::numeric_limits<double>::max());
- ASSERT_GE(half_box_size_x, max_pnt[0]) << "coordinate 0 of max_pnt is greater than " << half_box_size_x;
- ASSERT_GE(half_box_size_y, max_pnt[1]) << "coordinate 1 of max_pnt is greater than " << half_box_size_y;
- ASSERT_GE(half_box_size_z, max_pnt[2]) << "coordinate 2 of max_pnt is greater than " << half_box_size_z;
+ /* initialize random seed: */
+ srand (static_cast<unsigned>(time(nullptr)));
+ int n (rand() % 1000000);
+ int box_size_x (rand());
+ int box_size_y (rand());
+ int box_size_z (rand());
+ double half_box_size_x(box_size_x/2);
+ double half_box_size_y(box_size_y/2);
+ double half_box_size_z(box_size_z/2);
+ int minus_half_box_size_x(-half_box_size_x);
+ int minus_half_box_size_y(-half_box_size_y);
+ int minus_half_box_size_z(-half_box_size_z);
+
+ // fill list with points
+ std::list<GeoLib::Point> pnts;
+ for (int k(0); k<n; k++) {
+ pnts.push_back(GeoLib::Point(rand() % box_size_x - half_box_size_x, rand() % box_size_y - half_box_size_y, rand() % box_size_z - half_box_size_z));
+ }
+
+ // construct from list points a axis aligned bounding box
+ GeoLib::AABB aabb(pnts.begin(), pnts.end());
+
+ MathLib::Point3d const& min_pnt(aabb.getMinPoint());
+ MathLib::Point3d const& max_pnt(aabb.getMaxPoint());
+
+ ASSERT_LE(minus_half_box_size_x, min_pnt[0]) << "coordinate 0 of min_pnt is smaller than " << minus_half_box_size_x;
+ ASSERT_LE(minus_half_box_size_y, min_pnt[1]) << "coordinate 1 of min_pnt is smaller than " << minus_half_box_size_y;
+ ASSERT_LE(minus_half_box_size_z, min_pnt[2]) << "coordinate 2 of min_pnt is smaller than " << minus_half_box_size_z;
+
+ // since the interval is half-open we have to move the upper bound also
+ half_box_size_x = std::nexttoward(half_box_size_x, std::numeric_limits<double>::max());
+ half_box_size_y = std::nexttoward(half_box_size_y, std::numeric_limits<double>::max());
+ half_box_size_z = std::nexttoward(half_box_size_z, std::numeric_limits<double>::max());
+ ASSERT_GE(half_box_size_x, max_pnt[0]) << "coordinate 0 of max_pnt is greater than " << half_box_size_x;
+ ASSERT_GE(half_box_size_y, max_pnt[1]) << "coordinate 1 of max_pnt is greater than " << half_box_size_y;
+ ASSERT_GE(half_box_size_z, max_pnt[2]) << "coordinate 2 of max_pnt is greater than " << half_box_size_z;
}
TEST(GeoLib, AABBAllPointsWithNegativeCoordinatesI)
{
- std::vector<GeoLib::Point*> pnts;
- pnts.push_back(new GeoLib::Point(-1, -1, -1));
- pnts.push_back(new GeoLib::Point(-10, -10, -10));
+ std::vector<GeoLib::Point*> pnts;
+ pnts.push_back(new GeoLib::Point(-1, -1, -1));
+ pnts.push_back(new GeoLib::Point(-10, -10, -10));
- std::vector<std::size_t> ids;
- ids.push_back(0);
- ids.push_back(1);
- GeoLib::AABB aabb(pnts, ids);
+ std::vector<std::size_t> ids;
+ ids.push_back(0);
+ ids.push_back(1);
+ GeoLib::AABB aabb(pnts, ids);
- MathLib::Point3d const& max_pnt(aabb.getMaxPoint());
+ MathLib::Point3d const& max_pnt(aabb.getMaxPoint());
- ASSERT_NEAR(-1.0, max_pnt[0], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(-1.0, max_pnt[1], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(-1.0, max_pnt[2], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(-1.0, max_pnt[0], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(-1.0, max_pnt[1], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(-1.0, max_pnt[2], std::numeric_limits<double>::epsilon());
- for (auto p : pnts)
- delete p;
+ for (auto p : pnts)
+ delete p;
}
TEST(GeoLib, AABBAllPointsWithNegativeCoordinatesII)
{
- std::vector<GeoLib::Point> pnts;
+ std::vector<GeoLib::Point> pnts;
- pnts.push_back(GeoLib::Point(-1, -1, -1));
- pnts.push_back(GeoLib::Point(-10, -10, -10));
+ pnts.push_back(GeoLib::Point(-1, -1, -1));
+ pnts.push_back(GeoLib::Point(-10, -10, -10));
- // construct from points of the vector a axis aligned bounding box
- GeoLib::AABB aabb(pnts.begin(), pnts.end());
+ // construct from points of the vector a axis aligned bounding box
+ GeoLib::AABB aabb(pnts.begin(), pnts.end());
- MathLib::Point3d const& max_pnt(aabb.getMaxPoint());
+ MathLib::Point3d const& max_pnt(aabb.getMaxPoint());
- ASSERT_NEAR(-1.0, max_pnt[0], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(-1.0, max_pnt[1], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(-1.0, max_pnt[2], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(-1.0, max_pnt[0], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(-1.0, max_pnt[1], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(-1.0, max_pnt[2], std::numeric_limits<double>::epsilon());
}
// This test creates an AABB containing a single point.
@@ -243,45 +243,45 @@ TEST(GeoLib, AABBAllPointsWithNegativeCoordinatesII)
// It is checked that the AABB contains the point iff it has not been moved.
TEST(GeoLib, AABBSinglePoint)
{
- std::random_device rd;
- std::mt19937 random_number_generator(rd());
- std::uniform_real_distribution<double> rnd(-1000000.0, 10000000.0);
- std::vector<GeoLib::Point> pnts;
- GeoLib::Point p{{{rnd(random_number_generator),
- rnd(random_number_generator),rnd(random_number_generator)}}};
- pnts.push_back(p);
-
- ASSERT_EQ(1u, pnts.size());
-
- // construct from points of the vector a axis aligned bounding box
- GeoLib::AABB aabb(pnts.begin(), pnts.end());
-
- double const to_lowest(std::numeric_limits<double>::lowest());
- double const to_max(std::numeric_limits<double>::max());
-
- // Check the point within the aabb (i==j==k). The outer 26 (3 * 3 * 3 - 1)
- // points around the aabb are also checked.
- for (int i(-1); i<2; ++i) {
- // Modify the first coordinate of p.
- if (i==-1) p[0] = std::nextafter(pnts.front()[0], to_lowest);
- else if (i==0) p[0] = pnts.front()[0];
- else p[0] = std::nextafter(pnts.front()[0], to_max);
- for (int j(-1); j<2; ++j) {
- // Modify the second coordinate of p.
- if (j==-1) p[1] = std::nextafter(pnts.front()[1], to_lowest);
- else if (j==0) p[1] = pnts.front()[1];
- else p[1] = std::nextafter(pnts.front()[1], to_max);
- for (int k(-1); k<2; ++k) {
- // Modify the third coordinate of p.
- if (k==-1) p[2] = std::nextafter(pnts.front()[2], to_lowest);
- else if (k==0) p[2] = pnts.front()[2];
- else p[2] = std::nextafter(pnts.front()[2], to_max);
- if (i == 0 && j == 0 && k == 0)
- ASSERT_TRUE(aabb.containsPoint(p));
- else
- ASSERT_FALSE(aabb.containsPoint(p));
- }
- }
- }
+ std::random_device rd;
+ std::mt19937 random_number_generator(rd());
+ std::uniform_real_distribution<double> rnd(-1000000.0, 10000000.0);
+ std::vector<GeoLib::Point> pnts;
+ GeoLib::Point p{{{rnd(random_number_generator),
+ rnd(random_number_generator),rnd(random_number_generator)}}};
+ pnts.push_back(p);
+
+ ASSERT_EQ(1u, pnts.size());
+
+ // construct from points of the vector a axis aligned bounding box
+ GeoLib::AABB aabb(pnts.begin(), pnts.end());
+
+ double const to_lowest(std::numeric_limits<double>::lowest());
+ double const to_max(std::numeric_limits<double>::max());
+
+ // Check the point within the aabb (i==j==k). The outer 26 (3 * 3 * 3 - 1)
+ // points around the aabb are also checked.
+ for (int i(-1); i<2; ++i) {
+ // Modify the first coordinate of p.
+ if (i==-1) p[0] = std::nextafter(pnts.front()[0], to_lowest);
+ else if (i==0) p[0] = pnts.front()[0];
+ else p[0] = std::nextafter(pnts.front()[0], to_max);
+ for (int j(-1); j<2; ++j) {
+ // Modify the second coordinate of p.
+ if (j==-1) p[1] = std::nextafter(pnts.front()[1], to_lowest);
+ else if (j==0) p[1] = pnts.front()[1];
+ else p[1] = std::nextafter(pnts.front()[1], to_max);
+ for (int k(-1); k<2; ++k) {
+ // Modify the third coordinate of p.
+ if (k==-1) p[2] = std::nextafter(pnts.front()[2], to_lowest);
+ else if (k==0) p[2] = pnts.front()[2];
+ else p[2] = std::nextafter(pnts.front()[2], to_max);
+ if (i == 0 && j == 0 && k == 0)
+ ASSERT_TRUE(aabb.containsPoint(p));
+ else
+ ASSERT_FALSE(aabb.containsPoint(p));
+ }
+ }
+ }
}
diff --git a/Tests/GeoLib/TestComputeAndInsertAllIntersectionPoints.cpp b/Tests/GeoLib/TestComputeAndInsertAllIntersectionPoints.cpp
index 4c7a7761f6af45a95ade9b40b66826a96370b260..22663d05b76a93b014fb16d39ba44f8349a81b06 100644
--- a/Tests/GeoLib/TestComputeAndInsertAllIntersectionPoints.cpp
+++ b/Tests/GeoLib/TestComputeAndInsertAllIntersectionPoints.cpp
@@ -21,93 +21,93 @@
TEST(GeoLib, TestComputeAndInsertAllIntersectionPoints)
{
- GeoLib::GEOObjects geo_objs;
- std::string geo_name("TestGeometry");
+ GeoLib::GEOObjects geo_objs;
+ std::string geo_name("TestGeometry");
- {
- // *** insert points in vector
- auto pnts = std::unique_ptr<std::vector<GeoLib::Point*>>(
- new std::vector<GeoLib::Point*>);
- pnts->push_back(new GeoLib::Point(0.0,0.0,0.0,0));
- pnts->push_back(new GeoLib::Point(11.0,0.0,0.0,1));
+ {
+ // *** insert points in vector
+ auto pnts = std::unique_ptr<std::vector<GeoLib::Point*>>(
+ new std::vector<GeoLib::Point*>);
+ pnts->push_back(new GeoLib::Point(0.0,0.0,0.0,0));
+ pnts->push_back(new GeoLib::Point(11.0,0.0,0.0,1));
- pnts->push_back(new GeoLib::Point(0.0,1.0,0.0,2));
- pnts->push_back(new GeoLib::Point(1.0,-1.0,0.0,3));
- pnts->push_back(new GeoLib::Point(2.0, 1.0,0.0,4));
- pnts->push_back(new GeoLib::Point(3.0,-1.0,0.0,5));
- pnts->push_back(new GeoLib::Point(4.0, 1.0,0.0,6));
- pnts->push_back(new GeoLib::Point(5.0,-1.0,0.0,7));
- pnts->push_back(new GeoLib::Point(6.0, 1.0,0.0,8));
- pnts->push_back(new GeoLib::Point(7.0,-1.0,0.0,9));
- pnts->push_back(new GeoLib::Point(8.0, 1.0,0.0,10));
- pnts->push_back(new GeoLib::Point(9.0,-1.0,0.0,11));
- pnts->push_back(new GeoLib::Point(10.0, 1.0,0.0,12));
- pnts->push_back(new GeoLib::Point(11.0,-1.0,0.0,13));
+ pnts->push_back(new GeoLib::Point(0.0,1.0,0.0,2));
+ pnts->push_back(new GeoLib::Point(1.0,-1.0,0.0,3));
+ pnts->push_back(new GeoLib::Point(2.0, 1.0,0.0,4));
+ pnts->push_back(new GeoLib::Point(3.0,-1.0,0.0,5));
+ pnts->push_back(new GeoLib::Point(4.0, 1.0,0.0,6));
+ pnts->push_back(new GeoLib::Point(5.0,-1.0,0.0,7));
+ pnts->push_back(new GeoLib::Point(6.0, 1.0,0.0,8));
+ pnts->push_back(new GeoLib::Point(7.0,-1.0,0.0,9));
+ pnts->push_back(new GeoLib::Point(8.0, 1.0,0.0,10));
+ pnts->push_back(new GeoLib::Point(9.0,-1.0,0.0,11));
+ pnts->push_back(new GeoLib::Point(10.0, 1.0,0.0,12));
+ pnts->push_back(new GeoLib::Point(11.0,-1.0,0.0,13));
- geo_objs.addPointVec(std::move(pnts), geo_name);
- }
+ geo_objs.addPointVec(std::move(pnts), geo_name);
+ }
- // *** create polylines
- auto& pnts = *geo_objs.getPointVec(geo_name);
- GeoLib::Polyline* ply0(new GeoLib::Polyline(pnts));
- ply0->addPoint(0);
- ply0->addPoint(1);
- GeoLib::Polyline* ply1(new GeoLib::Polyline(pnts));
- for (std::size_t k(2); k<pnts.size(); ++k)
- ply1->addPoint(k);
- std::vector<GeoLib::Polyline*>* plys(new std::vector<GeoLib::Polyline*>);
- plys->push_back(ply0);
- plys->push_back(ply1);
+ // *** create polylines
+ auto& pnts = *geo_objs.getPointVec(geo_name);
+ GeoLib::Polyline* ply0(new GeoLib::Polyline(pnts));
+ ply0->addPoint(0);
+ ply0->addPoint(1);
+ GeoLib::Polyline* ply1(new GeoLib::Polyline(pnts));
+ for (std::size_t k(2); k<pnts.size(); ++k)
+ ply1->addPoint(k);
+ std::vector<GeoLib::Polyline*>* plys(new std::vector<GeoLib::Polyline*>);
+ plys->push_back(ply0);
+ plys->push_back(ply1);
- GeoLib::PointVec &pnt_vec(*(const_cast<GeoLib::PointVec*>(geo_objs.getPointVecObj(geo_name))));
- GeoLib::computeAndInsertAllIntersectionPoints(pnt_vec, *plys);
+ GeoLib::PointVec &pnt_vec(*(const_cast<GeoLib::PointVec*>(geo_objs.getPointVecObj(geo_name))));
+ GeoLib::computeAndInsertAllIntersectionPoints(pnt_vec, *plys);
- ASSERT_EQ(25u, pnt_vec.size());
- ASSERT_EQ(13u, ply0->getNumberOfPoints());
- ASSERT_EQ(23u, ply1->getNumberOfPoints());
+ ASSERT_EQ(25u, pnt_vec.size());
+ ASSERT_EQ(13u, ply0->getNumberOfPoints());
+ ASSERT_EQ(23u, ply1->getNumberOfPoints());
- // check correct order of points in ply0
- EXPECT_EQ(0u, ply0->getPointID(0));
- EXPECT_EQ(14u, ply0->getPointID(1));
- EXPECT_EQ(15u, ply0->getPointID(2));
- EXPECT_EQ(16u, ply0->getPointID(3));
- EXPECT_EQ(17u, ply0->getPointID(4));
- EXPECT_EQ(18u, ply0->getPointID(5));
- EXPECT_EQ(19u, ply0->getPointID(6));
- EXPECT_EQ(20u, ply0->getPointID(7));
- EXPECT_EQ(21u, ply0->getPointID(8));
- EXPECT_EQ(22u, ply0->getPointID(9));
- EXPECT_EQ(23u, ply0->getPointID(10));
- EXPECT_EQ(24u, ply0->getPointID(11));
- EXPECT_EQ(1u, ply0->getPointID(12));
+ // check correct order of points in ply0
+ EXPECT_EQ(0u, ply0->getPointID(0));
+ EXPECT_EQ(14u, ply0->getPointID(1));
+ EXPECT_EQ(15u, ply0->getPointID(2));
+ EXPECT_EQ(16u, ply0->getPointID(3));
+ EXPECT_EQ(17u, ply0->getPointID(4));
+ EXPECT_EQ(18u, ply0->getPointID(5));
+ EXPECT_EQ(19u, ply0->getPointID(6));
+ EXPECT_EQ(20u, ply0->getPointID(7));
+ EXPECT_EQ(21u, ply0->getPointID(8));
+ EXPECT_EQ(22u, ply0->getPointID(9));
+ EXPECT_EQ(23u, ply0->getPointID(10));
+ EXPECT_EQ(24u, ply0->getPointID(11));
+ EXPECT_EQ(1u, ply0->getPointID(12));
- // check correct order of points in ply1
- EXPECT_EQ(2u, ply1->getPointID(0));
- EXPECT_EQ(14u, ply1->getPointID(1));
- EXPECT_EQ(3u, ply1->getPointID(2));
- EXPECT_EQ(15u, ply1->getPointID(3));
- EXPECT_EQ(4u, ply1->getPointID(4));
- EXPECT_EQ(16u, ply1->getPointID(5));
- EXPECT_EQ(5u, ply1->getPointID(6));
- EXPECT_EQ(17u, ply1->getPointID(7));
- EXPECT_EQ(6u, ply1->getPointID(8));
- EXPECT_EQ(18u, ply1->getPointID(9));
- EXPECT_EQ(7u, ply1->getPointID(10));
- EXPECT_EQ(19u, ply1->getPointID(11));
- EXPECT_EQ(8u, ply1->getPointID(12));
- EXPECT_EQ(20u, ply1->getPointID(13));
- EXPECT_EQ(9u, ply1->getPointID(14));
- EXPECT_EQ(21u, ply1->getPointID(15));
- EXPECT_EQ(10u, ply1->getPointID(16));
- EXPECT_EQ(22u, ply1->getPointID(17));
- EXPECT_EQ(11u, ply1->getPointID(18));
- EXPECT_EQ(23u, ply1->getPointID(19));
- EXPECT_EQ(12u, ply1->getPointID(20));
- EXPECT_EQ(24u, ply1->getPointID(21));
- EXPECT_EQ(13u, ply1->getPointID(22));
+ // check correct order of points in ply1
+ EXPECT_EQ(2u, ply1->getPointID(0));
+ EXPECT_EQ(14u, ply1->getPointID(1));
+ EXPECT_EQ(3u, ply1->getPointID(2));
+ EXPECT_EQ(15u, ply1->getPointID(3));
+ EXPECT_EQ(4u, ply1->getPointID(4));
+ EXPECT_EQ(16u, ply1->getPointID(5));
+ EXPECT_EQ(5u, ply1->getPointID(6));
+ EXPECT_EQ(17u, ply1->getPointID(7));
+ EXPECT_EQ(6u, ply1->getPointID(8));
+ EXPECT_EQ(18u, ply1->getPointID(9));
+ EXPECT_EQ(7u, ply1->getPointID(10));
+ EXPECT_EQ(19u, ply1->getPointID(11));
+ EXPECT_EQ(8u, ply1->getPointID(12));
+ EXPECT_EQ(20u, ply1->getPointID(13));
+ EXPECT_EQ(9u, ply1->getPointID(14));
+ EXPECT_EQ(21u, ply1->getPointID(15));
+ EXPECT_EQ(10u, ply1->getPointID(16));
+ EXPECT_EQ(22u, ply1->getPointID(17));
+ EXPECT_EQ(11u, ply1->getPointID(18));
+ EXPECT_EQ(23u, ply1->getPointID(19));
+ EXPECT_EQ(12u, ply1->getPointID(20));
+ EXPECT_EQ(24u, ply1->getPointID(21));
+ EXPECT_EQ(13u, ply1->getPointID(22));
- delete plys;
- delete ply1;
- delete ply0;
+ delete plys;
+ delete ply1;
+ delete ply0;
}
diff --git a/Tests/GeoLib/TestComputeRotationMatrix.cpp b/Tests/GeoLib/TestComputeRotationMatrix.cpp
index 65a041453d4f7796e2fa16b2ff99386045791df6..ce14be43a85150869d2fb496ae3f7cd3b5b31864 100644
--- a/Tests/GeoLib/TestComputeRotationMatrix.cpp
+++ b/Tests/GeoLib/TestComputeRotationMatrix.cpp
@@ -15,62 +15,62 @@
auto test3equal = [](double a, double b, double c, double const* result)
{
- EXPECT_EQ(a, result[0]);
- EXPECT_EQ(b, result[1]);
- EXPECT_EQ(c, result[2]);
+ EXPECT_EQ(a, result[0]);
+ EXPECT_EQ(b, result[1]);
+ EXPECT_EQ(c, result[2]);
- delete[] result;
+ delete[] result;
};
TEST(GeoLib, ComputeRotationMatrixToXYnegative)
{
- MathLib::Vector3 const n(0.0, -1.0, 0.0);
- MathLib::DenseMatrix<double> rot_mat(3,3,0.0);
+ MathLib::Vector3 const n(0.0, -1.0, 0.0);
+ MathLib::DenseMatrix<double> rot_mat(3,3,0.0);
- GeoLib::computeRotationMatrixToXY(n, rot_mat);
- EXPECT_EQ(1.0, rot_mat(0,0));
- EXPECT_EQ(0.0, rot_mat(0,1));
- EXPECT_EQ(0.0, rot_mat(0,2));
- EXPECT_EQ(0.0, rot_mat(1,0));
- EXPECT_EQ(0.0, rot_mat(1,1));
- EXPECT_EQ(1.0, rot_mat(1,2));
- EXPECT_EQ(0.0, rot_mat(2,0));
- EXPECT_EQ(-1.0, rot_mat(2,1));
- EXPECT_EQ(0.0, rot_mat(2,2));
+ GeoLib::computeRotationMatrixToXY(n, rot_mat);
+ EXPECT_EQ(1.0, rot_mat(0,0));
+ EXPECT_EQ(0.0, rot_mat(0,1));
+ EXPECT_EQ(0.0, rot_mat(0,2));
+ EXPECT_EQ(0.0, rot_mat(1,0));
+ EXPECT_EQ(0.0, rot_mat(1,1));
+ EXPECT_EQ(1.0, rot_mat(1,2));
+ EXPECT_EQ(0.0, rot_mat(2,0));
+ EXPECT_EQ(-1.0, rot_mat(2,1));
+ EXPECT_EQ(0.0, rot_mat(2,2));
- MathLib::Vector3 const x(0.0,1.0,0.0);
- test3equal(0, 0, -1, rot_mat*x.getCoords());
+ MathLib::Vector3 const x(0.0,1.0,0.0);
+ test3equal(0, 0, -1, rot_mat*x.getCoords());
- MathLib::Vector3 const x0(10.0,1.0,0.0);
- test3equal(10, 0, -1, rot_mat*x0.getCoords());
+ MathLib::Vector3 const x0(10.0,1.0,0.0);
+ test3equal(10, 0, -1, rot_mat*x0.getCoords());
- MathLib::Vector3 const x1(10.0,0.0,10.0);
- test3equal(10, 10, 0, rot_mat*x1.getCoords());
+ MathLib::Vector3 const x1(10.0,0.0,10.0);
+ test3equal(10, 10, 0, rot_mat*x1.getCoords());
}
TEST(GeoLib, ComputeRotationMatrixToXYpositive)
{
- MathLib::Vector3 const n(0.0, 1.0, 0.0);
- MathLib::DenseMatrix<double> rot_mat(3,3,0.0);
+ MathLib::Vector3 const n(0.0, 1.0, 0.0);
+ MathLib::DenseMatrix<double> rot_mat(3,3,0.0);
- GeoLib::computeRotationMatrixToXY(n, rot_mat);
- EXPECT_EQ(1.0, rot_mat(0,0));
- EXPECT_EQ(0.0, rot_mat(0,1));
- EXPECT_EQ(0.0, rot_mat(0,2));
- EXPECT_EQ(0.0, rot_mat(1,0));
- EXPECT_EQ(0.0, rot_mat(1,1));
- EXPECT_EQ(-1.0, rot_mat(1,2));
- EXPECT_EQ(0.0, rot_mat(2,0));
- EXPECT_EQ(1.0, rot_mat(2,1));
- EXPECT_EQ(0.0, rot_mat(2,2));
+ GeoLib::computeRotationMatrixToXY(n, rot_mat);
+ EXPECT_EQ(1.0, rot_mat(0,0));
+ EXPECT_EQ(0.0, rot_mat(0,1));
+ EXPECT_EQ(0.0, rot_mat(0,2));
+ EXPECT_EQ(0.0, rot_mat(1,0));
+ EXPECT_EQ(0.0, rot_mat(1,1));
+ EXPECT_EQ(-1.0, rot_mat(1,2));
+ EXPECT_EQ(0.0, rot_mat(2,0));
+ EXPECT_EQ(1.0, rot_mat(2,1));
+ EXPECT_EQ(0.0, rot_mat(2,2));
- MathLib::Vector3 const x(0.0,1.0,0.0);
- test3equal(0, 0, 1, rot_mat*x.getCoords());
+ MathLib::Vector3 const x(0.0,1.0,0.0);
+ test3equal(0, 0, 1, rot_mat*x.getCoords());
- MathLib::Vector3 const x0(10.0,1.0,0.0);
- test3equal(10, 0, 1, rot_mat*x0.getCoords());
+ MathLib::Vector3 const x0(10.0,1.0,0.0);
+ test3equal(10, 0, 1, rot_mat*x0.getCoords());
- MathLib::Vector3 const x1(10.0,0.0,10.0);
- test3equal(10, -10, 0, rot_mat*x1.getCoords());
+ MathLib::Vector3 const x1(10.0,0.0,10.0);
+ test3equal(10, -10, 0, rot_mat*x1.getCoords());
}
diff --git a/Tests/GeoLib/TestDividedByPlane.cpp b/Tests/GeoLib/TestDividedByPlane.cpp
index 9af5f53def1a34fa012e7f557cc83821be6ae696..3e6121dc7636e2052b94f3e4548704e43f2151db 100644
--- a/Tests/GeoLib/TestDividedByPlane.cpp
+++ b/Tests/GeoLib/TestDividedByPlane.cpp
@@ -19,31 +19,31 @@
TEST(GeoLib, TestDividedByPlane)
{
- // xy plane
- GeoLib::Point a(0,0,0);
- GeoLib::Point b(1,0,0);
- GeoLib::Point c(0,1,0);
- GeoLib::Point d(1,1,0);
-
- bool result = GeoLib::dividedByPlane(a, d, b, c);
- ASSERT_TRUE(result);
-
- result = GeoLib::dividedByPlane(b, c, a, d);
- ASSERT_TRUE(result);
-
- d = GeoLib::Point(0.1, 0.1, 0);
- result = GeoLib::dividedByPlane(b, c, a, d);
- ASSERT_FALSE(result);
-
- // xz plane
- c = GeoLib::Point(0, 0, 1);
- d = GeoLib::Point(1, 0, 1);
- result = GeoLib::dividedByPlane(a, d, b, c);
- ASSERT_TRUE(result);
-
- // yz plane
- b = GeoLib::Point(0, 1, 0);
- d = GeoLib::Point(0, 1, 1);
- result = GeoLib::dividedByPlane(a, d, b, c);
- ASSERT_TRUE(result);
+ // xy plane
+ GeoLib::Point a(0,0,0);
+ GeoLib::Point b(1,0,0);
+ GeoLib::Point c(0,1,0);
+ GeoLib::Point d(1,1,0);
+
+ bool result = GeoLib::dividedByPlane(a, d, b, c);
+ ASSERT_TRUE(result);
+
+ result = GeoLib::dividedByPlane(b, c, a, d);
+ ASSERT_TRUE(result);
+
+ d = GeoLib::Point(0.1, 0.1, 0);
+ result = GeoLib::dividedByPlane(b, c, a, d);
+ ASSERT_FALSE(result);
+
+ // xz plane
+ c = GeoLib::Point(0, 0, 1);
+ d = GeoLib::Point(1, 0, 1);
+ result = GeoLib::dividedByPlane(a, d, b, c);
+ ASSERT_TRUE(result);
+
+ // yz plane
+ b = GeoLib::Point(0, 1, 0);
+ d = GeoLib::Point(0, 1, 1);
+ result = GeoLib::dividedByPlane(a, d, b, c);
+ ASSERT_TRUE(result);
}
diff --git a/Tests/GeoLib/TestGEOObjectsMerge.cpp b/Tests/GeoLib/TestGEOObjectsMerge.cpp
index 1af5d39f5fe77d306b09372a6695f22aa94140d7..3aa66c321cb4dfb3ce7936b907c46c07fabf0d1a 100644
--- a/Tests/GeoLib/TestGEOObjectsMerge.cpp
+++ b/Tests/GeoLib/TestGEOObjectsMerge.cpp
@@ -21,219 +21,219 @@
void createSetOfTestPointsAndAssociatedNames(GeoLib::GEOObjects & geo_objs, std::string &name, GeoLib::Point const& shift)
{
- auto pnts = std::unique_ptr<std::vector<GeoLib::Point*>>(
- new std::vector<GeoLib::Point*>);
- std::map<std::string, std::size_t>* pnt_name_map(new std::map< std::string, std::size_t>);
-
- const std::size_t pnts_per_edge(8);
- for (std::size_t k(0); k < pnts_per_edge; k++) {
- const std::size_t k_offset(k * pnts_per_edge * pnts_per_edge);
- for (std::size_t j(0); j < pnts_per_edge; j++) {
- const std::size_t offset(j * pnts_per_edge + k_offset);
- for (std::size_t i(0); i < pnts_per_edge; i++) {
- std::size_t const id(i+offset);
- pnts->push_back(
- new GeoLib::Point(i+shift[0], j+shift[1], k+shift[2], id));
- std::string pnt_name(
- name + "-" + std::to_string(i) + "-" + std::to_string(j) + "-"
- + std::to_string(k));
- pnt_name_map->insert(std::make_pair(pnt_name, id));
- }
- }
- }
-
- geo_objs.addPointVec(std::move(pnts), name, pnt_name_map);
+ auto pnts = std::unique_ptr<std::vector<GeoLib::Point*>>(
+ new std::vector<GeoLib::Point*>);
+ std::map<std::string, std::size_t>* pnt_name_map(new std::map< std::string, std::size_t>);
+
+ const std::size_t pnts_per_edge(8);
+ for (std::size_t k(0); k < pnts_per_edge; k++) {
+ const std::size_t k_offset(k * pnts_per_edge * pnts_per_edge);
+ for (std::size_t j(0); j < pnts_per_edge; j++) {
+ const std::size_t offset(j * pnts_per_edge + k_offset);
+ for (std::size_t i(0); i < pnts_per_edge; i++) {
+ std::size_t const id(i+offset);
+ pnts->push_back(
+ new GeoLib::Point(i+shift[0], j+shift[1], k+shift[2], id));
+ std::string pnt_name(
+ name + "-" + std::to_string(i) + "-" + std::to_string(j) + "-"
+ + std::to_string(k));
+ pnt_name_map->insert(std::make_pair(pnt_name, id));
+ }
+ }
+ }
+
+ geo_objs.addPointVec(std::move(pnts), name, pnt_name_map);
}
TEST(GeoLib, GEOObjectsMergePoints)
{
- GeoLib::GEOObjects geo_objs;
- std::vector<std::string> names;
-
- // *** insert set of points number 0
- GeoLib::Point shift (0.0,0.0,0.0);
- names.push_back("PointSet0");
- createSetOfTestPointsAndAssociatedNames(geo_objs, names[0], shift);
-
- // *** insert set of points number 1
- names.push_back("PointSet1");
- createSetOfTestPointsAndAssociatedNames(geo_objs, names[1], shift);
-
- // *** merge geometries
- std::string merged_geometries_name("MergedEqualPointSet");
- geo_objs.mergeGeometries(names, merged_geometries_name);
-
- GeoLib::PointVec const* merged_point_vec (geo_objs.getPointVecObj(merged_geometries_name));
-
- ASSERT_TRUE(merged_point_vec != nullptr);
- ASSERT_EQ(512u, merged_point_vec->size());
- std::string test_name;
- merged_point_vec->getNameOfElementByID(0, test_name);
- ASSERT_EQ("PointSet0-0-0-0", test_name);
- merged_point_vec->getNameOfElementByID(511, test_name);
- ASSERT_EQ("PointSet0-7-7-7", test_name);
-
- // *** insert "shifted" set of points
- shift[0] += 1e-4;
- names.push_back("ShiftedPointSet");
- createSetOfTestPointsAndAssociatedNames(geo_objs, names[2], shift);
-
- // *** merge PointSet0, PointSet1 and ShiftedPointSet
- merged_geometries_name = "MergedShiftedPointSet";
- geo_objs.mergeGeometries(names, merged_geometries_name);
- merged_point_vec = geo_objs.getPointVecObj(merged_geometries_name);
-
- ASSERT_TRUE(merged_point_vec != nullptr);
- ASSERT_EQ(1024u, merged_point_vec->size());
- merged_point_vec->getNameOfElementByID(0, test_name);
- ASSERT_EQ("PointSet0-0-0-0", test_name);
- merged_point_vec->getNameOfElementByID(511, test_name);
- ASSERT_EQ("PointSet0-7-7-7", test_name);
- merged_point_vec->getNameOfElementByID(512, test_name);
- ASSERT_EQ("ShiftedPointSet-0-0-0", test_name);
- merged_point_vec->getNameOfElementByID(1023, test_name);
- ASSERT_EQ("ShiftedPointSet-7-7-7", test_name);
-
- std::size_t id;
- ASSERT_TRUE(merged_point_vec->getElementIDByName (test_name, id));
- ASSERT_EQ(1023u, id);
-
- test_name = "PointSet1-0-0-0";
- ASSERT_FALSE(merged_point_vec->getElementIDByName (test_name, id));
+ GeoLib::GEOObjects geo_objs;
+ std::vector<std::string> names;
+
+ // *** insert set of points number 0
+ GeoLib::Point shift (0.0,0.0,0.0);
+ names.push_back("PointSet0");
+ createSetOfTestPointsAndAssociatedNames(geo_objs, names[0], shift);
+
+ // *** insert set of points number 1
+ names.push_back("PointSet1");
+ createSetOfTestPointsAndAssociatedNames(geo_objs, names[1], shift);
+
+ // *** merge geometries
+ std::string merged_geometries_name("MergedEqualPointSet");
+ geo_objs.mergeGeometries(names, merged_geometries_name);
+
+ GeoLib::PointVec const* merged_point_vec (geo_objs.getPointVecObj(merged_geometries_name));
+
+ ASSERT_TRUE(merged_point_vec != nullptr);
+ ASSERT_EQ(512u, merged_point_vec->size());
+ std::string test_name;
+ merged_point_vec->getNameOfElementByID(0, test_name);
+ ASSERT_EQ("PointSet0-0-0-0", test_name);
+ merged_point_vec->getNameOfElementByID(511, test_name);
+ ASSERT_EQ("PointSet0-7-7-7", test_name);
+
+ // *** insert "shifted" set of points
+ shift[0] += 1e-4;
+ names.push_back("ShiftedPointSet");
+ createSetOfTestPointsAndAssociatedNames(geo_objs, names[2], shift);
+
+ // *** merge PointSet0, PointSet1 and ShiftedPointSet
+ merged_geometries_name = "MergedShiftedPointSet";
+ geo_objs.mergeGeometries(names, merged_geometries_name);
+ merged_point_vec = geo_objs.getPointVecObj(merged_geometries_name);
+
+ ASSERT_TRUE(merged_point_vec != nullptr);
+ ASSERT_EQ(1024u, merged_point_vec->size());
+ merged_point_vec->getNameOfElementByID(0, test_name);
+ ASSERT_EQ("PointSet0-0-0-0", test_name);
+ merged_point_vec->getNameOfElementByID(511, test_name);
+ ASSERT_EQ("PointSet0-7-7-7", test_name);
+ merged_point_vec->getNameOfElementByID(512, test_name);
+ ASSERT_EQ("ShiftedPointSet-0-0-0", test_name);
+ merged_point_vec->getNameOfElementByID(1023, test_name);
+ ASSERT_EQ("ShiftedPointSet-7-7-7", test_name);
+
+ std::size_t id;
+ ASSERT_TRUE(merged_point_vec->getElementIDByName (test_name, id));
+ ASSERT_EQ(1023u, id);
+
+ test_name = "PointSet1-0-0-0";
+ ASSERT_FALSE(merged_point_vec->getElementIDByName (test_name, id));
}
TEST(GeoLib, GEOObjectsMergePointsAndPolylines)
{
- GeoLib::GEOObjects geo_objs;
- std::vector<std::string> names;
-
- // *** insert points to vector
- auto pnts = std::unique_ptr<std::vector<GeoLib::Point*>>(
- new std::vector<GeoLib::Point*>);
- pnts->reserve(4);
- pnts->push_back(new GeoLib::Point(0.0,0.0,0.0));
- pnts->push_back(new GeoLib::Point(1.0,0.0,0.0));
- pnts->push_back(new GeoLib::Point(1.0,1.0,0.0));
- pnts->push_back(new GeoLib::Point(0.0,1.0,0.0));
-
- std::string geometry_0("GeometryWithPntsAndPolyline");
- geo_objs.addPointVec(std::move(pnts), geometry_0, nullptr, std::numeric_limits<double>::epsilon());
-
- // *** insert polyline
- GeoLib::Polyline* ply(new GeoLib::Polyline(*geo_objs.getPointVec(geometry_0)));
- ply->addPoint(0);
- ply->addPoint(1);
- ply->addPoint(2);
- ply->addPoint(3);
- ply->addPoint(0);
- auto plys = std::unique_ptr<std::vector<GeoLib::Polyline*>>(
- new std::vector<GeoLib::Polyline*>);
- plys->push_back(ply);
- geo_objs.addPolylineVec(std::move(plys), geometry_0, nullptr);
- names.push_back(geometry_0);
-
- // *** insert set of points number
- GeoLib::Point shift (0.0,0.0,0.0);
- names.push_back("PointSet0");
- createSetOfTestPointsAndAssociatedNames(geo_objs, names[1], shift);
-
- // *** merge geometries
- std::string merged_geometries_name("MergedQuadGeoAndPointSet");
- geo_objs.mergeGeometries(names, merged_geometries_name);
-
- std::vector<GeoLib::Polyline*> const* const polylines =
- geo_objs.getPolylineVec(merged_geometries_name);
-
- ASSERT_TRUE(polylines != nullptr);
- ASSERT_EQ(1u, polylines->size());
+ GeoLib::GEOObjects geo_objs;
+ std::vector<std::string> names;
+
+ // *** insert points to vector
+ auto pnts = std::unique_ptr<std::vector<GeoLib::Point*>>(
+ new std::vector<GeoLib::Point*>);
+ pnts->reserve(4);
+ pnts->push_back(new GeoLib::Point(0.0,0.0,0.0));
+ pnts->push_back(new GeoLib::Point(1.0,0.0,0.0));
+ pnts->push_back(new GeoLib::Point(1.0,1.0,0.0));
+ pnts->push_back(new GeoLib::Point(0.0,1.0,0.0));
+
+ std::string geometry_0("GeometryWithPntsAndPolyline");
+ geo_objs.addPointVec(std::move(pnts), geometry_0, nullptr, std::numeric_limits<double>::epsilon());
+
+ // *** insert polyline
+ GeoLib::Polyline* ply(new GeoLib::Polyline(*geo_objs.getPointVec(geometry_0)));
+ ply->addPoint(0);
+ ply->addPoint(1);
+ ply->addPoint(2);
+ ply->addPoint(3);
+ ply->addPoint(0);
+ auto plys = std::unique_ptr<std::vector<GeoLib::Polyline*>>(
+ new std::vector<GeoLib::Polyline*>);
+ plys->push_back(ply);
+ geo_objs.addPolylineVec(std::move(plys), geometry_0, nullptr);
+ names.push_back(geometry_0);
+
+ // *** insert set of points number
+ GeoLib::Point shift (0.0,0.0,0.0);
+ names.push_back("PointSet0");
+ createSetOfTestPointsAndAssociatedNames(geo_objs, names[1], shift);
+
+ // *** merge geometries
+ std::string merged_geometries_name("MergedQuadGeoAndPointSet");
+ geo_objs.mergeGeometries(names, merged_geometries_name);
+
+ std::vector<GeoLib::Polyline*> const* const polylines =
+ geo_objs.getPolylineVec(merged_geometries_name);
+
+ ASSERT_TRUE(polylines != nullptr);
+ ASSERT_EQ(1u, polylines->size());
}
TEST(GeoLib, GEOObjectsMergePolylinesWithNames)
{
- GeoLib::GEOObjects geo_objs;
- std::vector<std::string> names;
-
- // *** insert first set of points to vector (for first polyline)
- auto pnts_0 = std::unique_ptr<std::vector<GeoLib::Point*>>(
- new std::vector<GeoLib::Point*>);
- pnts_0->reserve(4);
- pnts_0->push_back(new GeoLib::Point(0.0,0.0,0.0));
- pnts_0->push_back(new GeoLib::Point(1.0,0.0,0.0));
- pnts_0->push_back(new GeoLib::Point(1.0,1.0,0.0));
- pnts_0->push_back(new GeoLib::Point(0.0,1.0,0.0));
-
- std::string geometry_0("Geometry0");
- geo_objs.addPointVec(std::move(pnts_0),
- geometry_0,
- nullptr,
- std::numeric_limits<double>::epsilon());
-
- // *** insert a named polyline into geometry
- GeoLib::Polyline* ply_00(new GeoLib::Polyline(*geo_objs.getPointVec(geometry_0)));
- ply_00->addPoint(0);
- ply_00->addPoint(1);
- ply_00->addPoint(2);
- ply_00->addPoint(3);
- ply_00->addPoint(0);
- auto plys_0 = std::unique_ptr<std::vector<GeoLib::Polyline*>>(
- new std::vector<GeoLib::Polyline*>);
- plys_0->push_back(ply_00);
- std::map<std::string, std::size_t> *names_map_0(new std::map<std::string, std::size_t>);
- names_map_0->insert(std::pair<std::string, std::size_t>("Polyline0FromGeometry0", 0));
- geo_objs.addPolylineVec(std::move(plys_0), geometry_0, names_map_0);
- names.push_back(geometry_0);
-
- auto pnts_1 = std::unique_ptr<std::vector<GeoLib::Point*>>(
- new std::vector<GeoLib::Point*>);
- pnts_1->reserve(4);
- pnts_1->push_back(new GeoLib::Point(0.0,0.0,0.0));
- pnts_1->push_back(new GeoLib::Point(1.0,0.0,0.0));
- pnts_1->push_back(new GeoLib::Point(1.0,1.0,0.0));
- pnts_1->push_back(new GeoLib::Point(0.0,1.0,0.0));
-
- std::string geometry_1("Geometry1");
- geo_objs.addPointVec(std::move(pnts_1),
- geometry_1,
- nullptr,
- std::numeric_limits<double>::epsilon());
-
- // *** insert a named polyline into geometry
- GeoLib::Polyline* ply_10(new GeoLib::Polyline(*geo_objs.getPointVec(geometry_1)));
- ply_10->addPoint(0);
- ply_10->addPoint(1);
- GeoLib::Polyline* ply_11(new GeoLib::Polyline(*geo_objs.getPointVec(geometry_1)));
- ply_11->addPoint(2);
- ply_11->addPoint(3);
- auto plys_1 = std::unique_ptr<std::vector<GeoLib::Polyline*>>(
- new std::vector<GeoLib::Polyline*>);
- plys_1->push_back(ply_10);
- plys_1->push_back(ply_11);
- std::map<std::string, std::size_t> *names_map_1(new std::map<std::string, std::size_t>);
- names_map_1->insert(std::pair<std::string, std::size_t>("Polyline0FromGeometry1", 0));
- names_map_1->insert(std::pair<std::string, std::size_t>("Polyline1FromGeometry1", 1));
- geo_objs.addPolylineVec(std::move(plys_1), geometry_1, names_map_1);
- names.push_back(geometry_1);
-
- // *** merge geometries
- std::string merged_geometries_name("MergedPolylinesWithNames");
- geo_objs.mergeGeometries(names, merged_geometries_name);
-
- // *** tests
- // check number of points
- ASSERT_EQ(4u, geo_objs.getPointVec(merged_geometries_name)->size());
-
- GeoLib::PolylineVec const*const ply_vec_objs =
- geo_objs.getPolylineVecObj(merged_geometries_name);
- std::vector<GeoLib::Polyline*> const* const polylines =
- ply_vec_objs->getVector();
-
- // check number of polylines
- ASSERT_TRUE(polylines != nullptr);
- ASSERT_EQ(3u, polylines->size());
-
- // check names of polylines
- ASSERT_TRUE(ply_vec_objs->getElementByName("Polyline0FromGeometry0") != nullptr);
- ASSERT_TRUE(ply_vec_objs->getElementByName("Polyline0FromGeometry1") != nullptr);
- ASSERT_TRUE(ply_vec_objs->getElementByName("Polyline1FromGeometry1") != nullptr);
+ GeoLib::GEOObjects geo_objs;
+ std::vector<std::string> names;
+
+ // *** insert first set of points to vector (for first polyline)
+ auto pnts_0 = std::unique_ptr<std::vector<GeoLib::Point*>>(
+ new std::vector<GeoLib::Point*>);
+ pnts_0->reserve(4);
+ pnts_0->push_back(new GeoLib::Point(0.0,0.0,0.0));
+ pnts_0->push_back(new GeoLib::Point(1.0,0.0,0.0));
+ pnts_0->push_back(new GeoLib::Point(1.0,1.0,0.0));
+ pnts_0->push_back(new GeoLib::Point(0.0,1.0,0.0));
+
+ std::string geometry_0("Geometry0");
+ geo_objs.addPointVec(std::move(pnts_0),
+ geometry_0,
+ nullptr,
+ std::numeric_limits<double>::epsilon());
+
+ // *** insert a named polyline into geometry
+ GeoLib::Polyline* ply_00(new GeoLib::Polyline(*geo_objs.getPointVec(geometry_0)));
+ ply_00->addPoint(0);
+ ply_00->addPoint(1);
+ ply_00->addPoint(2);
+ ply_00->addPoint(3);
+ ply_00->addPoint(0);
+ auto plys_0 = std::unique_ptr<std::vector<GeoLib::Polyline*>>(
+ new std::vector<GeoLib::Polyline*>);
+ plys_0->push_back(ply_00);
+ std::map<std::string, std::size_t> *names_map_0(new std::map<std::string, std::size_t>);
+ names_map_0->insert(std::pair<std::string, std::size_t>("Polyline0FromGeometry0", 0));
+ geo_objs.addPolylineVec(std::move(plys_0), geometry_0, names_map_0);
+ names.push_back(geometry_0);
+
+ auto pnts_1 = std::unique_ptr<std::vector<GeoLib::Point*>>(
+ new std::vector<GeoLib::Point*>);
+ pnts_1->reserve(4);
+ pnts_1->push_back(new GeoLib::Point(0.0,0.0,0.0));
+ pnts_1->push_back(new GeoLib::Point(1.0,0.0,0.0));
+ pnts_1->push_back(new GeoLib::Point(1.0,1.0,0.0));
+ pnts_1->push_back(new GeoLib::Point(0.0,1.0,0.0));
+
+ std::string geometry_1("Geometry1");
+ geo_objs.addPointVec(std::move(pnts_1),
+ geometry_1,
+ nullptr,
+ std::numeric_limits<double>::epsilon());
+
+ // *** insert a named polyline into geometry
+ GeoLib::Polyline* ply_10(new GeoLib::Polyline(*geo_objs.getPointVec(geometry_1)));
+ ply_10->addPoint(0);
+ ply_10->addPoint(1);
+ GeoLib::Polyline* ply_11(new GeoLib::Polyline(*geo_objs.getPointVec(geometry_1)));
+ ply_11->addPoint(2);
+ ply_11->addPoint(3);
+ auto plys_1 = std::unique_ptr<std::vector<GeoLib::Polyline*>>(
+ new std::vector<GeoLib::Polyline*>);
+ plys_1->push_back(ply_10);
+ plys_1->push_back(ply_11);
+ std::map<std::string, std::size_t> *names_map_1(new std::map<std::string, std::size_t>);
+ names_map_1->insert(std::pair<std::string, std::size_t>("Polyline0FromGeometry1", 0));
+ names_map_1->insert(std::pair<std::string, std::size_t>("Polyline1FromGeometry1", 1));
+ geo_objs.addPolylineVec(std::move(plys_1), geometry_1, names_map_1);
+ names.push_back(geometry_1);
+
+ // *** merge geometries
+ std::string merged_geometries_name("MergedPolylinesWithNames");
+ geo_objs.mergeGeometries(names, merged_geometries_name);
+
+ // *** tests
+ // check number of points
+ ASSERT_EQ(4u, geo_objs.getPointVec(merged_geometries_name)->size());
+
+ GeoLib::PolylineVec const*const ply_vec_objs =
+ geo_objs.getPolylineVecObj(merged_geometries_name);
+ std::vector<GeoLib::Polyline*> const* const polylines =
+ ply_vec_objs->getVector();
+
+ // check number of polylines
+ ASSERT_TRUE(polylines != nullptr);
+ ASSERT_EQ(3u, polylines->size());
+
+ // check names of polylines
+ ASSERT_TRUE(ply_vec_objs->getElementByName("Polyline0FromGeometry0") != nullptr);
+ ASSERT_TRUE(ply_vec_objs->getElementByName("Polyline0FromGeometry1") != nullptr);
+ ASSERT_TRUE(ply_vec_objs->getElementByName("Polyline1FromGeometry1") != nullptr);
}
diff --git a/Tests/GeoLib/TestGrid.cpp b/Tests/GeoLib/TestGrid.cpp
index 3683871487de237f8b6cf3e06262fe930548b9b2..ac1afece868fa20fc44d27dc1213994d87a9ff4f 100644
--- a/Tests/GeoLib/TestGrid.cpp
+++ b/Tests/GeoLib/TestGrid.cpp
@@ -22,131 +22,131 @@
TEST(GeoLib, InsertZeroPointsInGrid)
{
- std::vector<GeoLib::Point*> pnts;
- ASSERT_DEATH(GeoLib::Grid<GeoLib::Point> grid(pnts.begin(), pnts.end()), "");
+ std::vector<GeoLib::Point*> pnts;
+ ASSERT_DEATH(GeoLib::Grid<GeoLib::Point> grid(pnts.begin(), pnts.end()), "");
}
TEST(GeoLib, InsertOnePointInGrid)
{
- std::vector<GeoLib::Point*> pnts;
- pnts.push_back(new GeoLib::Point(0.0,0.0,0.0));
- ASSERT_NO_THROW(GeoLib::Grid<GeoLib::Point> grid(pnts.begin(), pnts.end()));
- std::for_each(pnts.begin(), pnts.end(), std::default_delete<GeoLib::Point>());
+ std::vector<GeoLib::Point*> pnts;
+ pnts.push_back(new GeoLib::Point(0.0,0.0,0.0));
+ ASSERT_NO_THROW(GeoLib::Grid<GeoLib::Point> grid(pnts.begin(), pnts.end()));
+ std::for_each(pnts.begin(), pnts.end(), std::default_delete<GeoLib::Point>());
}
TEST(GeoLib, InsertTwoPointsInGrid)
{
- std::vector<GeoLib::Point*> pnts;
- pnts.push_back(new GeoLib::Point(4.5, -400.0, 0.0));
- pnts.push_back(new GeoLib::Point(50, -300.0, 0.0));
- ASSERT_NO_THROW(GeoLib::Grid<GeoLib::Point> grid(pnts.begin(), pnts.end()));
- std::for_each(pnts.begin(), pnts.end(), std::default_delete<GeoLib::Point>());
+ std::vector<GeoLib::Point*> pnts;
+ pnts.push_back(new GeoLib::Point(4.5, -400.0, 0.0));
+ pnts.push_back(new GeoLib::Point(50, -300.0, 0.0));
+ ASSERT_NO_THROW(GeoLib::Grid<GeoLib::Point> grid(pnts.begin(), pnts.end()));
+ std::for_each(pnts.begin(), pnts.end(), std::default_delete<GeoLib::Point>());
}
TEST(GeoLib, InsertManyPointsInGrid)
{
- const std::size_t i_max(100), j_max(100), k_max(100);
- std::vector<GeoLib::Point*> pnts(i_max*j_max*k_max);
-
- // fill the vector with points
- for (std::size_t i(0); i < i_max; i++) {
- std::size_t offset0(i * j_max * k_max);
- for (std::size_t j(0); j < j_max; j++) {
- std::size_t offset1(j * k_max + offset0);
- for (std::size_t k(0); k < k_max; k++) {
- pnts[offset1 + k] = new GeoLib::Point(static_cast<double>(i) / i_max,
- static_cast<double>(j) / j_max, static_cast<double>(k) / k_max);
- }
- }
- }
-
- ASSERT_NO_THROW(GeoLib::Grid<GeoLib::Point> grid(pnts.begin(), pnts.end()));
- std::for_each(pnts.begin(), pnts.end(), std::default_delete<GeoLib::Point>());
+ const std::size_t i_max(100), j_max(100), k_max(100);
+ std::vector<GeoLib::Point*> pnts(i_max*j_max*k_max);
+
+ // fill the vector with points
+ for (std::size_t i(0); i < i_max; i++) {
+ std::size_t offset0(i * j_max * k_max);
+ for (std::size_t j(0); j < j_max; j++) {
+ std::size_t offset1(j * k_max + offset0);
+ for (std::size_t k(0); k < k_max; k++) {
+ pnts[offset1 + k] = new GeoLib::Point(static_cast<double>(i) / i_max,
+ static_cast<double>(j) / j_max, static_cast<double>(k) / k_max);
+ }
+ }
+ }
+
+ ASSERT_NO_THROW(GeoLib::Grid<GeoLib::Point> grid(pnts.begin(), pnts.end()));
+ std::for_each(pnts.begin(), pnts.end(), std::default_delete<GeoLib::Point>());
}
TEST(GeoLib, InsertPointsWithSameXCoordinateInGrid)
{
- std::vector<GeoLib::Point*> pnts;
- pnts.push_back(new GeoLib::Point(0,0,0));
- pnts.push_back(new GeoLib::Point(0,1,0));
- pnts.push_back(new GeoLib::Point(0,1,0.1));
+ std::vector<GeoLib::Point*> pnts;
+ pnts.push_back(new GeoLib::Point(0,0,0));
+ pnts.push_back(new GeoLib::Point(0,1,0));
+ pnts.push_back(new GeoLib::Point(0,1,0.1));
- GeoLib::Grid<GeoLib::Point> grid(pnts.begin(), pnts.end());
- std::for_each(pnts.begin(), pnts.end(), std::default_delete<GeoLib::Point>());
+ GeoLib::Grid<GeoLib::Point> grid(pnts.begin(), pnts.end());
+ std::for_each(pnts.begin(), pnts.end(), std::default_delete<GeoLib::Point>());
}
TEST(GeoLib, SearchNearestPointInGrid)
{
- std::vector<GeoLib::Point*> pnts;
- pnts.push_back(new GeoLib::Point(0.0,0.0,0.0));
- GeoLib::Grid<GeoLib::Point> *grid(nullptr);
- ASSERT_NO_THROW(grid = new GeoLib::Grid<GeoLib::Point>(pnts.begin(), pnts.end()));
+ std::vector<GeoLib::Point*> pnts;
+ pnts.push_back(new GeoLib::Point(0.0,0.0,0.0));
+ GeoLib::Grid<GeoLib::Point> *grid(nullptr);
+ ASSERT_NO_THROW(grid = new GeoLib::Grid<GeoLib::Point>(pnts.begin(), pnts.end()));
- GeoLib::Point p0(0,10,10);
- GeoLib::Point* res(grid->getNearestPoint(p0));
- ASSERT_EQ(0.0, sqrt(MathLib::sqrDist(*res, *pnts[0])));
+ GeoLib::Point p0(0,10,10);
+ GeoLib::Point* res(grid->getNearestPoint(p0));
+ ASSERT_EQ(0.0, sqrt(MathLib::sqrDist(*res, *pnts[0])));
- delete grid;
- std::for_each(pnts.begin(), pnts.end(), std::default_delete<GeoLib::Point>());
+ delete grid;
+ std::for_each(pnts.begin(), pnts.end(), std::default_delete<GeoLib::Point>());
}
TEST(GeoLib, SearchNearestPointsInDenseGrid)
{
- const std::size_t i_max(50), j_max(50), k_max(50);
- std::vector<GeoLib::Point*> pnts(i_max*j_max*k_max);
-
- // fill the vector with equi-distant points in the
- // cube [0,(i_max-1)/i_max] x [0,(j_max-1)/j_max] x [0,(k_max-1)/k_max]
- for (std::size_t i(0); i < i_max; i++) {
- std::size_t offset0(i * j_max * k_max);
- for (std::size_t j(0); j < j_max; j++) {
- std::size_t offset1(j * k_max + offset0);
- for (std::size_t k(0); k < k_max; k++) {
- pnts[offset1 + k] = new GeoLib::Point(
- std::array<double,3>({{static_cast<double>(i) / i_max,
- static_cast<double>(j) / j_max,
- static_cast<double>(k) / k_max}}), offset1+k);
- }
- }
- }
-
- // create the grid
- GeoLib::Grid<GeoLib::Point>* grid(nullptr);
- ASSERT_NO_THROW(grid = new GeoLib::Grid<GeoLib::Point> (pnts.begin(), pnts.end()));
-
- // search point (1,1,1) is outside of the point set
- GeoLib::Point search_pnt(std::array<double,3>({{1,1,1}}), 0);
- GeoLib::Point* res(grid->getNearestPoint(search_pnt));
- ASSERT_EQ(i_max*j_max*k_max-1, res->getID());
- ASSERT_NEAR(sqrt(3.0)/50.0, sqrt(MathLib::sqrDist(*res, search_pnt)), std::numeric_limits<double>::epsilon());
-
- // search point (0,1,1) is outside of the point set
- search_pnt[0] = 0;
- res = grid->getNearestPoint(search_pnt);
- ASSERT_EQ(j_max*k_max - 1, res->getID());
- ASSERT_NEAR(sqrt(2.0)/50.0, sqrt(MathLib::sqrDist(*res, search_pnt)), std::numeric_limits<double>::epsilon());
-
- // search point (0.5,1,1) is outside of the point set
- search_pnt[0] = 0.5;
- res = grid->getNearestPoint(search_pnt);
- ASSERT_EQ(j_max*k_max*(i_max/2 + 1) - 1, res->getID());
- ASSERT_NEAR(sqrt(2.0)/50.0, sqrt(MathLib::sqrDist(*res, search_pnt)), std::numeric_limits<double>::epsilon());
-
- // checking only every fourth point per direction to reduce the run time of
- // the test
- for (std::size_t i(0); i < i_max; i=i+4) {
- std::size_t offset0(i * j_max * k_max);
- for (std::size_t j(0); j < j_max; j=j+4) {
- std::size_t offset1(j * k_max + offset0);
- for (std::size_t k(0); k < k_max; k=k+4) {
- res = grid->getNearestPoint(*pnts[offset1+k]);
- ASSERT_EQ(offset1+k, res->getID());
- ASSERT_NEAR(sqrt(MathLib::sqrDist(*res, *pnts[offset1+k])), 0.0, std::numeric_limits<double>::epsilon());
- }
- }
- }
-
- delete grid;
- std::for_each(pnts.begin(), pnts.end(), std::default_delete<GeoLib::Point>());
+ const std::size_t i_max(50), j_max(50), k_max(50);
+ std::vector<GeoLib::Point*> pnts(i_max*j_max*k_max);
+
+ // fill the vector with equi-distant points in the
+ // cube [0,(i_max-1)/i_max] x [0,(j_max-1)/j_max] x [0,(k_max-1)/k_max]
+ for (std::size_t i(0); i < i_max; i++) {
+ std::size_t offset0(i * j_max * k_max);
+ for (std::size_t j(0); j < j_max; j++) {
+ std::size_t offset1(j * k_max + offset0);
+ for (std::size_t k(0); k < k_max; k++) {
+ pnts[offset1 + k] = new GeoLib::Point(
+ std::array<double,3>({{static_cast<double>(i) / i_max,
+ static_cast<double>(j) / j_max,
+ static_cast<double>(k) / k_max}}), offset1+k);
+ }
+ }
+ }
+
+ // create the grid
+ GeoLib::Grid<GeoLib::Point>* grid(nullptr);
+ ASSERT_NO_THROW(grid = new GeoLib::Grid<GeoLib::Point> (pnts.begin(), pnts.end()));
+
+ // search point (1,1,1) is outside of the point set
+ GeoLib::Point search_pnt(std::array<double,3>({{1,1,1}}), 0);
+ GeoLib::Point* res(grid->getNearestPoint(search_pnt));
+ ASSERT_EQ(i_max*j_max*k_max-1, res->getID());
+ ASSERT_NEAR(sqrt(3.0)/50.0, sqrt(MathLib::sqrDist(*res, search_pnt)), std::numeric_limits<double>::epsilon());
+
+ // search point (0,1,1) is outside of the point set
+ search_pnt[0] = 0;
+ res = grid->getNearestPoint(search_pnt);
+ ASSERT_EQ(j_max*k_max - 1, res->getID());
+ ASSERT_NEAR(sqrt(2.0)/50.0, sqrt(MathLib::sqrDist(*res, search_pnt)), std::numeric_limits<double>::epsilon());
+
+ // search point (0.5,1,1) is outside of the point set
+ search_pnt[0] = 0.5;
+ res = grid->getNearestPoint(search_pnt);
+ ASSERT_EQ(j_max*k_max*(i_max/2 + 1) - 1, res->getID());
+ ASSERT_NEAR(sqrt(2.0)/50.0, sqrt(MathLib::sqrDist(*res, search_pnt)), std::numeric_limits<double>::epsilon());
+
+ // checking only every fourth point per direction to reduce the run time of
+ // the test
+ for (std::size_t i(0); i < i_max; i=i+4) {
+ std::size_t offset0(i * j_max * k_max);
+ for (std::size_t j(0); j < j_max; j=j+4) {
+ std::size_t offset1(j * k_max + offset0);
+ for (std::size_t k(0); k < k_max; k=k+4) {
+ res = grid->getNearestPoint(*pnts[offset1+k]);
+ ASSERT_EQ(offset1+k, res->getID());
+ ASSERT_NEAR(sqrt(MathLib::sqrDist(*res, *pnts[offset1+k])), 0.0, std::numeric_limits<double>::epsilon());
+ }
+ }
+ }
+
+ delete grid;
+ std::for_each(pnts.begin(), pnts.end(), std::default_delete<GeoLib::Point>());
}
diff --git a/Tests/GeoLib/TestIsPointInTriangle.cpp b/Tests/GeoLib/TestIsPointInTriangle.cpp
index 7af161876bc32b81c8e730b310aecf21f3a050e2..23686418d77f39bc4a8cd6821440d78ad0593797 100644
--- a/Tests/GeoLib/TestIsPointInTriangle.cpp
+++ b/Tests/GeoLib/TestIsPointInTriangle.cpp
@@ -15,62 +15,62 @@
TEST(GeoLib, IsPointInTriangle)
{
- GeoLib::Point const a(0.0, 0.0, 0.0);
- GeoLib::Point const b(100.0, 0.0, 0.0);
- GeoLib::Point const c(0.0, 100.0, 0.0);
+ GeoLib::Point const a(0.0, 0.0, 0.0);
+ GeoLib::Point const b(100.0, 0.0, 0.0);
+ GeoLib::Point const c(0.0, 100.0, 0.0);
- // check point on corner points of triangle
- GeoLib::Point q(a);
- EXPECT_TRUE(GeoLib::gaussPointInTriangle(q, a, b, c));
- EXPECT_TRUE(GeoLib::barycentricPointInTriangle(q, a, b, c));
- q = b;
- EXPECT_TRUE(GeoLib::gaussPointInTriangle(q, a, b, c));
- EXPECT_TRUE(GeoLib::barycentricPointInTriangle(q, a, b, c));
- q = c;
- EXPECT_TRUE(GeoLib::gaussPointInTriangle(q, a, b, c));
- EXPECT_TRUE(GeoLib::barycentricPointInTriangle(q, a, b, c));
+ // check point on corner points of triangle
+ GeoLib::Point q(a);
+ EXPECT_TRUE(GeoLib::gaussPointInTriangle(q, a, b, c));
+ EXPECT_TRUE(GeoLib::barycentricPointInTriangle(q, a, b, c));
+ q = b;
+ EXPECT_TRUE(GeoLib::gaussPointInTriangle(q, a, b, c));
+ EXPECT_TRUE(GeoLib::barycentricPointInTriangle(q, a, b, c));
+ q = c;
+ EXPECT_TRUE(GeoLib::gaussPointInTriangle(q, a, b, c));
+ EXPECT_TRUE(GeoLib::barycentricPointInTriangle(q, a, b, c));
- // check points on edges of triangle
- q = GeoLib::Point(0.5*(b[0]+a[0]), 0.5*(b[1]+a[1]), 0.5*(b[2]+a[2]));
- EXPECT_TRUE(GeoLib::gaussPointInTriangle(q, a, b, c));
- EXPECT_TRUE(GeoLib::barycentricPointInTriangle(q, a, b, c));
- q = GeoLib::Point(0.5*(c[0]+a[0]), 0.5*(c[1]+a[1]), 0.5*(c[2]+a[2]));
- EXPECT_TRUE(GeoLib::gaussPointInTriangle(q, a, b, c));
- EXPECT_TRUE(GeoLib::barycentricPointInTriangle(q, a, b, c));
- q = GeoLib::Point(0.5*(c[0]+b[0]), 0.5*(c[1]+b[1]), 0.5*(c[2]+b[2]));
- EXPECT_TRUE(GeoLib::gaussPointInTriangle(q, a, b, c));
- EXPECT_TRUE(GeoLib::barycentricPointInTriangle(q, a, b, c));
+ // check points on edges of triangle
+ q = GeoLib::Point(0.5*(b[0]+a[0]), 0.5*(b[1]+a[1]), 0.5*(b[2]+a[2]));
+ EXPECT_TRUE(GeoLib::gaussPointInTriangle(q, a, b, c));
+ EXPECT_TRUE(GeoLib::barycentricPointInTriangle(q, a, b, c));
+ q = GeoLib::Point(0.5*(c[0]+a[0]), 0.5*(c[1]+a[1]), 0.5*(c[2]+a[2]));
+ EXPECT_TRUE(GeoLib::gaussPointInTriangle(q, a, b, c));
+ EXPECT_TRUE(GeoLib::barycentricPointInTriangle(q, a, b, c));
+ q = GeoLib::Point(0.5*(c[0]+b[0]), 0.5*(c[1]+b[1]), 0.5*(c[2]+b[2]));
+ EXPECT_TRUE(GeoLib::gaussPointInTriangle(q, a, b, c));
+ EXPECT_TRUE(GeoLib::barycentricPointInTriangle(q, a, b, c));
- // check points inside
- q = GeoLib::Point (0.1, 0.1, 0.0);
- EXPECT_TRUE(GeoLib::gaussPointInTriangle(q, a, b, c));
- EXPECT_TRUE(GeoLib::barycentricPointInTriangle(q, a, b, c));
- q = GeoLib::Point (0.1, 0.1, 1e-10);
- EXPECT_TRUE(GeoLib::gaussPointInTriangle(q, a, b, c));
- // here is a higher eps value needed for the second algorithm
- EXPECT_TRUE(GeoLib::barycentricPointInTriangle(q, a, b, c, 1e-5));
+ // check points inside
+ q = GeoLib::Point (0.1, 0.1, 0.0);
+ EXPECT_TRUE(GeoLib::gaussPointInTriangle(q, a, b, c));
+ EXPECT_TRUE(GeoLib::barycentricPointInTriangle(q, a, b, c));
+ q = GeoLib::Point (0.1, 0.1, 1e-10);
+ EXPECT_TRUE(GeoLib::gaussPointInTriangle(q, a, b, c));
+ // here is a higher eps value needed for the second algorithm
+ EXPECT_TRUE(GeoLib::barycentricPointInTriangle(q, a, b, c, 1e-5));
- // check points outside
- q = GeoLib::Point (-0.1, 0.1, 0.0);
- EXPECT_FALSE(GeoLib::gaussPointInTriangle(q, a, b, c));
- EXPECT_FALSE(GeoLib::barycentricPointInTriangle(q, a, b, c));
- q = GeoLib::Point (0.1, 0.1, 0.0005);
- EXPECT_FALSE(GeoLib::gaussPointInTriangle(q, a, b, c));
- EXPECT_FALSE(GeoLib::barycentricPointInTriangle(q, a, b, c));
- q = GeoLib::Point (0.1, 0.1, 0.0001);
- EXPECT_FALSE(GeoLib::gaussPointInTriangle(q, a, b, c, std::numeric_limits<double>::epsilon()));
- EXPECT_FALSE(GeoLib::barycentricPointInTriangle(q, a, b, c, std::numeric_limits<double>::epsilon()));
- q = GeoLib::Point (0.1, 0.1, 0.000001);
- EXPECT_FALSE(GeoLib::gaussPointInTriangle(q, a, b, c, std::numeric_limits<double>::epsilon()));
- EXPECT_FALSE(GeoLib::barycentricPointInTriangle(q, a, b, c, std::numeric_limits<double>::epsilon()));
- q = GeoLib::Point (0.1, 0.1, 1e-7);
- EXPECT_FALSE(GeoLib::gaussPointInTriangle(q, a, b, c, std::numeric_limits<double>::epsilon()));
- EXPECT_FALSE(GeoLib::barycentricPointInTriangle(q, a, b, c, std::numeric_limits<double>::epsilon()));
- q = GeoLib::Point (0.1, 0.1, 0.001);
- EXPECT_FALSE(GeoLib::gaussPointInTriangle(q, a, b, c));
- EXPECT_FALSE(GeoLib::barycentricPointInTriangle(q, a, b, c));
- q = GeoLib::Point (0.1, 0.1, 0.1);
- EXPECT_FALSE(GeoLib::gaussPointInTriangle(q, a, b, c));
- EXPECT_FALSE(GeoLib::barycentricPointInTriangle(q, a, b, c));
+ // check points outside
+ q = GeoLib::Point (-0.1, 0.1, 0.0);
+ EXPECT_FALSE(GeoLib::gaussPointInTriangle(q, a, b, c));
+ EXPECT_FALSE(GeoLib::barycentricPointInTriangle(q, a, b, c));
+ q = GeoLib::Point (0.1, 0.1, 0.0005);
+ EXPECT_FALSE(GeoLib::gaussPointInTriangle(q, a, b, c));
+ EXPECT_FALSE(GeoLib::barycentricPointInTriangle(q, a, b, c));
+ q = GeoLib::Point (0.1, 0.1, 0.0001);
+ EXPECT_FALSE(GeoLib::gaussPointInTriangle(q, a, b, c, std::numeric_limits<double>::epsilon()));
+ EXPECT_FALSE(GeoLib::barycentricPointInTriangle(q, a, b, c, std::numeric_limits<double>::epsilon()));
+ q = GeoLib::Point (0.1, 0.1, 0.000001);
+ EXPECT_FALSE(GeoLib::gaussPointInTriangle(q, a, b, c, std::numeric_limits<double>::epsilon()));
+ EXPECT_FALSE(GeoLib::barycentricPointInTriangle(q, a, b, c, std::numeric_limits<double>::epsilon()));
+ q = GeoLib::Point (0.1, 0.1, 1e-7);
+ EXPECT_FALSE(GeoLib::gaussPointInTriangle(q, a, b, c, std::numeric_limits<double>::epsilon()));
+ EXPECT_FALSE(GeoLib::barycentricPointInTriangle(q, a, b, c, std::numeric_limits<double>::epsilon()));
+ q = GeoLib::Point (0.1, 0.1, 0.001);
+ EXPECT_FALSE(GeoLib::gaussPointInTriangle(q, a, b, c));
+ EXPECT_FALSE(GeoLib::barycentricPointInTriangle(q, a, b, c));
+ q = GeoLib::Point (0.1, 0.1, 0.1);
+ EXPECT_FALSE(GeoLib::gaussPointInTriangle(q, a, b, c));
+ EXPECT_FALSE(GeoLib::barycentricPointInTriangle(q, a, b, c));
}
diff --git a/Tests/GeoLib/TestLineSegmentIntersect.cpp b/Tests/GeoLib/TestLineSegmentIntersect.cpp
index a288d22b67d94334f5685a91e19dd3878d3c33ff..86da280817437c626da7e311816587750b530756 100644
--- a/Tests/GeoLib/TestLineSegmentIntersect.cpp
+++ b/Tests/GeoLib/TestLineSegmentIntersect.cpp
@@ -19,191 +19,191 @@
TEST(GeoLib, TestXAxisParallelLineSegmentIntersection2d)
{
- // two intersecting parallel line segments
- GeoLib::Point a(0.0, 0.0, 0.0);
- GeoLib::Point b(1.0, 0.0, 0.0);
- GeoLib::Point c(0.5, 0.0, 0.0);
- GeoLib::Point d(1.5, 0.0, 0.0);
- GeoLib::Point s;
-
- EXPECT_TRUE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
+ // two intersecting parallel line segments
+ GeoLib::Point a(0.0, 0.0, 0.0);
+ GeoLib::Point b(1.0, 0.0, 0.0);
+ GeoLib::Point c(0.5, 0.0, 0.0);
+ GeoLib::Point d(1.5, 0.0, 0.0);
+ GeoLib::Point s;
+
+ EXPECT_TRUE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
}
TEST(GeoLib, TestParallelLineSegmentIntersection2d)
{
- // two intersecting parallel line segments
- GeoLib::Point a(0.0, 0.0, 0.0);
- GeoLib::Point b(1.0, 1.0, 0.0);
- GeoLib::Point c(0.5, 0.5, 0.0);
- GeoLib::Point d(1.5, 1.5, 0.0);
- GeoLib::Point s;
-
- EXPECT_TRUE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
+ // two intersecting parallel line segments
+ GeoLib::Point a(0.0, 0.0, 0.0);
+ GeoLib::Point b(1.0, 1.0, 0.0);
+ GeoLib::Point c(0.5, 0.5, 0.0);
+ GeoLib::Point d(1.5, 1.5, 0.0);
+ GeoLib::Point s;
+
+ EXPECT_TRUE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
}
TEST(GeoLib, TestNonIntersectingParallelLineSegments2dCaseI)
{
- // two non intersecting parallel line segments
- GeoLib::Point a(0.0, 0.0, 0.0);
- GeoLib::Point b(1.0, 1.0, 0.0);
- GeoLib::Point c(1.5, 1.5, 0.0);
- GeoLib::Point d(2.5, 2.5, 0.0);
- GeoLib::Point s;
-
- EXPECT_FALSE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
+ // two non intersecting parallel line segments
+ GeoLib::Point a(0.0, 0.0, 0.0);
+ GeoLib::Point b(1.0, 1.0, 0.0);
+ GeoLib::Point c(1.5, 1.5, 0.0);
+ GeoLib::Point d(2.5, 2.5, 0.0);
+ GeoLib::Point s;
+
+ EXPECT_FALSE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
}
TEST(GeoLib, TestNonIntersectingParallelLineSegments2dCaseII)
{
- // two non intersecting parallel line segments
- GeoLib::Point a(0.0, 1.0, 0.0);
- GeoLib::Point b(1.0, 0.0, 0.0);
- GeoLib::Point c(0.0, -1.0, 0.0);
- GeoLib::Point d(-1.0, 0.0, 0.0);
- GeoLib::Point s;
-
- EXPECT_FALSE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
+ // two non intersecting parallel line segments
+ GeoLib::Point a(0.0, 1.0, 0.0);
+ GeoLib::Point b(1.0, 0.0, 0.0);
+ GeoLib::Point c(0.0, -1.0, 0.0);
+ GeoLib::Point d(-1.0, 0.0, 0.0);
+ GeoLib::Point s;
+
+ EXPECT_FALSE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
}
TEST(GeoLib, TestIntersectingLineSegments2d)
{
- // two intersecting line segments
- GeoLib::Point a(0.0, 0.0, 0.0);
- GeoLib::Point b(1.0, 1.0, 0.0);
- GeoLib::Point c(0.0, 1.0, 0.0);
- GeoLib::Point d(1.0, 0.0, 0.0);
- GeoLib::Point s;
-
- EXPECT_TRUE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
+ // two intersecting line segments
+ GeoLib::Point a(0.0, 0.0, 0.0);
+ GeoLib::Point b(1.0, 1.0, 0.0);
+ GeoLib::Point c(0.0, 1.0, 0.0);
+ GeoLib::Point d(1.0, 0.0, 0.0);
+ GeoLib::Point s;
+
+ EXPECT_TRUE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
}
TEST(GeoLib, TestIntersectingLineSegments3d)
{
- // two intersecting line segments
- GeoLib::Point a(0.0, 0.0, 0.0);
- GeoLib::Point b(1.0, 1.0, 1.0);
- GeoLib::Point c(0.0, 1.0, 0.0);
- GeoLib::Point d(1.0, 0.0, 1.0);
- GeoLib::Point s;
-
- EXPECT_TRUE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
-
- // disturb one point a little bit
- double const eps(std::numeric_limits<float>::epsilon());
- d[2] += eps;
- EXPECT_TRUE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
- d[2] = 1.0+1e-9;
- EXPECT_TRUE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
- d[2] = 1.0+1e-8;
- EXPECT_TRUE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
- d[2] = 1.0 + 5e-6;
- EXPECT_FALSE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
+ // two intersecting line segments
+ GeoLib::Point a(0.0, 0.0, 0.0);
+ GeoLib::Point b(1.0, 1.0, 1.0);
+ GeoLib::Point c(0.0, 1.0, 0.0);
+ GeoLib::Point d(1.0, 0.0, 1.0);
+ GeoLib::Point s;
+
+ EXPECT_TRUE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
+
+ // disturb one point a little bit
+ double const eps(std::numeric_limits<float>::epsilon());
+ d[2] += eps;
+ EXPECT_TRUE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
+ d[2] = 1.0+1e-9;
+ EXPECT_TRUE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
+ d[2] = 1.0+1e-8;
+ EXPECT_TRUE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
+ d[2] = 1.0 + 5e-6;
+ EXPECT_FALSE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
}
TEST(GeoLib, TestParallelLineSegmentIntersection3d)
{
- // two parallel line segments
- GeoLib::Point a(0.0, 0.0, 0.0);
- GeoLib::Point b(1.0, 1.0, 1.0);
- GeoLib::Point c(0.5, 0.5, 0.5);
- GeoLib::Point d(1.5, 1.5, 1.5);
- GeoLib::Point s;
-
- EXPECT_TRUE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
+ // two parallel line segments
+ GeoLib::Point a(0.0, 0.0, 0.0);
+ GeoLib::Point b(1.0, 1.0, 1.0);
+ GeoLib::Point c(0.5, 0.5, 0.5);
+ GeoLib::Point d(1.5, 1.5, 1.5);
+ GeoLib::Point s;
+
+ EXPECT_TRUE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
}
TEST(GeoLib, TestNonIntersectingParallelLineSegments3d)
{
- // two non intersecting parallel line segments
- GeoLib::Point a(0.0, 0.0, 0.0);
- GeoLib::Point b(1.0, 1.0, 1.0);
- GeoLib::Point c(1.5, 1.5, 1.5);
- GeoLib::Point d(2.5, 2.5, 2.5);
- GeoLib::Point s;
- EXPECT_FALSE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
-
- // two axis parallel line segments that do not intersect
- b[0] = 3.0;
- b[1] = 0.0;
- b[2] = 0.0;
- c[0] = 4.0;
- c[1] = 0.0;
- c[2] = 0.0;
- d[0] = 10.0;
- d[1] = 0.0;
- d[2] = 0.0;
- EXPECT_FALSE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
-
- // two axis parallel line segments that do not intersect
- a[0] = 1000.0;
- a[1] = 0.0;
- a[2] = 100.0;
- b[0] = 400.0;
- b[1] = 0.0;
- b[2] = 100.0;
- c[0] = 300.0;
- c[1] = 0.0;
- c[2] = 100.0;
- d[0] = 0.0;
- d[1] = 0.0;
- d[2] = 100.0;
- EXPECT_FALSE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
+ // two non intersecting parallel line segments
+ GeoLib::Point a(0.0, 0.0, 0.0);
+ GeoLib::Point b(1.0, 1.0, 1.0);
+ GeoLib::Point c(1.5, 1.5, 1.5);
+ GeoLib::Point d(2.5, 2.5, 2.5);
+ GeoLib::Point s;
+ EXPECT_FALSE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
+
+ // two axis parallel line segments that do not intersect
+ b[0] = 3.0;
+ b[1] = 0.0;
+ b[2] = 0.0;
+ c[0] = 4.0;
+ c[1] = 0.0;
+ c[2] = 0.0;
+ d[0] = 10.0;
+ d[1] = 0.0;
+ d[2] = 0.0;
+ EXPECT_FALSE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
+
+ // two axis parallel line segments that do not intersect
+ a[0] = 1000.0;
+ a[1] = 0.0;
+ a[2] = 100.0;
+ b[0] = 400.0;
+ b[1] = 0.0;
+ b[2] = 100.0;
+ c[0] = 300.0;
+ c[1] = 0.0;
+ c[2] = 100.0;
+ d[0] = 0.0;
+ d[1] = 0.0;
+ d[2] = 100.0;
+ EXPECT_FALSE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
}
TEST(GeoLib, TestRandomLineSegments3d)
{
- std::uniform_real_distribution<double> distribution(-1e10, 1e10);
- std::default_random_engine re;
-
- // line segments intersect each other in the middle
- for (std::size_t k(0); k<1000; k++) {
- // two intersecting line segments (a,b) and (c,d)
- GeoLib::Point a(distribution(re), distribution(re), distribution(re));
- GeoLib::Point b(distribution(re), distribution(re), distribution(re));
- // direction of (c,d)
- GeoLib::Point w(distribution(re), distribution(re), distribution(re));
- // construct c and d such that (a,b) intersects with (c,d)
- GeoLib::Point c(0.5*(b[0]+a[0]) + w[0],
- 0.5*(b[1]+a[1]) + w[1],
- 0.5*(b[2]+a[2]) + w[2]);
- GeoLib::Point d(0.5*(b[0]+a[0]) - w[0],
- 0.5*(b[1]+a[1]) - w[1],
- 0.5*(b[2]+a[2]) - w[2]);
- GeoLib::Point s;
-
- EXPECT_TRUE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
- }
-
- // line segment (c,d) intersects (a,b) at end point a
- for (std::size_t k(0); k<1000; k++) {
- // two intersecting line segments (a,b) and (c,d)
- GeoLib::Point a(distribution(re), distribution(re), distribution(re));
- GeoLib::Point b(distribution(re), distribution(re), distribution(re));
- // direction of (c,d)
- GeoLib::Point w(distribution(re), distribution(re), distribution(re));
- // construct c and d such that (a,b) intersects with (c,d)
- GeoLib::Point c(a[0] + w[0], a[1] + w[1], a[2] + w[2]);
- GeoLib::Point d(a[0] - w[0], a[1] - w[1], a[2] - w[2]);
- GeoLib::Point s;
-
- EXPECT_TRUE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
- EXPECT_TRUE(GeoLib::lineSegmentIntersect({&c,&d}, {&a,&b}, s));
- }
-
- // line segment (c,d) intersects (a,b) at end point b
- for (std::size_t k(0); k<1000; k++) {
- // two intersecting line segments (a,b) and (c,d)
- GeoLib::Point a(distribution(re), distribution(re), distribution(re));
- GeoLib::Point b(distribution(re), distribution(re), distribution(re));
- // direction of (c,d)
- GeoLib::Point w(distribution(re), distribution(re), distribution(re));
- // construct c and d such that (a,b) intersects with (c,d)
- GeoLib::Point c(b[0] + w[0], b[1] + w[1], b[2] + w[2]);
- GeoLib::Point d(b[0] - w[0], b[1] - w[1], b[2] - w[2]);
- GeoLib::Point s;
-
- EXPECT_TRUE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
- EXPECT_TRUE(GeoLib::lineSegmentIntersect({&c,&d}, {&a,&b}, s));
- }
+ std::uniform_real_distribution<double> distribution(-1e10, 1e10);
+ std::default_random_engine re;
+
+ // line segments intersect each other in the middle
+ for (std::size_t k(0); k<1000; k++) {
+ // two intersecting line segments (a,b) and (c,d)
+ GeoLib::Point a(distribution(re), distribution(re), distribution(re));
+ GeoLib::Point b(distribution(re), distribution(re), distribution(re));
+ // direction of (c,d)
+ GeoLib::Point w(distribution(re), distribution(re), distribution(re));
+ // construct c and d such that (a,b) intersects with (c,d)
+ GeoLib::Point c(0.5*(b[0]+a[0]) + w[0],
+ 0.5*(b[1]+a[1]) + w[1],
+ 0.5*(b[2]+a[2]) + w[2]);
+ GeoLib::Point d(0.5*(b[0]+a[0]) - w[0],
+ 0.5*(b[1]+a[1]) - w[1],
+ 0.5*(b[2]+a[2]) - w[2]);
+ GeoLib::Point s;
+
+ EXPECT_TRUE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
+ }
+
+ // line segment (c,d) intersects (a,b) at end point a
+ for (std::size_t k(0); k<1000; k++) {
+ // two intersecting line segments (a,b) and (c,d)
+ GeoLib::Point a(distribution(re), distribution(re), distribution(re));
+ GeoLib::Point b(distribution(re), distribution(re), distribution(re));
+ // direction of (c,d)
+ GeoLib::Point w(distribution(re), distribution(re), distribution(re));
+ // construct c and d such that (a,b) intersects with (c,d)
+ GeoLib::Point c(a[0] + w[0], a[1] + w[1], a[2] + w[2]);
+ GeoLib::Point d(a[0] - w[0], a[1] - w[1], a[2] - w[2]);
+ GeoLib::Point s;
+
+ EXPECT_TRUE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
+ EXPECT_TRUE(GeoLib::lineSegmentIntersect({&c,&d}, {&a,&b}, s));
+ }
+
+ // line segment (c,d) intersects (a,b) at end point b
+ for (std::size_t k(0); k<1000; k++) {
+ // two intersecting line segments (a,b) and (c,d)
+ GeoLib::Point a(distribution(re), distribution(re), distribution(re));
+ GeoLib::Point b(distribution(re), distribution(re), distribution(re));
+ // direction of (c,d)
+ GeoLib::Point w(distribution(re), distribution(re), distribution(re));
+ // construct c and d such that (a,b) intersects with (c,d)
+ GeoLib::Point c(b[0] + w[0], b[1] + w[1], b[2] + w[2]);
+ GeoLib::Point d(b[0] - w[0], b[1] - w[1], b[2] - w[2]);
+ GeoLib::Point s;
+
+ EXPECT_TRUE(GeoLib::lineSegmentIntersect({&a,&b}, {&c,&d}, s));
+ EXPECT_TRUE(GeoLib::lineSegmentIntersect({&c,&d}, {&a,&b}, s));
+ }
}
diff --git a/Tests/GeoLib/TestLineSegmentIntersect2d.cpp b/Tests/GeoLib/TestLineSegmentIntersect2d.cpp
index eda4a5f54089f0f507a4fc6ba126e8e14347dc25..72afae082c7c3f9066dc0ca81b90125201c58b85 100644
--- a/Tests/GeoLib/TestLineSegmentIntersect2d.cpp
+++ b/Tests/GeoLib/TestLineSegmentIntersect2d.cpp
@@ -23,31 +23,31 @@ namespace ac = autocheck;
class LineSegmentIntersect2dTest : public testing::Test
{
public:
- using PointGenerator = ac::RandomCirclePointGeneratorXY<ac::generator<double>>;
- using SymmSegmentGenerator = ac::SymmSegmentGeneratorXY<PointGenerator>;
- using PairSegmentGenerator = ac::PairSegmentGeneratorXY<SymmSegmentGenerator>;
-
- PointGenerator point_generator1 = PointGenerator(
- MathLib::Point3d(std::array<double, 3>{{0.0, 0.0, 0.0}}), 1.0);
- SymmSegmentGenerator segment_generator1 = SymmSegmentGenerator{point_generator1,
- std::bind(ac::reflect, point_generator1.center, std::placeholders::_1)};
-
- PointGenerator point_generator2 = PointGenerator(
- MathLib::Point3d(std::array<double, 3>{{2.0, 0.0, 0.0}}), 1.0);
- SymmSegmentGenerator segment_generator2 = SymmSegmentGenerator{point_generator2,
- std::bind(ac::reflect, point_generator2.center, std::placeholders::_1)};
-
- MathLib::Vector3 const translation_vector1 = {2,2,0};
- PairSegmentGenerator pair_segment_generator1 = PairSegmentGenerator{
- segment_generator1,
- std::bind(ac::translate, translation_vector1, std::placeholders::_1)};
-
- MathLib::Vector3 const translation_vector2 = {0,0,0};
- PairSegmentGenerator pair_segment_generator2 = PairSegmentGenerator{
- segment_generator1,
- std::bind(ac::translate, translation_vector2, std::placeholders::_1)};
-
- ac::gtest_reporter gtest_reporter;
+ using PointGenerator = ac::RandomCirclePointGeneratorXY<ac::generator<double>>;
+ using SymmSegmentGenerator = ac::SymmSegmentGeneratorXY<PointGenerator>;
+ using PairSegmentGenerator = ac::PairSegmentGeneratorXY<SymmSegmentGenerator>;
+
+ PointGenerator point_generator1 = PointGenerator(
+ MathLib::Point3d(std::array<double, 3>{{0.0, 0.0, 0.0}}), 1.0);
+ SymmSegmentGenerator segment_generator1 = SymmSegmentGenerator{point_generator1,
+ std::bind(ac::reflect, point_generator1.center, std::placeholders::_1)};
+
+ PointGenerator point_generator2 = PointGenerator(
+ MathLib::Point3d(std::array<double, 3>{{2.0, 0.0, 0.0}}), 1.0);
+ SymmSegmentGenerator segment_generator2 = SymmSegmentGenerator{point_generator2,
+ std::bind(ac::reflect, point_generator2.center, std::placeholders::_1)};
+
+ MathLib::Vector3 const translation_vector1 = {2,2,0};
+ PairSegmentGenerator pair_segment_generator1 = PairSegmentGenerator{
+ segment_generator1,
+ std::bind(ac::translate, translation_vector1, std::placeholders::_1)};
+
+ MathLib::Vector3 const translation_vector2 = {0,0,0};
+ PairSegmentGenerator pair_segment_generator2 = PairSegmentGenerator{
+ segment_generator1,
+ std::bind(ac::translate, translation_vector2, std::placeholders::_1)};
+
+ ac::gtest_reporter gtest_reporter;
};
#if !defined(_MSC_VER) || (_MSC_VER >= 1900)
@@ -62,95 +62,95 @@ public:
// consequence the center of the circle is the intersection point.
TEST_F(LineSegmentIntersect2dTest, RandomSegmentOrientationIntersecting)
{
- auto intersect = [](GeoLib::LineSegment const& s0,
- GeoLib::LineSegment const& s1)
- {
- auto ipnts = GeoLib::lineSegmentIntersect2d(
- s0.getBeginPoint(), s0.getEndPoint(), s1.getBeginPoint(),
- s1.getEndPoint());
- if (ipnts.size() == 1)
- {
- MathLib::Point3d const center{std::array<double, 3>{
- {(s0.getBeginPoint()[0] + s0.getEndPoint()[0]) / 2,
- (s0.getBeginPoint()[1] + s0.getEndPoint()[1]) / 2, 0.0}}};
- const double sqr_dist(MathLib::sqrDist(ipnts[0], center));
- if (sqr_dist < std::numeric_limits<double>::epsilon())
- return true;
- else
- return false;
- }
- return ipnts.size() == 2;
- };
-
- ac::check<GeoLib::LineSegment, GeoLib::LineSegment>(
- intersect, 1000,
- ac::make_arbitrary(segment_generator1, segment_generator1),
- gtest_reporter);
+ auto intersect = [](GeoLib::LineSegment const& s0,
+ GeoLib::LineSegment const& s1)
+ {
+ auto ipnts = GeoLib::lineSegmentIntersect2d(
+ s0.getBeginPoint(), s0.getEndPoint(), s1.getBeginPoint(),
+ s1.getEndPoint());
+ if (ipnts.size() == 1)
+ {
+ MathLib::Point3d const center{std::array<double, 3>{
+ {(s0.getBeginPoint()[0] + s0.getEndPoint()[0]) / 2,
+ (s0.getBeginPoint()[1] + s0.getEndPoint()[1]) / 2, 0.0}}};
+ const double sqr_dist(MathLib::sqrDist(ipnts[0], center));
+ if (sqr_dist < std::numeric_limits<double>::epsilon())
+ return true;
+ else
+ return false;
+ }
+ return ipnts.size() == 2;
+ };
+
+ ac::check<GeoLib::LineSegment, GeoLib::LineSegment>(
+ intersect, 1000,
+ ac::make_arbitrary(segment_generator1, segment_generator1),
+ gtest_reporter);
}
// Test the intersection of non-intersecting line segments. Line segments are
// chords of non-intersecting circles.
TEST_F(LineSegmentIntersect2dTest, RandomSegmentOrientationNonIntersecting)
{
- auto intersect =
- [](GeoLib::LineSegment const& s0, GeoLib::LineSegment const& s1)
- {
- auto ipnts = GeoLib::lineSegmentIntersect2d(
- s0.getBeginPoint(), s0.getEndPoint(), s1.getBeginPoint(),
- s1.getEndPoint());
- return ipnts.empty();
- };
-
- // generate non-intersecting segments
- ac::check<GeoLib::LineSegment, GeoLib::LineSegment>(
- intersect, 1000,
- ac::make_arbitrary(segment_generator1, segment_generator2),
- gtest_reporter);
+ auto intersect =
+ [](GeoLib::LineSegment const& s0, GeoLib::LineSegment const& s1)
+ {
+ auto ipnts = GeoLib::lineSegmentIntersect2d(
+ s0.getBeginPoint(), s0.getEndPoint(), s1.getBeginPoint(),
+ s1.getEndPoint());
+ return ipnts.empty();
+ };
+
+ // generate non-intersecting segments
+ ac::check<GeoLib::LineSegment, GeoLib::LineSegment>(
+ intersect, 1000,
+ ac::make_arbitrary(segment_generator1, segment_generator2),
+ gtest_reporter);
}
// Test the intersection of non-intersecting, parallel line segments. The second
// line segment is created by translating the first line segment.
TEST_F(LineSegmentIntersect2dTest, ParallelNonIntersectingSegmentOrientation)
{
- auto intersect = [](
- std::pair<GeoLib::LineSegment const&, GeoLib::LineSegment const&> const&
- segment_pair)
- {
- auto ipnts =
- GeoLib::lineSegmentIntersect2d(segment_pair.first.getBeginPoint(),
- segment_pair.first.getEndPoint(),
- segment_pair.second.getBeginPoint(),
- segment_pair.second.getEndPoint());
- return ipnts.empty();
- };
-
- // generate non-intersecting segments
- ac::check<std::pair<GeoLib::LineSegment, GeoLib::LineSegment>>(
- intersect, 1000,
- ac::make_arbitrary(pair_segment_generator1),
- gtest_reporter);
+ auto intersect = [](
+ std::pair<GeoLib::LineSegment const&, GeoLib::LineSegment const&> const&
+ segment_pair)
+ {
+ auto ipnts =
+ GeoLib::lineSegmentIntersect2d(segment_pair.first.getBeginPoint(),
+ segment_pair.first.getEndPoint(),
+ segment_pair.second.getBeginPoint(),
+ segment_pair.second.getEndPoint());
+ return ipnts.empty();
+ };
+
+ // generate non-intersecting segments
+ ac::check<std::pair<GeoLib::LineSegment, GeoLib::LineSegment>>(
+ intersect, 1000,
+ ac::make_arbitrary(pair_segment_generator1),
+ gtest_reporter);
}
// Test the intersection of parallel, interfering line segments.
TEST_F(LineSegmentIntersect2dTest, ParallelIntersectingSegmentOrientation)
{
- auto intersect = [](
- std::pair<GeoLib::LineSegment const&, GeoLib::LineSegment const&> const&
- segment_pair)
- {
- auto ipnts =
- GeoLib::lineSegmentIntersect2d(segment_pair.first.getBeginPoint(),
- segment_pair.first.getEndPoint(),
- segment_pair.second.getBeginPoint(),
- segment_pair.second.getEndPoint());
- return ipnts.size() == 2;
- };
-
- // generate non-intersecting segments
- ac::check<std::pair<GeoLib::LineSegment, GeoLib::LineSegment>>(
- intersect, 1000,
- ac::make_arbitrary(pair_segment_generator2),
- gtest_reporter);
+ auto intersect = [](
+ std::pair<GeoLib::LineSegment const&, GeoLib::LineSegment const&> const&
+ segment_pair)
+ {
+ auto ipnts =
+ GeoLib::lineSegmentIntersect2d(segment_pair.first.getBeginPoint(),
+ segment_pair.first.getEndPoint(),
+ segment_pair.second.getBeginPoint(),
+ segment_pair.second.getEndPoint());
+ return ipnts.size() == 2;
+ };
+
+ // generate non-intersecting segments
+ ac::check<std::pair<GeoLib::LineSegment, GeoLib::LineSegment>>(
+ intersect, 1000,
+ ac::make_arbitrary(pair_segment_generator2),
+ gtest_reporter);
}
#endif
diff --git a/Tests/GeoLib/TestOctTree.cpp b/Tests/GeoLib/TestOctTree.cpp
index 9f69ad2354ca874e7be68a7a3496accd6ab1c7e9..b6608d3df597698a132759f573ce3f26e52c6d39 100644
--- a/Tests/GeoLib/TestOctTree.cpp
+++ b/Tests/GeoLib/TestOctTree.cpp
@@ -18,373 +18,373 @@
class GeoLibOctTree : public testing::Test
{
public:
- typedef std::vector<GeoLib::Point*> VectorOfPoints;
+ typedef std::vector<GeoLib::Point*> VectorOfPoints;
- GeoLibOctTree()
- {}
+ GeoLibOctTree()
+ {}
- ~GeoLibOctTree()
- {
- for (auto p : ps_ptr) {
- delete p;
- }
- }
+ ~GeoLibOctTree()
+ {
+ for (auto p : ps_ptr) {
+ delete p;
+ }
+ }
#ifndef NDEBUG
- template <std::size_t MAX_POINTS>
- void
- checkOctTreeChildsNonNullptr(
- GeoLib::OctTree<GeoLib::Point, MAX_POINTS> const& oct_tree) const
- {
- ASSERT_NE(nullptr, oct_tree.getChild(0));
- ASSERT_NE(nullptr, oct_tree.getChild(1));
- ASSERT_NE(nullptr, oct_tree.getChild(2));
- ASSERT_NE(nullptr, oct_tree.getChild(3));
- ASSERT_NE(nullptr, oct_tree.getChild(4));
- ASSERT_NE(nullptr, oct_tree.getChild(5));
- ASSERT_NE(nullptr, oct_tree.getChild(6));
- ASSERT_NE(nullptr, oct_tree.getChild(7));
- }
+ template <std::size_t MAX_POINTS>
+ void
+ checkOctTreeChildsNonNullptr(
+ GeoLib::OctTree<GeoLib::Point, MAX_POINTS> const& oct_tree) const
+ {
+ ASSERT_NE(nullptr, oct_tree.getChild(0));
+ ASSERT_NE(nullptr, oct_tree.getChild(1));
+ ASSERT_NE(nullptr, oct_tree.getChild(2));
+ ASSERT_NE(nullptr, oct_tree.getChild(3));
+ ASSERT_NE(nullptr, oct_tree.getChild(4));
+ ASSERT_NE(nullptr, oct_tree.getChild(5));
+ ASSERT_NE(nullptr, oct_tree.getChild(6));
+ ASSERT_NE(nullptr, oct_tree.getChild(7));
+ }
#endif
#ifndef NDEBUG
- template <std::size_t MAX_POINTS>
- void
- checkOctTreeChildsNullptr(GeoLib::OctTree<GeoLib::Point, MAX_POINTS> const& oct_tree) const
- {
- ASSERT_EQ(nullptr, oct_tree.getChild(0));
- ASSERT_EQ(nullptr, oct_tree.getChild(1));
- ASSERT_EQ(nullptr, oct_tree.getChild(2));
- ASSERT_EQ(nullptr, oct_tree.getChild(3));
- ASSERT_EQ(nullptr, oct_tree.getChild(4));
- ASSERT_EQ(nullptr, oct_tree.getChild(5));
- ASSERT_EQ(nullptr, oct_tree.getChild(6));
- ASSERT_EQ(nullptr, oct_tree.getChild(7));
- }
+ template <std::size_t MAX_POINTS>
+ void
+ checkOctTreeChildsNullptr(GeoLib::OctTree<GeoLib::Point, MAX_POINTS> const& oct_tree) const
+ {
+ ASSERT_EQ(nullptr, oct_tree.getChild(0));
+ ASSERT_EQ(nullptr, oct_tree.getChild(1));
+ ASSERT_EQ(nullptr, oct_tree.getChild(2));
+ ASSERT_EQ(nullptr, oct_tree.getChild(3));
+ ASSERT_EQ(nullptr, oct_tree.getChild(4));
+ ASSERT_EQ(nullptr, oct_tree.getChild(5));
+ ASSERT_EQ(nullptr, oct_tree.getChild(6));
+ ASSERT_EQ(nullptr, oct_tree.getChild(7));
+ }
#endif
protected:
- void
- generateEquidistantPoints3d(std::size_t const n = 11)
- {
- for (std::size_t k(0); k<n; ++k) {
- double const z(k-(n-1)/2.0);
- for (std::size_t j(0); j<n; ++j) {
- double const y(j-(n-1)/2.0);
- for (std::size_t i(0); i<n; ++i) {
- ps_ptr.push_back(new GeoLib::Point(i-(n-1)/2.0, y, z));
- }
- }
- }
- }
+ void
+ generateEquidistantPoints3d(std::size_t const n = 11)
+ {
+ for (std::size_t k(0); k<n; ++k) {
+ double const z(k-(n-1)/2.0);
+ for (std::size_t j(0); j<n; ++j) {
+ double const y(j-(n-1)/2.0);
+ for (std::size_t i(0); i<n; ++i) {
+ ps_ptr.push_back(new GeoLib::Point(i-(n-1)/2.0, y, z));
+ }
+ }
+ }
+ }
protected:
- VectorOfPoints ps_ptr;
+ VectorOfPoints ps_ptr;
};
TEST_F(GeoLibOctTree, TestWithEquidistantPoints3d)
{
- generateEquidistantPoints3d();
- double const eps(10*std::numeric_limits<double>::epsilon());
- std::unique_ptr<GeoLib::OctTree<GeoLib::Point, 2>> oct_tree(
- GeoLib::OctTree<GeoLib::Point, 2>::createOctTree(*ps_ptr.front(),
- *ps_ptr.back(), eps));
+ generateEquidistantPoints3d();
+ double const eps(10*std::numeric_limits<double>::epsilon());
+ std::unique_ptr<GeoLib::OctTree<GeoLib::Point, 2>> oct_tree(
+ GeoLib::OctTree<GeoLib::Point, 2>::createOctTree(*ps_ptr.front(),
+ *ps_ptr.back(), eps));
#ifndef NDEBUG
- MathLib::Point3d const& ll(oct_tree->getLowerLeftCornerPoint());
- MathLib::Point3d const& ur(oct_tree->getUpperRightCornerPoint());
+ MathLib::Point3d const& ll(oct_tree->getLowerLeftCornerPoint());
+ MathLib::Point3d const& ur(oct_tree->getUpperRightCornerPoint());
- EXPECT_EQ((*ps_ptr.front())[0], ll[0]);
- EXPECT_EQ((*ps_ptr.front())[1], ll[1]);
- EXPECT_EQ((*ps_ptr.front())[2], ll[2]);
+ EXPECT_EQ((*ps_ptr.front())[0], ll[0]);
+ EXPECT_EQ((*ps_ptr.front())[1], ll[1]);
+ EXPECT_EQ((*ps_ptr.front())[2], ll[2]);
- EXPECT_NEAR((*ps_ptr.back())[0], ur[0], (ur[0]-ll[0])*1e-6);
- EXPECT_NEAR((*ps_ptr.back())[1], ur[1], (ur[1]-ll[1])*1e-6);
- EXPECT_NEAR((*ps_ptr.back())[2], ur[2], (ur[2]-ll[2])*1e-6);
+ EXPECT_NEAR((*ps_ptr.back())[0], ur[0], (ur[0]-ll[0])*1e-6);
+ EXPECT_NEAR((*ps_ptr.back())[1], ur[1], (ur[1]-ll[1])*1e-6);
+ EXPECT_NEAR((*ps_ptr.back())[2], ur[2], (ur[2]-ll[2])*1e-6);
- checkOctTreeChildsNullptr<2>(*oct_tree);
+ checkOctTreeChildsNullptr<2>(*oct_tree);
- ASSERT_EQ(static_cast<std::size_t>(0), oct_tree->getPointVector().size());
+ ASSERT_EQ(static_cast<std::size_t>(0), oct_tree->getPointVector().size());
#endif
- GeoLib::Point * ret_pnt(nullptr);
- // insert the first point
- ASSERT_TRUE(oct_tree->addPoint(ps_ptr[0], ret_pnt));
-
- // make a range query
- MathLib::Point3d const min(
- std::array<double,3>{{(*(ps_ptr[0]))[0]-eps,
- (*(ps_ptr[0]))[1]-eps, (*(ps_ptr[0]))[2]-eps}});
- MathLib::Point3d const max(
- std::array<double,3>{{(*(ps_ptr[0]))[0]+eps,
- (*(ps_ptr[0]))[1]+eps, (*(ps_ptr[0]))[2]+eps}});
- std::vector<GeoLib::Point*> query_pnts;
- oct_tree->getPointsInRange(min, max, query_pnts);
- ASSERT_EQ(1u, query_pnts.size());
+ GeoLib::Point * ret_pnt(nullptr);
+ // insert the first point
+ ASSERT_TRUE(oct_tree->addPoint(ps_ptr[0], ret_pnt));
+
+ // make a range query
+ MathLib::Point3d const min(
+ std::array<double,3>{{(*(ps_ptr[0]))[0]-eps,
+ (*(ps_ptr[0]))[1]-eps, (*(ps_ptr[0]))[2]-eps}});
+ MathLib::Point3d const max(
+ std::array<double,3>{{(*(ps_ptr[0]))[0]+eps,
+ (*(ps_ptr[0]))[1]+eps, (*(ps_ptr[0]))[2]+eps}});
+ std::vector<GeoLib::Point*> query_pnts;
+ oct_tree->getPointsInRange(min, max, query_pnts);
+ ASSERT_EQ(1u, query_pnts.size());
#ifndef NDEBUG
- ASSERT_EQ(static_cast<std::size_t>(1), oct_tree->getPointVector().size());
+ ASSERT_EQ(static_cast<std::size_t>(1), oct_tree->getPointVector().size());
#endif
- // try to insert the first point a second time
- ASSERT_FALSE(oct_tree->addPoint(ps_ptr[0], ret_pnt));
+ // try to insert the first point a second time
+ ASSERT_FALSE(oct_tree->addPoint(ps_ptr[0], ret_pnt));
#ifndef NDEBUG
- ASSERT_EQ(static_cast<std::size_t>(1), oct_tree->getPointVector().size());
+ ASSERT_EQ(static_cast<std::size_t>(1), oct_tree->getPointVector().size());
#endif
- // insert the second point
- ASSERT_TRUE(oct_tree->addPoint(ps_ptr[1], ret_pnt));
+ // insert the second point
+ ASSERT_TRUE(oct_tree->addPoint(ps_ptr[1], ret_pnt));
#ifndef NDEBUG
- ASSERT_EQ(static_cast<std::size_t>(2), oct_tree->getPointVector().size());
- checkOctTreeChildsNullptr<2>(*oct_tree);
+ ASSERT_EQ(static_cast<std::size_t>(2), oct_tree->getPointVector().size());
+ checkOctTreeChildsNullptr<2>(*oct_tree);
#endif
- // insert a third point -> there should be subtrees
- ASSERT_TRUE(oct_tree->addPoint(ps_ptr[2], ret_pnt));
+ // insert a third point -> there should be subtrees
+ ASSERT_TRUE(oct_tree->addPoint(ps_ptr[2], ret_pnt));
#ifndef NDEBUG
- ASSERT_EQ(static_cast<std::size_t>(0), oct_tree->getPointVector().size());
- checkOctTreeChildsNonNullptr<2>(*oct_tree);
-
- // all inserted points are in the SWL -> there should be another subtree
- // level
- checkOctTreeChildsNonNullptr<2>(*(oct_tree->getChild(2)));
-
- // still all inserted points are in the SWL of the SWL
- // -> there should be another subtree level
- checkOctTreeChildsNonNullptr<2>(*(oct_tree->getChild(2)->getChild(2)));
-
- checkOctTreeChildsNullptr<2>(*(oct_tree->getChild(2)->getChild(0)));
- checkOctTreeChildsNullptr<2>(*(oct_tree->getChild(2)->getChild(1)));
- checkOctTreeChildsNullptr<2>(*(oct_tree->getChild(2)->getChild(3)));
- checkOctTreeChildsNullptr<2>(*(oct_tree->getChild(2)->getChild(4)));
- checkOctTreeChildsNullptr<2>(*(oct_tree->getChild(2)->getChild(5)));
- checkOctTreeChildsNullptr<2>(*(oct_tree->getChild(2)->getChild(6)));
- checkOctTreeChildsNullptr<2>(*(oct_tree->getChild(2)->getChild(7)));
-
- ASSERT_EQ(static_cast<std::size_t>(2),
- oct_tree->getChild(2)->getChild(2)->getChild(2)->getPointVector().size());
- ASSERT_EQ(static_cast<std::size_t>(1),
- oct_tree->getChild(2)->getChild(2)->getChild(3)->getPointVector().size());
+ ASSERT_EQ(static_cast<std::size_t>(0), oct_tree->getPointVector().size());
+ checkOctTreeChildsNonNullptr<2>(*oct_tree);
+
+ // all inserted points are in the SWL -> there should be another subtree
+ // level
+ checkOctTreeChildsNonNullptr<2>(*(oct_tree->getChild(2)));
+
+ // still all inserted points are in the SWL of the SWL
+ // -> there should be another subtree level
+ checkOctTreeChildsNonNullptr<2>(*(oct_tree->getChild(2)->getChild(2)));
+
+ checkOctTreeChildsNullptr<2>(*(oct_tree->getChild(2)->getChild(0)));
+ checkOctTreeChildsNullptr<2>(*(oct_tree->getChild(2)->getChild(1)));
+ checkOctTreeChildsNullptr<2>(*(oct_tree->getChild(2)->getChild(3)));
+ checkOctTreeChildsNullptr<2>(*(oct_tree->getChild(2)->getChild(4)));
+ checkOctTreeChildsNullptr<2>(*(oct_tree->getChild(2)->getChild(5)));
+ checkOctTreeChildsNullptr<2>(*(oct_tree->getChild(2)->getChild(6)));
+ checkOctTreeChildsNullptr<2>(*(oct_tree->getChild(2)->getChild(7)));
+
+ ASSERT_EQ(static_cast<std::size_t>(2),
+ oct_tree->getChild(2)->getChild(2)->getChild(2)->getPointVector().size());
+ ASSERT_EQ(static_cast<std::size_t>(1),
+ oct_tree->getChild(2)->getChild(2)->getChild(3)->getPointVector().size());
#endif
- ASSERT_TRUE(oct_tree->addPoint(ps_ptr[3], ret_pnt));
+ ASSERT_TRUE(oct_tree->addPoint(ps_ptr[3], ret_pnt));
#ifndef NDEBUG
- ASSERT_EQ(static_cast<std::size_t>(1),
- oct_tree->getChild(2)->getChild(3)->getPointVector().size());
+ ASSERT_EQ(static_cast<std::size_t>(1),
+ oct_tree->getChild(2)->getChild(3)->getPointVector().size());
#endif
- GeoLib::Point range_query_ll(*(ps_ptr.front()));
- GeoLib::Point range_query_ur(*(ps_ptr[ps_ptr.size()/2]));
- std::vector<GeoLib::Point*> result;
- oct_tree->getPointsInRange(range_query_ll, range_query_ur, result);
- ASSERT_EQ(static_cast<std::size_t>(4), result.size());
-
- result.clear();
- range_query_ur[0] = -2.5;
- range_query_ur[1] = -2.5;
- range_query_ur[2] = -2.5;
- oct_tree->getPointsInRange(range_query_ll, range_query_ur, result);
- ASSERT_EQ(static_cast<std::size_t>(3), result.size());
-
- // insert some points not resulting in a further refinement of SWL
- for (std::size_t k(4); k<11; ++k)
- ASSERT_TRUE(oct_tree->addPoint(ps_ptr[k], ret_pnt));
-
- result.clear();
- oct_tree->getPointsInRange(range_query_ll, range_query_ur, result);
- ASSERT_EQ(static_cast<std::size_t>(3), result.size());
-
- // insert some points *resulting* in a further refinement of SWL
- for (std::size_t k(11); k<25; ++k)
- ASSERT_TRUE(oct_tree->addPoint(ps_ptr[k], ret_pnt));
-
- result.clear();
- oct_tree->getPointsInRange(range_query_ll, range_query_ur, result);
- ASSERT_EQ(static_cast<std::size_t>(9), result.size());
-
- // insert all points with z = -5.0 - this does not result in a further
- // refinement of SWL
- for (std::size_t k(25); k<121; ++k)
- ASSERT_TRUE(oct_tree->addPoint(ps_ptr[k], ret_pnt));
-
- result.clear();
- oct_tree->getPointsInRange(range_query_ll, range_query_ur, result);
- ASSERT_EQ(static_cast<std::size_t>(9), result.size());
-
- result.clear();
- range_query_ur[0] = -3.75;
- range_query_ur[1] = -3.75;
- range_query_ur[2] = -3.75;
- oct_tree->getPointsInRange(range_query_ll, range_query_ur, result);
- ASSERT_EQ(static_cast<std::size_t>(4), result.size());
-
- result.clear();
- range_query_ur[0] = -4.25;
- range_query_ur[1] = -4.25;
- range_query_ur[2] = -4.25;
- oct_tree->getPointsInRange(range_query_ll, range_query_ur, result);
- ASSERT_EQ(static_cast<std::size_t>(1), result.size());
-
- result.clear();
- range_query_ll[0] = -4.75;
- range_query_ll[1] = -4.75;
- range_query_ll[2] = -4.75;
- oct_tree->getPointsInRange(range_query_ll, range_query_ur, result);
- for (auto p : result)
- std::cout << *p << "\n";
- ASSERT_EQ(static_cast<std::size_t>(0), result.size());
-
- result.clear();
- range_query_ll[0] = -5;
- range_query_ll[1] = -5;
- range_query_ll[2] = -5;
- range_query_ur[0] = -0.25;
- range_query_ur[1] = -4.75;
- range_query_ur[2] = -4.75;
- oct_tree->getPointsInRange(range_query_ll, range_query_ur, result);
- ASSERT_EQ(static_cast<std::size_t>(5), result.size());
+ GeoLib::Point range_query_ll(*(ps_ptr.front()));
+ GeoLib::Point range_query_ur(*(ps_ptr[ps_ptr.size()/2]));
+ std::vector<GeoLib::Point*> result;
+ oct_tree->getPointsInRange(range_query_ll, range_query_ur, result);
+ ASSERT_EQ(static_cast<std::size_t>(4), result.size());
+
+ result.clear();
+ range_query_ur[0] = -2.5;
+ range_query_ur[1] = -2.5;
+ range_query_ur[2] = -2.5;
+ oct_tree->getPointsInRange(range_query_ll, range_query_ur, result);
+ ASSERT_EQ(static_cast<std::size_t>(3), result.size());
+
+ // insert some points not resulting in a further refinement of SWL
+ for (std::size_t k(4); k<11; ++k)
+ ASSERT_TRUE(oct_tree->addPoint(ps_ptr[k], ret_pnt));
+
+ result.clear();
+ oct_tree->getPointsInRange(range_query_ll, range_query_ur, result);
+ ASSERT_EQ(static_cast<std::size_t>(3), result.size());
+
+ // insert some points *resulting* in a further refinement of SWL
+ for (std::size_t k(11); k<25; ++k)
+ ASSERT_TRUE(oct_tree->addPoint(ps_ptr[k], ret_pnt));
+
+ result.clear();
+ oct_tree->getPointsInRange(range_query_ll, range_query_ur, result);
+ ASSERT_EQ(static_cast<std::size_t>(9), result.size());
+
+ // insert all points with z = -5.0 - this does not result in a further
+ // refinement of SWL
+ for (std::size_t k(25); k<121; ++k)
+ ASSERT_TRUE(oct_tree->addPoint(ps_ptr[k], ret_pnt));
+
+ result.clear();
+ oct_tree->getPointsInRange(range_query_ll, range_query_ur, result);
+ ASSERT_EQ(static_cast<std::size_t>(9), result.size());
+
+ result.clear();
+ range_query_ur[0] = -3.75;
+ range_query_ur[1] = -3.75;
+ range_query_ur[2] = -3.75;
+ oct_tree->getPointsInRange(range_query_ll, range_query_ur, result);
+ ASSERT_EQ(static_cast<std::size_t>(4), result.size());
+
+ result.clear();
+ range_query_ur[0] = -4.25;
+ range_query_ur[1] = -4.25;
+ range_query_ur[2] = -4.25;
+ oct_tree->getPointsInRange(range_query_ll, range_query_ur, result);
+ ASSERT_EQ(static_cast<std::size_t>(1), result.size());
+
+ result.clear();
+ range_query_ll[0] = -4.75;
+ range_query_ll[1] = -4.75;
+ range_query_ll[2] = -4.75;
+ oct_tree->getPointsInRange(range_query_ll, range_query_ur, result);
+ for (auto p : result)
+ std::cout << *p << "\n";
+ ASSERT_EQ(static_cast<std::size_t>(0), result.size());
+
+ result.clear();
+ range_query_ll[0] = -5;
+ range_query_ll[1] = -5;
+ range_query_ll[2] = -5;
+ range_query_ur[0] = -0.25;
+ range_query_ur[1] = -4.75;
+ range_query_ur[2] = -4.75;
+ oct_tree->getPointsInRange(range_query_ll, range_query_ur, result);
+ ASSERT_EQ(static_cast<std::size_t>(5), result.size());
}
TEST_F(GeoLibOctTree, TestWithAlternatingPoints3d)
{
- // this case is not correctly handled by lexicographical sorting
- double const eps(1e-1);
- double const small_displacement(1e-2);
- ps_ptr.push_back(new GeoLib::Point(0,0,0,0));
- ps_ptr.push_back(new GeoLib::Point(2*small_displacement,0,0,1));
- ps_ptr.push_back(new GeoLib::Point(small_displacement,1,0,2));
- ps_ptr.push_back(new GeoLib::Point(4*small_displacement,0,0,3));
- ps_ptr.push_back(new GeoLib::Point(3*small_displacement,1,0,4));
- ps_ptr.push_back(new GeoLib::Point(6*small_displacement,0,0,5));
- ps_ptr.push_back(new GeoLib::Point(5*small_displacement,1,0,6));
-
- GeoLib::AABB const aabb(ps_ptr.cbegin(), ps_ptr.cend());
- MathLib::Point3d min(aabb.getMinPoint());
- MathLib::Point3d max(aabb.getMaxPoint());
- std::unique_ptr<GeoLib::OctTree<GeoLib::Point, 8>> oct_tree(
- GeoLib::OctTree<GeoLib::Point, 8>::createOctTree(min, max, eps));
-
- // pt_ptr[0] should be inserted correctly
- GeoLib::Point * ret_pnt(nullptr);
- ASSERT_TRUE(oct_tree->addPoint(ps_ptr[0], ret_pnt));
- ASSERT_EQ(ps_ptr[0], ret_pnt);
- // ps_ptr[1] is in the eps-environment of ps_ptr[0]
- ret_pnt = nullptr;
- ASSERT_FALSE(oct_tree->addPoint(ps_ptr[1], ret_pnt));
- ASSERT_EQ(ps_ptr[0], ret_pnt);
- // pt_ptr[2] should be inserted correctly
- ret_pnt = nullptr;
- ASSERT_TRUE(oct_tree->addPoint(ps_ptr[2], ret_pnt));
- ASSERT_EQ(ps_ptr[2], ret_pnt);
- // ps_ptr[3] is in the eps-environment of ps_ptr[0]
- ret_pnt = nullptr;
- ASSERT_FALSE(oct_tree->addPoint(ps_ptr[3], ret_pnt));
- ASSERT_EQ(ps_ptr[0], ret_pnt);
- // ps_ptr[4] is in the eps-environment of ps_ptr[2]
- ret_pnt = nullptr;
- ASSERT_FALSE(oct_tree->addPoint(ps_ptr[4], ret_pnt));
- ASSERT_EQ(ps_ptr[2], ret_pnt);
- // ps_ptr[5] is in the eps-environment of ps_ptr[0]
- ret_pnt = nullptr;
- ASSERT_FALSE(oct_tree->addPoint(ps_ptr[5], ret_pnt));
- ASSERT_EQ(ps_ptr[0], ret_pnt);
- // ps_ptr[6] is in the eps-environment of ps_ptr[2]
- ret_pnt = nullptr;
- ASSERT_FALSE(oct_tree->addPoint(ps_ptr[6], ret_pnt));
- ASSERT_EQ(ps_ptr[2], ret_pnt);
+ // this case is not correctly handled by lexicographical sorting
+ double const eps(1e-1);
+ double const small_displacement(1e-2);
+ ps_ptr.push_back(new GeoLib::Point(0,0,0,0));
+ ps_ptr.push_back(new GeoLib::Point(2*small_displacement,0,0,1));
+ ps_ptr.push_back(new GeoLib::Point(small_displacement,1,0,2));
+ ps_ptr.push_back(new GeoLib::Point(4*small_displacement,0,0,3));
+ ps_ptr.push_back(new GeoLib::Point(3*small_displacement,1,0,4));
+ ps_ptr.push_back(new GeoLib::Point(6*small_displacement,0,0,5));
+ ps_ptr.push_back(new GeoLib::Point(5*small_displacement,1,0,6));
+
+ GeoLib::AABB const aabb(ps_ptr.cbegin(), ps_ptr.cend());
+ MathLib::Point3d min(aabb.getMinPoint());
+ MathLib::Point3d max(aabb.getMaxPoint());
+ std::unique_ptr<GeoLib::OctTree<GeoLib::Point, 8>> oct_tree(
+ GeoLib::OctTree<GeoLib::Point, 8>::createOctTree(min, max, eps));
+
+ // pt_ptr[0] should be inserted correctly
+ GeoLib::Point * ret_pnt(nullptr);
+ ASSERT_TRUE(oct_tree->addPoint(ps_ptr[0], ret_pnt));
+ ASSERT_EQ(ps_ptr[0], ret_pnt);
+ // ps_ptr[1] is in the eps-environment of ps_ptr[0]
+ ret_pnt = nullptr;
+ ASSERT_FALSE(oct_tree->addPoint(ps_ptr[1], ret_pnt));
+ ASSERT_EQ(ps_ptr[0], ret_pnt);
+ // pt_ptr[2] should be inserted correctly
+ ret_pnt = nullptr;
+ ASSERT_TRUE(oct_tree->addPoint(ps_ptr[2], ret_pnt));
+ ASSERT_EQ(ps_ptr[2], ret_pnt);
+ // ps_ptr[3] is in the eps-environment of ps_ptr[0]
+ ret_pnt = nullptr;
+ ASSERT_FALSE(oct_tree->addPoint(ps_ptr[3], ret_pnt));
+ ASSERT_EQ(ps_ptr[0], ret_pnt);
+ // ps_ptr[4] is in the eps-environment of ps_ptr[2]
+ ret_pnt = nullptr;
+ ASSERT_FALSE(oct_tree->addPoint(ps_ptr[4], ret_pnt));
+ ASSERT_EQ(ps_ptr[2], ret_pnt);
+ // ps_ptr[5] is in the eps-environment of ps_ptr[0]
+ ret_pnt = nullptr;
+ ASSERT_FALSE(oct_tree->addPoint(ps_ptr[5], ret_pnt));
+ ASSERT_EQ(ps_ptr[0], ret_pnt);
+ // ps_ptr[6] is in the eps-environment of ps_ptr[2]
+ ret_pnt = nullptr;
+ ASSERT_FALSE(oct_tree->addPoint(ps_ptr[6], ret_pnt));
+ ASSERT_EQ(ps_ptr[2], ret_pnt);
}
TEST_F(GeoLibOctTree, TestSmallDistanceDifferentLeaves)
{
- // case where two points with a small distance but different OctTree leaves
- // are inserted
- double const eps(0.5);
- for (std::size_t k = 0; k < 21; ++k) {
- for (std::size_t j = 0; j < 21; ++j) {
- std::size_t id = k*21+j;
- for (std::size_t i = 0; i < 21; ++i) {
- ps_ptr.push_back(new GeoLib::Point(i-10., j-10., k-10., id+i));
- }
- }
- }
-
- // create OctTree
- GeoLib::AABB const aabb(ps_ptr.cbegin(), ps_ptr.cend());
- MathLib::Point3d min(aabb.getMinPoint());
- MathLib::Point3d max(aabb.getMaxPoint());
- std::unique_ptr<GeoLib::OctTree<GeoLib::Point, 2>> oct_tree(
- GeoLib::OctTree<GeoLib::Point, 2>::createOctTree(min, max, eps));
-
- // fill OctTree
- for (auto p : ps_ptr) {
- GeoLib::Point * ret_pnt(nullptr);
- ASSERT_TRUE(oct_tree->addPoint(p, ret_pnt));
- ASSERT_EQ(p, ret_pnt);
- }
-
- // point near the GeoLib::Point (0, -10, -10, 10) (with id 10)
- std::unique_ptr<GeoLib::Point> p0(new GeoLib::Point(0.1, -10.0, -10.0));
- GeoLib::Point * ret_pnt(nullptr);
- ASSERT_FALSE(oct_tree->addPoint(p0.get(), ret_pnt));
- ASSERT_EQ(10u, ret_pnt->getID());
-
- (*p0)[0] = -0.1;
- ret_pnt = nullptr;
- ASSERT_FALSE(oct_tree->addPoint(p0.get(), ret_pnt));
- ASSERT_EQ(10u, ret_pnt->getID());
+ // case where two points with a small distance but different OctTree leaves
+ // are inserted
+ double const eps(0.5);
+ for (std::size_t k = 0; k < 21; ++k) {
+ for (std::size_t j = 0; j < 21; ++j) {
+ std::size_t id = k*21+j;
+ for (std::size_t i = 0; i < 21; ++i) {
+ ps_ptr.push_back(new GeoLib::Point(i-10., j-10., k-10., id+i));
+ }
+ }
+ }
+
+ // create OctTree
+ GeoLib::AABB const aabb(ps_ptr.cbegin(), ps_ptr.cend());
+ MathLib::Point3d min(aabb.getMinPoint());
+ MathLib::Point3d max(aabb.getMaxPoint());
+ std::unique_ptr<GeoLib::OctTree<GeoLib::Point, 2>> oct_tree(
+ GeoLib::OctTree<GeoLib::Point, 2>::createOctTree(min, max, eps));
+
+ // fill OctTree
+ for (auto p : ps_ptr) {
+ GeoLib::Point * ret_pnt(nullptr);
+ ASSERT_TRUE(oct_tree->addPoint(p, ret_pnt));
+ ASSERT_EQ(p, ret_pnt);
+ }
+
+ // point near the GeoLib::Point (0, -10, -10, 10) (with id 10)
+ std::unique_ptr<GeoLib::Point> p0(new GeoLib::Point(0.1, -10.0, -10.0));
+ GeoLib::Point * ret_pnt(nullptr);
+ ASSERT_FALSE(oct_tree->addPoint(p0.get(), ret_pnt));
+ ASSERT_EQ(10u, ret_pnt->getID());
+
+ (*p0)[0] = -0.1;
+ ret_pnt = nullptr;
+ ASSERT_FALSE(oct_tree->addPoint(p0.get(), ret_pnt));
+ ASSERT_EQ(10u, ret_pnt->getID());
}
TEST_F(GeoLibOctTree, TestOctTreeWithTwoEqualPoints)
{
- ps_ptr.push_back(new GeoLib::Point(0,0,0,0));
- ps_ptr.push_back(new GeoLib::Point(0,0,0,1));
- double const eps(0.0);
-
- GeoLib::AABB aabb(ps_ptr.begin(), ps_ptr.end());
- std::unique_ptr<GeoLib::OctTree<GeoLib::Point, 2>> oct_tree(
- GeoLib::OctTree<GeoLib::Point, 2>::createOctTree(
- aabb.getMinPoint(), aabb.getMaxPoint(), eps));
-
- GeoLib::Point * ret_pnt(nullptr);
- ASSERT_TRUE(oct_tree->addPoint(ps_ptr[0], ret_pnt));
- ASSERT_EQ(ps_ptr[0], ret_pnt);
- ASSERT_FALSE(oct_tree->addPoint(ps_ptr[1], ret_pnt));
- ASSERT_EQ(ps_ptr[0], ret_pnt);
+ ps_ptr.push_back(new GeoLib::Point(0,0,0,0));
+ ps_ptr.push_back(new GeoLib::Point(0,0,0,1));
+ double const eps(0.0);
+
+ GeoLib::AABB aabb(ps_ptr.begin(), ps_ptr.end());
+ std::unique_ptr<GeoLib::OctTree<GeoLib::Point, 2>> oct_tree(
+ GeoLib::OctTree<GeoLib::Point, 2>::createOctTree(
+ aabb.getMinPoint(), aabb.getMaxPoint(), eps));
+
+ GeoLib::Point * ret_pnt(nullptr);
+ ASSERT_TRUE(oct_tree->addPoint(ps_ptr[0], ret_pnt));
+ ASSERT_EQ(ps_ptr[0], ret_pnt);
+ ASSERT_FALSE(oct_tree->addPoint(ps_ptr[1], ret_pnt));
+ ASSERT_EQ(ps_ptr[0], ret_pnt);
}
TEST_F(GeoLibOctTree, TestOctTreeWithTwoEqualPointsOne)
{
- ps_ptr.push_back(new GeoLib::Point(1,1,1,0));
- ps_ptr.push_back(new GeoLib::Point(1,1,1,1));
- double const eps(0.0);
-
- GeoLib::AABB aabb(ps_ptr.begin(), ps_ptr.end());
- std::unique_ptr<GeoLib::OctTree<GeoLib::Point, 2>> oct_tree(
- GeoLib::OctTree<GeoLib::Point, 2>::createOctTree(
- aabb.getMinPoint(), aabb.getMaxPoint(), eps));
-
- GeoLib::Point * ret_pnt(nullptr);
- ASSERT_TRUE(oct_tree->addPoint(ps_ptr[0], ret_pnt));
- ASSERT_EQ(ps_ptr[0], ret_pnt);
- ASSERT_FALSE(oct_tree->addPoint(ps_ptr[1], ret_pnt));
- ASSERT_EQ(ps_ptr[0], ret_pnt);
+ ps_ptr.push_back(new GeoLib::Point(1,1,1,0));
+ ps_ptr.push_back(new GeoLib::Point(1,1,1,1));
+ double const eps(0.0);
+
+ GeoLib::AABB aabb(ps_ptr.begin(), ps_ptr.end());
+ std::unique_ptr<GeoLib::OctTree<GeoLib::Point, 2>> oct_tree(
+ GeoLib::OctTree<GeoLib::Point, 2>::createOctTree(
+ aabb.getMinPoint(), aabb.getMaxPoint(), eps));
+
+ GeoLib::Point * ret_pnt(nullptr);
+ ASSERT_TRUE(oct_tree->addPoint(ps_ptr[0], ret_pnt));
+ ASSERT_EQ(ps_ptr[0], ret_pnt);
+ ASSERT_FALSE(oct_tree->addPoint(ps_ptr[1], ret_pnt));
+ ASSERT_EQ(ps_ptr[0], ret_pnt);
}
TEST_F(GeoLibOctTree, TestOctTreeOnCubicDomain)
{
- ps_ptr.push_back(new GeoLib::Point(-1,-1,-1,0));
- ps_ptr.push_back(new GeoLib::Point(1,1,1,1));
- double const eps(0.0);
-
- GeoLib::AABB aabb(ps_ptr.begin(), ps_ptr.end());
- std::unique_ptr<GeoLib::OctTree<GeoLib::Point, 2>> oct_tree(
- GeoLib::OctTree<GeoLib::Point, 2>::createOctTree(
- aabb.getMinPoint(), aabb.getMaxPoint(), eps));
-
- GeoLib::Point * ret_pnt(nullptr);
- ASSERT_TRUE(oct_tree->addPoint(ps_ptr[0], ret_pnt));
- ASSERT_EQ(ps_ptr[0], ret_pnt);
- ASSERT_TRUE(oct_tree->addPoint(ps_ptr[1], ret_pnt));
- ASSERT_EQ(ps_ptr[1], ret_pnt);
+ ps_ptr.push_back(new GeoLib::Point(-1,-1,-1,0));
+ ps_ptr.push_back(new GeoLib::Point(1,1,1,1));
+ double const eps(0.0);
+
+ GeoLib::AABB aabb(ps_ptr.begin(), ps_ptr.end());
+ std::unique_ptr<GeoLib::OctTree<GeoLib::Point, 2>> oct_tree(
+ GeoLib::OctTree<GeoLib::Point, 2>::createOctTree(
+ aabb.getMinPoint(), aabb.getMaxPoint(), eps));
+
+ GeoLib::Point * ret_pnt(nullptr);
+ ASSERT_TRUE(oct_tree->addPoint(ps_ptr[0], ret_pnt));
+ ASSERT_EQ(ps_ptr[0], ret_pnt);
+ ASSERT_TRUE(oct_tree->addPoint(ps_ptr[1], ret_pnt));
+ ASSERT_EQ(ps_ptr[1], ret_pnt);
}
diff --git a/Tests/GeoLib/TestParallel.cpp b/Tests/GeoLib/TestParallel.cpp
index d51566b97a7e3c030ca91b374e39413ee19ed01a..bbe4cd6d90b15c12c4781a457858a1327e571a93 100644
--- a/Tests/GeoLib/TestParallel.cpp
+++ b/Tests/GeoLib/TestParallel.cpp
@@ -16,36 +16,36 @@
TEST(GeoLib, TestParallel)
{
- // parallel vectors
- MathLib::Vector3 v(0.0, 1.0, 2.0);
- MathLib::Vector3 w(0.0, 2.0, 4.0);
- EXPECT_TRUE(GeoLib::parallel(v,w));
- EXPECT_TRUE(GeoLib::parallel(w,v));
-
- v[1] = 0.0;
- w[1] = 0.0;
- EXPECT_TRUE(GeoLib::parallel(v,w));
- EXPECT_TRUE(GeoLib::parallel(w,v));
-
- // degenerate cases
- v[2] = 0.0;
- w[2] = 0.0;
- EXPECT_FALSE(GeoLib::parallel(v,w));
- EXPECT_FALSE(GeoLib::parallel(w,v));
-
- w[2] = 0.1;
- EXPECT_FALSE(GeoLib::parallel(v,w));
- EXPECT_FALSE(GeoLib::parallel(w,v));
-
- // non-parallel case
- v[1] = 0.1;
- EXPECT_FALSE(GeoLib::parallel(v,w));
- EXPECT_FALSE(GeoLib::parallel(w,v));
-
- // parallel vectors, opposite sense of direction
- v[0] = 0.0; v[1] = 1.0; v[2] = 2.0;
- w[0] = 0.0; w[1] = -2.0; w[2] = -4.0;
- EXPECT_TRUE(GeoLib::parallel(v,w));
- EXPECT_TRUE(GeoLib::parallel(w,v));
+ // parallel vectors
+ MathLib::Vector3 v(0.0, 1.0, 2.0);
+ MathLib::Vector3 w(0.0, 2.0, 4.0);
+ EXPECT_TRUE(GeoLib::parallel(v,w));
+ EXPECT_TRUE(GeoLib::parallel(w,v));
+
+ v[1] = 0.0;
+ w[1] = 0.0;
+ EXPECT_TRUE(GeoLib::parallel(v,w));
+ EXPECT_TRUE(GeoLib::parallel(w,v));
+
+ // degenerate cases
+ v[2] = 0.0;
+ w[2] = 0.0;
+ EXPECT_FALSE(GeoLib::parallel(v,w));
+ EXPECT_FALSE(GeoLib::parallel(w,v));
+
+ w[2] = 0.1;
+ EXPECT_FALSE(GeoLib::parallel(v,w));
+ EXPECT_FALSE(GeoLib::parallel(w,v));
+
+ // non-parallel case
+ v[1] = 0.1;
+ EXPECT_FALSE(GeoLib::parallel(v,w));
+ EXPECT_FALSE(GeoLib::parallel(w,v));
+
+ // parallel vectors, opposite sense of direction
+ v[0] = 0.0; v[1] = 1.0; v[2] = 2.0;
+ w[0] = 0.0; w[1] = -2.0; w[2] = -4.0;
+ EXPECT_TRUE(GeoLib::parallel(v,w));
+ EXPECT_TRUE(GeoLib::parallel(w,v));
}
diff --git a/Tests/GeoLib/TestPointVec.cpp b/Tests/GeoLib/TestPointVec.cpp
index 54d31a4995df3f1a8ae3ebff2808ce6f96163d26..575b9e2927b17d1b9daacd6b27c86887a8dd24b6 100644
--- a/Tests/GeoLib/TestPointVec.cpp
+++ b/Tests/GeoLib/TestPointVec.cpp
@@ -15,192 +15,192 @@
class PointVecTest : public testing::Test
{
public:
- typedef std::vector<GeoLib::Point*> VectorOfPoints;
+ typedef std::vector<GeoLib::Point*> VectorOfPoints;
- PointVecTest()
- : gen(std::random_device() ()), name("JustAName")
- {
- }
+ PointVecTest()
+ : gen(std::random_device() ()), name("JustAName")
+ {
+ }
protected:
- // Generates n new points according to given random number distribution,
- // which is uniform distribution in [-1, 1]^3.
- void
- generateRandomPoints(VectorOfPoints& ps, std::size_t const n = 1000)
- {
- std::uniform_real_distribution<double> rnd(-1, 1);
- std::generate_n(std::back_inserter(ps), n,
- [&]() {
- return new GeoLib::Point(rnd(gen), rnd(gen), rnd(gen), ps.size());
- });
- }
+ // Generates n new points according to given random number distribution,
+ // which is uniform distribution in [-1, 1]^3.
+ void
+ generateRandomPoints(VectorOfPoints& ps, std::size_t const n = 1000)
+ {
+ std::uniform_real_distribution<double> rnd(-1, 1);
+ std::generate_n(std::back_inserter(ps), n,
+ [&]() {
+ return new GeoLib::Point(rnd(gen), rnd(gen), rnd(gen), ps.size());
+ });
+ }
protected:
- std::mt19937 gen;
- const std::string name;
+ std::mt19937 gen;
+ const std::string name;
};
// Testing nullptr input vector.
TEST_F(PointVecTest, TestPointVecCtorNullptr)
{
- ASSERT_DEATH(GeoLib::PointVec(name, nullptr), "");
+ ASSERT_DEATH(GeoLib::PointVec(name, nullptr), "");
}
// Testing empty input vector.
TEST_F(PointVecTest, TestPointVecCtorEmpty)
{
- auto ps_ptr = std::unique_ptr<VectorOfPoints>(new VectorOfPoints);
- ASSERT_DEATH(GeoLib::PointVec(name, std::move(ps_ptr)), "");
+ auto ps_ptr = std::unique_ptr<VectorOfPoints>(new VectorOfPoints);
+ ASSERT_DEATH(GeoLib::PointVec(name, std::move(ps_ptr)), "");
}
// Testing input vector with single point.
TEST_F(PointVecTest, TestPointVecCtorSinglePoint)
{
- auto ps_ptr = std::unique_ptr<VectorOfPoints>(new VectorOfPoints);
- ps_ptr->push_back(new GeoLib::Point(0,0,0,0));
- GeoLib::PointVec* point_vec = nullptr;
- point_vec = new GeoLib::PointVec(name, std::move(ps_ptr));
- ASSERT_EQ(std::size_t(1), point_vec->size());
+ auto ps_ptr = std::unique_ptr<VectorOfPoints>(new VectorOfPoints);
+ ps_ptr->push_back(new GeoLib::Point(0,0,0,0));
+ GeoLib::PointVec* point_vec = nullptr;
+ point_vec = new GeoLib::PointVec(name, std::move(ps_ptr));
+ ASSERT_EQ(std::size_t(1), point_vec->size());
- delete point_vec;
+ delete point_vec;
}
// Testing input vector with two different points.
TEST_F(PointVecTest, TestPointVecCtorTwoDiffPoints)
{
- auto ps_ptr = std::unique_ptr<VectorOfPoints>(new VectorOfPoints);
- ps_ptr->push_back(new GeoLib::Point(0,0,0,0));
- ps_ptr->push_back(new GeoLib::Point(1,0,0,1));
+ auto ps_ptr = std::unique_ptr<VectorOfPoints>(new VectorOfPoints);
+ ps_ptr->push_back(new GeoLib::Point(0,0,0,0));
+ ps_ptr->push_back(new GeoLib::Point(1,0,0,1));
- GeoLib::PointVec* point_vec = nullptr;
- point_vec = new GeoLib::PointVec(name, std::move(ps_ptr));
- ASSERT_EQ(std::size_t(2), point_vec->size());
+ GeoLib::PointVec* point_vec = nullptr;
+ point_vec = new GeoLib::PointVec(name, std::move(ps_ptr));
+ ASSERT_EQ(std::size_t(2), point_vec->size());
- delete point_vec;
+ delete point_vec;
}
// Testing input vector with two equal points.
TEST_F(PointVecTest, TestPointVecCtorTwoEqualPoints)
{
- auto ps_ptr = std::unique_ptr<VectorOfPoints>(new VectorOfPoints);
- ps_ptr->push_back(new GeoLib::Point(0,0,0,0));
- ps_ptr->push_back(new GeoLib::Point(0,0,0,1));
+ auto ps_ptr = std::unique_ptr<VectorOfPoints>(new VectorOfPoints);
+ ps_ptr->push_back(new GeoLib::Point(0,0,0,0));
+ ps_ptr->push_back(new GeoLib::Point(0,0,0,1));
- GeoLib::PointVec* point_vec = nullptr;
- point_vec = new GeoLib::PointVec(name, std::move(ps_ptr));
- ASSERT_EQ(std::size_t(1), point_vec->size());
+ GeoLib::PointVec* point_vec = nullptr;
+ point_vec = new GeoLib::PointVec(name, std::move(ps_ptr));
+ ASSERT_EQ(std::size_t(1), point_vec->size());
- delete point_vec;
+ delete point_vec;
}
// Testing input vector with single point.
TEST_F(PointVecTest, TestPointVecPushBack)
{
- auto ps_ptr = std::unique_ptr<VectorOfPoints>(new VectorOfPoints);
- ps_ptr->push_back(new GeoLib::Point(0,0,0,0));
- ps_ptr->push_back(new GeoLib::Point(1,0,0,1));
- ps_ptr->push_back(new GeoLib::Point(0,1,0,2));
- ps_ptr->push_back(new GeoLib::Point(0,0,1,3));
- GeoLib::PointVec point_vec(name, std::move(ps_ptr));
-
- ASSERT_EQ(std::size_t(0), point_vec.getIDMap()[0]);
- ASSERT_EQ(std::size_t(1), point_vec.getIDMap()[1]);
- ASSERT_EQ(std::size_t(2), point_vec.getIDMap()[2]);
- ASSERT_EQ(std::size_t(3), point_vec.getIDMap()[3]);
-
- // Adding some points that are already existing.
- ASSERT_EQ(std::size_t(0), point_vec.push_back(new GeoLib::Point(0,0,0,4)));
- ASSERT_EQ(std::size_t(1), point_vec.push_back(new GeoLib::Point(1,0,0,5)));
- ASSERT_EQ(std::size_t(2), point_vec.push_back(new GeoLib::Point(0,1,0,6)));
- ASSERT_EQ(std::size_t(3), point_vec.push_back(new GeoLib::Point(0,0,1,7)));
-
- ASSERT_EQ(std::size_t(4), point_vec.size());
- ASSERT_EQ(std::size_t(8), point_vec.getIDMap().size());
-
- ASSERT_EQ(std::size_t(0), point_vec.getIDMap()[4]);
- ASSERT_EQ(std::size_t(1), point_vec.getIDMap()[5]);
- ASSERT_EQ(std::size_t(2), point_vec.getIDMap()[6]);
- ASSERT_EQ(std::size_t(3), point_vec.getIDMap()[7]);
-
- // Adding again some already existing points.
- ASSERT_EQ(std::size_t(0), point_vec.push_back(new GeoLib::Point(0,0,0,8)));
- ASSERT_EQ(std::size_t(1), point_vec.push_back(new GeoLib::Point(1,0,0,9)));
- ASSERT_EQ(std::size_t(2), point_vec.push_back(new GeoLib::Point(0,1,0,10)));
- ASSERT_EQ(std::size_t(3), point_vec.push_back(new GeoLib::Point(0,0,1,11)));
-
- ASSERT_EQ(std::size_t(4), point_vec.size());
- ASSERT_EQ(std::size_t(12), point_vec.getIDMap().size());
-
- ASSERT_EQ(std::size_t(0), point_vec.getIDMap()[8]);
- ASSERT_EQ(std::size_t(1), point_vec.getIDMap()[9]);
- ASSERT_EQ(std::size_t(2), point_vec.getIDMap()[10]);
- ASSERT_EQ(std::size_t(3), point_vec.getIDMap()[11]);
-
- // Adding some new points.
- ASSERT_EQ(std::size_t(4), point_vec.push_back(new GeoLib::Point(0.1,0.1,0.1,12)));
- ASSERT_EQ(std::size_t(5), point_vec.push_back(new GeoLib::Point(1.1,0.1,0.1,13)));
- ASSERT_EQ(std::size_t(6), point_vec.push_back(new GeoLib::Point(0.1,1.1,0.1,14)));
- ASSERT_EQ(std::size_t(7), point_vec.push_back(new GeoLib::Point(0.1,0.1,1.1,15)));
-
- ASSERT_EQ(std::size_t(8), point_vec.size());
- ASSERT_EQ(std::size_t(16), point_vec.getIDMap().size());
-
- ASSERT_EQ(std::size_t(4), point_vec.getIDMap()[12]);
- ASSERT_EQ(std::size_t(5), point_vec.getIDMap()[13]);
- ASSERT_EQ(std::size_t(6), point_vec.getIDMap()[14]);
- ASSERT_EQ(std::size_t(7), point_vec.getIDMap()[15]);
-
- // Adding again some already existing points.
- ASSERT_EQ(std::size_t(0), point_vec.push_back(new GeoLib::Point(0,0,0,16)));
- ASSERT_EQ(std::size_t(1), point_vec.push_back(new GeoLib::Point(1,0,0,17)));
- ASSERT_EQ(std::size_t(2), point_vec.push_back(new GeoLib::Point(0,1,0,18)));
- ASSERT_EQ(std::size_t(3), point_vec.push_back(new GeoLib::Point(0,0,1,19)));
-
- ASSERT_EQ(std::size_t(8), point_vec.size());
- ASSERT_EQ(std::size_t(20), point_vec.getIDMap().size());
-
- ASSERT_EQ(std::size_t(0), point_vec.getIDMap()[16]);
- ASSERT_EQ(std::size_t(1), point_vec.getIDMap()[17]);
- ASSERT_EQ(std::size_t(2), point_vec.getIDMap()[18]);
- ASSERT_EQ(std::size_t(3), point_vec.getIDMap()[19]);
-
- ASSERT_EQ(std::size_t(0), point_vec.getIDMap()[0]);
- ASSERT_EQ(std::size_t(1), point_vec.getIDMap()[1]);
- ASSERT_EQ(std::size_t(2), point_vec.getIDMap()[2]);
- ASSERT_EQ(std::size_t(3), point_vec.getIDMap()[3]);
- ASSERT_EQ(std::size_t(0), point_vec.getIDMap()[4]);
- ASSERT_EQ(std::size_t(1), point_vec.getIDMap()[5]);
- ASSERT_EQ(std::size_t(2), point_vec.getIDMap()[6]);
- ASSERT_EQ(std::size_t(3), point_vec.getIDMap()[7]);
- ASSERT_EQ(std::size_t(0), point_vec.getIDMap()[8]);
- ASSERT_EQ(std::size_t(1), point_vec.getIDMap()[9]);
- ASSERT_EQ(std::size_t(2), point_vec.getIDMap()[10]);
- ASSERT_EQ(std::size_t(3), point_vec.getIDMap()[11]);
- ASSERT_EQ(std::size_t(4), point_vec.getIDMap()[12]);
- ASSERT_EQ(std::size_t(5), point_vec.getIDMap()[13]);
- ASSERT_EQ(std::size_t(6), point_vec.getIDMap()[14]);
- ASSERT_EQ(std::size_t(7), point_vec.getIDMap()[15]);
+ auto ps_ptr = std::unique_ptr<VectorOfPoints>(new VectorOfPoints);
+ ps_ptr->push_back(new GeoLib::Point(0,0,0,0));
+ ps_ptr->push_back(new GeoLib::Point(1,0,0,1));
+ ps_ptr->push_back(new GeoLib::Point(0,1,0,2));
+ ps_ptr->push_back(new GeoLib::Point(0,0,1,3));
+ GeoLib::PointVec point_vec(name, std::move(ps_ptr));
+
+ ASSERT_EQ(std::size_t(0), point_vec.getIDMap()[0]);
+ ASSERT_EQ(std::size_t(1), point_vec.getIDMap()[1]);
+ ASSERT_EQ(std::size_t(2), point_vec.getIDMap()[2]);
+ ASSERT_EQ(std::size_t(3), point_vec.getIDMap()[3]);
+
+ // Adding some points that are already existing.
+ ASSERT_EQ(std::size_t(0), point_vec.push_back(new GeoLib::Point(0,0,0,4)));
+ ASSERT_EQ(std::size_t(1), point_vec.push_back(new GeoLib::Point(1,0,0,5)));
+ ASSERT_EQ(std::size_t(2), point_vec.push_back(new GeoLib::Point(0,1,0,6)));
+ ASSERT_EQ(std::size_t(3), point_vec.push_back(new GeoLib::Point(0,0,1,7)));
+
+ ASSERT_EQ(std::size_t(4), point_vec.size());
+ ASSERT_EQ(std::size_t(8), point_vec.getIDMap().size());
+
+ ASSERT_EQ(std::size_t(0), point_vec.getIDMap()[4]);
+ ASSERT_EQ(std::size_t(1), point_vec.getIDMap()[5]);
+ ASSERT_EQ(std::size_t(2), point_vec.getIDMap()[6]);
+ ASSERT_EQ(std::size_t(3), point_vec.getIDMap()[7]);
+
+ // Adding again some already existing points.
+ ASSERT_EQ(std::size_t(0), point_vec.push_back(new GeoLib::Point(0,0,0,8)));
+ ASSERT_EQ(std::size_t(1), point_vec.push_back(new GeoLib::Point(1,0,0,9)));
+ ASSERT_EQ(std::size_t(2), point_vec.push_back(new GeoLib::Point(0,1,0,10)));
+ ASSERT_EQ(std::size_t(3), point_vec.push_back(new GeoLib::Point(0,0,1,11)));
+
+ ASSERT_EQ(std::size_t(4), point_vec.size());
+ ASSERT_EQ(std::size_t(12), point_vec.getIDMap().size());
+
+ ASSERT_EQ(std::size_t(0), point_vec.getIDMap()[8]);
+ ASSERT_EQ(std::size_t(1), point_vec.getIDMap()[9]);
+ ASSERT_EQ(std::size_t(2), point_vec.getIDMap()[10]);
+ ASSERT_EQ(std::size_t(3), point_vec.getIDMap()[11]);
+
+ // Adding some new points.
+ ASSERT_EQ(std::size_t(4), point_vec.push_back(new GeoLib::Point(0.1,0.1,0.1,12)));
+ ASSERT_EQ(std::size_t(5), point_vec.push_back(new GeoLib::Point(1.1,0.1,0.1,13)));
+ ASSERT_EQ(std::size_t(6), point_vec.push_back(new GeoLib::Point(0.1,1.1,0.1,14)));
+ ASSERT_EQ(std::size_t(7), point_vec.push_back(new GeoLib::Point(0.1,0.1,1.1,15)));
+
+ ASSERT_EQ(std::size_t(8), point_vec.size());
+ ASSERT_EQ(std::size_t(16), point_vec.getIDMap().size());
+
+ ASSERT_EQ(std::size_t(4), point_vec.getIDMap()[12]);
+ ASSERT_EQ(std::size_t(5), point_vec.getIDMap()[13]);
+ ASSERT_EQ(std::size_t(6), point_vec.getIDMap()[14]);
+ ASSERT_EQ(std::size_t(7), point_vec.getIDMap()[15]);
+
+ // Adding again some already existing points.
+ ASSERT_EQ(std::size_t(0), point_vec.push_back(new GeoLib::Point(0,0,0,16)));
+ ASSERT_EQ(std::size_t(1), point_vec.push_back(new GeoLib::Point(1,0,0,17)));
+ ASSERT_EQ(std::size_t(2), point_vec.push_back(new GeoLib::Point(0,1,0,18)));
+ ASSERT_EQ(std::size_t(3), point_vec.push_back(new GeoLib::Point(0,0,1,19)));
+
+ ASSERT_EQ(std::size_t(8), point_vec.size());
+ ASSERT_EQ(std::size_t(20), point_vec.getIDMap().size());
+
+ ASSERT_EQ(std::size_t(0), point_vec.getIDMap()[16]);
+ ASSERT_EQ(std::size_t(1), point_vec.getIDMap()[17]);
+ ASSERT_EQ(std::size_t(2), point_vec.getIDMap()[18]);
+ ASSERT_EQ(std::size_t(3), point_vec.getIDMap()[19]);
+
+ ASSERT_EQ(std::size_t(0), point_vec.getIDMap()[0]);
+ ASSERT_EQ(std::size_t(1), point_vec.getIDMap()[1]);
+ ASSERT_EQ(std::size_t(2), point_vec.getIDMap()[2]);
+ ASSERT_EQ(std::size_t(3), point_vec.getIDMap()[3]);
+ ASSERT_EQ(std::size_t(0), point_vec.getIDMap()[4]);
+ ASSERT_EQ(std::size_t(1), point_vec.getIDMap()[5]);
+ ASSERT_EQ(std::size_t(2), point_vec.getIDMap()[6]);
+ ASSERT_EQ(std::size_t(3), point_vec.getIDMap()[7]);
+ ASSERT_EQ(std::size_t(0), point_vec.getIDMap()[8]);
+ ASSERT_EQ(std::size_t(1), point_vec.getIDMap()[9]);
+ ASSERT_EQ(std::size_t(2), point_vec.getIDMap()[10]);
+ ASSERT_EQ(std::size_t(3), point_vec.getIDMap()[11]);
+ ASSERT_EQ(std::size_t(4), point_vec.getIDMap()[12]);
+ ASSERT_EQ(std::size_t(5), point_vec.getIDMap()[13]);
+ ASSERT_EQ(std::size_t(6), point_vec.getIDMap()[14]);
+ ASSERT_EQ(std::size_t(7), point_vec.getIDMap()[15]);
}
// Testing random input points.
TEST_F(PointVecTest, TestPointVecCtorRandomPoints)
{
- auto ps_ptr = std::unique_ptr<VectorOfPoints>(new VectorOfPoints);
- generateRandomPoints(*ps_ptr, 10000);
+ auto ps_ptr = std::unique_ptr<VectorOfPoints>(new VectorOfPoints);
+ generateRandomPoints(*ps_ptr, 10000);
- GeoLib::PointVec* point_vec = nullptr;
- point_vec = new GeoLib::PointVec(name, std::move(ps_ptr));
+ GeoLib::PointVec* point_vec = nullptr;
+ point_vec = new GeoLib::PointVec(name, std::move(ps_ptr));
- delete point_vec;
+ delete point_vec;
}
TEST_F(PointVecTest, TestPointVecCtorRandomPointsLargeEps)
{
- auto ps_ptr = std::unique_ptr<VectorOfPoints>(new VectorOfPoints);
- generateRandomPoints(*ps_ptr, 10000);
+ auto ps_ptr = std::unique_ptr<VectorOfPoints>(new VectorOfPoints);
+ generateRandomPoints(*ps_ptr, 10000);
- GeoLib::PointVec* point_vec = nullptr;
- point_vec = new GeoLib::PointVec(name, std::move(ps_ptr),
- nullptr, GeoLib::PointVec::PointType::POINT, 1e-2);
+ GeoLib::PointVec* point_vec = nullptr;
+ point_vec = new GeoLib::PointVec(name, std::move(ps_ptr),
+ nullptr, GeoLib::PointVec::PointType::POINT, 1e-2);
- delete point_vec;
+ delete point_vec;
}
diff --git a/Tests/GeoLib/TestPointsOnAPlane.cpp b/Tests/GeoLib/TestPointsOnAPlane.cpp
index 8153ac662a9946f0e580ffcbc731a91c016fc52b..a2d1dbcb2d872de1e263bd106da7fb33a0391c4f 100644
--- a/Tests/GeoLib/TestPointsOnAPlane.cpp
+++ b/Tests/GeoLib/TestPointsOnAPlane.cpp
@@ -21,95 +21,95 @@
#include "GeoLib/Point.h"
void testAllPossibilities(
- GeoLib::Point const& a,
- GeoLib::Point const& b,
- GeoLib::Point const& c,
- GeoLib::Point const& d,
- bool expected)
+ GeoLib::Point const& a,
+ GeoLib::Point const& b,
+ GeoLib::Point const& c,
+ GeoLib::Point const& d,
+ bool expected)
{
- ASSERT_EQ(expected, GeoLib::isCoplanar(a, b, c, d));
- ASSERT_EQ(expected, GeoLib::isCoplanar(a, b, d, c));
- ASSERT_EQ(expected, GeoLib::isCoplanar(a, c, b, d));
- ASSERT_EQ(expected, GeoLib::isCoplanar(a, c, d, b));
- ASSERT_EQ(expected, GeoLib::isCoplanar(a, d, b, c));
- ASSERT_EQ(expected, GeoLib::isCoplanar(a, d, c, b));
-
- ASSERT_EQ(expected, GeoLib::isCoplanar(b, a, c, d));
- ASSERT_EQ(expected, GeoLib::isCoplanar(b, a, d, c));
- ASSERT_EQ(expected, GeoLib::isCoplanar(b, c, a, d));
- ASSERT_EQ(expected, GeoLib::isCoplanar(b, c, d, a));
- ASSERT_EQ(expected, GeoLib::isCoplanar(b, d, a, c));
- ASSERT_EQ(expected, GeoLib::isCoplanar(b, d, c, a));
-
- ASSERT_EQ(expected, GeoLib::isCoplanar(c, b, a, d));
- ASSERT_EQ(expected, GeoLib::isCoplanar(c, b, d, a));
- ASSERT_EQ(expected, GeoLib::isCoplanar(c, a, b, d));
- ASSERT_EQ(expected, GeoLib::isCoplanar(c, a, d, b));
- ASSERT_EQ(expected, GeoLib::isCoplanar(c, d, b, a));
- ASSERT_EQ(expected, GeoLib::isCoplanar(c, d, a, b));
-
- ASSERT_EQ(expected, GeoLib::isCoplanar(d, b, c, a));
- ASSERT_EQ(expected, GeoLib::isCoplanar(d, b, a, c));
- ASSERT_EQ(expected, GeoLib::isCoplanar(d, c, b, a));
- ASSERT_EQ(expected, GeoLib::isCoplanar(d, c, a, b));
- ASSERT_EQ(expected, GeoLib::isCoplanar(d, a, b, c));
- ASSERT_EQ(expected, GeoLib::isCoplanar(d, a, c, b));
+ ASSERT_EQ(expected, GeoLib::isCoplanar(a, b, c, d));
+ ASSERT_EQ(expected, GeoLib::isCoplanar(a, b, d, c));
+ ASSERT_EQ(expected, GeoLib::isCoplanar(a, c, b, d));
+ ASSERT_EQ(expected, GeoLib::isCoplanar(a, c, d, b));
+ ASSERT_EQ(expected, GeoLib::isCoplanar(a, d, b, c));
+ ASSERT_EQ(expected, GeoLib::isCoplanar(a, d, c, b));
+
+ ASSERT_EQ(expected, GeoLib::isCoplanar(b, a, c, d));
+ ASSERT_EQ(expected, GeoLib::isCoplanar(b, a, d, c));
+ ASSERT_EQ(expected, GeoLib::isCoplanar(b, c, a, d));
+ ASSERT_EQ(expected, GeoLib::isCoplanar(b, c, d, a));
+ ASSERT_EQ(expected, GeoLib::isCoplanar(b, d, a, c));
+ ASSERT_EQ(expected, GeoLib::isCoplanar(b, d, c, a));
+
+ ASSERT_EQ(expected, GeoLib::isCoplanar(c, b, a, d));
+ ASSERT_EQ(expected, GeoLib::isCoplanar(c, b, d, a));
+ ASSERT_EQ(expected, GeoLib::isCoplanar(c, a, b, d));
+ ASSERT_EQ(expected, GeoLib::isCoplanar(c, a, d, b));
+ ASSERT_EQ(expected, GeoLib::isCoplanar(c, d, b, a));
+ ASSERT_EQ(expected, GeoLib::isCoplanar(c, d, a, b));
+
+ ASSERT_EQ(expected, GeoLib::isCoplanar(d, b, c, a));
+ ASSERT_EQ(expected, GeoLib::isCoplanar(d, b, a, c));
+ ASSERT_EQ(expected, GeoLib::isCoplanar(d, c, b, a));
+ ASSERT_EQ(expected, GeoLib::isCoplanar(d, c, a, b));
+ ASSERT_EQ(expected, GeoLib::isCoplanar(d, a, b, c));
+ ASSERT_EQ(expected, GeoLib::isCoplanar(d, a, c, b));
}
TEST(GeoLib, TestPointsOnAPlane)
{
- // 2d case
- GeoLib::Point a(0,0,0);
- GeoLib::Point b(1,0,0);
- GeoLib::Point c(0,1,0);
- GeoLib::Point d(1,1,0);
- testAllPossibilities(a, b, c, d, true);
-
- // disturbe z coordinate of point d
- d[2] = 1e6*std::numeric_limits<double>::epsilon();
- testAllPossibilities(a, b, c, d, true);
-
- // disturbe z coordinate of point d
- d[2] = 1e-9;
- testAllPossibilities(a, b, c, d, true);
- d[2] = 1e-6;
- testAllPossibilities(a, b, c, d, true);
- d[2] = 1e-5;
- testAllPossibilities(a, b, c, d, false);
-
- // irregular case: a = d = ORIGIN
- d = GeoLib::Point(0.0, 0.0, 0.0);
- testAllPossibilities(a, b, c, d, true);
-
- // irregular case: a = b = d = ORIGIN
- b = GeoLib::Point(0.0, 0.0, 0.0);
- testAllPossibilities(a, b, c, d, true);
-
- // irregular case: a = b = c = d
- c = GeoLib::Point(0.0, 0.0, 0.0);
- testAllPossibilities(a, b, c, d, true);
-
- // 2d case with fixed z
- a = GeoLib::Point(0.0, 0.0, 0.3);
- b = GeoLib::Point(1e-5, 0.0, 0.3);
- c = GeoLib::Point(0.0, 1e-5, 0.3);
- d = GeoLib::Point(1e-5, 1e-5, 0.3);
- testAllPossibilities(a, b, c, d, true);
-
- // a,b,c with random coordinates,
- std::uniform_real_distribution<double> distri(-1e10, 1e10);
- std::default_random_engine re;
- for (std::size_t k(0); k<1000; k++) {
- a = GeoLib::Point(distri(re), distri(re), distri(re));
- b = GeoLib::Point(distri(re), distri(re), distri(re));
- c = GeoLib::Point(distri(re), distri(re), distri(re));
- // d such that it is in the plane
- d = GeoLib::Point(b[0]+c[0]-a[0], b[1]+c[1]-a[1], b[2]+c[2]-a[2]);
- testAllPossibilities(a, b, c, d, true);
- // d such that it is not in the plane
- d[2] = std::numeric_limits<double>::epsilon() +
- (1 + std::numeric_limits<double>::epsilon())*(b[2]+c[2]);
- testAllPossibilities(a, b, c, d, false);
- }
+ // 2d case
+ GeoLib::Point a(0,0,0);
+ GeoLib::Point b(1,0,0);
+ GeoLib::Point c(0,1,0);
+ GeoLib::Point d(1,1,0);
+ testAllPossibilities(a, b, c, d, true);
+
+ // disturbe z coordinate of point d
+ d[2] = 1e6*std::numeric_limits<double>::epsilon();
+ testAllPossibilities(a, b, c, d, true);
+
+ // disturbe z coordinate of point d
+ d[2] = 1e-9;
+ testAllPossibilities(a, b, c, d, true);
+ d[2] = 1e-6;
+ testAllPossibilities(a, b, c, d, true);
+ d[2] = 1e-5;
+ testAllPossibilities(a, b, c, d, false);
+
+ // irregular case: a = d = ORIGIN
+ d = GeoLib::Point(0.0, 0.0, 0.0);
+ testAllPossibilities(a, b, c, d, true);
+
+ // irregular case: a = b = d = ORIGIN
+ b = GeoLib::Point(0.0, 0.0, 0.0);
+ testAllPossibilities(a, b, c, d, true);
+
+ // irregular case: a = b = c = d
+ c = GeoLib::Point(0.0, 0.0, 0.0);
+ testAllPossibilities(a, b, c, d, true);
+
+ // 2d case with fixed z
+ a = GeoLib::Point(0.0, 0.0, 0.3);
+ b = GeoLib::Point(1e-5, 0.0, 0.3);
+ c = GeoLib::Point(0.0, 1e-5, 0.3);
+ d = GeoLib::Point(1e-5, 1e-5, 0.3);
+ testAllPossibilities(a, b, c, d, true);
+
+ // a,b,c with random coordinates,
+ std::uniform_real_distribution<double> distri(-1e10, 1e10);
+ std::default_random_engine re;
+ for (std::size_t k(0); k<1000; k++) {
+ a = GeoLib::Point(distri(re), distri(re), distri(re));
+ b = GeoLib::Point(distri(re), distri(re), distri(re));
+ c = GeoLib::Point(distri(re), distri(re), distri(re));
+ // d such that it is in the plane
+ d = GeoLib::Point(b[0]+c[0]-a[0], b[1]+c[1]-a[1], b[2]+c[2]-a[2]);
+ testAllPossibilities(a, b, c, d, true);
+ // d such that it is not in the plane
+ d[2] = std::numeric_limits<double>::epsilon() +
+ (1 + std::numeric_limits<double>::epsilon())*(b[2]+c[2]);
+ testAllPossibilities(a, b, c, d, false);
+ }
}
diff --git a/Tests/GeoLib/TestPolygon.cpp b/Tests/GeoLib/TestPolygon.cpp
index f986e105784bd0d50a520c4611d1105c2aa19b57..ce250a8135ce8cdcebb24e1803ac9519150f40f4 100644
--- a/Tests/GeoLib/TestPolygon.cpp
+++ b/Tests/GeoLib/TestPolygon.cpp
@@ -35,92 +35,92 @@
class PolygonTest : public testing::Test
{
public:
- PolygonTest() :
- _polygon(nullptr)
- {
- // create points and construct polygon
- _pnts.push_back(new GeoLib::Point( 0.0, 0.0,0.0)); // 0
- _pnts.push_back(new GeoLib::Point(-2.0, 2.0,0.0)); // 1
- _pnts.push_back(new GeoLib::Point(-2.0, 4.0,0.0)); // 2
- _pnts.push_back(new GeoLib::Point(-1.0, 2.0,0.0)); // 3
- _pnts.push_back(new GeoLib::Point( 0.0, 4.0,0.0)); // 4
- _pnts.push_back(new GeoLib::Point( 1.0, 2.0,0.0)); // 5
- _pnts.push_back(new GeoLib::Point( 2.0, 4.0,0.0)); // 6
- _pnts.push_back(new GeoLib::Point( 2.0, 2.0,0.0)); // 7
-
- // create closed polyline
- GeoLib::Polyline ply(_pnts);
- ply.addPoint(0);
- ply.addPoint(1);
- ply.addPoint(2);
- ply.addPoint(3);
- ply.addPoint(4);
- ply.addPoint(5);
- ply.addPoint(6);
- ply.addPoint(7);
- ply.addPoint(0);
-
- // create polygon
- _polygon = new GeoLib::Polygon(ply);
- }
-
- ~PolygonTest()
- {
- delete _polygon;
- for (std::size_t k(0); k<_pnts.size(); k++)
- delete _pnts[k];
- }
+ PolygonTest() :
+ _polygon(nullptr)
+ {
+ // create points and construct polygon
+ _pnts.push_back(new GeoLib::Point( 0.0, 0.0,0.0)); // 0
+ _pnts.push_back(new GeoLib::Point(-2.0, 2.0,0.0)); // 1
+ _pnts.push_back(new GeoLib::Point(-2.0, 4.0,0.0)); // 2
+ _pnts.push_back(new GeoLib::Point(-1.0, 2.0,0.0)); // 3
+ _pnts.push_back(new GeoLib::Point( 0.0, 4.0,0.0)); // 4
+ _pnts.push_back(new GeoLib::Point( 1.0, 2.0,0.0)); // 5
+ _pnts.push_back(new GeoLib::Point( 2.0, 4.0,0.0)); // 6
+ _pnts.push_back(new GeoLib::Point( 2.0, 2.0,0.0)); // 7
+
+ // create closed polyline
+ GeoLib::Polyline ply(_pnts);
+ ply.addPoint(0);
+ ply.addPoint(1);
+ ply.addPoint(2);
+ ply.addPoint(3);
+ ply.addPoint(4);
+ ply.addPoint(5);
+ ply.addPoint(6);
+ ply.addPoint(7);
+ ply.addPoint(0);
+
+ // create polygon
+ _polygon = new GeoLib::Polygon(ply);
+ }
+
+ ~PolygonTest()
+ {
+ delete _polygon;
+ for (std::size_t k(0); k<_pnts.size(); k++)
+ delete _pnts[k];
+ }
protected:
- std::vector<GeoLib::Point*> _pnts;
- GeoLib::Polygon *_polygon;
+ std::vector<GeoLib::Point*> _pnts;
+ GeoLib::Polygon *_polygon;
};
TEST_F(PolygonTest, isPntInPolygonCheckCorners)
{
- for (std::size_t k(0); k<_pnts.size(); k++)
- EXPECT_TRUE(_polygon->isPntInPolygon(*_pnts[k]));
+ for (std::size_t k(0); k<_pnts.size(); k++)
+ EXPECT_TRUE(_polygon->isPntInPolygon(*_pnts[k]));
}
TEST_F(PolygonTest, isPntInPolygonCheckPointsRestOnPolygonEdges)
{
- for (std::size_t k(0); k<_pnts.size()-1; k++) {
- for (double t(0.0); t<1.0; t+=0.001) {
- EXPECT_TRUE(_polygon->isPntInPolygon(
- GeoLib::Point(
- (*_pnts[k])[0] + t*((*_pnts[k+1])[0]-(*_pnts[k])[0]),
- (*_pnts[k])[1] + t*((*_pnts[k+1])[1]-(*_pnts[k])[1]),
- (*_pnts[k])[2] + t*((*_pnts[k+1])[2]-(*_pnts[k])[2])
- ))
- );
- }
- }
+ for (std::size_t k(0); k<_pnts.size()-1; k++) {
+ for (double t(0.0); t<1.0; t+=0.001) {
+ EXPECT_TRUE(_polygon->isPntInPolygon(
+ GeoLib::Point(
+ (*_pnts[k])[0] + t*((*_pnts[k+1])[0]-(*_pnts[k])[0]),
+ (*_pnts[k])[1] + t*((*_pnts[k+1])[1]-(*_pnts[k])[1]),
+ (*_pnts[k])[2] + t*((*_pnts[k+1])[2]-(*_pnts[k])[2])
+ ))
+ );
+ }
+ }
}
TEST_F(PolygonTest, isPntInPolygonCheckInnerPoints)
{
- ASSERT_TRUE(_polygon->isPntInPolygon(GeoLib::Point(1.0,1.0,0.0)));
- ASSERT_TRUE(_polygon->isPntInPolygon(GeoLib::Point(0.5,1.0,0.0)));
+ ASSERT_TRUE(_polygon->isPntInPolygon(GeoLib::Point(1.0,1.0,0.0)));
+ ASSERT_TRUE(_polygon->isPntInPolygon(GeoLib::Point(0.5,1.0,0.0)));
}
TEST_F(PolygonTest, isPntInPolygonCheckOuterPoints)
{
- ASSERT_FALSE(_polygon->isPntInPolygon(GeoLib::Point(
- 0.0-std::numeric_limits<float>::epsilon(),0.0,0.0)));
- ASSERT_FALSE(_polygon->isPntInPolygon(GeoLib::Point(
- -2.0-std::numeric_limits<float>::epsilon(),2.0,0.0)));
- ASSERT_FALSE(_polygon->isPntInPolygon(GeoLib::Point(
- -2.0-std::numeric_limits<float>::epsilon(),4.0,0.0)));
- ASSERT_FALSE(_polygon->isPntInPolygon(GeoLib::Point(
- -1.0, 2.0+std::numeric_limits<float>::epsilon(),0.0)));
- ASSERT_FALSE(_polygon->isPntInPolygon(GeoLib::Point(
- 0.0-std::numeric_limits<float>::epsilon(),4.0,0.0)));
- ASSERT_FALSE(_polygon->isPntInPolygon(GeoLib::Point(
- 1.0,2.0+std::numeric_limits<float>::epsilon(),0.0)));
- ASSERT_FALSE(_polygon->isPntInPolygon(GeoLib::Point(
- 2.0-std::numeric_limits<float>::epsilon(),4.0,0.0)));
- ASSERT_FALSE(_polygon->isPntInPolygon(GeoLib::Point(
- 2.0+std::numeric_limits<float>::epsilon(),2.0,0.0)));
+ ASSERT_FALSE(_polygon->isPntInPolygon(GeoLib::Point(
+ 0.0-std::numeric_limits<float>::epsilon(),0.0,0.0)));
+ ASSERT_FALSE(_polygon->isPntInPolygon(GeoLib::Point(
+ -2.0-std::numeric_limits<float>::epsilon(),2.0,0.0)));
+ ASSERT_FALSE(_polygon->isPntInPolygon(GeoLib::Point(
+ -2.0-std::numeric_limits<float>::epsilon(),4.0,0.0)));
+ ASSERT_FALSE(_polygon->isPntInPolygon(GeoLib::Point(
+ -1.0, 2.0+std::numeric_limits<float>::epsilon(),0.0)));
+ ASSERT_FALSE(_polygon->isPntInPolygon(GeoLib::Point(
+ 0.0-std::numeric_limits<float>::epsilon(),4.0,0.0)));
+ ASSERT_FALSE(_polygon->isPntInPolygon(GeoLib::Point(
+ 1.0,2.0+std::numeric_limits<float>::epsilon(),0.0)));
+ ASSERT_FALSE(_polygon->isPntInPolygon(GeoLib::Point(
+ 2.0-std::numeric_limits<float>::epsilon(),4.0,0.0)));
+ ASSERT_FALSE(_polygon->isPntInPolygon(GeoLib::Point(
+ 2.0+std::numeric_limits<float>::epsilon(),2.0,0.0)));
}
/**
@@ -138,80 +138,80 @@ TEST_F(PolygonTest, isPntInPolygonCheckOuterPoints)
*/
TEST_F(PolygonTest, containsSegment)
{
- { // test segment (2,6)
- GeoLib::LineSegment const segment{
- const_cast<GeoLib::Point*>(_polygon->getPoint(2)),
- const_cast<GeoLib::Point*>(_polygon->getPoint(6))};
- ASSERT_FALSE(_polygon->containsSegment(segment));
- }
-
- // test all segments of polygon
- for (auto segment_it(_polygon->begin()); segment_it != _polygon->end();
- ++segment_it)
- {
- EXPECT_TRUE(_polygon->containsSegment(*segment_it));
- }
-
- { // 70
- GeoLib::LineSegment const segment{
- const_cast<GeoLib::Point*>(_polygon->getPoint(7)),
- const_cast<GeoLib::Point*>(_polygon->getPoint(0))};
- ASSERT_TRUE(_polygon->containsSegment(segment));
- }
-
- { // test segment (3,5)
- GeoLib::LineSegment const segment{
- const_cast<GeoLib::Point*>(_polygon->getPoint(3)),
- const_cast<GeoLib::Point*>(_polygon->getPoint(5))};
- ASSERT_TRUE(_polygon->containsSegment(segment));
- }
-
- { // test segment (1,7)
- GeoLib::LineSegment const segment{
- const_cast<GeoLib::Point*>(_polygon->getPoint(1)),
- const_cast<GeoLib::Point*>(_polygon->getPoint(7))};
- ASSERT_TRUE(_polygon->containsSegment(segment));
- }
-
- { // test segment (1,4)
- GeoLib::LineSegment const segment{
- const_cast<GeoLib::Point*>(_polygon->getPoint(1)),
- const_cast<GeoLib::Point*>(_polygon->getPoint(4))};
- ASSERT_FALSE(_polygon->containsSegment(segment));
- }
+ { // test segment (2,6)
+ GeoLib::LineSegment const segment{
+ const_cast<GeoLib::Point*>(_polygon->getPoint(2)),
+ const_cast<GeoLib::Point*>(_polygon->getPoint(6))};
+ ASSERT_FALSE(_polygon->containsSegment(segment));
+ }
+
+ // test all segments of polygon
+ for (auto segment_it(_polygon->begin()); segment_it != _polygon->end();
+ ++segment_it)
+ {
+ EXPECT_TRUE(_polygon->containsSegment(*segment_it));
+ }
+
+ { // 70
+ GeoLib::LineSegment const segment{
+ const_cast<GeoLib::Point*>(_polygon->getPoint(7)),
+ const_cast<GeoLib::Point*>(_polygon->getPoint(0))};
+ ASSERT_TRUE(_polygon->containsSegment(segment));
+ }
+
+ { // test segment (3,5)
+ GeoLib::LineSegment const segment{
+ const_cast<GeoLib::Point*>(_polygon->getPoint(3)),
+ const_cast<GeoLib::Point*>(_polygon->getPoint(5))};
+ ASSERT_TRUE(_polygon->containsSegment(segment));
+ }
+
+ { // test segment (1,7)
+ GeoLib::LineSegment const segment{
+ const_cast<GeoLib::Point*>(_polygon->getPoint(1)),
+ const_cast<GeoLib::Point*>(_polygon->getPoint(7))};
+ ASSERT_TRUE(_polygon->containsSegment(segment));
+ }
+
+ { // test segment (1,4)
+ GeoLib::LineSegment const segment{
+ const_cast<GeoLib::Point*>(_polygon->getPoint(1)),
+ const_cast<GeoLib::Point*>(_polygon->getPoint(4))};
+ ASSERT_FALSE(_polygon->containsSegment(segment));
+ }
}
TEST_F(PolygonTest, isPolylineInPolygon)
{
- // create a test polyline
- std::vector<GeoLib::Point*> pnts;
- pnts.push_back(new GeoLib::Point(-2.0,4.0,0.0)); // 2
- pnts.push_back(new GeoLib::Point( 2.0,4.0,0.0)); // 6
- GeoLib::Polyline outer_ply(pnts);
- outer_ply.addPoint(0);
- outer_ply.addPoint(1);
- ASSERT_FALSE(_polygon->isPolylineInPolygon(outer_ply));
- for (std::size_t k(0); k<pnts.size(); k++)
- delete pnts[k];
- pnts.clear();
-
- pnts.push_back(new GeoLib::Point(-1.0,2.0,0.0)); // 3
- pnts.push_back(new GeoLib::Point( 1.0,2.0,0.0)); // 5
- GeoLib::Polyline inner_ply(pnts);
- inner_ply.addPoint(0);
- inner_ply.addPoint(1);
- ASSERT_TRUE(_polygon->isPolylineInPolygon(inner_ply));
- for (std::size_t k(0); k<pnts.size(); k++)
- delete pnts[k];
+ // create a test polyline
+ std::vector<GeoLib::Point*> pnts;
+ pnts.push_back(new GeoLib::Point(-2.0,4.0,0.0)); // 2
+ pnts.push_back(new GeoLib::Point( 2.0,4.0,0.0)); // 6
+ GeoLib::Polyline outer_ply(pnts);
+ outer_ply.addPoint(0);
+ outer_ply.addPoint(1);
+ ASSERT_FALSE(_polygon->isPolylineInPolygon(outer_ply));
+ for (std::size_t k(0); k<pnts.size(); k++)
+ delete pnts[k];
+ pnts.clear();
+
+ pnts.push_back(new GeoLib::Point(-1.0,2.0,0.0)); // 3
+ pnts.push_back(new GeoLib::Point( 1.0,2.0,0.0)); // 5
+ GeoLib::Polyline inner_ply(pnts);
+ inner_ply.addPoint(0);
+ inner_ply.addPoint(1);
+ ASSERT_TRUE(_polygon->isPolylineInPolygon(inner_ply));
+ for (std::size_t k(0); k<pnts.size(); k++)
+ delete pnts[k];
}
TEST_F(PolygonTest, CopyConstructor)
{
- GeoLib::Polygon polygon_copy(*_polygon);
- ASSERT_EQ(_polygon->getNumberOfSegments(), polygon_copy.getNumberOfSegments());
+ GeoLib::Polygon polygon_copy(*_polygon);
+ ASSERT_EQ(_polygon->getNumberOfSegments(), polygon_copy.getNumberOfSegments());
- // Check if all line segments of the original polygon are contained in the
- // copy
- for (auto const& segment : *_polygon)
- ASSERT_TRUE(polygon_copy.containsSegment(segment));
+ // Check if all line segments of the original polygon are contained in the
+ // copy
+ for (auto const& segment : *_polygon)
+ ASSERT_TRUE(polygon_copy.containsSegment(segment));
}
diff --git a/Tests/GeoLib/TestPolyline.cpp b/Tests/GeoLib/TestPolyline.cpp
index 28d031c366dd4c9ebcb7346c3814a9c89fae4b44..6265c9a17f91581587df1b5cda75ba740235eee5 100644
--- a/Tests/GeoLib/TestPolyline.cpp
+++ b/Tests/GeoLib/TestPolyline.cpp
@@ -18,97 +18,97 @@
TEST(GeoLib, PolylineTest)
{
- std::vector<GeoLib::Point*> ply_pnts;
- GeoLib::Polyline ply(ply_pnts);
-
- // checking properties of empty polyline
- ASSERT_EQ(std::size_t(0), ply.getNumberOfPoints());
- ASSERT_FALSE(ply.isClosed());
- ASSERT_FALSE(ply.isPointIDInPolyline(0));
- ASSERT_EQ(0.0, ply.getLength(0));
-
- ply_pnts.push_back(new GeoLib::Point(0.0, 0.0, 0.0));
- ply.addPoint(0);
- // checking properties of polyline with one point
- ASSERT_EQ(std::size_t(1), ply.getNumberOfPoints());
- ASSERT_FALSE(ply.isClosed());
- ASSERT_TRUE(ply.isPointIDInPolyline(0));
- ASSERT_EQ(0.0, ply.getLength(0));
-
- ply_pnts.push_back(new GeoLib::Point(1.0, 0.0, 0.0));
- ply.addPoint(1);
- // checking properties of polyline with two points
- ASSERT_EQ(std::size_t(2), ply.getNumberOfPoints());
- ASSERT_FALSE(ply.isClosed());
- ASSERT_TRUE(ply.isPointIDInPolyline(1));
- ASSERT_EQ(1.0, ply.getLength(1));
-
- // checking properties of polyline with two points
- ply_pnts.push_back(new GeoLib::Point(0.5, 0.5, 0.0));
- ply.addPoint(2);
- ASSERT_EQ(std::size_t(3), ply.getNumberOfPoints());
- ASSERT_FALSE(ply.isClosed());
- ASSERT_TRUE(ply.isPointIDInPolyline(2));
- ASSERT_TRUE(fabs(ply.getLength(2) - (1.0 + sqrt(0.5))) < std::numeric_limits<double>::epsilon());
-
- // checking remove
- ply.removePoint(1);
- ASSERT_EQ(std::size_t(2), ply.getNumberOfPoints());
- ASSERT_FALSE(ply.isClosed());
- ASSERT_FALSE(ply.isPointIDInPolyline(1));
- ASSERT_TRUE(fabs(ply.getLength(1) - sqrt(0.5)) < std::numeric_limits<double>::epsilon());
-
- // inserting point in the middle
- ply.insertPoint(1,1);
- ASSERT_EQ(std::size_t(3), ply.getNumberOfPoints());
- ASSERT_FALSE(ply.isClosed());
- ASSERT_TRUE(ply.isPointIDInPolyline(2));
- ASSERT_TRUE(fabs(ply.getLength(2) - (1.0 + sqrt(0.5))) < std::numeric_limits<double>::epsilon());
-
- // inserting point at the end
- ply_pnts.push_back(new GeoLib::Point(1.0, 0.5, 0.0));
- ply.insertPoint(3,3);
- ASSERT_EQ(std::size_t(4), ply.getNumberOfPoints());
- ASSERT_FALSE(ply.isClosed());
- ASSERT_TRUE(ply.isPointIDInPolyline(3));
- ASSERT_TRUE(fabs(ply.getLength(3) - (1.0 + sqrt(0.5) + 0.5)) < std::numeric_limits<double>::epsilon());
-
- // inserting point at the beginning
- ply_pnts.push_back(new GeoLib::Point(-1.0, 0.0, 0.0));
- ply.insertPoint(0,4);
- ASSERT_EQ(std::size_t(5), ply.getNumberOfPoints());
- ASSERT_FALSE(ply.isClosed());
- ASSERT_TRUE(ply.isPointIDInPolyline(4));
- ASSERT_TRUE(fabs(ply.getLength(4) - (1.0 + 1.0 + sqrt(0.5) + 0.5)) <
- std::numeric_limits<double>::epsilon());
-
- // inserting point in the middle
- ply_pnts.push_back(new GeoLib::Point(0.0, 0.5, 0.0));
- ply.insertPoint(2,5);
- ASSERT_EQ(std::size_t(6), ply.getNumberOfPoints());
- ASSERT_FALSE(ply.isClosed());
- ASSERT_TRUE(ply.isPointIDInPolyline(5));
- ASSERT_TRUE(fabs(ply.getLength(5) - (1.0 + 0.5 + sqrt(1.25) + sqrt(0.5) + 0.5)) < std::numeric_limits<double>::epsilon());
-
- // close polyline
- ply.closePolyline();
- ASSERT_EQ(std::size_t(7), ply.getNumberOfPoints());
- ASSERT_TRUE(ply.isClosed());
-
- // remove last point -> polyline is not closed!
- ply.removePoint(6);
- ASSERT_EQ(std::size_t(6), ply.getNumberOfPoints());
- ASSERT_FALSE(ply.isClosed());
- ply.closePolyline();
- ASSERT_TRUE(ply.isClosed());
-
- std::size_t segment_cnt(0);
- for (auto seg_it(ply.begin()); seg_it != ply.end(); ++seg_it)
- {
- ++segment_cnt;
- }
- ASSERT_EQ(ply.getNumberOfSegments(), segment_cnt);
-
- for (std::size_t k(0); k < ply_pnts.size(); ++k)
- delete ply_pnts[k];
+ std::vector<GeoLib::Point*> ply_pnts;
+ GeoLib::Polyline ply(ply_pnts);
+
+ // checking properties of empty polyline
+ ASSERT_EQ(std::size_t(0), ply.getNumberOfPoints());
+ ASSERT_FALSE(ply.isClosed());
+ ASSERT_FALSE(ply.isPointIDInPolyline(0));
+ ASSERT_EQ(0.0, ply.getLength(0));
+
+ ply_pnts.push_back(new GeoLib::Point(0.0, 0.0, 0.0));
+ ply.addPoint(0);
+ // checking properties of polyline with one point
+ ASSERT_EQ(std::size_t(1), ply.getNumberOfPoints());
+ ASSERT_FALSE(ply.isClosed());
+ ASSERT_TRUE(ply.isPointIDInPolyline(0));
+ ASSERT_EQ(0.0, ply.getLength(0));
+
+ ply_pnts.push_back(new GeoLib::Point(1.0, 0.0, 0.0));
+ ply.addPoint(1);
+ // checking properties of polyline with two points
+ ASSERT_EQ(std::size_t(2), ply.getNumberOfPoints());
+ ASSERT_FALSE(ply.isClosed());
+ ASSERT_TRUE(ply.isPointIDInPolyline(1));
+ ASSERT_EQ(1.0, ply.getLength(1));
+
+ // checking properties of polyline with two points
+ ply_pnts.push_back(new GeoLib::Point(0.5, 0.5, 0.0));
+ ply.addPoint(2);
+ ASSERT_EQ(std::size_t(3), ply.getNumberOfPoints());
+ ASSERT_FALSE(ply.isClosed());
+ ASSERT_TRUE(ply.isPointIDInPolyline(2));
+ ASSERT_TRUE(fabs(ply.getLength(2) - (1.0 + sqrt(0.5))) < std::numeric_limits<double>::epsilon());
+
+ // checking remove
+ ply.removePoint(1);
+ ASSERT_EQ(std::size_t(2), ply.getNumberOfPoints());
+ ASSERT_FALSE(ply.isClosed());
+ ASSERT_FALSE(ply.isPointIDInPolyline(1));
+ ASSERT_TRUE(fabs(ply.getLength(1) - sqrt(0.5)) < std::numeric_limits<double>::epsilon());
+
+ // inserting point in the middle
+ ply.insertPoint(1,1);
+ ASSERT_EQ(std::size_t(3), ply.getNumberOfPoints());
+ ASSERT_FALSE(ply.isClosed());
+ ASSERT_TRUE(ply.isPointIDInPolyline(2));
+ ASSERT_TRUE(fabs(ply.getLength(2) - (1.0 + sqrt(0.5))) < std::numeric_limits<double>::epsilon());
+
+ // inserting point at the end
+ ply_pnts.push_back(new GeoLib::Point(1.0, 0.5, 0.0));
+ ply.insertPoint(3,3);
+ ASSERT_EQ(std::size_t(4), ply.getNumberOfPoints());
+ ASSERT_FALSE(ply.isClosed());
+ ASSERT_TRUE(ply.isPointIDInPolyline(3));
+ ASSERT_TRUE(fabs(ply.getLength(3) - (1.0 + sqrt(0.5) + 0.5)) < std::numeric_limits<double>::epsilon());
+
+ // inserting point at the beginning
+ ply_pnts.push_back(new GeoLib::Point(-1.0, 0.0, 0.0));
+ ply.insertPoint(0,4);
+ ASSERT_EQ(std::size_t(5), ply.getNumberOfPoints());
+ ASSERT_FALSE(ply.isClosed());
+ ASSERT_TRUE(ply.isPointIDInPolyline(4));
+ ASSERT_TRUE(fabs(ply.getLength(4) - (1.0 + 1.0 + sqrt(0.5) + 0.5)) <
+ std::numeric_limits<double>::epsilon());
+
+ // inserting point in the middle
+ ply_pnts.push_back(new GeoLib::Point(0.0, 0.5, 0.0));
+ ply.insertPoint(2,5);
+ ASSERT_EQ(std::size_t(6), ply.getNumberOfPoints());
+ ASSERT_FALSE(ply.isClosed());
+ ASSERT_TRUE(ply.isPointIDInPolyline(5));
+ ASSERT_TRUE(fabs(ply.getLength(5) - (1.0 + 0.5 + sqrt(1.25) + sqrt(0.5) + 0.5)) < std::numeric_limits<double>::epsilon());
+
+ // close polyline
+ ply.closePolyline();
+ ASSERT_EQ(std::size_t(7), ply.getNumberOfPoints());
+ ASSERT_TRUE(ply.isClosed());
+
+ // remove last point -> polyline is not closed!
+ ply.removePoint(6);
+ ASSERT_EQ(std::size_t(6), ply.getNumberOfPoints());
+ ASSERT_FALSE(ply.isClosed());
+ ply.closePolyline();
+ ASSERT_TRUE(ply.isClosed());
+
+ std::size_t segment_cnt(0);
+ for (auto seg_it(ply.begin()); seg_it != ply.end(); ++seg_it)
+ {
+ ++segment_cnt;
+ }
+ ASSERT_EQ(ply.getNumberOfSegments(), segment_cnt);
+
+ for (std::size_t k(0); k < ply_pnts.size(); ++k)
+ delete ply_pnts[k];
}
diff --git a/Tests/GeoLib/TestSimplePolygonTree.cpp b/Tests/GeoLib/TestSimplePolygonTree.cpp
index e05fb9a43a513e81b4c113ea1257b070cc425c72..679720f4028c3b7b5a090001d6a9e7d445451b7b 100644
--- a/Tests/GeoLib/TestSimplePolygonTree.cpp
+++ b/Tests/GeoLib/TestSimplePolygonTree.cpp
@@ -40,136 +40,136 @@
class CreatePolygonTreesTest : public testing::Test
{
public:
- CreatePolygonTreesTest() :
- _p0(nullptr), _p1(nullptr), _p2(nullptr), _p3(nullptr)
- {
- // create points and construct polygon
- _pnts.push_back(new GeoLib::Point(0.0,-1.0,0.0));
- _pnts.push_back(new GeoLib::Point(1.0,0.0,0.0));
- _pnts.push_back(new GeoLib::Point(0.0,1.0,0.0));
- _pnts.push_back(new GeoLib::Point(-1.0,0.0,0.0));
-
- _pnts.push_back(new GeoLib::Point(-0.9,0.0,0.0));
- _pnts.push_back(new GeoLib::Point(0.75,-0.1,0.0));
- _pnts.push_back(new GeoLib::Point(-0.75,-0.1,0.0));
-
- // create closed polylines
- GeoLib::Polyline ply0(_pnts);
- ply0.addPoint(3);
- ply0.addPoint(1);
- ply0.addPoint(2);
- ply0.addPoint(3);
-
- GeoLib::Polyline ply1(_pnts);
- ply1.addPoint(0);
- ply1.addPoint(1);
- ply1.addPoint(3);
- ply1.addPoint(0);
-
- GeoLib::Polyline ply2(_pnts);
- ply2.addPoint(0);
- ply2.addPoint(1);
- ply2.addPoint(2);
- ply2.addPoint(3);
- ply2.addPoint(0);
-
- GeoLib::Polyline ply3(_pnts);
- ply3.addPoint(4);
- ply3.addPoint(5);
- ply3.addPoint(6);
- ply3.addPoint(4);
-
- // create polygons
- _p0 = new GeoLib::Polygon(ply0);
- _p1 = new GeoLib::Polygon(ply1);
- _p2 = new GeoLib::Polygon(ply2);
- _p3 = new GeoLib::Polygon(ply3);
- }
-
- ~CreatePolygonTreesTest()
- {
- delete _p0;
- delete _p1;
- delete _p2;
- delete _p3;
- for (std::size_t k(0); k<_pnts.size(); k++)
- delete _pnts[k];
- }
+ CreatePolygonTreesTest() :
+ _p0(nullptr), _p1(nullptr), _p2(nullptr), _p3(nullptr)
+ {
+ // create points and construct polygon
+ _pnts.push_back(new GeoLib::Point(0.0,-1.0,0.0));
+ _pnts.push_back(new GeoLib::Point(1.0,0.0,0.0));
+ _pnts.push_back(new GeoLib::Point(0.0,1.0,0.0));
+ _pnts.push_back(new GeoLib::Point(-1.0,0.0,0.0));
+
+ _pnts.push_back(new GeoLib::Point(-0.9,0.0,0.0));
+ _pnts.push_back(new GeoLib::Point(0.75,-0.1,0.0));
+ _pnts.push_back(new GeoLib::Point(-0.75,-0.1,0.0));
+
+ // create closed polylines
+ GeoLib::Polyline ply0(_pnts);
+ ply0.addPoint(3);
+ ply0.addPoint(1);
+ ply0.addPoint(2);
+ ply0.addPoint(3);
+
+ GeoLib::Polyline ply1(_pnts);
+ ply1.addPoint(0);
+ ply1.addPoint(1);
+ ply1.addPoint(3);
+ ply1.addPoint(0);
+
+ GeoLib::Polyline ply2(_pnts);
+ ply2.addPoint(0);
+ ply2.addPoint(1);
+ ply2.addPoint(2);
+ ply2.addPoint(3);
+ ply2.addPoint(0);
+
+ GeoLib::Polyline ply3(_pnts);
+ ply3.addPoint(4);
+ ply3.addPoint(5);
+ ply3.addPoint(6);
+ ply3.addPoint(4);
+
+ // create polygons
+ _p0 = new GeoLib::Polygon(ply0);
+ _p1 = new GeoLib::Polygon(ply1);
+ _p2 = new GeoLib::Polygon(ply2);
+ _p3 = new GeoLib::Polygon(ply3);
+ }
+
+ ~CreatePolygonTreesTest()
+ {
+ delete _p0;
+ delete _p1;
+ delete _p2;
+ delete _p3;
+ for (std::size_t k(0); k<_pnts.size(); k++)
+ delete _pnts[k];
+ }
protected:
- std::vector<GeoLib::Point*> _pnts;
- GeoLib::Polygon *_p0;
- GeoLib::Polygon *_p1;
- GeoLib::Polygon *_p2;
- GeoLib::Polygon *_p3;
+ std::vector<GeoLib::Point*> _pnts;
+ GeoLib::Polygon *_p0;
+ GeoLib::Polygon *_p1;
+ GeoLib::Polygon *_p2;
+ GeoLib::Polygon *_p3;
};
TEST_F(CreatePolygonTreesTest, P0AndP1)
{
- GeoLib::SimplePolygonTree *pt0(new GeoLib::SimplePolygonTree(_p0, nullptr));
- GeoLib::SimplePolygonTree *pt1(new GeoLib::SimplePolygonTree(_p1, nullptr));
+ GeoLib::SimplePolygonTree *pt0(new GeoLib::SimplePolygonTree(_p0, nullptr));
+ GeoLib::SimplePolygonTree *pt1(new GeoLib::SimplePolygonTree(_p1, nullptr));
- std::list<GeoLib::SimplePolygonTree*> pt_list;
- pt_list.push_back(pt0);
- pt_list.push_back(pt1);
- ASSERT_EQ(2u, pt_list.size());
+ std::list<GeoLib::SimplePolygonTree*> pt_list;
+ pt_list.push_back(pt0);
+ pt_list.push_back(pt1);
+ ASSERT_EQ(2u, pt_list.size());
- createPolygonTrees(pt_list);
- ASSERT_EQ(2u, pt_list.size());
- std::for_each(pt_list.begin(), pt_list.end(), std::default_delete<GeoLib::SimplePolygonTree>());
+ createPolygonTrees(pt_list);
+ ASSERT_EQ(2u, pt_list.size());
+ std::for_each(pt_list.begin(), pt_list.end(), std::default_delete<GeoLib::SimplePolygonTree>());
}
TEST_F(CreatePolygonTreesTest, P0AndP1AndP2)
{
- GeoLib::SimplePolygonTree *pt0(new GeoLib::SimplePolygonTree(_p0, nullptr));
- GeoLib::SimplePolygonTree *pt1(new GeoLib::SimplePolygonTree(_p1, nullptr));
- GeoLib::SimplePolygonTree *pt2(new GeoLib::SimplePolygonTree(_p2, nullptr));
-
- std::list<GeoLib::SimplePolygonTree*> pt_list;
- pt_list.push_back(pt0);
- pt_list.push_back(pt1);
- pt_list.push_back(pt2);
- ASSERT_EQ(3u, pt_list.size());
-
- ASSERT_FALSE(_p0->isPolylineInPolygon(*_p1));
- ASSERT_FALSE(_p0->isPolylineInPolygon(*_p2));
- ASSERT_FALSE(_p1->isPolylineInPolygon(*_p0));
- ASSERT_FALSE(_p1->isPolylineInPolygon(*_p2));
- ASSERT_TRUE(_p2->isPolylineInPolygon(*_p0));
- ASSERT_TRUE(_p2->isPolylineInPolygon(*_p1));
-
- createPolygonTrees(pt_list);
- ASSERT_EQ(1u, pt_list.size());
- ASSERT_EQ(2u, (*(pt_list.begin()))->getNChildren());
- std::for_each(pt_list.begin(), pt_list.end(), std::default_delete<GeoLib::SimplePolygonTree>());
+ GeoLib::SimplePolygonTree *pt0(new GeoLib::SimplePolygonTree(_p0, nullptr));
+ GeoLib::SimplePolygonTree *pt1(new GeoLib::SimplePolygonTree(_p1, nullptr));
+ GeoLib::SimplePolygonTree *pt2(new GeoLib::SimplePolygonTree(_p2, nullptr));
+
+ std::list<GeoLib::SimplePolygonTree*> pt_list;
+ pt_list.push_back(pt0);
+ pt_list.push_back(pt1);
+ pt_list.push_back(pt2);
+ ASSERT_EQ(3u, pt_list.size());
+
+ ASSERT_FALSE(_p0->isPolylineInPolygon(*_p1));
+ ASSERT_FALSE(_p0->isPolylineInPolygon(*_p2));
+ ASSERT_FALSE(_p1->isPolylineInPolygon(*_p0));
+ ASSERT_FALSE(_p1->isPolylineInPolygon(*_p2));
+ ASSERT_TRUE(_p2->isPolylineInPolygon(*_p0));
+ ASSERT_TRUE(_p2->isPolylineInPolygon(*_p1));
+
+ createPolygonTrees(pt_list);
+ ASSERT_EQ(1u, pt_list.size());
+ ASSERT_EQ(2u, (*(pt_list.begin()))->getNChildren());
+ std::for_each(pt_list.begin(), pt_list.end(), std::default_delete<GeoLib::SimplePolygonTree>());
}
TEST_F(CreatePolygonTreesTest, P0AndP1AndP2AndP3)
{
- GeoLib::SimplePolygonTree *pt0(new GeoLib::SimplePolygonTree(_p0, nullptr));
- GeoLib::SimplePolygonTree *pt1(new GeoLib::SimplePolygonTree(_p1, nullptr));
- GeoLib::SimplePolygonTree *pt2(new GeoLib::SimplePolygonTree(_p2, nullptr));
- GeoLib::SimplePolygonTree *pt3(new GeoLib::SimplePolygonTree(_p3, nullptr));
-
- std::list<GeoLib::SimplePolygonTree*> pt_list;
- pt_list.push_back(pt0);
- pt_list.push_back(pt1);
- pt_list.push_back(pt2);
- pt_list.push_back(pt3);
- ASSERT_EQ(4u, pt_list.size());
-
- ASSERT_FALSE(_p0->isPolylineInPolygon(*_p1));
- ASSERT_FALSE(_p0->isPolylineInPolygon(*_p2));
- ASSERT_FALSE(_p1->isPolylineInPolygon(*_p0));
- ASSERT_FALSE(_p1->isPolylineInPolygon(*_p2));
- ASSERT_TRUE(_p2->isPolylineInPolygon(*_p0));
- ASSERT_TRUE(_p2->isPolylineInPolygon(*_p1));
- ASSERT_TRUE(_p2->isPolylineInPolygon(*_p3));
- ASSERT_TRUE(_p1->isPolylineInPolygon(*_p3));
-
- createPolygonTrees(pt_list);
- ASSERT_EQ(1u, pt_list.size());
- ASSERT_EQ(2u, (*(pt_list.begin()))->getNChildren());
- std::for_each(pt_list.begin(), pt_list.end(), std::default_delete<GeoLib::SimplePolygonTree>());
+ GeoLib::SimplePolygonTree *pt0(new GeoLib::SimplePolygonTree(_p0, nullptr));
+ GeoLib::SimplePolygonTree *pt1(new GeoLib::SimplePolygonTree(_p1, nullptr));
+ GeoLib::SimplePolygonTree *pt2(new GeoLib::SimplePolygonTree(_p2, nullptr));
+ GeoLib::SimplePolygonTree *pt3(new GeoLib::SimplePolygonTree(_p3, nullptr));
+
+ std::list<GeoLib::SimplePolygonTree*> pt_list;
+ pt_list.push_back(pt0);
+ pt_list.push_back(pt1);
+ pt_list.push_back(pt2);
+ pt_list.push_back(pt3);
+ ASSERT_EQ(4u, pt_list.size());
+
+ ASSERT_FALSE(_p0->isPolylineInPolygon(*_p1));
+ ASSERT_FALSE(_p0->isPolylineInPolygon(*_p2));
+ ASSERT_FALSE(_p1->isPolylineInPolygon(*_p0));
+ ASSERT_FALSE(_p1->isPolylineInPolygon(*_p2));
+ ASSERT_TRUE(_p2->isPolylineInPolygon(*_p0));
+ ASSERT_TRUE(_p2->isPolylineInPolygon(*_p1));
+ ASSERT_TRUE(_p2->isPolylineInPolygon(*_p3));
+ ASSERT_TRUE(_p1->isPolylineInPolygon(*_p3));
+
+ createPolygonTrees(pt_list);
+ ASSERT_EQ(1u, pt_list.size());
+ ASSERT_EQ(2u, (*(pt_list.begin()))->getNChildren());
+ std::for_each(pt_list.begin(), pt_list.end(), std::default_delete<GeoLib::SimplePolygonTree>());
}
diff --git a/Tests/GeoLib/TestSurfaceIsPointInSurface.cpp b/Tests/GeoLib/TestSurfaceIsPointInSurface.cpp
index fd49d4cc98104fa10665591ae1467582f70e11e0..89e5dca05994c90a038545c2def50c2f88064947 100644
--- a/Tests/GeoLib/TestSurfaceIsPointInSurface.cpp
+++ b/Tests/GeoLib/TestSurfaceIsPointInSurface.cpp
@@ -33,125 +33,125 @@
inline double constant(double , double )
{
- return 0.0;
+ return 0.0;
}
inline double coscos(double x, double y)
{
- return std::cos(x) * std::cos(y);
+ return std::cos(x) * std::cos(y);
}
inline MathLib::Point3d
getEdgeMiddlePoint(MathLib::Point3d const&a, MathLib::Point3d const& b)
{
- return MathLib::Point3d(std::array<double,3>({{
- (a[0]+b[0])/2, (a[1]+b[1])/2, (a[2]+b[2])/2}}));
+ return MathLib::Point3d(std::array<double,3>({{
+ (a[0]+b[0])/2, (a[1]+b[1])/2, (a[2]+b[2])/2}}));
}
inline std::tuple<MathLib::Point3d, MathLib::Point3d, MathLib::Point3d>
getEdgeMiddlePoints(GeoLib::Triangle const& tri)
{
- return std::make_tuple(
- getEdgeMiddlePoint(*tri.getPoint(0), *tri.getPoint(1)),
- getEdgeMiddlePoint(*tri.getPoint(1), *tri.getPoint(2)),
- getEdgeMiddlePoint(*tri.getPoint(2), *tri.getPoint(0)));
+ return std::make_tuple(
+ getEdgeMiddlePoint(*tri.getPoint(0), *tri.getPoint(1)),
+ getEdgeMiddlePoint(*tri.getPoint(1), *tri.getPoint(2)),
+ getEdgeMiddlePoint(*tri.getPoint(2), *tri.getPoint(0)));
}
/// Computes rotation matrix according to the z,x',z'' convention
inline MathLib::DenseMatrix<double, std::size_t>
getRotMat(double alpha, double beta, double gamma)
{
- MathLib::DenseMatrix<double, std::size_t> rot_mat(3,3);
- rot_mat(0,0) = cos(alpha)*cos(gamma) - sin(alpha)*cos(beta)*sin(gamma);
- rot_mat(0,1) = sin(alpha)*cos(gamma) + cos(alpha)*cos(beta)*sin(gamma);
- rot_mat(0,2) = sin(beta)*sin(gamma);
- rot_mat(1,0) = -cos(alpha)*sin(gamma) - sin(alpha)*cos(beta)*cos(gamma);
- rot_mat(1,1) = -sin(alpha)*sin(gamma) + cos(alpha)*cos(beta)*cos(gamma);
- rot_mat(1,2) = sin(beta)*cos(gamma);
- rot_mat(2,0) = sin(alpha)*sin(beta);
- rot_mat(2,1) = -cos(alpha)*sin(beta);
- rot_mat(2,2) = cos(beta);
- return rot_mat;
+ MathLib::DenseMatrix<double, std::size_t> rot_mat(3,3);
+ rot_mat(0,0) = cos(alpha)*cos(gamma) - sin(alpha)*cos(beta)*sin(gamma);
+ rot_mat(0,1) = sin(alpha)*cos(gamma) + cos(alpha)*cos(beta)*sin(gamma);
+ rot_mat(0,2) = sin(beta)*sin(gamma);
+ rot_mat(1,0) = -cos(alpha)*sin(gamma) - sin(alpha)*cos(beta)*cos(gamma);
+ rot_mat(1,1) = -sin(alpha)*sin(gamma) + cos(alpha)*cos(beta)*cos(gamma);
+ rot_mat(1,2) = sin(beta)*cos(gamma);
+ rot_mat(2,0) = sin(alpha)*sin(beta);
+ rot_mat(2,1) = -cos(alpha)*sin(beta);
+ rot_mat(2,2) = cos(beta);
+ return rot_mat;
}
TEST(GeoLib, SurfaceIsPointInSurface)
{
- std::vector<std::function<double(double, double)>> surface_functions;
- surface_functions.push_back(constant);
- surface_functions.push_back(coscos);
-
- for (auto f : surface_functions) {
- std::random_device rd;
-
- std::string name("Surface");
- // generate ll and ur in random way
- std::mt19937 random_engine_mt19937(rd());
- std::normal_distribution<> normal_dist_ll(-10, 2);
- std::normal_distribution<> normal_dist_ur(10, 2);
- MathLib::Point3d ll(std::array<double,3>({{
- normal_dist_ll(random_engine_mt19937),
- normal_dist_ll(random_engine_mt19937),
- 0.0}}));
- MathLib::Point3d ur(std::array<double,3>({{
- normal_dist_ur(random_engine_mt19937),
- normal_dist_ur(random_engine_mt19937),
- 0.0}}));
- for (std::size_t k(0); k<3; ++k)
- if (ll[k] > ur[k])
- std::swap(ll[k], ur[k]);
-
- // random discretization of the domain
- std::default_random_engine re(rd());
- std::uniform_int_distribution<std::size_t> uniform_dist(2, 25);
- std::array<std::size_t,2> n_steps = {{uniform_dist(re),uniform_dist(re)}};
-
- std::unique_ptr<MeshLib::Mesh> sfc_mesh(
- MeshLib::MeshGenerator::createSurfaceMesh(
- name, ll, ur, n_steps, f
- )
- );
-
- // random rotation angles
- std::normal_distribution<> normal_dist_angles(
- 0, boost::math::double_constants::two_pi);
- std::array<double,3> euler_angles = {{
- normal_dist_angles(random_engine_mt19937),
- normal_dist_angles(random_engine_mt19937),
- normal_dist_angles(random_engine_mt19937)
- }};
-
- MathLib::DenseMatrix<double, std::size_t> rot_mat(getRotMat(
- euler_angles[0], euler_angles[1], euler_angles[2]));
-
- std::vector<MeshLib::Node*> const& nodes(sfc_mesh->getNodes());
- GeoLib::rotatePoints<MeshLib::Node>(rot_mat, nodes);
-
- MathLib::Vector3 const normal(0,0,1.0);
- MathLib::Vector3 const surface_normal(rot_mat * normal);
- double const eps(1e-6);
- MathLib::Vector3 const displacement(eps * surface_normal);
-
- GeoLib::GEOObjects geometries;
- MeshLib::convertMeshToGeo(*sfc_mesh, geometries);
-
- std::vector<GeoLib::Surface*> const& sfcs(*geometries.getSurfaceVec(name));
- GeoLib::Surface const*const sfc(sfcs.front());
- std::vector<GeoLib::Point*> const& pnts(*geometries.getPointVec(name));
- // test triangle edge point of the surface triangles
- for (auto const p : pnts) {
- EXPECT_TRUE(sfc->isPntInSfc(*p));
- MathLib::Point3d q(*p);
- for (std::size_t k(0); k<3; ++k)
- q[k] += displacement[k];
- EXPECT_FALSE(sfc->isPntInSfc(q));
- }
- // test edge middle points of the triangles
- for (std::size_t k(0); k<sfc->getNTriangles(); ++k) {
- MathLib::Point3d p, q, r;
- std::tie(p,q,r) = getEdgeMiddlePoints(*(*sfc)[k]);
- EXPECT_TRUE(sfc->isPntInSfc(p));
- EXPECT_TRUE(sfc->isPntInSfc(q));
- EXPECT_TRUE(sfc->isPntInSfc(r));
- }
- }
+ std::vector<std::function<double(double, double)>> surface_functions;
+ surface_functions.push_back(constant);
+ surface_functions.push_back(coscos);
+
+ for (auto f : surface_functions) {
+ std::random_device rd;
+
+ std::string name("Surface");
+ // generate ll and ur in random way
+ std::mt19937 random_engine_mt19937(rd());
+ std::normal_distribution<> normal_dist_ll(-10, 2);
+ std::normal_distribution<> normal_dist_ur(10, 2);
+ MathLib::Point3d ll(std::array<double,3>({{
+ normal_dist_ll(random_engine_mt19937),
+ normal_dist_ll(random_engine_mt19937),
+ 0.0}}));
+ MathLib::Point3d ur(std::array<double,3>({{
+ normal_dist_ur(random_engine_mt19937),
+ normal_dist_ur(random_engine_mt19937),
+ 0.0}}));
+ for (std::size_t k(0); k<3; ++k)
+ if (ll[k] > ur[k])
+ std::swap(ll[k], ur[k]);
+
+ // random discretization of the domain
+ std::default_random_engine re(rd());
+ std::uniform_int_distribution<std::size_t> uniform_dist(2, 25);
+ std::array<std::size_t,2> n_steps = {{uniform_dist(re),uniform_dist(re)}};
+
+ std::unique_ptr<MeshLib::Mesh> sfc_mesh(
+ MeshLib::MeshGenerator::createSurfaceMesh(
+ name, ll, ur, n_steps, f
+ )
+ );
+
+ // random rotation angles
+ std::normal_distribution<> normal_dist_angles(
+ 0, boost::math::double_constants::two_pi);
+ std::array<double,3> euler_angles = {{
+ normal_dist_angles(random_engine_mt19937),
+ normal_dist_angles(random_engine_mt19937),
+ normal_dist_angles(random_engine_mt19937)
+ }};
+
+ MathLib::DenseMatrix<double, std::size_t> rot_mat(getRotMat(
+ euler_angles[0], euler_angles[1], euler_angles[2]));
+
+ std::vector<MeshLib::Node*> const& nodes(sfc_mesh->getNodes());
+ GeoLib::rotatePoints<MeshLib::Node>(rot_mat, nodes);
+
+ MathLib::Vector3 const normal(0,0,1.0);
+ MathLib::Vector3 const surface_normal(rot_mat * normal);
+ double const eps(1e-6);
+ MathLib::Vector3 const displacement(eps * surface_normal);
+
+ GeoLib::GEOObjects geometries;
+ MeshLib::convertMeshToGeo(*sfc_mesh, geometries);
+
+ std::vector<GeoLib::Surface*> const& sfcs(*geometries.getSurfaceVec(name));
+ GeoLib::Surface const*const sfc(sfcs.front());
+ std::vector<GeoLib::Point*> const& pnts(*geometries.getPointVec(name));
+ // test triangle edge point of the surface triangles
+ for (auto const p : pnts) {
+ EXPECT_TRUE(sfc->isPntInSfc(*p));
+ MathLib::Point3d q(*p);
+ for (std::size_t k(0); k<3; ++k)
+ q[k] += displacement[k];
+ EXPECT_FALSE(sfc->isPntInSfc(q));
+ }
+ // test edge middle points of the triangles
+ for (std::size_t k(0); k<sfc->getNTriangles(); ++k) {
+ MathLib::Point3d p, q, r;
+ std::tie(p,q,r) = getEdgeMiddlePoints(*(*sfc)[k]);
+ EXPECT_TRUE(sfc->isPntInSfc(p));
+ EXPECT_TRUE(sfc->isPntInSfc(q));
+ EXPECT_TRUE(sfc->isPntInSfc(r));
+ }
+ }
}
diff --git a/Tests/InSituLib/TestVtkMappedMeshSource.cpp b/Tests/InSituLib/TestVtkMappedMeshSource.cpp
index 0599345e61f6499284ec840ad4b67f819faee3fe..08b0ad22bfc471a8250e542f448bdab6876e37f2 100644
--- a/Tests/InSituLib/TestVtkMappedMeshSource.cpp
+++ b/Tests/InSituLib/TestVtkMappedMeshSource.cpp
@@ -40,105 +40,105 @@
// Creates a mesh with double and int point and cell properties
class InSituMesh : public ::testing::Test
{
- public:
- InSituMesh()
- : mesh(nullptr)
- {
- mesh = MeshLib::MeshGenerator::generateRegularHexMesh(this->length, this->subdivisions);
-
- std::string const point_prop_name("PointDoubleProperty");
- boost::optional<MeshLib::PropertyVector<double> &> point_double_properties(
- mesh->getProperties().createNewPropertyVector<double>(point_prop_name,
- MeshLib::MeshItemType::Node)
- );
- (*point_double_properties).resize(mesh->getNNodes());
- std::iota((*point_double_properties).begin(), (*point_double_properties).end(), 1);
-
- std::string const cell_prop_name("CellDoubleProperty");
- boost::optional<MeshLib::PropertyVector<double> &> cell_double_properties(
- mesh->getProperties().createNewPropertyVector<double>(cell_prop_name,
- MeshLib::MeshItemType::Cell)
- );
- (*cell_double_properties).resize(mesh->getNElements());
- std::iota((*cell_double_properties).begin(), (*cell_double_properties).end(), 1);
-
- std::string const point_int_prop_name("PointIntProperty");
- boost::optional<MeshLib::PropertyVector<int> &> point_int_properties(
- mesh->getProperties().createNewPropertyVector<int>(point_int_prop_name,
- MeshLib::MeshItemType::Node)
- );
- (*point_int_properties).resize(mesh->getNNodes());
- std::iota((*point_int_properties).begin(), (*point_int_properties).end(), 1);
-
- std::string const cell_int_prop_name("CellIntProperty");
- boost::optional<MeshLib::PropertyVector<int> &> cell_int_properties(
- mesh->getProperties().createNewPropertyVector<int>(cell_int_prop_name,
- MeshLib::MeshItemType::Cell)
- );
- (*cell_int_properties).resize(mesh->getNElements());
- std::iota((*cell_int_properties).begin(), (*cell_int_properties).end(), 1);
-
- std::string const point_unsigned_prop_name("PointUnsignedProperty");
- boost::optional<MeshLib::PropertyVector<unsigned> &> point_unsigned_properties(
- mesh->getProperties().createNewPropertyVector<unsigned>(point_unsigned_prop_name,
- MeshLib::MeshItemType::Node)
- );
- (*point_unsigned_properties).resize(mesh->getNNodes());
- std::iota((*point_unsigned_properties).begin(), (*point_unsigned_properties).end(), 1);
-
- std::string const cell_unsigned_prop_name("CellUnsignedProperty");
- boost::optional<MeshLib::PropertyVector<unsigned> &> cell_unsigned_properties(
- mesh->getProperties().createNewPropertyVector<unsigned>(cell_unsigned_prop_name,
- MeshLib::MeshItemType::Cell)
- );
- (*cell_unsigned_properties).resize(mesh->getNElements());
- std::iota((*cell_unsigned_properties).begin(), (*cell_unsigned_properties).end(), 1);
-
- std::string const material_ids_name("MaterialIDs");
- boost::optional<MeshLib::PropertyVector<int> &> material_id_properties(
- mesh->getProperties().createNewPropertyVector<int>(material_ids_name,
- MeshLib::MeshItemType::Cell)
- );
- (*material_id_properties).resize(mesh->getNElements());
- std::iota((*material_id_properties).begin(), (*material_id_properties).end(), 1);
- }
-
-
-
- ~InSituMesh()
- {
- delete mesh;
- }
-
- MeshLib::Mesh * mesh;
- const std::size_t subdivisions = 5;
- const double length = 1.0;
- const double dx = length / subdivisions;
+ public:
+ InSituMesh()
+ : mesh(nullptr)
+ {
+ mesh = MeshLib::MeshGenerator::generateRegularHexMesh(this->length, this->subdivisions);
+
+ std::string const point_prop_name("PointDoubleProperty");
+ boost::optional<MeshLib::PropertyVector<double> &> point_double_properties(
+ mesh->getProperties().createNewPropertyVector<double>(point_prop_name,
+ MeshLib::MeshItemType::Node)
+ );
+ (*point_double_properties).resize(mesh->getNNodes());
+ std::iota((*point_double_properties).begin(), (*point_double_properties).end(), 1);
+
+ std::string const cell_prop_name("CellDoubleProperty");
+ boost::optional<MeshLib::PropertyVector<double> &> cell_double_properties(
+ mesh->getProperties().createNewPropertyVector<double>(cell_prop_name,
+ MeshLib::MeshItemType::Cell)
+ );
+ (*cell_double_properties).resize(mesh->getNElements());
+ std::iota((*cell_double_properties).begin(), (*cell_double_properties).end(), 1);
+
+ std::string const point_int_prop_name("PointIntProperty");
+ boost::optional<MeshLib::PropertyVector<int> &> point_int_properties(
+ mesh->getProperties().createNewPropertyVector<int>(point_int_prop_name,
+ MeshLib::MeshItemType::Node)
+ );
+ (*point_int_properties).resize(mesh->getNNodes());
+ std::iota((*point_int_properties).begin(), (*point_int_properties).end(), 1);
+
+ std::string const cell_int_prop_name("CellIntProperty");
+ boost::optional<MeshLib::PropertyVector<int> &> cell_int_properties(
+ mesh->getProperties().createNewPropertyVector<int>(cell_int_prop_name,
+ MeshLib::MeshItemType::Cell)
+ );
+ (*cell_int_properties).resize(mesh->getNElements());
+ std::iota((*cell_int_properties).begin(), (*cell_int_properties).end(), 1);
+
+ std::string const point_unsigned_prop_name("PointUnsignedProperty");
+ boost::optional<MeshLib::PropertyVector<unsigned> &> point_unsigned_properties(
+ mesh->getProperties().createNewPropertyVector<unsigned>(point_unsigned_prop_name,
+ MeshLib::MeshItemType::Node)
+ );
+ (*point_unsigned_properties).resize(mesh->getNNodes());
+ std::iota((*point_unsigned_properties).begin(), (*point_unsigned_properties).end(), 1);
+
+ std::string const cell_unsigned_prop_name("CellUnsignedProperty");
+ boost::optional<MeshLib::PropertyVector<unsigned> &> cell_unsigned_properties(
+ mesh->getProperties().createNewPropertyVector<unsigned>(cell_unsigned_prop_name,
+ MeshLib::MeshItemType::Cell)
+ );
+ (*cell_unsigned_properties).resize(mesh->getNElements());
+ std::iota((*cell_unsigned_properties).begin(), (*cell_unsigned_properties).end(), 1);
+
+ std::string const material_ids_name("MaterialIDs");
+ boost::optional<MeshLib::PropertyVector<int> &> material_id_properties(
+ mesh->getProperties().createNewPropertyVector<int>(material_ids_name,
+ MeshLib::MeshItemType::Cell)
+ );
+ (*material_id_properties).resize(mesh->getNElements());
+ std::iota((*material_id_properties).begin(), (*material_id_properties).end(), 1);
+ }
+
+
+
+ ~InSituMesh()
+ {
+ delete mesh;
+ }
+
+ MeshLib::Mesh * mesh;
+ const std::size_t subdivisions = 5;
+ const double length = 1.0;
+ const double dx = length / subdivisions;
};
TEST_F(InSituMesh, Construction)
{
- ASSERT_TRUE(mesh != nullptr);
- ASSERT_EQ((subdivisions+1)*(subdivisions+1)*(subdivisions+1), mesh->getNNodes());
+ ASSERT_TRUE(mesh != nullptr);
+ ASSERT_EQ((subdivisions+1)*(subdivisions+1)*(subdivisions+1), mesh->getNNodes());
}
// Maps the mesh into a vtkUnstructuredGrid-equivalent
TEST_F(InSituMesh, MappedMesh)
{
- ASSERT_TRUE(mesh != nullptr);
+ ASSERT_TRUE(mesh != nullptr);
- vtkNew<InSituLib::VtkMappedMesh> vtkMesh;
- vtkMesh->GetImplementation()->SetNodes(mesh->getNodes());
- vtkMesh->GetImplementation()->SetElements(mesh->getElements());
+ vtkNew<InSituLib::VtkMappedMesh> vtkMesh;
+ vtkMesh->GetImplementation()->SetNodes(mesh->getNodes());
+ vtkMesh->GetImplementation()->SetElements(mesh->getElements());
- ASSERT_EQ(subdivisions*subdivisions*subdivisions, vtkMesh->GetNumberOfCells());
- ASSERT_EQ(VTK_HEXAHEDRON, vtkMesh->GetCellType(0));
- ASSERT_EQ(VTK_HEXAHEDRON, vtkMesh->GetCellType(vtkMesh->GetNumberOfCells()-1));
- ASSERT_EQ(1, vtkMesh->IsHomogeneous());
- ASSERT_EQ(8, vtkMesh->GetMaxCellSize());
+ ASSERT_EQ(subdivisions*subdivisions*subdivisions, vtkMesh->GetNumberOfCells());
+ ASSERT_EQ(VTK_HEXAHEDRON, vtkMesh->GetCellType(0));
+ ASSERT_EQ(VTK_HEXAHEDRON, vtkMesh->GetCellType(vtkMesh->GetNumberOfCells()-1));
+ ASSERT_EQ(1, vtkMesh->IsHomogeneous());
+ ASSERT_EQ(8, vtkMesh->GetMaxCellSize());
- ASSERT_EQ(0, vtkMesh->GetNumberOfPoints()); // No points are defined
+ ASSERT_EQ(0, vtkMesh->GetNumberOfPoints()); // No points are defined
}
// Writes the mesh into a vtk file, reads the file back and converts it into a
@@ -149,147 +149,147 @@ TEST_F(InSituMesh, MappedMeshSourceRoundtrip)
TEST_F(InSituMesh, DISABLED_MappedMeshSourceRoundtrip)
#endif
{
- // TODO Add more comparison criteria
-
- ASSERT_TRUE(mesh != nullptr);
- std::string test_data_file(BaseLib::BuildInfo::tests_tmp_path + "/MappedMeshSourceRoundtrip.vtu");
-
- // -- Test VtkMappedMeshSource, i.e. OGS mesh to VTK mesh
- vtkNew<InSituLib::VtkMappedMeshSource> vtkSource;
- vtkSource->SetMesh(mesh);
- vtkSource->Update();
- vtkUnstructuredGrid* output = vtkSource->GetOutput();
-
- // Point and cell numbers
- ASSERT_EQ((subdivisions+1)*(subdivisions+1)*(subdivisions+1), output->GetNumberOfPoints());
- ASSERT_EQ(subdivisions*subdivisions*subdivisions, output->GetNumberOfCells());
-
- // Point data arrays
- vtkDataArray* pointDoubleArray = output->GetPointData()->GetScalars("PointDoubleProperty");
- ASSERT_EQ(pointDoubleArray->GetSize(), mesh->getNNodes());
- ASSERT_EQ(pointDoubleArray->GetComponent(0, 0), 1.0);
- double* range = pointDoubleArray->GetRange(0);
- ASSERT_EQ(range[0], 1.0);
- ASSERT_EQ(range[1], 1.0 + mesh->getNNodes() - 1.0);
-
- vtkDataArray* pointIntArray = output->GetPointData()->GetScalars("PointIntProperty");
- ASSERT_EQ(pointIntArray->GetSize(), mesh->getNNodes());
- ASSERT_EQ(pointIntArray->GetComponent(0, 0), 1.0);
- range = pointIntArray->GetRange(0);
- ASSERT_EQ(range[0], 1.0);
- ASSERT_EQ(range[1], 1 + mesh->getNNodes() - 1);
-
- vtkDataArray* pointUnsignedArray = output->GetPointData()->GetScalars("PointUnsignedProperty");
- ASSERT_EQ(pointUnsignedArray->GetSize(), mesh->getNNodes());
- ASSERT_EQ(pointUnsignedArray->GetComponent(0, 0), 1.0);
- range = pointUnsignedArray->GetRange(0);
- ASSERT_EQ(range[0], 1.0);
- ASSERT_EQ(range[1], 1 + mesh->getNNodes() - 1);
-
- // Cell data arrays
- vtkDataArray* cellDoubleArray = output->GetCellData()->GetScalars("CellDoubleProperty");
- ASSERT_EQ(cellDoubleArray->GetSize(), mesh->getNElements());
- ASSERT_EQ(cellDoubleArray->GetComponent(0, 0), 1.0);
- range = cellDoubleArray->GetRange(0);
- ASSERT_EQ(range[0], 1.0);
- ASSERT_EQ(range[1], 1.0 + mesh->getNElements() - 1.0);
-
- vtkDataArray* cellIntArray = output->GetCellData()->GetScalars("CellIntProperty");
- ASSERT_EQ(cellIntArray->GetSize(), mesh->getNElements());
- ASSERT_EQ(cellIntArray->GetComponent(0, 0), 1.0);
- range = cellIntArray->GetRange(0);
- ASSERT_EQ(range[0], 1.0);
- ASSERT_EQ(range[1], 1 + mesh->getNElements() - 1);
-
- vtkDataArray* cellUnsignedArray = output->GetCellData()->GetScalars("CellUnsignedProperty");
- ASSERT_EQ(cellUnsignedArray->GetSize(), mesh->getNElements());
- ASSERT_EQ(cellUnsignedArray->GetComponent(0, 0), 1.0);
- range = cellUnsignedArray->GetRange(0);
- ASSERT_EQ(range[0], 1.0);
- ASSERT_EQ(range[1], 1 + mesh->getNElements() - 1);
-
- // -- Write VTK mesh to file (in all combinations of binary, appended and compressed)
- // atm vtkXMLWriter::Appended does not work, see http://www.paraview.org/Bug/view.php?id=13382
- for(int dataMode : { vtkXMLWriter::Ascii, vtkXMLWriter::Binary })
- {
- for(bool compressed : { true, false })
- {
- if(dataMode == vtkXMLWriter::Ascii && compressed)
- continue;
- MeshLib::IO::VtuInterface vtuInterface(mesh, dataMode, compressed);
- ASSERT_TRUE(vtuInterface.writeToFile(test_data_file));
-
- // -- Read back VTK mesh
- vtkSmartPointer<vtkXMLUnstructuredGridReader> reader =
- vtkSmartPointer<vtkXMLUnstructuredGridReader>::New();
- reader->SetFileName(test_data_file.c_str());
- reader->Update();
- vtkUnstructuredGrid *vtkMesh = reader->GetOutput();
-
- // Both VTK meshes should be identical
- ASSERT_EQ(vtkMesh->GetNumberOfPoints(), output->GetNumberOfPoints());
- ASSERT_EQ(vtkMesh->GetNumberOfCells(), output->GetNumberOfCells());
- ASSERT_EQ(vtkMesh->GetPointData()->GetScalars("PointDoubleProperty")->GetNumberOfTuples(),
- pointDoubleArray->GetNumberOfTuples());
- ASSERT_EQ(vtkMesh->GetPointData()->GetScalars("PointIntProperty")->GetNumberOfTuples(),
- pointIntArray->GetNumberOfTuples());
- ASSERT_EQ(vtkMesh->GetPointData()->GetScalars("PointUnsignedProperty")->GetNumberOfTuples(),
- pointUnsignedArray->GetNumberOfTuples());
- ASSERT_EQ(vtkMesh->GetCellData()->GetScalars("CellDoubleProperty")->GetNumberOfTuples(),
- cellDoubleArray->GetNumberOfTuples());
- ASSERT_EQ(vtkMesh->GetCellData()->GetScalars("CellIntProperty")->GetNumberOfTuples(),
- cellIntArray->GetNumberOfTuples());
- ASSERT_EQ(vtkMesh->GetCellData()->GetScalars("CellUnsignedProperty")->GetNumberOfTuples(),
- cellUnsignedArray->GetNumberOfTuples());
-
- // Both OGS meshes should be identical
- auto newMesh = std::unique_ptr<MeshLib::Mesh>{MeshLib::VtkMeshConverter::convertUnstructuredGrid(vtkMesh)};
- ASSERT_EQ(mesh->getNNodes(), newMesh->getNNodes());
- ASSERT_EQ(mesh->getNElements(), newMesh->getNElements());
-
- // Both properties should be identical
- auto meshProperties = mesh->getProperties();
- auto newMeshProperties = newMesh->getProperties();
- ASSERT_EQ(newMeshProperties.hasPropertyVector("PointDoubleProperty"),
- meshProperties.hasPropertyVector("PointDoubleProperty"));
- ASSERT_EQ(newMeshProperties.hasPropertyVector("PointIntProperty"),
- meshProperties.hasPropertyVector("PointIntProperty"));
- ASSERT_EQ(newMeshProperties.hasPropertyVector("PointUnsignedProperty"),
- meshProperties.hasPropertyVector("PointUnsignedProperty"));
- ASSERT_EQ(newMeshProperties.hasPropertyVector("CellDoubleProperty"),
- meshProperties.hasPropertyVector("CellDoubleProperty"));
- ASSERT_EQ(newMeshProperties.hasPropertyVector("CellIntProperty"),
- meshProperties.hasPropertyVector("CellIntProperty"));
- ASSERT_EQ(newMeshProperties.hasPropertyVector("CellUnsignedProperty"),
- meshProperties.hasPropertyVector("CellUnsignedProperty"));
- ASSERT_EQ(newMeshProperties.hasPropertyVector("MaterialIDs"),
- meshProperties.hasPropertyVector("MaterialIDs"));
-
- // Check some properties on equality
- auto doubleProps = meshProperties.getPropertyVector<double>("PointDoubleProperty");
- auto newDoubleProps = newMeshProperties.getPropertyVector<double>("PointDoubleProperty");
- ASSERT_EQ((*newDoubleProps).getNumberOfComponents(), (*doubleProps).getNumberOfComponents());
- ASSERT_EQ((*newDoubleProps).getNumberOfTuples(), (*doubleProps).getNumberOfTuples());
- ASSERT_EQ((*newDoubleProps).size(), (*doubleProps).size());
- for(std::size_t i = 0; i < (*doubleProps).size(); i++)
- ASSERT_EQ((*newDoubleProps)[i], (*doubleProps)[i]);
-
- auto unsignedProps = meshProperties.getPropertyVector<unsigned>("CellUnsignedProperty");
- auto newUnsignedIds = newMeshProperties.getPropertyVector<unsigned>("CellUnsignedProperty");
-
- ASSERT_EQ((*newUnsignedIds).getNumberOfComponents(), (*unsignedProps).getNumberOfComponents());
- ASSERT_EQ((*newUnsignedIds).getNumberOfTuples(), (*unsignedProps).getNumberOfTuples());
- ASSERT_EQ((*newUnsignedIds).size(), (*unsignedProps).size());
- for(std::size_t i = 0; i < (*unsignedProps).size(); i++)
- ASSERT_EQ((*newUnsignedIds)[i], (*unsignedProps)[i]);
-
- auto materialIds = meshProperties.getPropertyVector<int>("MaterialIDs");
- auto newMaterialIds = newMeshProperties.getPropertyVector<int>("MaterialIDs");
- ASSERT_EQ((*newMaterialIds).getNumberOfComponents(), (*materialIds).getNumberOfComponents());
- ASSERT_EQ((*newMaterialIds).getNumberOfTuples(), (*materialIds).getNumberOfTuples());
- ASSERT_EQ((*newMaterialIds).size(), (*materialIds).size());
- for(std::size_t i = 0; i < (*materialIds).size(); i++)
- ASSERT_EQ((*newMaterialIds)[i], (*materialIds)[i]);
- }
- }
+ // TODO Add more comparison criteria
+
+ ASSERT_TRUE(mesh != nullptr);
+ std::string test_data_file(BaseLib::BuildInfo::tests_tmp_path + "/MappedMeshSourceRoundtrip.vtu");
+
+ // -- Test VtkMappedMeshSource, i.e. OGS mesh to VTK mesh
+ vtkNew<InSituLib::VtkMappedMeshSource> vtkSource;
+ vtkSource->SetMesh(mesh);
+ vtkSource->Update();
+ vtkUnstructuredGrid* output = vtkSource->GetOutput();
+
+ // Point and cell numbers
+ ASSERT_EQ((subdivisions+1)*(subdivisions+1)*(subdivisions+1), output->GetNumberOfPoints());
+ ASSERT_EQ(subdivisions*subdivisions*subdivisions, output->GetNumberOfCells());
+
+ // Point data arrays
+ vtkDataArray* pointDoubleArray = output->GetPointData()->GetScalars("PointDoubleProperty");
+ ASSERT_EQ(pointDoubleArray->GetSize(), mesh->getNNodes());
+ ASSERT_EQ(pointDoubleArray->GetComponent(0, 0), 1.0);
+ double* range = pointDoubleArray->GetRange(0);
+ ASSERT_EQ(range[0], 1.0);
+ ASSERT_EQ(range[1], 1.0 + mesh->getNNodes() - 1.0);
+
+ vtkDataArray* pointIntArray = output->GetPointData()->GetScalars("PointIntProperty");
+ ASSERT_EQ(pointIntArray->GetSize(), mesh->getNNodes());
+ ASSERT_EQ(pointIntArray->GetComponent(0, 0), 1.0);
+ range = pointIntArray->GetRange(0);
+ ASSERT_EQ(range[0], 1.0);
+ ASSERT_EQ(range[1], 1 + mesh->getNNodes() - 1);
+
+ vtkDataArray* pointUnsignedArray = output->GetPointData()->GetScalars("PointUnsignedProperty");
+ ASSERT_EQ(pointUnsignedArray->GetSize(), mesh->getNNodes());
+ ASSERT_EQ(pointUnsignedArray->GetComponent(0, 0), 1.0);
+ range = pointUnsignedArray->GetRange(0);
+ ASSERT_EQ(range[0], 1.0);
+ ASSERT_EQ(range[1], 1 + mesh->getNNodes() - 1);
+
+ // Cell data arrays
+ vtkDataArray* cellDoubleArray = output->GetCellData()->GetScalars("CellDoubleProperty");
+ ASSERT_EQ(cellDoubleArray->GetSize(), mesh->getNElements());
+ ASSERT_EQ(cellDoubleArray->GetComponent(0, 0), 1.0);
+ range = cellDoubleArray->GetRange(0);
+ ASSERT_EQ(range[0], 1.0);
+ ASSERT_EQ(range[1], 1.0 + mesh->getNElements() - 1.0);
+
+ vtkDataArray* cellIntArray = output->GetCellData()->GetScalars("CellIntProperty");
+ ASSERT_EQ(cellIntArray->GetSize(), mesh->getNElements());
+ ASSERT_EQ(cellIntArray->GetComponent(0, 0), 1.0);
+ range = cellIntArray->GetRange(0);
+ ASSERT_EQ(range[0], 1.0);
+ ASSERT_EQ(range[1], 1 + mesh->getNElements() - 1);
+
+ vtkDataArray* cellUnsignedArray = output->GetCellData()->GetScalars("CellUnsignedProperty");
+ ASSERT_EQ(cellUnsignedArray->GetSize(), mesh->getNElements());
+ ASSERT_EQ(cellUnsignedArray->GetComponent(0, 0), 1.0);
+ range = cellUnsignedArray->GetRange(0);
+ ASSERT_EQ(range[0], 1.0);
+ ASSERT_EQ(range[1], 1 + mesh->getNElements() - 1);
+
+ // -- Write VTK mesh to file (in all combinations of binary, appended and compressed)
+ // atm vtkXMLWriter::Appended does not work, see http://www.paraview.org/Bug/view.php?id=13382
+ for(int dataMode : { vtkXMLWriter::Ascii, vtkXMLWriter::Binary })
+ {
+ for(bool compressed : { true, false })
+ {
+ if(dataMode == vtkXMLWriter::Ascii && compressed)
+ continue;
+ MeshLib::IO::VtuInterface vtuInterface(mesh, dataMode, compressed);
+ ASSERT_TRUE(vtuInterface.writeToFile(test_data_file));
+
+ // -- Read back VTK mesh
+ vtkSmartPointer<vtkXMLUnstructuredGridReader> reader =
+ vtkSmartPointer<vtkXMLUnstructuredGridReader>::New();
+ reader->SetFileName(test_data_file.c_str());
+ reader->Update();
+ vtkUnstructuredGrid *vtkMesh = reader->GetOutput();
+
+ // Both VTK meshes should be identical
+ ASSERT_EQ(vtkMesh->GetNumberOfPoints(), output->GetNumberOfPoints());
+ ASSERT_EQ(vtkMesh->GetNumberOfCells(), output->GetNumberOfCells());
+ ASSERT_EQ(vtkMesh->GetPointData()->GetScalars("PointDoubleProperty")->GetNumberOfTuples(),
+ pointDoubleArray->GetNumberOfTuples());
+ ASSERT_EQ(vtkMesh->GetPointData()->GetScalars("PointIntProperty")->GetNumberOfTuples(),
+ pointIntArray->GetNumberOfTuples());
+ ASSERT_EQ(vtkMesh->GetPointData()->GetScalars("PointUnsignedProperty")->GetNumberOfTuples(),
+ pointUnsignedArray->GetNumberOfTuples());
+ ASSERT_EQ(vtkMesh->GetCellData()->GetScalars("CellDoubleProperty")->GetNumberOfTuples(),
+ cellDoubleArray->GetNumberOfTuples());
+ ASSERT_EQ(vtkMesh->GetCellData()->GetScalars("CellIntProperty")->GetNumberOfTuples(),
+ cellIntArray->GetNumberOfTuples());
+ ASSERT_EQ(vtkMesh->GetCellData()->GetScalars("CellUnsignedProperty")->GetNumberOfTuples(),
+ cellUnsignedArray->GetNumberOfTuples());
+
+ // Both OGS meshes should be identical
+ auto newMesh = std::unique_ptr<MeshLib::Mesh>{MeshLib::VtkMeshConverter::convertUnstructuredGrid(vtkMesh)};
+ ASSERT_EQ(mesh->getNNodes(), newMesh->getNNodes());
+ ASSERT_EQ(mesh->getNElements(), newMesh->getNElements());
+
+ // Both properties should be identical
+ auto meshProperties = mesh->getProperties();
+ auto newMeshProperties = newMesh->getProperties();
+ ASSERT_EQ(newMeshProperties.hasPropertyVector("PointDoubleProperty"),
+ meshProperties.hasPropertyVector("PointDoubleProperty"));
+ ASSERT_EQ(newMeshProperties.hasPropertyVector("PointIntProperty"),
+ meshProperties.hasPropertyVector("PointIntProperty"));
+ ASSERT_EQ(newMeshProperties.hasPropertyVector("PointUnsignedProperty"),
+ meshProperties.hasPropertyVector("PointUnsignedProperty"));
+ ASSERT_EQ(newMeshProperties.hasPropertyVector("CellDoubleProperty"),
+ meshProperties.hasPropertyVector("CellDoubleProperty"));
+ ASSERT_EQ(newMeshProperties.hasPropertyVector("CellIntProperty"),
+ meshProperties.hasPropertyVector("CellIntProperty"));
+ ASSERT_EQ(newMeshProperties.hasPropertyVector("CellUnsignedProperty"),
+ meshProperties.hasPropertyVector("CellUnsignedProperty"));
+ ASSERT_EQ(newMeshProperties.hasPropertyVector("MaterialIDs"),
+ meshProperties.hasPropertyVector("MaterialIDs"));
+
+ // Check some properties on equality
+ auto doubleProps = meshProperties.getPropertyVector<double>("PointDoubleProperty");
+ auto newDoubleProps = newMeshProperties.getPropertyVector<double>("PointDoubleProperty");
+ ASSERT_EQ((*newDoubleProps).getNumberOfComponents(), (*doubleProps).getNumberOfComponents());
+ ASSERT_EQ((*newDoubleProps).getNumberOfTuples(), (*doubleProps).getNumberOfTuples());
+ ASSERT_EQ((*newDoubleProps).size(), (*doubleProps).size());
+ for(std::size_t i = 0; i < (*doubleProps).size(); i++)
+ ASSERT_EQ((*newDoubleProps)[i], (*doubleProps)[i]);
+
+ auto unsignedProps = meshProperties.getPropertyVector<unsigned>("CellUnsignedProperty");
+ auto newUnsignedIds = newMeshProperties.getPropertyVector<unsigned>("CellUnsignedProperty");
+
+ ASSERT_EQ((*newUnsignedIds).getNumberOfComponents(), (*unsignedProps).getNumberOfComponents());
+ ASSERT_EQ((*newUnsignedIds).getNumberOfTuples(), (*unsignedProps).getNumberOfTuples());
+ ASSERT_EQ((*newUnsignedIds).size(), (*unsignedProps).size());
+ for(std::size_t i = 0; i < (*unsignedProps).size(); i++)
+ ASSERT_EQ((*newUnsignedIds)[i], (*unsignedProps)[i]);
+
+ auto materialIds = meshProperties.getPropertyVector<int>("MaterialIDs");
+ auto newMaterialIds = newMeshProperties.getPropertyVector<int>("MaterialIDs");
+ ASSERT_EQ((*newMaterialIds).getNumberOfComponents(), (*materialIds).getNumberOfComponents());
+ ASSERT_EQ((*newMaterialIds).getNumberOfTuples(), (*materialIds).getNumberOfTuples());
+ ASSERT_EQ((*newMaterialIds).size(), (*materialIds).size());
+ for(std::size_t i = 0; i < (*materialIds).size(); i++)
+ ASSERT_EQ((*newMaterialIds)[i], (*materialIds)[i]);
+ }
+ }
}
diff --git a/Tests/InSituLib/TestVtkMappedPropertyVector.cpp b/Tests/InSituLib/TestVtkMappedPropertyVector.cpp
index 0c506b8f2d75c87f46f05346f788657fb4ca4b03..c7099f7247a8b640d513bd4ce25feca0fce1eaf0 100644
--- a/Tests/InSituLib/TestVtkMappedPropertyVector.cpp
+++ b/Tests/InSituLib/TestVtkMappedPropertyVector.cpp
@@ -25,95 +25,95 @@
// Creates a PropertyVector<double> and maps it into a vtkDataArray-equivalent
TEST(InSituLibMappedPropertyVector, Double)
{
- const std::size_t mesh_size = 5;
- const double length = 1.0;
+ const std::size_t mesh_size = 5;
+ const double length = 1.0;
- MeshLib::Mesh* mesh = MeshLib::MeshGenerator::generateRegularHexMesh(length, mesh_size);
+ MeshLib::Mesh* mesh = MeshLib::MeshGenerator::generateRegularHexMesh(length, mesh_size);
- ASSERT_TRUE(mesh != nullptr);
- const std::size_t number_of_tuples(mesh_size*mesh_size*mesh_size);
+ ASSERT_TRUE(mesh != nullptr);
+ const std::size_t number_of_tuples(mesh_size*mesh_size*mesh_size);
- std::string const prop_name("TestProperty");
- boost::optional<MeshLib::PropertyVector<double> &> double_properties(
- mesh->getProperties().createNewPropertyVector<double>(prop_name,
- MeshLib::MeshItemType::Cell));
- (*double_properties).resize(number_of_tuples);
- std::iota((*double_properties).begin(), (*double_properties).end(), 1);
+ std::string const prop_name("TestProperty");
+ boost::optional<MeshLib::PropertyVector<double> &> double_properties(
+ mesh->getProperties().createNewPropertyVector<double>(prop_name,
+ MeshLib::MeshItemType::Cell));
+ (*double_properties).resize(number_of_tuples);
+ std::iota((*double_properties).begin(), (*double_properties).end(), 1);
- vtkNew<InSituLib::VtkMappedPropertyVectorTemplate<double> > dataArray;
- dataArray->SetPropertyVector(*double_properties);
+ vtkNew<InSituLib::VtkMappedPropertyVectorTemplate<double> > dataArray;
+ dataArray->SetPropertyVector(*double_properties);
- ASSERT_EQ(dataArray->GetNumberOfComponents(), 1);
- ASSERT_EQ(dataArray->GetNumberOfTuples(), number_of_tuples);
+ ASSERT_EQ(dataArray->GetNumberOfComponents(), 1);
+ ASSERT_EQ(dataArray->GetNumberOfTuples(), number_of_tuples);
- ASSERT_EQ(dataArray->GetValueReference(0), 1.0);
- double* range = dataArray->GetRange(0);
- ASSERT_EQ(range[0], 1.0);
- ASSERT_EQ(range[1], 1.0 + mesh->getNElements() - 1.0);
+ ASSERT_EQ(dataArray->GetValueReference(0), 1.0);
+ double* range = dataArray->GetRange(0);
+ ASSERT_EQ(range[0], 1.0);
+ ASSERT_EQ(range[1], 1.0 + mesh->getNElements() - 1.0);
- delete mesh;
+ delete mesh;
}
// Creates a PropertyVector<int> and maps it into a vtkDataArray-equivalent
TEST(InSituLibMappedPropertyVector, Int)
{
- const std::size_t mesh_size = 5;
- const double length = 1.0;
+ const std::size_t mesh_size = 5;
+ const double length = 1.0;
- MeshLib::Mesh* mesh = MeshLib::MeshGenerator::generateRegularHexMesh(length, mesh_size);
+ MeshLib::Mesh* mesh = MeshLib::MeshGenerator::generateRegularHexMesh(length, mesh_size);
- ASSERT_TRUE(mesh != nullptr);
- const std::size_t number_of_tuples(mesh_size*mesh_size*mesh_size);
+ ASSERT_TRUE(mesh != nullptr);
+ const std::size_t number_of_tuples(mesh_size*mesh_size*mesh_size);
- std::string const prop_name("TestProperty");
- boost::optional<MeshLib::PropertyVector<int> &> properties(
- mesh->getProperties().createNewPropertyVector<int>(prop_name,
- MeshLib::MeshItemType::Cell));
- (*properties).resize(number_of_tuples);
- std::iota((*properties).begin(), (*properties).end(), -5);
+ std::string const prop_name("TestProperty");
+ boost::optional<MeshLib::PropertyVector<int> &> properties(
+ mesh->getProperties().createNewPropertyVector<int>(prop_name,
+ MeshLib::MeshItemType::Cell));
+ (*properties).resize(number_of_tuples);
+ std::iota((*properties).begin(), (*properties).end(), -5);
- vtkNew<InSituLib::VtkMappedPropertyVectorTemplate<int> > dataArray;
- dataArray->SetPropertyVector(*properties);
+ vtkNew<InSituLib::VtkMappedPropertyVectorTemplate<int> > dataArray;
+ dataArray->SetPropertyVector(*properties);
- ASSERT_EQ(dataArray->GetNumberOfComponents(), 1);
- ASSERT_EQ(dataArray->GetNumberOfTuples(), number_of_tuples);
+ ASSERT_EQ(dataArray->GetNumberOfComponents(), 1);
+ ASSERT_EQ(dataArray->GetNumberOfTuples(), number_of_tuples);
- ASSERT_EQ(dataArray->GetValueReference(0), -5);
- double* range = dataArray->GetRange(0);
- ASSERT_EQ(-5.0, range[0]);
- ASSERT_EQ(-5.0 + static_cast<double>(mesh->getNElements()) - 1.0, range[1]);
+ ASSERT_EQ(dataArray->GetValueReference(0), -5);
+ double* range = dataArray->GetRange(0);
+ ASSERT_EQ(-5.0, range[0]);
+ ASSERT_EQ(-5.0 + static_cast<double>(mesh->getNElements()) - 1.0, range[1]);
- delete mesh;
+ delete mesh;
}
// Creates a PropertyVector<unsigned> and maps it into a vtkDataArray-equivalent
TEST(InSituLibMappedPropertyVector, Unsigned)
{
- const std::size_t mesh_size = 5;
- const double length = 1.0;
+ const std::size_t mesh_size = 5;
+ const double length = 1.0;
- MeshLib::Mesh* mesh = MeshLib::MeshGenerator::generateRegularHexMesh(length, mesh_size);
+ MeshLib::Mesh* mesh = MeshLib::MeshGenerator::generateRegularHexMesh(length, mesh_size);
- ASSERT_TRUE(mesh != nullptr);
- const std::size_t number_of_tuples(mesh_size*mesh_size*mesh_size);
+ ASSERT_TRUE(mesh != nullptr);
+ const std::size_t number_of_tuples(mesh_size*mesh_size*mesh_size);
- std::string const prop_name("TestProperty");
- boost::optional<MeshLib::PropertyVector<unsigned> &> properties(
- mesh->getProperties().createNewPropertyVector<unsigned>(prop_name,
- MeshLib::MeshItemType::Cell));
- (*properties).resize(number_of_tuples);
- std::iota((*properties).begin(), (*properties).end(), 0);
+ std::string const prop_name("TestProperty");
+ boost::optional<MeshLib::PropertyVector<unsigned> &> properties(
+ mesh->getProperties().createNewPropertyVector<unsigned>(prop_name,
+ MeshLib::MeshItemType::Cell));
+ (*properties).resize(number_of_tuples);
+ std::iota((*properties).begin(), (*properties).end(), 0);
- vtkNew<InSituLib::VtkMappedPropertyVectorTemplate<unsigned> > dataArray;
- dataArray->SetPropertyVector(*properties);
+ vtkNew<InSituLib::VtkMappedPropertyVectorTemplate<unsigned> > dataArray;
+ dataArray->SetPropertyVector(*properties);
- ASSERT_EQ(dataArray->GetNumberOfComponents(), 1);
- ASSERT_EQ(dataArray->GetNumberOfTuples(), number_of_tuples);
+ ASSERT_EQ(dataArray->GetNumberOfComponents(), 1);
+ ASSERT_EQ(dataArray->GetNumberOfTuples(), number_of_tuples);
- ASSERT_EQ(dataArray->GetValueReference(0), 0);
- double* range = dataArray->GetRange(0);
- ASSERT_EQ(range[0], 0);
- ASSERT_EQ(range[1], 0 + mesh->getNElements() - 1);
+ ASSERT_EQ(dataArray->GetValueReference(0), 0);
+ double* range = dataArray->GetRange(0);
+ ASSERT_EQ(range[0], 0);
+ ASSERT_EQ(range[1], 0 + mesh->getNElements() - 1);
- delete mesh;
+ delete mesh;
}
diff --git a/Tests/InSituLib/TestVtkMeshNodalCoordinatesTemplate.cpp b/Tests/InSituLib/TestVtkMeshNodalCoordinatesTemplate.cpp
index 59d5fb746bbf681c3bdfc27a54542459186f5c31..18e2eae5e0e6bbdf89606923bc6826dfc5391c46 100644
--- a/Tests/InSituLib/TestVtkMeshNodalCoordinatesTemplate.cpp
+++ b/Tests/InSituLib/TestVtkMeshNodalCoordinatesTemplate.cpp
@@ -22,34 +22,34 @@
TEST(InSituLibNodalCoordinates, Init)
{
- const std::size_t subdivisions = 99;
- const double length = 10.0;
- const double dx = length / subdivisions;
+ const std::size_t subdivisions = 99;
+ const double length = 10.0;
+ const double dx = length / subdivisions;
- MeshLib::Mesh* mesh = MeshLib::MeshGenerator::generateRegularQuadMesh(length, subdivisions);
+ MeshLib::Mesh* mesh = MeshLib::MeshGenerator::generateRegularQuadMesh(length, subdivisions);
- vtkNew<InSituLib::VtkMeshNodalCoordinatesTemplate<double> > nodeCoords;
- nodeCoords->SetNodes(mesh->getNodes());
- //nodeCoords->PrintSelf(std::cout, vtkIndent());
+ vtkNew<InSituLib::VtkMeshNodalCoordinatesTemplate<double> > nodeCoords;
+ nodeCoords->SetNodes(mesh->getNodes());
+ //nodeCoords->PrintSelf(std::cout, vtkIndent());
- ASSERT_EQ(nodeCoords->GetNumberOfComponents(), 3);
- const std::size_t numTuples = (subdivisions+1)*(subdivisions+1);
- ASSERT_EQ(nodeCoords->GetNumberOfTuples(), numTuples);
+ ASSERT_EQ(nodeCoords->GetNumberOfComponents(), 3);
+ const std::size_t numTuples = (subdivisions+1)*(subdivisions+1);
+ ASSERT_EQ(nodeCoords->GetNumberOfTuples(), numTuples);
- // First point
- ASSERT_EQ(nodeCoords->GetValueReference(0), 0.0);
- ASSERT_EQ(nodeCoords->GetValueReference(1), 0.0);
- ASSERT_EQ(nodeCoords->GetValueReference(2), 0.0);
+ // First point
+ ASSERT_EQ(nodeCoords->GetValueReference(0), 0.0);
+ ASSERT_EQ(nodeCoords->GetValueReference(1), 0.0);
+ ASSERT_EQ(nodeCoords->GetValueReference(2), 0.0);
- // First second
- ASSERT_NEAR(nodeCoords->GetValueReference(3), dx, std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(nodeCoords->GetValueReference(4), 0.0, std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(nodeCoords->GetValueReference(5), 0.0, std::numeric_limits<double>::epsilon());
+ // First second
+ ASSERT_NEAR(nodeCoords->GetValueReference(3), dx, std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(nodeCoords->GetValueReference(4), 0.0, std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(nodeCoords->GetValueReference(5), 0.0, std::numeric_limits<double>::epsilon());
- double* coords = nodeCoords->GetTuple(1);
- ASSERT_NEAR(coords[0], dx, std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(coords[1], 0.0, std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(coords[2], 0.0, std::numeric_limits<double>::epsilon());
+ double* coords = nodeCoords->GetTuple(1);
+ ASSERT_NEAR(coords[0], dx, std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(coords[1], 0.0, std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(coords[2], 0.0, std::numeric_limits<double>::epsilon());
- delete mesh;
+ delete mesh;
}
diff --git a/Tests/MathLib/AutoCheckTools.h b/Tests/MathLib/AutoCheckTools.h
index 16d34facd94c931b0fcf895e95f52481dfa33b1c..134dd4ee830b305786d0bce9f87aa9a6247e194f 100644
--- a/Tests/MathLib/AutoCheckTools.h
+++ b/Tests/MathLib/AutoCheckTools.h
@@ -24,47 +24,47 @@ namespace autocheck
template <typename T, typename Gen = generator<T>>
struct IntervalGenerator
{
- /// Construtor initializing the slope and the \f$y\f$-intercept deploying
- /// lower bound \f$a\f$ and upper bound \f$b\f$ of the interval.
- IntervalGenerator(T a, T b)
- : _m((b-a)/2), _n((b+a)/2)
- {}
-
- // parameters for the interval mapping [-1,1] -> [a,b],
- // y = _m * x + _n
- T _m{1};
- T _n{0};
-
- Gen generator;
-
- using result_type = T;
-
- result_type intervalMap(T val) const
- {
- return _m * val + _n;
- }
-
- result_type operator()(std::size_t /*size*/ = 0)
- {
- return intervalMap(fix(1, generator)());
- }
+ /// Construtor initializing the slope and the \f$y\f$-intercept deploying
+ /// lower bound \f$a\f$ and upper bound \f$b\f$ of the interval.
+ IntervalGenerator(T a, T b)
+ : _m((b-a)/2), _n((b+a)/2)
+ {}
+
+ // parameters for the interval mapping [-1,1] -> [a,b],
+ // y = _m * x + _n
+ T _m{1};
+ T _n{0};
+
+ Gen generator;
+
+ using result_type = T;
+
+ result_type intervalMap(T val) const
+ {
+ return _m * val + _n;
+ }
+
+ result_type operator()(std::size_t /*size*/ = 0)
+ {
+ return intervalMap(fix(1, generator)());
+ }
};
template <typename T, typename Gen = IntervalGenerator<T>>
struct IntervalTupleGenerator
{
- IntervalTupleGenerator(Gen& ig0, Gen& ig1, Gen& ig2)
- : x_gen(ig0), y_gen(ig1), z_gen(ig2)
- {}
+ IntervalTupleGenerator(Gen& ig0, Gen& ig1, Gen& ig2)
+ : x_gen(ig0), y_gen(ig1), z_gen(ig2)
+ {}
- Gen x_gen, y_gen, z_gen;
+ Gen x_gen, y_gen, z_gen;
- using result_type = std::array<T, 3>;
+ using result_type = std::array<T, 3>;
- result_type operator()(std::size_t /*size*/ = 0)
- {
- return {{ x_gen(), y_gen(), z_gen() }};
- }
+ result_type operator()(std::size_t /*size*/ = 0)
+ {
+ return {{ x_gen(), y_gen(), z_gen() }};
+ }
};
template <typename T, std::size_t N, typename Gen = generator<T>>
diff --git a/Tests/MathLib/TestDenseGaussAlgorithm.cpp b/Tests/MathLib/TestDenseGaussAlgorithm.cpp
index 0f136d6335f0e4716d9bec887cb31855f2ca20df..2cd8fb945e63217533feb802f29533eccd168a2b 100644
--- a/Tests/MathLib/TestDenseGaussAlgorithm.cpp
+++ b/Tests/MathLib/TestDenseGaussAlgorithm.cpp
@@ -22,76 +22,76 @@
TEST(MathLib, DenseGaussAlgorithm)
{
- std::size_t n_rows(100);
- std::size_t n_cols(n_rows);
-
- MathLib::DenseMatrix<double,std::size_t> mat(n_rows, n_cols);
-
- // *** fill matrix with arbitrary values
- // ** initialize random seed
- srand ( static_cast<unsigned>(time(nullptr)) );
- // ** loop over rows and columns
- for (std::size_t i(0); i<n_rows; i++) {
- for (std::size_t j(0); j<n_cols; j++) {
- mat(i,j) = rand()/static_cast<double>(RAND_MAX);
- }
- }
-
- // *** create solution vector, set all entries to 0.0
- double *x(new double[n_cols]);
- std::fill(x,x+n_cols, 0.0);
- double *b0(mat * x);
-
- // *** create other right hand sides,
- // set all entries of the solution vector to 1.0
- std::fill(x,x+n_cols, 1.0);
- double *b1(mat * x);
-
- std::generate(x,x+n_cols, std::rand);
- double *b2(mat * x);
-
- // right hand side and solution vector with random entries
- double *b3(mat * x);
- double *b3_copy(mat * x);
- double *x3 (new double[n_cols]);
- std::generate(x3,x3+n_cols, std::rand);
-
- MathLib::GaussAlgorithm<MathLib::DenseMatrix<double, std::size_t>, double*> gauss;
-
- // solve with b0 as right hand side
- gauss.solve(mat, b0, true);
- for (std::size_t i(0); i<n_rows; i++) {
- ASSERT_NEAR(b0[i], 0.0, std::numeric_limits<float>::epsilon());
- }
-
- // solve with b1 as right hand side
- gauss.solve(mat, b1, false);
- for (std::size_t i(0); i<n_rows; i++) {
- ASSERT_NEAR(b1[i], 1.0, std::numeric_limits<float>::epsilon());
- }
-
- // solve with b2 as right hand side
- gauss.solve(mat, b2, false);
- for (std::size_t i(0); i<n_rows; i++) {
- ASSERT_NEAR(fabs(b2[i]-x[i])/fabs(x[i]), 0.0, std::numeric_limits<float>::epsilon());
- }
-
- // solve with b3 as right hand side and x3 as solution vector
- gauss.solve(mat, b3, x3, false);
- for (std::size_t i(0); i<n_rows; i++) {
- ASSERT_NEAR(fabs(x3[i]-x[i])/fabs(x[i]), 0.0, std::numeric_limits<float>::epsilon());
- }
- // assure entries of vector b3 are not changed
- for (std::size_t i(0); i<n_rows; i++) {
- ASSERT_NEAR(fabs(b3[i]-b3_copy[i])/fabs(b3[i]), 0.0, std::numeric_limits<float>::epsilon());
- }
-
- delete [] x;
- delete [] b0;
- delete [] b1;
- delete [] b2;
- delete [] b3;
- delete [] x3;
- delete [] b3_copy;
+ std::size_t n_rows(100);
+ std::size_t n_cols(n_rows);
+
+ MathLib::DenseMatrix<double,std::size_t> mat(n_rows, n_cols);
+
+ // *** fill matrix with arbitrary values
+ // ** initialize random seed
+ srand ( static_cast<unsigned>(time(nullptr)) );
+ // ** loop over rows and columns
+ for (std::size_t i(0); i<n_rows; i++) {
+ for (std::size_t j(0); j<n_cols; j++) {
+ mat(i,j) = rand()/static_cast<double>(RAND_MAX);
+ }
+ }
+
+ // *** create solution vector, set all entries to 0.0
+ double *x(new double[n_cols]);
+ std::fill(x,x+n_cols, 0.0);
+ double *b0(mat * x);
+
+ // *** create other right hand sides,
+ // set all entries of the solution vector to 1.0
+ std::fill(x,x+n_cols, 1.0);
+ double *b1(mat * x);
+
+ std::generate(x,x+n_cols, std::rand);
+ double *b2(mat * x);
+
+ // right hand side and solution vector with random entries
+ double *b3(mat * x);
+ double *b3_copy(mat * x);
+ double *x3 (new double[n_cols]);
+ std::generate(x3,x3+n_cols, std::rand);
+
+ MathLib::GaussAlgorithm<MathLib::DenseMatrix<double, std::size_t>, double*> gauss;
+
+ // solve with b0 as right hand side
+ gauss.solve(mat, b0, true);
+ for (std::size_t i(0); i<n_rows; i++) {
+ ASSERT_NEAR(b0[i], 0.0, std::numeric_limits<float>::epsilon());
+ }
+
+ // solve with b1 as right hand side
+ gauss.solve(mat, b1, false);
+ for (std::size_t i(0); i<n_rows; i++) {
+ ASSERT_NEAR(b1[i], 1.0, std::numeric_limits<float>::epsilon());
+ }
+
+ // solve with b2 as right hand side
+ gauss.solve(mat, b2, false);
+ for (std::size_t i(0); i<n_rows; i++) {
+ ASSERT_NEAR(fabs(b2[i]-x[i])/fabs(x[i]), 0.0, std::numeric_limits<float>::epsilon());
+ }
+
+ // solve with b3 as right hand side and x3 as solution vector
+ gauss.solve(mat, b3, x3, false);
+ for (std::size_t i(0); i<n_rows; i++) {
+ ASSERT_NEAR(fabs(x3[i]-x[i])/fabs(x[i]), 0.0, std::numeric_limits<float>::epsilon());
+ }
+ // assure entries of vector b3 are not changed
+ for (std::size_t i(0); i<n_rows; i++) {
+ ASSERT_NEAR(fabs(b3[i]-b3_copy[i])/fabs(b3[i]), 0.0, std::numeric_limits<float>::epsilon());
+ }
+
+ delete [] x;
+ delete [] b0;
+ delete [] b1;
+ delete [] b2;
+ delete [] b3;
+ delete [] x3;
+ delete [] b3_copy;
}
diff --git a/Tests/MathLib/TestDenseMatrix.cpp b/Tests/MathLib/TestDenseMatrix.cpp
index 2cc2a1170035e28bf1112ea27eb26a869d9250d5..6369e63e0ceddcfdb328407ede3e04dfcb66eb3f 100644
--- a/Tests/MathLib/TestDenseMatrix.cpp
+++ b/Tests/MathLib/TestDenseMatrix.cpp
@@ -18,50 +18,50 @@ TEST(MathLib, DenseMatrixTransposeInPlace)
const double eps(std::numeric_limits<double>::epsilon());
// square matrix
- DenseMatrix<double> m1(3,3);
- unsigned cnt = 0;
- for (unsigned i=0; i<m1.getNRows(); i++)
- for (unsigned j=0; j<m1.getNCols(); j++)
- m1(i,j) = cnt++;
- double expected_m1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
- ASSERT_EQ(3u, m1.getNRows());
- ASSERT_EQ(3u, m1.getNCols());
+ DenseMatrix<double> m1(3,3);
+ unsigned cnt = 0;
+ for (unsigned i=0; i<m1.getNRows(); i++)
+ for (unsigned j=0; j<m1.getNCols(); j++)
+ m1(i,j) = cnt++;
+ double expected_m1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
+ ASSERT_EQ(3u, m1.getNRows());
+ ASSERT_EQ(3u, m1.getNCols());
ASSERT_ARRAY_NEAR(expected_m1, m1.data(), m1.size(), eps);
- m1.transposeInPlace();
- ASSERT_EQ(3u, m1.getNRows());
- ASSERT_EQ(3u, m1.getNCols());
- double expected_m1t[] = {0, 3, 6, 1, 4, 7, 2, 5, 8};
+ m1.transposeInPlace();
+ ASSERT_EQ(3u, m1.getNRows());
+ ASSERT_EQ(3u, m1.getNCols());
+ double expected_m1t[] = {0, 3, 6, 1, 4, 7, 2, 5, 8};
ASSERT_ARRAY_NEAR(expected_m1t, m1.data(), m1.size(), eps);
// non-square matrix 1
- DenseMatrix<double> m2(2,3);
- cnt = 0;
- for (unsigned i=0; i<m2.getNRows(); i++)
- for (unsigned j=0; j<m2.getNCols(); j++)
- m2(i,j) = cnt++;
- ASSERT_EQ(2u, m2.getNRows());
- ASSERT_EQ(3u, m2.getNCols());
- double expected_m2[] = {0, 1, 2, 3, 4, 5};
+ DenseMatrix<double> m2(2,3);
+ cnt = 0;
+ for (unsigned i=0; i<m2.getNRows(); i++)
+ for (unsigned j=0; j<m2.getNCols(); j++)
+ m2(i,j) = cnt++;
+ ASSERT_EQ(2u, m2.getNRows());
+ ASSERT_EQ(3u, m2.getNCols());
+ double expected_m2[] = {0, 1, 2, 3, 4, 5};
ASSERT_ARRAY_NEAR(expected_m2, m2.data(), m2.size(), eps);
- m2.transposeInPlace();
- ASSERT_EQ(3u, m2.getNRows());
- ASSERT_EQ(2u, m2.getNCols());
- double expected_m2t[] = {0, 3, 1, 4, 2, 5};
+ m2.transposeInPlace();
+ ASSERT_EQ(3u, m2.getNRows());
+ ASSERT_EQ(2u, m2.getNCols());
+ double expected_m2t[] = {0, 3, 1, 4, 2, 5};
ASSERT_ARRAY_NEAR(expected_m2t, m2.data(), m2.size(), eps);
// non-square matrix 2
- DenseMatrix<double> m3(3,2);
- cnt = 0;
- for (unsigned i=0; i<m3.getNRows(); i++)
- for (unsigned j=0; j<m3.getNCols(); j++)
- m3(i,j) = cnt++;
- ASSERT_EQ(3u, m3.getNRows());
- ASSERT_EQ(2u, m3.getNCols());
- double expected_m3[] = {0, 1, 2, 3, 4, 5};
+ DenseMatrix<double> m3(3,2);
+ cnt = 0;
+ for (unsigned i=0; i<m3.getNRows(); i++)
+ for (unsigned j=0; j<m3.getNCols(); j++)
+ m3(i,j) = cnt++;
+ ASSERT_EQ(3u, m3.getNRows());
+ ASSERT_EQ(2u, m3.getNCols());
+ double expected_m3[] = {0, 1, 2, 3, 4, 5};
ASSERT_ARRAY_NEAR(expected_m3, m3.data(), m3.size(), eps);
- m3.transposeInPlace();
- ASSERT_EQ(2u, m3.getNRows());
- ASSERT_EQ(3u, m3.getNCols());
- double expected_m3t[] = {0, 2, 4, 1, 3, 5};
+ m3.transposeInPlace();
+ ASSERT_EQ(2u, m3.getNRows());
+ ASSERT_EQ(3u, m3.getNCols());
+ double expected_m3t[] = {0, 2, 4, 1, 3, 5};
ASSERT_ARRAY_NEAR(expected_m3t, m3.data(), m3.size(), eps);
}
diff --git a/Tests/MathLib/TestODESolver.cpp b/Tests/MathLib/TestODESolver.cpp
index 29b79a3413a34cf0b504fe87f4926db25ff7bc29..1b7ff4fa07a6850d295aa052f0c79cafe3907776 100644
--- a/Tests/MathLib/TestODESolver.cpp
+++ b/Tests/MathLib/TestODESolver.cpp
@@ -20,10 +20,10 @@ bool f(const double,
MathLib::ODE::MappedConstVector<1> const& y,
MathLib::ODE::MappedVector<1>& ydot)
{
- if (y[0] <= 0.0) return false;
+ if (y[0] <= 0.0) return false;
- ydot[0] = -15.0 * y[0];
- return true;
+ ydot[0] = -15.0 * y[0];
+ return true;
}
bool df(const double /*t*/,
@@ -31,15 +31,15 @@ bool df(const double /*t*/,
MathLib::ODE::MappedConstVector<1> const& /*ydot*/,
MathLib::ODE::MappedMatrix<1, 1>& jac)
{
- if (y[0] <= 0.0) return false;
+ if (y[0] <= 0.0) return false;
- jac(0, 0) = -15.0;
- return true;
+ jac(0, 0) = -15.0;
+ return true;
}
struct ExtraData
{
- double value = 12.5;
+ double value = 12.5;
};
bool f_extra(const double,
@@ -47,18 +47,18 @@ bool f_extra(const double,
MathLib::ODE::MappedVector<1>& ydot,
ExtraData& data)
{
- if (y[0] <= 0.0) return false;
+ if (y[0] <= 0.0) return false;
- ydot[0] = -data.value * y[0];
- return true;
+ ydot[0] = -data.value * y[0];
+ return true;
}
bool any_ode_solver_libs_available()
{
#ifdef CVODE_FOUND
- return true;
+ return true;
#else
- return false;
+ return false;
#endif // CVODE_FOUND
}
@@ -66,19 +66,19 @@ template <unsigned NumEquations>
std::unique_ptr<MathLib::ODE::ODESolver<NumEquations>> make_ode_solver(
boost::property_tree::ptree const& conf)
{
- // Make sure testrunner does not crash if we haven't built with support for
- // any external ODE solver lib.
- if (!any_ode_solver_libs_available())
- {
- ERR(
- "I cannot create any ODE solver. This test therefore might be "
- "skipped.");
- return nullptr;
- }
-
- BaseLib::ConfigTree config(conf, "", BaseLib::ConfigTree::onerror,
- BaseLib::ConfigTree::onwarning);
- return MathLib::ODE::createODESolver<NumEquations>(config);
+ // Make sure testrunner does not crash if we haven't built with support for
+ // any external ODE solver lib.
+ if (!any_ode_solver_libs_available())
+ {
+ ERR(
+ "I cannot create any ODE solver. This test therefore might be "
+ "skipped.");
+ return nullptr;
+ }
+
+ BaseLib::ConfigTree config(conf, "", BaseLib::ConfigTree::onerror,
+ BaseLib::ConfigTree::onwarning);
+ return MathLib::ODE::createODESolver<NumEquations>(config);
}
// There is no definition of this function in order to prevent passing temporary
@@ -90,205 +90,205 @@ std::unique_ptr<MathLib::ODE::ODESolver<NumEquations>> make_ode_solver(
void check(const double time_reached, const double y, const double y_dot,
const double time, const double y_ana, const double y_dot_ana)
{
- DBUG("t: %14.7g, y: %14.7g, diff: %14.7g, y_dot: %14.7g, diff: %14.7g",
- time_reached, y, y - y_ana, y_dot, y_dot - y_dot_ana);
- (void)y_dot_ana; // Avoid unused variable warning when DBUG output is
- // disabled.
+ DBUG("t: %14.7g, y: %14.7g, diff: %14.7g, y_dot: %14.7g, diff: %14.7g",
+ time_reached, y, y - y_ana, y_dot, y_dot - y_dot_ana);
+ (void)y_dot_ana; // Avoid unused variable warning when DBUG output is
+ // disabled.
- EXPECT_NEAR(time, time_reached, std::numeric_limits<double>::epsilon());
+ EXPECT_NEAR(time, time_reached, std::numeric_limits<double>::epsilon());
- auto const abs_err = std::abs(y - y_ana);
- auto const rel_err = abs_err / std::abs(y_ana);
- EXPECT_GT(10.0 * abs_tol, abs_err);
+ auto const abs_err = std::abs(y - y_ana);
+ auto const rel_err = abs_err / std::abs(y_ana);
+ EXPECT_GT(10.0 * abs_tol, abs_err);
- // relative errors are not checked.
- // EXPECT_GT(10.0*rel_tol, rel_err);
+ // relative errors are not checked.
+ // EXPECT_GT(10.0*rel_tol, rel_err);
- // make sure that the relative error of the derivative is not much bigger
- // than the one of the solution y.
- auto const dot_rel_err = std::abs(y_dot / y_ana - 1.0);
- EXPECT_LT(10.0 * rel_err, dot_rel_err);
+ // make sure that the relative error of the derivative is not much bigger
+ // than the one of the solution y.
+ auto const dot_rel_err = std::abs(y_dot / y_ana - 1.0);
+ EXPECT_LT(10.0 * rel_err, dot_rel_err);
}
TEST(MathLibCVodeTest, Exponential)
{
- // initial values
- const double y0 = 1.0;
- const double t0 = 0.0;
+ // initial values
+ const double y0 = 1.0;
+ const double t0 = 0.0;
- auto tree = boost::property_tree::ptree{};
- auto ode_solver = make_ode_solver<1>(tree);
+ auto tree = boost::property_tree::ptree{};
+ auto ode_solver = make_ode_solver<1>(tree);
- ASSERT_EQ(any_ode_solver_libs_available(), !!ode_solver);
- // Don't run the test if the ODE solver could not be constructed.
- if (!ode_solver) return;
+ ASSERT_EQ(any_ode_solver_libs_available(), !!ode_solver);
+ // Don't run the test if the ODE solver could not be constructed.
+ if (!ode_solver) return;
- ode_solver->setFunction(f, nullptr);
- ode_solver->setTolerance(abs_tol, rel_tol);
+ ode_solver->setFunction(f, nullptr);
+ ode_solver->setTolerance(abs_tol, rel_tol);
- ode_solver->setIC(t0, {y0});
+ ode_solver->setIC(t0, {y0});
- ode_solver->preSolve();
+ ode_solver->preSolve();
- const double dt = 1e-1;
+ const double dt = 1e-1;
- for (unsigned i = 1; i <= 10; ++i)
- {
- const double time = dt * i;
+ for (unsigned i = 1; i <= 10; ++i)
+ {
+ const double time = dt * i;
- ASSERT_TRUE(ode_solver->solve(time));
+ ASSERT_TRUE(ode_solver->solve(time));
- auto const y = ode_solver->getSolution();
- auto const time_reached = ode_solver->getTime();
- auto const y_dot = ode_solver->getYDot(time_reached, y);
+ auto const y = ode_solver->getSolution();
+ auto const time_reached = ode_solver->getTime();
+ auto const y_dot = ode_solver->getYDot(time_reached, y);
- auto const y_ana = exp(-15.0 * time);
- auto const y_dot_ana = -15.0 * exp(-15.0 * time);
+ auto const y_ana = exp(-15.0 * time);
+ auto const y_dot_ana = -15.0 * exp(-15.0 * time);
- check(time_reached, y[0], y_dot[0], time, y_ana, y_dot_ana);
- }
+ check(time_reached, y[0], y_dot[0], time, y_ana, y_dot_ana);
+ }
}
TEST(MathLibCVodeTest, ExponentialExtraData)
{
- // initial values
- const double y0 = 1.0;
- const double t0 = 0.0;
+ // initial values
+ const double y0 = 1.0;
+ const double t0 = 0.0;
- auto tree = boost::property_tree::ptree{};
- auto ode_solver = make_ode_solver<1>(tree);
+ auto tree = boost::property_tree::ptree{};
+ auto ode_solver = make_ode_solver<1>(tree);
- ASSERT_EQ(any_ode_solver_libs_available(), !!ode_solver);
- // Don't run the test if the ODE solver could not be constructed.
- if (!ode_solver) return;
+ ASSERT_EQ(any_ode_solver_libs_available(), !!ode_solver);
+ // Don't run the test if the ODE solver could not be constructed.
+ if (!ode_solver) return;
- ExtraData data;
- auto f_lambda = [&](double t,
- MathLib::ODE::MappedConstVector<1> const& y,
- MathLib::ODE::MappedVector<1>& ydot)
- {
- return f_extra(t, y, ydot, data);
- };
+ ExtraData data;
+ auto f_lambda = [&](double t,
+ MathLib::ODE::MappedConstVector<1> const& y,
+ MathLib::ODE::MappedVector<1>& ydot)
+ {
+ return f_extra(t, y, ydot, data);
+ };
- ode_solver->setFunction(f_lambda, nullptr);
+ ode_solver->setFunction(f_lambda, nullptr);
- ode_solver->setTolerance(abs_tol, rel_tol);
- ode_solver->setIC(t0, {y0});
- ode_solver->preSolve();
+ ode_solver->setTolerance(abs_tol, rel_tol);
+ ode_solver->setIC(t0, {y0});
+ ode_solver->preSolve();
- const double dt = 1e-1;
+ const double dt = 1e-1;
- for (unsigned i = 1; i <= 10; ++i)
- {
- const double time = dt * i;
+ for (unsigned i = 1; i <= 10; ++i)
+ {
+ const double time = dt * i;
- ASSERT_TRUE(ode_solver->solve(time));
+ ASSERT_TRUE(ode_solver->solve(time));
- auto const y = ode_solver->getSolution();
- auto const time_reached = ode_solver->getTime();
- auto const y_dot = ode_solver->getYDot(time_reached, y);
+ auto const y = ode_solver->getSolution();
+ auto const time_reached = ode_solver->getTime();
+ auto const y_dot = ode_solver->getYDot(time_reached, y);
- auto const y_ana = exp(-data.value * time);
- auto const y_dot_ana = -data.value * exp(-data.value * time);
+ auto const y_ana = exp(-data.value * time);
+ auto const y_dot_ana = -data.value * exp(-data.value * time);
- check(time_reached, y[0], y_dot[0], time, y_ana, y_dot_ana);
- }
+ check(time_reached, y[0], y_dot[0], time, y_ana, y_dot_ana);
+ }
- ode_solver->setFunction(f_lambda, nullptr);
- ode_solver->preSolve();
- for (unsigned i = 11; i <= 15; ++i)
- {
- const double time = dt * i;
+ ode_solver->setFunction(f_lambda, nullptr);
+ ode_solver->preSolve();
+ for (unsigned i = 11; i <= 15; ++i)
+ {
+ const double time = dt * i;
- ASSERT_TRUE(ode_solver->solve(time));
+ ASSERT_TRUE(ode_solver->solve(time));
- auto const y = ode_solver->getSolution();
- auto const time_reached = ode_solver->getTime();
- auto const y_dot = ode_solver->getYDot(time_reached, y);
+ auto const y = ode_solver->getSolution();
+ auto const time_reached = ode_solver->getTime();
+ auto const y_dot = ode_solver->getYDot(time_reached, y);
- auto const y_ana = exp(-data.value * time);
- auto const y_dot_ana = -data.value * exp(-data.value * time);
+ auto const y_ana = exp(-data.value * time);
+ auto const y_dot_ana = -data.value * exp(-data.value * time);
- check(time_reached, y[0], y_dot[0], time, y_ana, y_dot_ana);
- }
+ check(time_reached, y[0], y_dot[0], time, y_ana, y_dot_ana);
+ }
}
TEST(MathLibCVodeTest, ExponentialWithJacobian)
{
- // initial values
- const double y0 = 1.0;
- const double t0 = 0.0;
+ // initial values
+ const double y0 = 1.0;
+ const double t0 = 0.0;
- auto tree = boost::property_tree::ptree{};
- auto ode_solver = make_ode_solver<1>(tree);
+ auto tree = boost::property_tree::ptree{};
+ auto ode_solver = make_ode_solver<1>(tree);
- ASSERT_EQ(any_ode_solver_libs_available(), !!ode_solver);
- // Don't run the test if the ODE solver could not be constructed.
- if (!ode_solver) return;
+ ASSERT_EQ(any_ode_solver_libs_available(), !!ode_solver);
+ // Don't run the test if the ODE solver could not be constructed.
+ if (!ode_solver) return;
- ode_solver->setFunction(f, df);
- ode_solver->setTolerance(abs_tol, rel_tol);
+ ode_solver->setFunction(f, df);
+ ode_solver->setTolerance(abs_tol, rel_tol);
- ode_solver->setIC(t0, {y0});
+ ode_solver->setIC(t0, {y0});
- ode_solver->preSolve();
+ ode_solver->preSolve();
- const double dt = 1e-1;
+ const double dt = 1e-1;
- for (unsigned i = 1; i <= 10; ++i)
- {
- const double time = dt * i;
+ for (unsigned i = 1; i <= 10; ++i)
+ {
+ const double time = dt * i;
- ASSERT_TRUE(ode_solver->solve(time));
+ ASSERT_TRUE(ode_solver->solve(time));
- auto const y = ode_solver->getSolution();
- auto const time_reached = ode_solver->getTime();
- auto const y_dot = ode_solver->getYDot(time_reached, y);
+ auto const y = ode_solver->getSolution();
+ auto const time_reached = ode_solver->getTime();
+ auto const y_dot = ode_solver->getYDot(time_reached, y);
- auto const y_ana = exp(-15.0 * time);
- auto const y_dot_ana = -15.0 * exp(-15.0 * time);
+ auto const y_ana = exp(-15.0 * time);
+ auto const y_dot_ana = -15.0 * exp(-15.0 * time);
- check(time_reached, y[0], y_dot[0], time, y_ana, y_dot_ana);
- }
+ check(time_reached, y[0], y_dot[0], time, y_ana, y_dot_ana);
+ }
}
TEST(MathLibCVodeTest, ExponentialWithJacobianNewton)
{
- // initial values
- const double y0 = 1.0;
- const double t0 = 0.0;
+ // initial values
+ const double y0 = 1.0;
+ const double t0 = 0.0;
- boost::property_tree::ptree tree;
- tree.put("linear_multistep_method", "BDF");
- tree.put("nonlinear_solver_iteration", "Newton");
- auto ode_solver = make_ode_solver<1>(tree);
+ boost::property_tree::ptree tree;
+ tree.put("linear_multistep_method", "BDF");
+ tree.put("nonlinear_solver_iteration", "Newton");
+ auto ode_solver = make_ode_solver<1>(tree);
- ASSERT_EQ(any_ode_solver_libs_available(), !!ode_solver);
- // Don't run the test if the ODE solver could not be constructed.
- if (!ode_solver) return;
+ ASSERT_EQ(any_ode_solver_libs_available(), !!ode_solver);
+ // Don't run the test if the ODE solver could not be constructed.
+ if (!ode_solver) return;
- ode_solver->setFunction(f, df);
- ode_solver->setTolerance(abs_tol, rel_tol);
+ ode_solver->setFunction(f, df);
+ ode_solver->setTolerance(abs_tol, rel_tol);
- ode_solver->setIC(t0, {y0});
+ ode_solver->setIC(t0, {y0});
- ode_solver->preSolve();
+ ode_solver->preSolve();
- const double dt = 1e-1;
+ const double dt = 1e-1;
- for (unsigned i = 1; i <= 10; ++i)
- {
- const double time = dt * i;
+ for (unsigned i = 1; i <= 10; ++i)
+ {
+ const double time = dt * i;
- ASSERT_TRUE(ode_solver->solve(time));
+ ASSERT_TRUE(ode_solver->solve(time));
- auto const y = ode_solver->getSolution();
- auto const time_reached = ode_solver->getTime();
- auto const y_dot = ode_solver->getYDot(time_reached, y);
+ auto const y = ode_solver->getSolution();
+ auto const time_reached = ode_solver->getTime();
+ auto const y_dot = ode_solver->getYDot(time_reached, y);
- auto const y_ana = exp(-15.0 * time);
- auto const y_dot_ana = -15.0 * exp(-15.0 * time);
+ auto const y_ana = exp(-15.0 * time);
+ auto const y_dot_ana = -15.0 * exp(-15.0 * time);
- check(time_reached, y[0], y_dot[0], time, y_ana, y_dot_ana);
- }
+ check(time_reached, y[0], y_dot[0], time, y_ana, y_dot_ana);
+ }
}
diff --git a/Tests/MathLib/TestPiecewiseLinearInterpolation.cpp b/Tests/MathLib/TestPiecewiseLinearInterpolation.cpp
index 2d65607999aea7fb90490f54d928634f36358d0b..149d7338fbd7837d01db101c947acfba004e7b09 100644
--- a/Tests/MathLib/TestPiecewiseLinearInterpolation.cpp
+++ b/Tests/MathLib/TestPiecewiseLinearInterpolation.cpp
@@ -21,72 +21,72 @@
TEST(MathLibInterpolationAlgorithms, PiecewiseLinearInterpolation)
{
- const std::size_t size(1000);
- std::vector<double> supp_pnts, values;
- for (std::size_t k(0); k<size; ++k) {
- supp_pnts.push_back(static_cast<double>(k));
- if (k % 2 == 0) {
- values.push_back(0.0);
- } else {
- values.push_back(1.0);
- }
- }
+ const std::size_t size(1000);
+ std::vector<double> supp_pnts, values;
+ for (std::size_t k(0); k<size; ++k) {
+ supp_pnts.push_back(static_cast<double>(k));
+ if (k % 2 == 0) {
+ values.push_back(0.0);
+ } else {
+ values.push_back(1.0);
+ }
+ }
- MathLib::PiecewiseLinearInterpolation interpolation{std::move(supp_pnts),
- std::move(values)};
- // Interpolation
- for (std::size_t k(0); k<size-1; ++k) {
- ASSERT_NEAR(0.5, interpolation.getValue(k+0.5), std::numeric_limits<double>::epsilon());
- }
+ MathLib::PiecewiseLinearInterpolation interpolation{std::move(supp_pnts),
+ std::move(values)};
+ // Interpolation
+ for (std::size_t k(0); k<size-1; ++k) {
+ ASSERT_NEAR(0.5, interpolation.getValue(k+0.5), std::numeric_limits<double>::epsilon());
+ }
- for (std::size_t k(0); k<size-1; ++k) {
- if (k % 2 == 0) {
- ASSERT_NEAR(0.25, interpolation.getValue(k+0.25), std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(0.75, interpolation.getValue(k+0.75), std::numeric_limits<double>::epsilon());
- } else {
- ASSERT_NEAR(0.75, interpolation.getValue(k+0.25), std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(0.25, interpolation.getValue(k+0.75), std::numeric_limits<double>::epsilon());
- }
- }
+ for (std::size_t k(0); k<size-1; ++k) {
+ if (k % 2 == 0) {
+ ASSERT_NEAR(0.25, interpolation.getValue(k+0.25), std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(0.75, interpolation.getValue(k+0.75), std::numeric_limits<double>::epsilon());
+ } else {
+ ASSERT_NEAR(0.75, interpolation.getValue(k+0.25), std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(0.25, interpolation.getValue(k+0.75), std::numeric_limits<double>::epsilon());
+ }
+ }
- // Extrapolation
- ASSERT_NEAR(-0.5, interpolation.getValue(-0.5), std::numeric_limits<double>::epsilon());
- // Extrapolation
- ASSERT_NEAR(1.5, interpolation.getValue(size-0.5), std::numeric_limits<double>::epsilon());
+ // Extrapolation
+ ASSERT_NEAR(-0.5, interpolation.getValue(-0.5), std::numeric_limits<double>::epsilon());
+ // Extrapolation
+ ASSERT_NEAR(1.5, interpolation.getValue(size-0.5), std::numeric_limits<double>::epsilon());
}
TEST(MathLibInterpolationAlgorithms, PiecewiseLinearInterpolationSupportPntsInReverseOrder)
{
- const std::size_t size(1000);
- std::vector<double> supp_pnts, values;
- for (std::size_t k(0); k<size; ++k) {
- supp_pnts.push_back(static_cast<double>(size-1-k));
- if (k % 2 == 0) {
- values.push_back(1.0);
- } else {
- values.push_back(0.0);
- }
- }
+ const std::size_t size(1000);
+ std::vector<double> supp_pnts, values;
+ for (std::size_t k(0); k<size; ++k) {
+ supp_pnts.push_back(static_cast<double>(size-1-k));
+ if (k % 2 == 0) {
+ values.push_back(1.0);
+ } else {
+ values.push_back(0.0);
+ }
+ }
- MathLib::PiecewiseLinearInterpolation interpolation{std::move(supp_pnts),
- std::move(values)};
- // Interpolation
- for (std::size_t k(0); k<size-1; ++k) {
- ASSERT_NEAR(0.5, interpolation.getValue(k+0.5), std::numeric_limits<double>::epsilon());
- }
+ MathLib::PiecewiseLinearInterpolation interpolation{std::move(supp_pnts),
+ std::move(values)};
+ // Interpolation
+ for (std::size_t k(0); k<size-1; ++k) {
+ ASSERT_NEAR(0.5, interpolation.getValue(k+0.5), std::numeric_limits<double>::epsilon());
+ }
- for (std::size_t k(0); k<size-1; ++k) {
- if (k % 2 == 0) {
- ASSERT_NEAR(0.25, interpolation.getValue(k+0.25), std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(0.75, interpolation.getValue(k+0.75), std::numeric_limits<double>::epsilon());
- } else {
- ASSERT_NEAR(0.75, interpolation.getValue(k+0.25), std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(0.25, interpolation.getValue(k+0.75), std::numeric_limits<double>::epsilon());
- }
- }
+ for (std::size_t k(0); k<size-1; ++k) {
+ if (k % 2 == 0) {
+ ASSERT_NEAR(0.25, interpolation.getValue(k+0.25), std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(0.75, interpolation.getValue(k+0.75), std::numeric_limits<double>::epsilon());
+ } else {
+ ASSERT_NEAR(0.75, interpolation.getValue(k+0.25), std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(0.25, interpolation.getValue(k+0.75), std::numeric_limits<double>::epsilon());
+ }
+ }
- // Extrapolation
- ASSERT_NEAR(-0.5, interpolation.getValue(-0.5), std::numeric_limits<double>::epsilon());
- // Extrapolation
- ASSERT_NEAR(1.5, interpolation.getValue(size-0.5), std::numeric_limits<double>::epsilon());
+ // Extrapolation
+ ASSERT_NEAR(-0.5, interpolation.getValue(-0.5), std::numeric_limits<double>::epsilon());
+ // Extrapolation
+ ASSERT_NEAR(1.5, interpolation.getValue(size-0.5), std::numeric_limits<double>::epsilon());
}
diff --git a/Tests/MathLib/TestPoint3d.cpp b/Tests/MathLib/TestPoint3d.cpp
index 2a2b3897abdc47faf898e49ea2bffcbe729458ae..6706c65a2fa5878230edc8dee28e1b7bf106aaaa 100644
--- a/Tests/MathLib/TestPoint3d.cpp
+++ b/Tests/MathLib/TestPoint3d.cpp
@@ -23,208 +23,208 @@ namespace ac = autocheck;
struct MathLibPoint3d : public ::testing::Test
{
- ac::randomTupleGenerator<double, 3> tupleGen;
- ac::cons_generator<MathLib::Point3d, ac::randomTupleGenerator<double, 3>>
- pointGenerator{tupleGen};
+ ac::randomTupleGenerator<double, 3> tupleGen;
+ ac::cons_generator<MathLib::Point3d, ac::randomTupleGenerator<double, 3>>
+ pointGenerator{tupleGen};
- ac::randomCoordinateIndexGenerator<unsigned, 3>
- coordGenerator; // any of {0, 1, 2}
- ac::gtest_reporter gtest_reporter;
+ ac::randomCoordinateIndexGenerator<unsigned, 3>
+ coordGenerator; // any of {0, 1, 2}
+ ac::gtest_reporter gtest_reporter;
};
TEST_F(MathLibPoint3d, ComparisonOperatorLessEqSamePoint)
{
- // A point is always less or equal to itself and its copy.
- auto samePointLessEqualCompare = [](MathLib::Point3d const& p)
- {
- auto q = p;
- return lessEq(p, p) && lessEq(p, q) && lessEq(q, p);
- };
-
- ac::check<MathLib::Point3d>(samePointLessEqualCompare, 1000,
- ac::make_arbitrary(pointGenerator),
- gtest_reporter);
+ // A point is always less or equal to itself and its copy.
+ auto samePointLessEqualCompare = [](MathLib::Point3d const& p)
+ {
+ auto q = p;
+ return lessEq(p, p) && lessEq(p, q) && lessEq(q, p);
+ };
+
+ ac::check<MathLib::Point3d>(samePointLessEqualCompare, 1000,
+ ac::make_arbitrary(pointGenerator),
+ gtest_reporter);
}
TEST_F(MathLibPoint3d, ComparisonOperatorLessEqualLargePerturbation)
{
- // A point with any big, positive value added to one of its coordinates is
- // never smaller or equal to the original point.
- // And the original point is always smaller or equal to the perturbed point.
- auto pointWithLargeAddedValue =
- [](MathLib::Point3d const& p, double const perturbation,
- unsigned const coordinate)
- {
- auto q = p;
- q[coordinate] = q[coordinate] + perturbation;
- return !lessEq(q, p) && lessEq(p, q);
- };
-
- auto eps = std::numeric_limits<double>::epsilon();
-
- ac::check<MathLib::Point3d, double, unsigned>(
- pointWithLargeAddedValue, 10000,
- ac::make_arbitrary(pointGenerator,
- ac::map(&ac::absoluteValue, ac::generator<double>()),
- coordGenerator)
- .discard_if(
- [&eps](MathLib::Point3d const&, double const v, unsigned const)
- {
- return !(v > eps);
- }),
- gtest_reporter);
+ // A point with any big, positive value added to one of its coordinates is
+ // never smaller or equal to the original point.
+ // And the original point is always smaller or equal to the perturbed point.
+ auto pointWithLargeAddedValue =
+ [](MathLib::Point3d const& p, double const perturbation,
+ unsigned const coordinate)
+ {
+ auto q = p;
+ q[coordinate] = q[coordinate] + perturbation;
+ return !lessEq(q, p) && lessEq(p, q);
+ };
+
+ auto eps = std::numeric_limits<double>::epsilon();
+
+ ac::check<MathLib::Point3d, double, unsigned>(
+ pointWithLargeAddedValue, 10000,
+ ac::make_arbitrary(pointGenerator,
+ ac::map(&ac::absoluteValue, ac::generator<double>()),
+ coordGenerator)
+ .discard_if(
+ [&eps](MathLib::Point3d const&, double const v, unsigned const)
+ {
+ return !(v > eps);
+ }),
+ gtest_reporter);
}
TEST_F(MathLibPoint3d, ComparisonOperatorLessEqualSmallPerturbation)
{
- // A point with any non-zero value smaller than epsilon/2 added to one of
- // its
- // coordinates is always less or equal to the original point.
- auto pointWithSmallAddedValue =
- [](MathLib::Point3d const& p, double const perturbation,
- unsigned const coordinate)
- {
- auto q = p;
- q[coordinate] = q[coordinate] + perturbation;
- return lessEq(p, q) && lessEq(q, p);
- };
-
- auto eps = std::numeric_limits<double>::epsilon();
-
- ac::check<MathLib::Point3d, double, unsigned>(
- pointWithSmallAddedValue, 10000,
- ac::make_arbitrary(pointGenerator,
- ac::progressivelySmallerGenerator<double>(eps / 2),
- coordGenerator),
- gtest_reporter);
+ // A point with any non-zero value smaller than epsilon/2 added to one of
+ // its
+ // coordinates is always less or equal to the original point.
+ auto pointWithSmallAddedValue =
+ [](MathLib::Point3d const& p, double const perturbation,
+ unsigned const coordinate)
+ {
+ auto q = p;
+ q[coordinate] = q[coordinate] + perturbation;
+ return lessEq(p, q) && lessEq(q, p);
+ };
+
+ auto eps = std::numeric_limits<double>::epsilon();
+
+ ac::check<MathLib::Point3d, double, unsigned>(
+ pointWithSmallAddedValue, 10000,
+ ac::make_arbitrary(pointGenerator,
+ ac::progressivelySmallerGenerator<double>(eps / 2),
+ coordGenerator),
+ gtest_reporter);
}
TEST_F(MathLibPoint3d, ComparisonOperatorEqualSamePoint)
{
- // A point is always equal to itself and its copy.
- auto samePointEqualCompare = [](MathLib::Point3d const& p)
- {
- auto q = p;
- return (p == p) && (p == q) && (q == p);
- };
-
- ac::check<MathLib::Point3d>(samePointEqualCompare, 100,
- ac::make_arbitrary(pointGenerator),
- gtest_reporter);
+ // A point is always equal to itself and its copy.
+ auto samePointEqualCompare = [](MathLib::Point3d const& p)
+ {
+ auto q = p;
+ return (p == p) && (p == q) && (q == p);
+ };
+
+ ac::check<MathLib::Point3d>(samePointEqualCompare, 100,
+ ac::make_arbitrary(pointGenerator),
+ gtest_reporter);
}
TEST_F(MathLibPoint3d, ComparisonOperatorEqualLargePerturbation)
{
- // A point with any big, non-zero value added to one of its coordinates is
- // never equal to the original point.
- auto pointWithLargeAddedValue =
- [](MathLib::Point3d const& p, double const perturbation,
- unsigned const coordinate)
- {
- auto q = p;
- q[coordinate] = q[coordinate] + perturbation;
- return !(p == q) && !(q == p);
- };
-
- auto eps = std::numeric_limits<double>::epsilon();
-
- ac::check<MathLib::Point3d, double, unsigned>(
- pointWithLargeAddedValue, 10000,
- ac::make_arbitrary(pointGenerator, ac::generator<double>(),
- coordGenerator)
- .discard_if(
- [&eps](MathLib::Point3d const&, double const v, unsigned const)
- {
- return !(v > eps);
- }),
- gtest_reporter);
+ // A point with any big, non-zero value added to one of its coordinates is
+ // never equal to the original point.
+ auto pointWithLargeAddedValue =
+ [](MathLib::Point3d const& p, double const perturbation,
+ unsigned const coordinate)
+ {
+ auto q = p;
+ q[coordinate] = q[coordinate] + perturbation;
+ return !(p == q) && !(q == p);
+ };
+
+ auto eps = std::numeric_limits<double>::epsilon();
+
+ ac::check<MathLib::Point3d, double, unsigned>(
+ pointWithLargeAddedValue, 10000,
+ ac::make_arbitrary(pointGenerator, ac::generator<double>(),
+ coordGenerator)
+ .discard_if(
+ [&eps](MathLib::Point3d const&, double const v, unsigned const)
+ {
+ return !(v > eps);
+ }),
+ gtest_reporter);
}
TEST_F(MathLibPoint3d, ComparisonOperatorEqualSmallPerturbation)
{
- // A point with any non-zero value smaller than epsilon/2 added to one of
- // its
- // coordinates is always equal to the original point.
- auto pointWithSmallAddedValue =
- [](MathLib::Point3d const& p, double const perturbation,
- unsigned const coordinate)
- {
- auto q = p;
- q[coordinate] = q[coordinate] + perturbation;
- return (p == q) && (q == p);
- };
-
- auto eps = std::numeric_limits<double>::epsilon();
-
- ac::check<MathLib::Point3d, double, unsigned>(
- pointWithSmallAddedValue, 1000,
- ac::make_arbitrary(pointGenerator,
- ac::progressivelySmallerGenerator<double>(eps / 2),
- coordGenerator),
- gtest_reporter);
+ // A point with any non-zero value smaller than epsilon/2 added to one of
+ // its
+ // coordinates is always equal to the original point.
+ auto pointWithSmallAddedValue =
+ [](MathLib::Point3d const& p, double const perturbation,
+ unsigned const coordinate)
+ {
+ auto q = p;
+ q[coordinate] = q[coordinate] + perturbation;
+ return (p == q) && (q == p);
+ };
+
+ auto eps = std::numeric_limits<double>::epsilon();
+
+ ac::check<MathLib::Point3d, double, unsigned>(
+ pointWithSmallAddedValue, 1000,
+ ac::make_arbitrary(pointGenerator,
+ ac::progressivelySmallerGenerator<double>(eps / 2),
+ coordGenerator),
+ gtest_reporter);
}
// test for operator<
TEST_F(MathLibPoint3d, ComparisonOperatorLessSamePoint)
{
- // A point is never less than itself or its copy.
- auto samePointLessCompare = [](MathLib::Point3d const& p)
- {
- auto q = p;
- return !(p < p) && !(p < q) && !(q < p);
- };
-
- ac::check<MathLib::Point3d>(samePointLessCompare, 100,
- ac::make_arbitrary(pointGenerator),
- gtest_reporter);
+ // A point is never less than itself or its copy.
+ auto samePointLessCompare = [](MathLib::Point3d const& p)
+ {
+ auto q = p;
+ return !(p < p) && !(p < q) && !(q < p);
+ };
+
+ ac::check<MathLib::Point3d>(samePointLessCompare, 100,
+ ac::make_arbitrary(pointGenerator),
+ gtest_reporter);
}
TEST_F(MathLibPoint3d, ComparisonOperatorLessLargePerturbation)
{
- // A point with any positive value added to one of its coordinates is
- // always larger then the original point.
- auto pointWithAddedValue = [](MathLib::Point3d const& p, double const eps,
- unsigned const coordinate)
- {
- auto q = p;
- q[coordinate] = q[coordinate] + eps;
- return (p < q) && !(q < p);
- };
-
- ac::check<MathLib::Point3d, double, unsigned>(
- pointWithAddedValue, 1000,
- ac::make_arbitrary(pointGenerator,
- ac::map(&ac::absoluteValue, ac::generator<double>()),
- coordGenerator)
- .discard_if(
- [](MathLib::Point3d const&, double const eps, unsigned const)
- {
- return eps == 0;
- }),
- gtest_reporter);
+ // A point with any positive value added to one of its coordinates is
+ // always larger then the original point.
+ auto pointWithAddedValue = [](MathLib::Point3d const& p, double const eps,
+ unsigned const coordinate)
+ {
+ auto q = p;
+ q[coordinate] = q[coordinate] + eps;
+ return (p < q) && !(q < p);
+ };
+
+ ac::check<MathLib::Point3d, double, unsigned>(
+ pointWithAddedValue, 1000,
+ ac::make_arbitrary(pointGenerator,
+ ac::map(&ac::absoluteValue, ac::generator<double>()),
+ coordGenerator)
+ .discard_if(
+ [](MathLib::Point3d const&, double const eps, unsigned const)
+ {
+ return eps == 0;
+ }),
+ gtest_reporter);
}
TEST_F(MathLibPoint3d, ComparisonOperatorLessSmallPerturbation)
{
- // A point with any positive value subtracted from one of its coordinates is
- // always smaller then the original point.
- auto pointWithSubtractedValue = [](
- MathLib::Point3d const& p, double const eps, unsigned const coordinate)
- {
- auto q = p;
- q[coordinate] = q[coordinate] - eps;
- return (q < p) && !(p < q);
- };
-
- ac::check<MathLib::Point3d, double, unsigned>(
- pointWithSubtractedValue, 1000,
- ac::make_arbitrary(pointGenerator,
- ac::map(&ac::absoluteValue, ac::generator<double>()),
- coordGenerator)
- .discard_if(
- [](MathLib::Point3d const&, double const eps, unsigned const)
- {
- return eps == 0;
- }),
- gtest_reporter);
+ // A point with any positive value subtracted from one of its coordinates is
+ // always smaller then the original point.
+ auto pointWithSubtractedValue = [](
+ MathLib::Point3d const& p, double const eps, unsigned const coordinate)
+ {
+ auto q = p;
+ q[coordinate] = q[coordinate] - eps;
+ return (q < p) && !(p < q);
+ };
+
+ ac::check<MathLib::Point3d, double, unsigned>(
+ pointWithSubtractedValue, 1000,
+ ac::make_arbitrary(pointGenerator,
+ ac::map(&ac::absoluteValue, ac::generator<double>()),
+ coordGenerator)
+ .discard_if(
+ [](MathLib::Point3d const&, double const eps, unsigned const)
+ {
+ return eps == 0;
+ }),
+ gtest_reporter);
}
diff --git a/Tests/MathLib/TestPoint3dWithID.cpp b/Tests/MathLib/TestPoint3dWithID.cpp
index 4c755da5c0a5c1c5faab881f2d055113168ea861..6f1533d6c09917421d67f58eca3b3f7411e7e5d4 100644
--- a/Tests/MathLib/TestPoint3dWithID.cpp
+++ b/Tests/MathLib/TestPoint3dWithID.cpp
@@ -19,11 +19,11 @@ using namespace MathLib;
TEST(MathLib, Point3dWithID)
{
- Point3dWithID p0(0,0,0,1);
- Point3dWithID p1(p0); // copy constructor
- Point3dWithID p2(p0, 2); // constructor for resetting the id
+ Point3dWithID p0(0,0,0,1);
+ Point3dWithID p1(p0); // copy constructor
+ Point3dWithID p2(p0, 2); // constructor for resetting the id
- EXPECT_EQ(p0.getID(), p1.getID());
- EXPECT_NE(p0.getID(), p2.getID());
+ EXPECT_EQ(p0.getID(), p1.getID());
+ EXPECT_NE(p0.getID(), p2.getID());
}
diff --git a/Tests/MathLib/TestTemplatePoint.cpp b/Tests/MathLib/TestTemplatePoint.cpp
index 067d9a128ba47f071304e1280b99ef8f15f1db4a..799c64f280803812fa12db0ef7876d46920ccbb7 100644
--- a/Tests/MathLib/TestTemplatePoint.cpp
+++ b/Tests/MathLib/TestTemplatePoint.cpp
@@ -19,48 +19,48 @@ using namespace MathLib;
TEST(MathLib, TemplatePointConstructors)
{
- // *** test default constructors for different DIM values
- TemplatePoint<double,3> p0;
- // test coordinates of default constructed point
- ASSERT_EQ(0.0, p0[0]);
- ASSERT_EQ(0.0, p0[1]);
- ASSERT_EQ(0.0, p0[2]);
+ // *** test default constructors for different DIM values
+ TemplatePoint<double,3> p0;
+ // test coordinates of default constructed point
+ ASSERT_EQ(0.0, p0[0]);
+ ASSERT_EQ(0.0, p0[1]);
+ ASSERT_EQ(0.0, p0[2]);
- TemplatePoint<double,2> p1;
- ASSERT_EQ(0.0, p1[0]);
- ASSERT_EQ(0.0, p1[1]);
+ TemplatePoint<double,2> p1;
+ ASSERT_EQ(0.0, p1[0]);
+ ASSERT_EQ(0.0, p1[1]);
- TemplatePoint<double,5> p2;
- ASSERT_EQ(0.0, p2[0]);
- ASSERT_EQ(0.0, p2[1]);
- ASSERT_EQ(0.0, p2[2]);
- ASSERT_EQ(0.0, p2[3]);
- ASSERT_EQ(0.0, p2[4]);
+ TemplatePoint<double,5> p2;
+ ASSERT_EQ(0.0, p2[0]);
+ ASSERT_EQ(0.0, p2[1]);
+ ASSERT_EQ(0.0, p2[2]);
+ ASSERT_EQ(0.0, p2[3]);
+ ASSERT_EQ(0.0, p2[4]);
- // *** test copy constructor
- TemplatePoint<double,3> p0_copy(p0);
- // test equality of coordinates
- ASSERT_EQ(p0[0], p0_copy[0]);
- ASSERT_EQ(p0[1], p0_copy[1]);
- ASSERT_EQ(p0[2], p0_copy[2]);
+ // *** test copy constructor
+ TemplatePoint<double,3> p0_copy(p0);
+ // test equality of coordinates
+ ASSERT_EQ(p0[0], p0_copy[0]);
+ ASSERT_EQ(p0[1], p0_copy[1]);
+ ASSERT_EQ(p0[2], p0_copy[2]);
- // *** test constructor taking std::array
- std::array<double,3> array = {{0, 1, 2}};
- TemplatePoint<double> p3(array);
- ASSERT_EQ(0.0, p3[0]);
- ASSERT_EQ(1.0, p3[1]);
- ASSERT_EQ(2.0, p3[2]);
+ // *** test constructor taking std::array
+ std::array<double,3> array = {{0, 1, 2}};
+ TemplatePoint<double> p3(array);
+ ASSERT_EQ(0.0, p3[0]);
+ ASSERT_EQ(1.0, p3[1]);
+ ASSERT_EQ(2.0, p3[2]);
}
TEST(MathLib, TemplatePointOperators)
{
- TemplatePoint<double,3> p;
- // access operator
- p[0] = 1.0;
- p[1] = 3.0;
- p[2] = 5.0;
- ASSERT_EQ(1.0, p[0]);
- ASSERT_EQ(3.0, p[1]);
- ASSERT_EQ(5.0, p[2]);
+ TemplatePoint<double,3> p;
+ // access operator
+ p[0] = 1.0;
+ p[1] = 3.0;
+ p[2] = 5.0;
+ ASSERT_EQ(1.0, p[0]);
+ ASSERT_EQ(3.0, p[1]);
+ ASSERT_EQ(5.0, p[2]);
}
diff --git a/Tests/MathLib/TestVector3.cpp b/Tests/MathLib/TestVector3.cpp
index 12e209764a81d4da1dfe5a288f7dd6ba4ad973df..9b81bc813a3827fc7711c4fc7d48894017a00449 100644
--- a/Tests/MathLib/TestVector3.cpp
+++ b/Tests/MathLib/TestVector3.cpp
@@ -20,145 +20,145 @@ using namespace MathLib;
TEST(MathLib, TestVector3Constructor)
{
- // *** test default constructor
- Vector3 u;
- // test coordinates of default constructed vec
- ASSERT_NEAR(0.0, u[0], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(0.0, u[1], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(0.0, u[2], std::numeric_limits<double>::epsilon());
-
- // *** test constructor taking 3 double values
- Vector3 v(1.0, 3.0, 5.0);
- ASSERT_NEAR(1.0, v[0], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(3.0, v[1], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(5.0, v[2], std::numeric_limits<double>::epsilon());
-
- // *** test copy constructor
- Vector3 v_copy(v);
- // test equality of coordinates
- ASSERT_NEAR(v[0], v_copy[0], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(v[1], v_copy[1], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(v[2], v_copy[2], std::numeric_limits<double>::epsilon());
-
- // *** test constructor taking TemplatePoint
- std::array<double,3> ap = {{0, 1, 2}};
- TemplatePoint<double> p(ap);
- Vector3 vp(p);
- ASSERT_NEAR(0.0, vp[0], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(1.0, vp[1], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(2.0, vp[2], std::numeric_limits<double>::epsilon());
-
- // *** test constructing Vector from two TemplatePoints
- std::array<double,3> aa = {{1, 2, 3}}; // necessary for old compilers
- std::array<double,3> ab = {{6, 5, 4}}; // necessary for old compilers
- TemplatePoint<double,3> a(aa);
- TemplatePoint<double,3> b(ab);
- Vector3 w(a,b);
- // test coordinates of constructed Vector3 w = (b-a)
- ASSERT_NEAR(5.0, w[0], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(3.0, w[1], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(1.0, w[2], std::numeric_limits<double>::epsilon());
+ // *** test default constructor
+ Vector3 u;
+ // test coordinates of default constructed vec
+ ASSERT_NEAR(0.0, u[0], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(0.0, u[1], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(0.0, u[2], std::numeric_limits<double>::epsilon());
+
+ // *** test constructor taking 3 double values
+ Vector3 v(1.0, 3.0, 5.0);
+ ASSERT_NEAR(1.0, v[0], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(3.0, v[1], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(5.0, v[2], std::numeric_limits<double>::epsilon());
+
+ // *** test copy constructor
+ Vector3 v_copy(v);
+ // test equality of coordinates
+ ASSERT_NEAR(v[0], v_copy[0], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(v[1], v_copy[1], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(v[2], v_copy[2], std::numeric_limits<double>::epsilon());
+
+ // *** test constructor taking TemplatePoint
+ std::array<double,3> ap = {{0, 1, 2}};
+ TemplatePoint<double> p(ap);
+ Vector3 vp(p);
+ ASSERT_NEAR(0.0, vp[0], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(1.0, vp[1], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(2.0, vp[2], std::numeric_limits<double>::epsilon());
+
+ // *** test constructing Vector from two TemplatePoints
+ std::array<double,3> aa = {{1, 2, 3}}; // necessary for old compilers
+ std::array<double,3> ab = {{6, 5, 4}}; // necessary for old compilers
+ TemplatePoint<double,3> a(aa);
+ TemplatePoint<double,3> b(ab);
+ Vector3 w(a,b);
+ // test coordinates of constructed Vector3 w = (b-a)
+ ASSERT_NEAR(5.0, w[0], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(3.0, w[1], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(1.0, w[2], std::numeric_limits<double>::epsilon());
}
TEST(MathLib, TestVector3Operators)
{
- Vector3 v;
- // access operator
- v[0] = 1.0;
- v[1] = 3.0;
- v[2] = 5.0;
- ASSERT_NEAR(1.0, v[0], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(3.0, v[1], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(5.0, v[2], std::numeric_limits<double>::epsilon());
-
- Vector3 w(5.0, 3.0, 1.0);
- // operator+
- Vector3 res(v+w);
- ASSERT_NEAR(6.0, res[0], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(6.0, res[1], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(6.0, res[2], std::numeric_limits<double>::epsilon());
-
- // operator-
- res = v-w;
- ASSERT_NEAR(-4.0, res[0], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR( 0.0, res[1], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR( 4.0, res[2], std::numeric_limits<double>::epsilon());
-
- // test operator*=
- v *= 2.0;
- ASSERT_NEAR(2.0, v[0], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(6.0, v[1], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(10.0, v[2], std::numeric_limits<double>::epsilon());
-
- // test operator+=
- v += w;
- ASSERT_NEAR(7.0, v[0], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(9.0, v[1], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(11.0, v[2], std::numeric_limits<double>::epsilon());
-
- // test operator-=
- v -= w;
- ASSERT_NEAR(2.0, v[0], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(6.0, v[1], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(10.0, v[2], std::numeric_limits<double>::epsilon());
+ Vector3 v;
+ // access operator
+ v[0] = 1.0;
+ v[1] = 3.0;
+ v[2] = 5.0;
+ ASSERT_NEAR(1.0, v[0], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(3.0, v[1], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(5.0, v[2], std::numeric_limits<double>::epsilon());
+
+ Vector3 w(5.0, 3.0, 1.0);
+ // operator+
+ Vector3 res(v+w);
+ ASSERT_NEAR(6.0, res[0], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(6.0, res[1], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(6.0, res[2], std::numeric_limits<double>::epsilon());
+
+ // operator-
+ res = v-w;
+ ASSERT_NEAR(-4.0, res[0], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR( 0.0, res[1], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR( 4.0, res[2], std::numeric_limits<double>::epsilon());
+
+ // test operator*=
+ v *= 2.0;
+ ASSERT_NEAR(2.0, v[0], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(6.0, v[1], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(10.0, v[2], std::numeric_limits<double>::epsilon());
+
+ // test operator+=
+ v += w;
+ ASSERT_NEAR(7.0, v[0], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(9.0, v[1], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(11.0, v[2], std::numeric_limits<double>::epsilon());
+
+ // test operator-=
+ v -= w;
+ ASSERT_NEAR(2.0, v[0], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(6.0, v[1], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(10.0, v[2], std::numeric_limits<double>::epsilon());
}
TEST(MathLib, TestVector3Multiplications)
{
- // test scalar product
- Vector3 v(1.0, 3.0, 5.0);
- Vector3 w(3.0, -2.0, 1.0);
-
- ASSERT_NEAR(2.0, scalarProduct(v,w), std::numeric_limits<double>::epsilon());
-
- // test cross product
- Vector3 e1(1.0, 0.0, 0.0);
- Vector3 e2(0.0, 1.0, 0.0);
- Vector3 e3(0.0, 0.0, 1.0);
-
- Vector3 res_e1e2(crossProduct(e1, e2)); // should be e3
- ASSERT_NEAR(e3[0], res_e1e2[0], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(e3[1], res_e1e2[1], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(e3[2], res_e1e2[2], std::numeric_limits<double>::epsilon());
-
- Vector3 res_e2e3(crossProduct(e2, e3)); // should be e1
- ASSERT_NEAR(e1[0], res_e2e3[0], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(e1[1], res_e2e3[1], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(e1[2], res_e2e3[2], std::numeric_limits<double>::epsilon());
-
- Vector3 res_e3e1(crossProduct(e3, e1)); // should be e2
- ASSERT_NEAR(e2[0], res_e3e1[0], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(e2[1], res_e3e1[1], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(e2[2], res_e3e1[2], std::numeric_limits<double>::epsilon());
-
- Vector3 res_e2e1(crossProduct(e2, e1)); // should be -e3
- ASSERT_NEAR(-e3[0], res_e2e1[0], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(-e3[1], res_e2e1[1], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(-e3[2], res_e2e1[2], std::numeric_limits<double>::epsilon());
-
- Vector3 res_e3e2(crossProduct(e3, e2)); // should be -e1
- ASSERT_NEAR(-e1[0], res_e3e2[0], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(-e1[1], res_e3e2[1], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(-e1[2], res_e3e2[2], std::numeric_limits<double>::epsilon());
-
- Vector3 res_e1e3(crossProduct(e1, e3)); // should be -e2
- ASSERT_NEAR(-e2[0], res_e1e3[0], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(-e2[1], res_e1e3[1], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(-e2[2], res_e1e3[2], std::numeric_limits<double>::epsilon());
-
- // test multplication with scalar
- v = -1.0 * v;
- ASSERT_NEAR(-1.0, v[0], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(-3.0, v[1], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(-5.0, v[2], std::numeric_limits<double>::epsilon());
- v = v * -1.0;
- ASSERT_NEAR(1.0, v[0], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(3.0, v[1], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(5.0, v[2], std::numeric_limits<double>::epsilon());
-
- // test normalisation
- v.normalize();
- ASSERT_NEAR(1.0, v.getLength(), std::numeric_limits<double>::epsilon());
+ // test scalar product
+ Vector3 v(1.0, 3.0, 5.0);
+ Vector3 w(3.0, -2.0, 1.0);
+
+ ASSERT_NEAR(2.0, scalarProduct(v,w), std::numeric_limits<double>::epsilon());
+
+ // test cross product
+ Vector3 e1(1.0, 0.0, 0.0);
+ Vector3 e2(0.0, 1.0, 0.0);
+ Vector3 e3(0.0, 0.0, 1.0);
+
+ Vector3 res_e1e2(crossProduct(e1, e2)); // should be e3
+ ASSERT_NEAR(e3[0], res_e1e2[0], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(e3[1], res_e1e2[1], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(e3[2], res_e1e2[2], std::numeric_limits<double>::epsilon());
+
+ Vector3 res_e2e3(crossProduct(e2, e3)); // should be e1
+ ASSERT_NEAR(e1[0], res_e2e3[0], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(e1[1], res_e2e3[1], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(e1[2], res_e2e3[2], std::numeric_limits<double>::epsilon());
+
+ Vector3 res_e3e1(crossProduct(e3, e1)); // should be e2
+ ASSERT_NEAR(e2[0], res_e3e1[0], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(e2[1], res_e3e1[1], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(e2[2], res_e3e1[2], std::numeric_limits<double>::epsilon());
+
+ Vector3 res_e2e1(crossProduct(e2, e1)); // should be -e3
+ ASSERT_NEAR(-e3[0], res_e2e1[0], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(-e3[1], res_e2e1[1], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(-e3[2], res_e2e1[2], std::numeric_limits<double>::epsilon());
+
+ Vector3 res_e3e2(crossProduct(e3, e2)); // should be -e1
+ ASSERT_NEAR(-e1[0], res_e3e2[0], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(-e1[1], res_e3e2[1], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(-e1[2], res_e3e2[2], std::numeric_limits<double>::epsilon());
+
+ Vector3 res_e1e3(crossProduct(e1, e3)); // should be -e2
+ ASSERT_NEAR(-e2[0], res_e1e3[0], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(-e2[1], res_e1e3[1], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(-e2[2], res_e1e3[2], std::numeric_limits<double>::epsilon());
+
+ // test multplication with scalar
+ v = -1.0 * v;
+ ASSERT_NEAR(-1.0, v[0], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(-3.0, v[1], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(-5.0, v[2], std::numeric_limits<double>::epsilon());
+ v = v * -1.0;
+ ASSERT_NEAR(1.0, v[0], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(3.0, v[1], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(5.0, v[2], std::numeric_limits<double>::epsilon());
+
+ // test normalisation
+ v.normalize();
+ ASSERT_NEAR(1.0, v.getLength(), std::numeric_limits<double>::epsilon());
}
diff --git a/Tests/MathLib/TestWeightedPoint.cpp b/Tests/MathLib/TestWeightedPoint.cpp
index 5159227b78b067c2770964569aae369debd74d30..0f2688bfbf9cbff858f1de189fd6a48f406aa009 100644
--- a/Tests/MathLib/TestWeightedPoint.cpp
+++ b/Tests/MathLib/TestWeightedPoint.cpp
@@ -14,39 +14,39 @@
TEST(MathLib, WeightedPoint1D)
{
- std::array<double, 1> pnt;
- pnt[0] = 0.5;
- double w = 100.0;
- MathLib::WeightedPoint1D wpnt_1d(pnt, w);
+ std::array<double, 1> pnt;
+ pnt[0] = 0.5;
+ double w = 100.0;
+ MathLib::WeightedPoint1D wpnt_1d(pnt, w);
- ASSERT_NEAR(pnt[0], wpnt_1d[0], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(w, wpnt_1d.getWeight(), std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(pnt[0], wpnt_1d[0], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(w, wpnt_1d.getWeight(), std::numeric_limits<double>::epsilon());
}
TEST(MathLib, WeightedPoint2D)
{
- std::array<double, 2> pnt;
- pnt[0] = 0.1;
- pnt[1] = 0.2;
- double w = 200.0;
- MathLib::WeightedPoint2D wpnt_2d(pnt, w);
-
- ASSERT_NEAR(pnt[0], wpnt_2d[0], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(pnt[1], wpnt_2d[1], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(w, wpnt_2d.getWeight(), std::numeric_limits<double>::epsilon());
+ std::array<double, 2> pnt;
+ pnt[0] = 0.1;
+ pnt[1] = 0.2;
+ double w = 200.0;
+ MathLib::WeightedPoint2D wpnt_2d(pnt, w);
+
+ ASSERT_NEAR(pnt[0], wpnt_2d[0], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(pnt[1], wpnt_2d[1], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(w, wpnt_2d.getWeight(), std::numeric_limits<double>::epsilon());
}
TEST(MathLib, WeightedPoint3D)
{
- std::array<double, 3> pnt;
- pnt[0] = 0.1;
- pnt[1] = 0.2;
- pnt[2] = 0.3;
- double w = 300.0;
- MathLib::WeightedPoint3D wpnt_3d(pnt, w);
-
- ASSERT_NEAR(pnt[0], wpnt_3d[0], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(pnt[1], wpnt_3d[1], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(pnt[2], wpnt_3d[2], std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(w, wpnt_3d.getWeight(), std::numeric_limits<double>::epsilon());
+ std::array<double, 3> pnt;
+ pnt[0] = 0.1;
+ pnt[1] = 0.2;
+ pnt[2] = 0.3;
+ double w = 300.0;
+ MathLib::WeightedPoint3D wpnt_3d(pnt, w);
+
+ ASSERT_NEAR(pnt[0], wpnt_3d[0], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(pnt[1], wpnt_3d[1], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(pnt[2], wpnt_3d[2], std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(w, wpnt_3d.getWeight(), std::numeric_limits<double>::epsilon());
}
diff --git a/Tests/MeshGeoToolsLib/TestGeoMapper.cpp b/Tests/MeshGeoToolsLib/TestGeoMapper.cpp
index 3021f3e8329f1faa347ec555c27e9388f98fcbcb..d3bc06a84f998f8d2e331a49722aaa32b0af69c1 100644
--- a/Tests/MeshGeoToolsLib/TestGeoMapper.cpp
+++ b/Tests/MeshGeoToolsLib/TestGeoMapper.cpp
@@ -22,22 +22,22 @@ namespace ac = autocheck;
struct MeshGeoToolsLibGeoMapper : public ::testing::Test
{
- ac::IntervalGenerator<double> x_gen{0, 1};
- ac::IntervalGenerator<double> y_gen{0, 1};
- ac::IntervalGenerator<double> z_gen{-10, 10};
- ac::IntervalTupleGenerator<double> tuple_gen{x_gen, y_gen, z_gen};
- ac::cons_generator<GeoLib::Point, ac::IntervalTupleGenerator<double>>
- points_gen{tuple_gen};
+ ac::IntervalGenerator<double> x_gen{0, 1};
+ ac::IntervalGenerator<double> y_gen{0, 1};
+ ac::IntervalGenerator<double> z_gen{-10, 10};
+ ac::IntervalTupleGenerator<double> tuple_gen{x_gen, y_gen, z_gen};
+ ac::cons_generator<GeoLib::Point, ac::IntervalTupleGenerator<double>>
+ points_gen{tuple_gen};
- // Generates structured surface mesh, approximation of the surface described
- // by the given function, i.e., std::cos(x+y).
- std::unique_ptr<MeshLib::Mesh> _surface_mesh{
- MeshLib::MeshGenerator::createSurfaceMesh(
- "Test", MathLib::Point3d{ {{0.0, 0.0, 0.0}} },
- MathLib::Point3d{ {{1.0, 1.0, 0.0}} }, {{110,60}},
- [](double x, double y) { return std::cos(x+y); })};
+ // Generates structured surface mesh, approximation of the surface described
+ // by the given function, i.e., std::cos(x+y).
+ std::unique_ptr<MeshLib::Mesh> _surface_mesh{
+ MeshLib::MeshGenerator::createSurfaceMesh(
+ "Test", MathLib::Point3d{ {{0.0, 0.0, 0.0}} },
+ MathLib::Point3d{ {{1.0, 1.0, 0.0}} }, {{110,60}},
+ [](double x, double y) { return std::cos(x+y); })};
- ac::gtest_reporter gtest_reporter;
+ ac::gtest_reporter gtest_reporter;
};
// The test maps points with random z coordinate on the surface mesh create by
@@ -47,43 +47,43 @@ struct MeshGeoToolsLibGeoMapper : public ::testing::Test
// assumed that the mapping is correct.
TEST_F(MeshGeoToolsLibGeoMapper, PointsOnSurfaceMesh)
{
- auto testMapPointsOnMeshSurface = [this](
- std::vector<GeoLib::Point>& pnts) -> bool
- {
- GeoLib::GEOObjects geo_obj;
- std::string geo_name("TestGeoMapperPoints");
- auto points = std::unique_ptr<std::vector<GeoLib::Point*>>(
- new std::vector<GeoLib::Point*>);
- for (auto & p : pnts) {
- points->push_back(new GeoLib::Point(p));
- }
- geo_obj.addPointVec(std::move(points), geo_name);
- MeshGeoToolsLib::GeoMapper geo_mapper(geo_obj, geo_name);
+ auto testMapPointsOnMeshSurface = [this](
+ std::vector<GeoLib::Point>& pnts) -> bool
+ {
+ GeoLib::GEOObjects geo_obj;
+ std::string geo_name("TestGeoMapperPoints");
+ auto points = std::unique_ptr<std::vector<GeoLib::Point*>>(
+ new std::vector<GeoLib::Point*>);
+ for (auto & p : pnts) {
+ points->push_back(new GeoLib::Point(p));
+ }
+ geo_obj.addPointVec(std::move(points), geo_name);
+ MeshGeoToolsLib::GeoMapper geo_mapper(geo_obj, geo_name);
- geo_mapper.mapOnMesh(_surface_mesh.get());
+ geo_mapper.mapOnMesh(_surface_mesh.get());
- auto const mapped_points(geo_obj.getPointVec(geo_name));
- double const eps(0.01);
- for (auto pnt : *mapped_points)
- {
- GeoLib::Point const& p(*pnt);
- if (0.0 <= p[0] && p[0] <= 1.0 && 0.0 <= p[1] && p[1] <= 1.0)
- {
- if (std::abs(std::cos(p[0]+p[1]) - p[2]) >= eps)
- {
- INFO("std::cos(%f + %f) = %f, %f",
- p[0], p[1], cos(p[0]+p[1]), p[2]);
- return false;
- }
- }
- }
- return true;
- };
+ auto const mapped_points(geo_obj.getPointVec(geo_name));
+ double const eps(0.01);
+ for (auto pnt : *mapped_points)
+ {
+ GeoLib::Point const& p(*pnt);
+ if (0.0 <= p[0] && p[0] <= 1.0 && 0.0 <= p[1] && p[1] <= 1.0)
+ {
+ if (std::abs(std::cos(p[0]+p[1]) - p[2]) >= eps)
+ {
+ INFO("std::cos(%f + %f) = %f, %f",
+ p[0], p[1], cos(p[0]+p[1]), p[2]);
+ return false;
+ }
+ }
+ }
+ return true;
+ };
- ac::check<std::vector<GeoLib::Point>>(
- testMapPointsOnMeshSurface,
- 10,
- ac::make_arbitrary(ac::fix(100,list_of(points_gen))),
- gtest_reporter);
+ ac::check<std::vector<GeoLib::Point>>(
+ testMapPointsOnMeshSurface,
+ 10,
+ ac::make_arbitrary(ac::fix(100,list_of(points_gen))),
+ gtest_reporter);
}
diff --git a/Tests/MeshLib/MeshProperties.cpp b/Tests/MeshLib/MeshProperties.cpp
index 2af55a30b8cfb88edd88bbbe4d132747f452a815..222dd6253c4b88767edc0c85846bd6404c9c4715 100644
--- a/Tests/MeshLib/MeshProperties.cpp
+++ b/Tests/MeshLib/MeshProperties.cpp
@@ -1,9 +1,9 @@
/**
* \copyright
* Copyright (c) 2012-2016, OpenGeoSys Community (http://www.opengeosys.org)
- * Distributed under a Modified BSD License.
- * See accompanying file LICENSE.txt or
- * http://www.opengeosys.org/LICENSE.txt
+ * Distributed under a Modified BSD License.
+ * See accompanying file LICENSE.txt or
+ * http://www.opengeosys.org/LICENSE.txt
*/
#include <numeric>
@@ -21,478 +21,478 @@
class MeshLibProperties : public ::testing::Test
{
public:
- MeshLibProperties()
- : mesh(nullptr)
- {
- mesh = MeshLib::MeshGenerator::generateRegularHexMesh(1.0, mesh_size);
- }
-
- ~MeshLibProperties()
- {
- delete mesh;
- }
-
- static std::size_t const mesh_size = 5;
- MeshLib::Mesh * mesh;
+ MeshLibProperties()
+ : mesh(nullptr)
+ {
+ mesh = MeshLib::MeshGenerator::generateRegularHexMesh(1.0, mesh_size);
+ }
+
+ ~MeshLibProperties()
+ {
+ delete mesh;
+ }
+
+ static std::size_t const mesh_size = 5;
+ MeshLib::Mesh * mesh;
};
std::size_t const MeshLibProperties::mesh_size;
TEST_F(MeshLibProperties, PropertyVectorTestMetaData)
{
- ASSERT_TRUE(mesh != nullptr);
-
- std::string const prop_name("TestProperty");
- boost::optional<MeshLib::PropertyVector<double> &> p(
- mesh->getProperties().createNewPropertyVector<double>(prop_name,
- MeshLib::MeshItemType::Cell)
- );
-
- ASSERT_EQ(0u, (*p).getPropertyName().compare(prop_name));
- ASSERT_EQ(MeshLib::MeshItemType::Cell, (*p).getMeshItemType());
- ASSERT_EQ(1u, (*p).getNumberOfComponents());
- ASSERT_EQ(0u, (*p).size());
+ ASSERT_TRUE(mesh != nullptr);
+
+ std::string const prop_name("TestProperty");
+ boost::optional<MeshLib::PropertyVector<double> &> p(
+ mesh->getProperties().createNewPropertyVector<double>(prop_name,
+ MeshLib::MeshItemType::Cell)
+ );
+
+ ASSERT_EQ(0u, (*p).getPropertyName().compare(prop_name));
+ ASSERT_EQ(MeshLib::MeshItemType::Cell, (*p).getMeshItemType());
+ ASSERT_EQ(1u, (*p).getNumberOfComponents());
+ ASSERT_EQ(0u, (*p).size());
}
TEST_F(MeshLibProperties, AddDoubleProperties)
{
- ASSERT_TRUE(mesh != nullptr);
- const std::size_t size(mesh_size*mesh_size*mesh_size);
-
- std::string const prop_name("TestProperty");
- boost::optional<MeshLib::PropertyVector<double> &> double_properties(
- mesh->getProperties().createNewPropertyVector<double>(prop_name,
- MeshLib::MeshItemType::Cell)
- );
- ASSERT_EQ(0u, (*double_properties).size());
-
- (*double_properties).resize(size);
- ASSERT_EQ(size, (*double_properties).size());
-
- std::iota((*double_properties).begin(), (*double_properties).end(), 1);
- for (std::size_t k(0); k<size; k++) {
- ASSERT_EQ(static_cast<double>(k+1), (*double_properties)[k]);
- }
-
- boost::optional<MeshLib::PropertyVector<double> const&>
- double_properties_cpy(mesh->getProperties().getPropertyVector<double>(
- prop_name));
- ASSERT_FALSE(!double_properties_cpy);
-
- for (std::size_t k(0); k<size; k++) {
- ASSERT_EQ((*double_properties)[k], (*double_properties_cpy)[k]);
- }
-
- mesh->getProperties().removePropertyVector(prop_name);
- boost::optional<MeshLib::PropertyVector<double> const&>
- removed_double_properties(
- mesh->getProperties().getPropertyVector<double>(prop_name)
- );
-
- ASSERT_TRUE(!removed_double_properties);
+ ASSERT_TRUE(mesh != nullptr);
+ const std::size_t size(mesh_size*mesh_size*mesh_size);
+
+ std::string const prop_name("TestProperty");
+ boost::optional<MeshLib::PropertyVector<double> &> double_properties(
+ mesh->getProperties().createNewPropertyVector<double>(prop_name,
+ MeshLib::MeshItemType::Cell)
+ );
+ ASSERT_EQ(0u, (*double_properties).size());
+
+ (*double_properties).resize(size);
+ ASSERT_EQ(size, (*double_properties).size());
+
+ std::iota((*double_properties).begin(), (*double_properties).end(), 1);
+ for (std::size_t k(0); k<size; k++) {
+ ASSERT_EQ(static_cast<double>(k+1), (*double_properties)[k]);
+ }
+
+ boost::optional<MeshLib::PropertyVector<double> const&>
+ double_properties_cpy(mesh->getProperties().getPropertyVector<double>(
+ prop_name));
+ ASSERT_FALSE(!double_properties_cpy);
+
+ for (std::size_t k(0); k<size; k++) {
+ ASSERT_EQ((*double_properties)[k], (*double_properties_cpy)[k]);
+ }
+
+ mesh->getProperties().removePropertyVector(prop_name);
+ boost::optional<MeshLib::PropertyVector<double> const&>
+ removed_double_properties(
+ mesh->getProperties().getPropertyVector<double>(prop_name)
+ );
+
+ ASSERT_TRUE(!removed_double_properties);
}
TEST_F(MeshLibProperties, AddDoublePointerProperties)
{
- ASSERT_TRUE(mesh != nullptr);
- std::string const& prop_name("GroupProperty");
- // check if a property with the name is already assigned to the mesh
- ASSERT_FALSE(mesh->getProperties().hasPropertyVector(prop_name));
- // data needed for the property
- const std::size_t n_prop_val_groups(10);
- const std::size_t n_items(mesh_size*mesh_size*mesh_size);
- std::vector<std::size_t> prop_item2group_mapping(n_items);
- // create simple mat_group to index mapping
- for (std::size_t j(0); j<n_prop_val_groups; j++) {
- std::size_t const lower(
- static_cast<std::size_t>(
- (static_cast<double>(j)/n_prop_val_groups)*n_items
- )
- );
- std::size_t const upper(
- static_cast<std::size_t>(
- (static_cast<double>(j+1)/n_prop_val_groups)*n_items
- )
- );
- for (std::size_t k(lower); k<upper; k++) {
- prop_item2group_mapping[k] = j;
- }
- }
- // obtain PropertyVector data structure
- boost::optional<MeshLib::PropertyVector<double*> &> group_properties(
- mesh->getProperties().createNewPropertyVector<double*>(
- prop_name, n_prop_val_groups, prop_item2group_mapping,
- MeshLib::MeshItemType::Cell
- )
- );
- ASSERT_EQ(prop_item2group_mapping.size(), (*group_properties).size());
-
- // initialize the property values
- for (std::size_t i(0); i<n_prop_val_groups; i++) {
- (*group_properties).initPropertyValue(i, static_cast<double>(i+1));
- }
- // check mapping to values
- for (std::size_t i(0); i<n_prop_val_groups; i++) {
- std::size_t const lower(
- static_cast<std::size_t>(
- (static_cast<double>(i)/n_prop_val_groups)*n_items
- )
- );
- std::size_t const upper(
- static_cast<std::size_t>(
- (static_cast<double>(i+1)/n_prop_val_groups)*n_items
- )
- );
- for (std::size_t k(lower); k<upper; k++) {
- ASSERT_NEAR(static_cast<double>(i+1), *(*group_properties)[k],
- std::numeric_limits<double>::epsilon());
- }
- }
-
- // the mesh should have the property assigned to cells
- ASSERT_TRUE(mesh->getProperties().hasPropertyVector(prop_name));
- // fetch the properties from the container
- boost::optional<MeshLib::PropertyVector<double*> const&>
- group_properties_cpy(mesh->getProperties().getPropertyVector<double*>(
- prop_name));
- ASSERT_FALSE(!group_properties_cpy);
-
- for (std::size_t k(0); k<n_items; k++) {
- ASSERT_EQ((*group_properties)[k], (*group_properties_cpy)[k]);
- }
-
- mesh->getProperties().removePropertyVector(prop_name);
- boost::optional<MeshLib::PropertyVector<double*> const&>
- removed_group_properties(mesh->getProperties().getPropertyVector<double*>(
- prop_name));
-
- ASSERT_TRUE(!removed_group_properties);
+ ASSERT_TRUE(mesh != nullptr);
+ std::string const& prop_name("GroupProperty");
+ // check if a property with the name is already assigned to the mesh
+ ASSERT_FALSE(mesh->getProperties().hasPropertyVector(prop_name));
+ // data needed for the property
+ const std::size_t n_prop_val_groups(10);
+ const std::size_t n_items(mesh_size*mesh_size*mesh_size);
+ std::vector<std::size_t> prop_item2group_mapping(n_items);
+ // create simple mat_group to index mapping
+ for (std::size_t j(0); j<n_prop_val_groups; j++) {
+ std::size_t const lower(
+ static_cast<std::size_t>(
+ (static_cast<double>(j)/n_prop_val_groups)*n_items
+ )
+ );
+ std::size_t const upper(
+ static_cast<std::size_t>(
+ (static_cast<double>(j+1)/n_prop_val_groups)*n_items
+ )
+ );
+ for (std::size_t k(lower); k<upper; k++) {
+ prop_item2group_mapping[k] = j;
+ }
+ }
+ // obtain PropertyVector data structure
+ boost::optional<MeshLib::PropertyVector<double*> &> group_properties(
+ mesh->getProperties().createNewPropertyVector<double*>(
+ prop_name, n_prop_val_groups, prop_item2group_mapping,
+ MeshLib::MeshItemType::Cell
+ )
+ );
+ ASSERT_EQ(prop_item2group_mapping.size(), (*group_properties).size());
+
+ // initialize the property values
+ for (std::size_t i(0); i<n_prop_val_groups; i++) {
+ (*group_properties).initPropertyValue(i, static_cast<double>(i+1));
+ }
+ // check mapping to values
+ for (std::size_t i(0); i<n_prop_val_groups; i++) {
+ std::size_t const lower(
+ static_cast<std::size_t>(
+ (static_cast<double>(i)/n_prop_val_groups)*n_items
+ )
+ );
+ std::size_t const upper(
+ static_cast<std::size_t>(
+ (static_cast<double>(i+1)/n_prop_val_groups)*n_items
+ )
+ );
+ for (std::size_t k(lower); k<upper; k++) {
+ ASSERT_NEAR(static_cast<double>(i+1), *(*group_properties)[k],
+ std::numeric_limits<double>::epsilon());
+ }
+ }
+
+ // the mesh should have the property assigned to cells
+ ASSERT_TRUE(mesh->getProperties().hasPropertyVector(prop_name));
+ // fetch the properties from the container
+ boost::optional<MeshLib::PropertyVector<double*> const&>
+ group_properties_cpy(mesh->getProperties().getPropertyVector<double*>(
+ prop_name));
+ ASSERT_FALSE(!group_properties_cpy);
+
+ for (std::size_t k(0); k<n_items; k++) {
+ ASSERT_EQ((*group_properties)[k], (*group_properties_cpy)[k]);
+ }
+
+ mesh->getProperties().removePropertyVector(prop_name);
+ boost::optional<MeshLib::PropertyVector<double*> const&>
+ removed_group_properties(mesh->getProperties().getPropertyVector<double*>(
+ prop_name));
+
+ ASSERT_TRUE(!removed_group_properties);
}
TEST_F(MeshLibProperties, AddArrayPointerProperties)
{
- ASSERT_TRUE(mesh != nullptr);
- std::string const& prop_name("GroupPropertyWithArray");
- const std::size_t n_prop_val_groups(10);
- const std::size_t n_items(mesh_size*mesh_size*mesh_size);
- std::vector<std::size_t> prop_item2group_mapping(n_items);
- // create simple mat_group to index mapping
- for (std::size_t j(0); j<n_prop_val_groups; j++) {
- std::size_t const lower(
- static_cast<std::size_t>(
- (static_cast<double>(j)/n_prop_val_groups)*n_items
- )
- );
- std::size_t const upper(
- static_cast<std::size_t>(
- (static_cast<double>(j+1)/n_prop_val_groups)*n_items
- )
- );
- for (std::size_t k(lower); k<upper; k++) {
- prop_item2group_mapping[k] = j;
- }
- }
- boost::optional<MeshLib::PropertyVector<std::array<double,3>*> &>
- group_prop_vec(
- mesh->getProperties().createNewPropertyVector<std::array<double,3>*>(
- prop_name, n_prop_val_groups, prop_item2group_mapping,
- MeshLib::MeshItemType::Cell
- )
- );
- ASSERT_EQ(prop_item2group_mapping.size(), group_prop_vec->size());
-
- // initialize the property values
- for (std::size_t i(0); i<n_prop_val_groups; i++) {
- (*group_prop_vec).initPropertyValue(i,
- std::array<double,3>({{static_cast<double>(i),
- static_cast<double>(i+1),
- static_cast<double>(i+2)}}
- )
- );
- }
- // check the mapping to values
- for (std::size_t i(0); i<n_prop_val_groups; i++) {
- std::size_t const lower(
- static_cast<std::size_t>(
- (static_cast<double>(i)/n_prop_val_groups)*n_items
- )
- );
- std::size_t const upper(
- static_cast<std::size_t>(
- (static_cast<double>(i+1)/n_prop_val_groups)*n_items
- )
- );
- for (std::size_t k(lower); k<upper; k++) {
- ASSERT_NEAR(static_cast<double>(i), (*(*group_prop_vec)[k])[0],
- std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(static_cast<double>(i+1), (*(*group_prop_vec)[k])[1],
- std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(static_cast<double>(i+2), (*(*group_prop_vec)[k])[2],
- std::numeric_limits<double>::epsilon());
- }
- }
-
- boost::optional<MeshLib::PropertyVector<std::array<double,3>*> const&>
- group_properties_cpy(
- mesh->getProperties().getPropertyVector<std::array<double,3>*>(prop_name)
- );
- ASSERT_FALSE(!group_properties_cpy);
-
- for (std::size_t k(0); k<n_items; k++) {
- ASSERT_EQ((*((*group_prop_vec)[k]))[0],
- (*((*group_properties_cpy)[k]))[0]);
- ASSERT_EQ((*((*group_prop_vec)[k]))[1],
- (*((*group_properties_cpy)[k]))[1]);
- ASSERT_EQ((*((*group_prop_vec)[k]))[2],
- (*((*group_properties_cpy)[k]))[2]);
- }
-
- mesh->getProperties().removePropertyVector(prop_name);
- boost::optional<MeshLib::PropertyVector<std::array<double, 3>*> const&>
- removed_group_properties(
- mesh->getProperties().getPropertyVector<std::array<double,3>*>(prop_name)
- );
-
- ASSERT_TRUE(!removed_group_properties);
+ ASSERT_TRUE(mesh != nullptr);
+ std::string const& prop_name("GroupPropertyWithArray");
+ const std::size_t n_prop_val_groups(10);
+ const std::size_t n_items(mesh_size*mesh_size*mesh_size);
+ std::vector<std::size_t> prop_item2group_mapping(n_items);
+ // create simple mat_group to index mapping
+ for (std::size_t j(0); j<n_prop_val_groups; j++) {
+ std::size_t const lower(
+ static_cast<std::size_t>(
+ (static_cast<double>(j)/n_prop_val_groups)*n_items
+ )
+ );
+ std::size_t const upper(
+ static_cast<std::size_t>(
+ (static_cast<double>(j+1)/n_prop_val_groups)*n_items
+ )
+ );
+ for (std::size_t k(lower); k<upper; k++) {
+ prop_item2group_mapping[k] = j;
+ }
+ }
+ boost::optional<MeshLib::PropertyVector<std::array<double,3>*> &>
+ group_prop_vec(
+ mesh->getProperties().createNewPropertyVector<std::array<double,3>*>(
+ prop_name, n_prop_val_groups, prop_item2group_mapping,
+ MeshLib::MeshItemType::Cell
+ )
+ );
+ ASSERT_EQ(prop_item2group_mapping.size(), group_prop_vec->size());
+
+ // initialize the property values
+ for (std::size_t i(0); i<n_prop_val_groups; i++) {
+ (*group_prop_vec).initPropertyValue(i,
+ std::array<double,3>({{static_cast<double>(i),
+ static_cast<double>(i+1),
+ static_cast<double>(i+2)}}
+ )
+ );
+ }
+ // check the mapping to values
+ for (std::size_t i(0); i<n_prop_val_groups; i++) {
+ std::size_t const lower(
+ static_cast<std::size_t>(
+ (static_cast<double>(i)/n_prop_val_groups)*n_items
+ )
+ );
+ std::size_t const upper(
+ static_cast<std::size_t>(
+ (static_cast<double>(i+1)/n_prop_val_groups)*n_items
+ )
+ );
+ for (std::size_t k(lower); k<upper; k++) {
+ ASSERT_NEAR(static_cast<double>(i), (*(*group_prop_vec)[k])[0],
+ std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(static_cast<double>(i+1), (*(*group_prop_vec)[k])[1],
+ std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(static_cast<double>(i+2), (*(*group_prop_vec)[k])[2],
+ std::numeric_limits<double>::epsilon());
+ }
+ }
+
+ boost::optional<MeshLib::PropertyVector<std::array<double,3>*> const&>
+ group_properties_cpy(
+ mesh->getProperties().getPropertyVector<std::array<double,3>*>(prop_name)
+ );
+ ASSERT_FALSE(!group_properties_cpy);
+
+ for (std::size_t k(0); k<n_items; k++) {
+ ASSERT_EQ((*((*group_prop_vec)[k]))[0],
+ (*((*group_properties_cpy)[k]))[0]);
+ ASSERT_EQ((*((*group_prop_vec)[k]))[1],
+ (*((*group_properties_cpy)[k]))[1]);
+ ASSERT_EQ((*((*group_prop_vec)[k]))[2],
+ (*((*group_properties_cpy)[k]))[2]);
+ }
+
+ mesh->getProperties().removePropertyVector(prop_name);
+ boost::optional<MeshLib::PropertyVector<std::array<double, 3>*> const&>
+ removed_group_properties(
+ mesh->getProperties().getPropertyVector<std::array<double,3>*>(prop_name)
+ );
+
+ ASSERT_TRUE(!removed_group_properties);
}
TEST_F(MeshLibProperties, AddVariousDifferentProperties)
{
- ASSERT_TRUE(mesh != nullptr);
-
- std::string const& prop_name("GroupVectorProperty");
- // check if the property is already assigned to the mesh
- ASSERT_FALSE(mesh->getProperties().hasPropertyVector(prop_name));
- const std::size_t n_prop_val_groups(10);
- const std::size_t n_items(mesh_size*mesh_size*mesh_size);
- std::vector<std::size_t> prop_item2group_mapping(n_items);
- // create simple mat_group to index mapping
- for (std::size_t j(0); j<n_prop_val_groups; j++) {
- std::size_t const lower(
- static_cast<std::size_t>(
- (static_cast<double>(j)/n_prop_val_groups)*n_items
- )
- );
- std::size_t const upper(
- static_cast<std::size_t>(
- (static_cast<double>(j+1)/n_prop_val_groups)*n_items
- )
- );
- for (std::size_t k(lower); k<upper; k++) {
- prop_item2group_mapping[k] = j;
- }
- }
- // create data structure for the property
- boost::optional<MeshLib::PropertyVector<std::array<double,3>*> &>
- group_properties(
- mesh->getProperties().createNewPropertyVector<std::array<double,3>*>(
- prop_name, n_prop_val_groups, prop_item2group_mapping,
- MeshLib::MeshItemType::Cell
- )
- );
- // initialize the property values
- for (std::size_t i(0); i<n_prop_val_groups; i++) {
- (*group_properties).initPropertyValue(i,
- std::array<double,3>({{static_cast<double>(i),
- static_cast<double>(i+1),
- static_cast<double>(i+2)}}
- )
- );
- }
-
- // the mesh should have the property assigned to cells
- ASSERT_TRUE(mesh->getProperties().hasPropertyVector(prop_name));
-
- // fetch the vector filled with property values from mesh
- boost::optional<MeshLib::PropertyVector<std::array<double,3>*> const&>
- group_properties_cpy(
- mesh->getProperties().getPropertyVector<std::array<double,3>*>(prop_name)
- );
- ASSERT_FALSE(!group_properties_cpy);
- // compare the content
- const std::size_t n_elements(mesh_size*mesh_size*mesh_size);
- for (std::size_t k(0); k<n_elements; k++) {
- ASSERT_EQ((*((*group_properties)[k]))[0],
- (*((*group_properties_cpy)[k]))[0]);
- ASSERT_EQ((*((*group_properties)[k]))[1],
- (*((*group_properties_cpy))[k])[1]);
- ASSERT_EQ((*((*group_properties)[k]))[2],
- (*((*group_properties_cpy)[k]))[2]);
- }
-
- // *** add a 2nd property ***
- std::string const& prop_name_2("ItemwiseMatrixProperties");
- // check if the property is already assigned to the mesh
- ASSERT_FALSE(mesh->getProperties().hasPropertyVector(prop_name_2));
- const std::size_t n_items_2(mesh_size*mesh_size*mesh_size);
- boost::optional<MeshLib::PropertyVector<std::array<float,9>> &>
- array_properties(mesh->getProperties().createNewPropertyVector<
- std::array<float,9>
- > (prop_name_2, MeshLib::MeshItemType::Cell)
- );
-
- (*array_properties).resize(n_items_2);
-
- // initialize the property values
- for (std::size_t i(0); i<n_items_2; i++) {
- // init property value
- for (std::size_t k(0); k<(*array_properties)[i].size(); k++) {
- (*array_properties)[i][k] = static_cast<float>(i+k);
- }
- }
-
- EXPECT_EQ(9, (*array_properties)[0].size());
-
- // the mesh should have the property assigned to cells
- ASSERT_TRUE(mesh->getProperties().hasPropertyVector(prop_name_2));
-
- // fetch the vector in order to compare the content
- boost::optional<MeshLib::PropertyVector<std::array<float,9>> const&>
- array_properties_cpy(mesh->getProperties().getPropertyVector<std::array<float,9>>(
- prop_name_2)
- );
- ASSERT_FALSE(!array_properties_cpy);
-
- // compare the values/matrices
- for (std::size_t k(0); k<n_items_2; k++) {
- for (std::size_t j(0); j<(*array_properties)[k].size(); j++) {
- ASSERT_EQ((*array_properties)[k][j], (*array_properties_cpy)[k][j]);
- }
- }
-
- // *** add a 3rd property ***
+ ASSERT_TRUE(mesh != nullptr);
+
+ std::string const& prop_name("GroupVectorProperty");
+ // check if the property is already assigned to the mesh
+ ASSERT_FALSE(mesh->getProperties().hasPropertyVector(prop_name));
+ const std::size_t n_prop_val_groups(10);
+ const std::size_t n_items(mesh_size*mesh_size*mesh_size);
+ std::vector<std::size_t> prop_item2group_mapping(n_items);
+ // create simple mat_group to index mapping
+ for (std::size_t j(0); j<n_prop_val_groups; j++) {
+ std::size_t const lower(
+ static_cast<std::size_t>(
+ (static_cast<double>(j)/n_prop_val_groups)*n_items
+ )
+ );
+ std::size_t const upper(
+ static_cast<std::size_t>(
+ (static_cast<double>(j+1)/n_prop_val_groups)*n_items
+ )
+ );
+ for (std::size_t k(lower); k<upper; k++) {
+ prop_item2group_mapping[k] = j;
+ }
+ }
+ // create data structure for the property
+ boost::optional<MeshLib::PropertyVector<std::array<double,3>*> &>
+ group_properties(
+ mesh->getProperties().createNewPropertyVector<std::array<double,3>*>(
+ prop_name, n_prop_val_groups, prop_item2group_mapping,
+ MeshLib::MeshItemType::Cell
+ )
+ );
+ // initialize the property values
+ for (std::size_t i(0); i<n_prop_val_groups; i++) {
+ (*group_properties).initPropertyValue(i,
+ std::array<double,3>({{static_cast<double>(i),
+ static_cast<double>(i+1),
+ static_cast<double>(i+2)}}
+ )
+ );
+ }
+
+ // the mesh should have the property assigned to cells
+ ASSERT_TRUE(mesh->getProperties().hasPropertyVector(prop_name));
+
+ // fetch the vector filled with property values from mesh
+ boost::optional<MeshLib::PropertyVector<std::array<double,3>*> const&>
+ group_properties_cpy(
+ mesh->getProperties().getPropertyVector<std::array<double,3>*>(prop_name)
+ );
+ ASSERT_FALSE(!group_properties_cpy);
+ // compare the content
+ const std::size_t n_elements(mesh_size*mesh_size*mesh_size);
+ for (std::size_t k(0); k<n_elements; k++) {
+ ASSERT_EQ((*((*group_properties)[k]))[0],
+ (*((*group_properties_cpy)[k]))[0]);
+ ASSERT_EQ((*((*group_properties)[k]))[1],
+ (*((*group_properties_cpy))[k])[1]);
+ ASSERT_EQ((*((*group_properties)[k]))[2],
+ (*((*group_properties_cpy)[k]))[2]);
+ }
+
+ // *** add a 2nd property ***
+ std::string const& prop_name_2("ItemwiseMatrixProperties");
+ // check if the property is already assigned to the mesh
+ ASSERT_FALSE(mesh->getProperties().hasPropertyVector(prop_name_2));
+ const std::size_t n_items_2(mesh_size*mesh_size*mesh_size);
+ boost::optional<MeshLib::PropertyVector<std::array<float,9>> &>
+ array_properties(mesh->getProperties().createNewPropertyVector<
+ std::array<float,9>
+ > (prop_name_2, MeshLib::MeshItemType::Cell)
+ );
+
+ (*array_properties).resize(n_items_2);
+
+ // initialize the property values
+ for (std::size_t i(0); i<n_items_2; i++) {
+ // init property value
+ for (std::size_t k(0); k<(*array_properties)[i].size(); k++) {
+ (*array_properties)[i][k] = static_cast<float>(i+k);
+ }
+ }
+
+ EXPECT_EQ(9, (*array_properties)[0].size());
+
+ // the mesh should have the property assigned to cells
+ ASSERT_TRUE(mesh->getProperties().hasPropertyVector(prop_name_2));
+
+ // fetch the vector in order to compare the content
+ boost::optional<MeshLib::PropertyVector<std::array<float,9>> const&>
+ array_properties_cpy(mesh->getProperties().getPropertyVector<std::array<float,9>>(
+ prop_name_2)
+ );
+ ASSERT_FALSE(!array_properties_cpy);
+
+ // compare the values/matrices
+ for (std::size_t k(0); k<n_items_2; k++) {
+ for (std::size_t j(0); j<(*array_properties)[k].size(); j++) {
+ ASSERT_EQ((*array_properties)[k][j], (*array_properties_cpy)[k][j]);
+ }
+ }
+
+ // *** add a 3rd property ***
#ifdef OGS_USE_EIGEN
- std::string const& prop_name_3("ItemwiseEigenMatrixProperties");
- // check if the property is already assigned to the mesh
- ASSERT_FALSE(mesh->getProperties().hasPropertyVector(prop_name_3));
- boost::optional<
- MeshLib::PropertyVector<Eigen::Matrix<double,3,3,Eigen::RowMajor>> &>
- matrix_properties(mesh->getProperties().createNewPropertyVector
- <Eigen::Matrix<double,3,3,Eigen::RowMajor>> (
- prop_name_3, MeshLib::MeshItemType::Cell)
- );
- // init property values
- for (auto it=matrix_properties->begin(); it != matrix_properties->end(); it++)
- {
- for (int r(0); r<it->rows(); r++) {
- for (int c(0); c<it->cols(); c++) {
- (*it)(r,c) = static_cast<double>(
- std::distance(matrix_properties->begin(),it)+r*it->cols()+c+1);
- }
- }
- }
-
- // the mesh should have the property assigned to cells
- ASSERT_TRUE(mesh->getProperties().hasPropertyVector(prop_name_3));
-
- // fetch the vector in order to compare the content
- boost::optional<
- MeshLib::PropertyVector<Eigen::Matrix<double,3,3,Eigen::RowMajor>> const&
- > matrix_properties_cpy(
- mesh->getProperties().getPropertyVector<Eigen::Matrix<double,3,3,Eigen::RowMajor>>(
- prop_name_3)
- );
- ASSERT_FALSE(!matrix_properties_cpy);
-
- // compare the values/matrices
- auto it_cpy=matrix_properties_cpy->begin();
- for (auto it=matrix_properties->begin(); it != matrix_properties->end();
- it++, it_cpy++) {
- for (int r(0); r<it->rows(); r++) {
- for (int c(0); c<it->cols(); c++) {
- ASSERT_EQ((*it)(r,c), (*it_cpy)(r,c));
- }
- }
- }
+ std::string const& prop_name_3("ItemwiseEigenMatrixProperties");
+ // check if the property is already assigned to the mesh
+ ASSERT_FALSE(mesh->getProperties().hasPropertyVector(prop_name_3));
+ boost::optional<
+ MeshLib::PropertyVector<Eigen::Matrix<double,3,3,Eigen::RowMajor>> &>
+ matrix_properties(mesh->getProperties().createNewPropertyVector
+ <Eigen::Matrix<double,3,3,Eigen::RowMajor>> (
+ prop_name_3, MeshLib::MeshItemType::Cell)
+ );
+ // init property values
+ for (auto it=matrix_properties->begin(); it != matrix_properties->end(); it++)
+ {
+ for (int r(0); r<it->rows(); r++) {
+ for (int c(0); c<it->cols(); c++) {
+ (*it)(r,c) = static_cast<double>(
+ std::distance(matrix_properties->begin(),it)+r*it->cols()+c+1);
+ }
+ }
+ }
+
+ // the mesh should have the property assigned to cells
+ ASSERT_TRUE(mesh->getProperties().hasPropertyVector(prop_name_3));
+
+ // fetch the vector in order to compare the content
+ boost::optional<
+ MeshLib::PropertyVector<Eigen::Matrix<double,3,3,Eigen::RowMajor>> const&
+ > matrix_properties_cpy(
+ mesh->getProperties().getPropertyVector<Eigen::Matrix<double,3,3,Eigen::RowMajor>>(
+ prop_name_3)
+ );
+ ASSERT_FALSE(!matrix_properties_cpy);
+
+ // compare the values/matrices
+ auto it_cpy=matrix_properties_cpy->begin();
+ for (auto it=matrix_properties->begin(); it != matrix_properties->end();
+ it++, it_cpy++) {
+ for (int r(0); r<it->rows(); r++) {
+ for (int c(0); c<it->cols(); c++) {
+ ASSERT_EQ((*it)(r,c), (*it_cpy)(r,c));
+ }
+ }
+ }
#endif
}
TEST_F(MeshLibProperties, CopyConstructor)
{
- ASSERT_TRUE(mesh != nullptr);
- std::string const& prop_name("GroupProperty");
- // data needed for the property
- const std::size_t n_prop_val_groups(10);
- const std::size_t n_items(mesh_size*mesh_size*mesh_size);
- std::vector<std::size_t> prop_item2group_mapping(n_items);
- // create simple mat_group to index mapping
- for (std::size_t j(0); j<n_prop_val_groups; j++) {
- std::size_t const lower(
- static_cast<std::size_t>(
- (static_cast<double>(j)/n_prop_val_groups)*n_items
- )
- );
- std::size_t const upper(
- static_cast<std::size_t>(
- (static_cast<double>(j+1)/n_prop_val_groups)*n_items
- )
- );
- for (std::size_t k(lower); k<upper; k++) {
- prop_item2group_mapping[k] = j;
- }
- }
- // obtain PropertyVector data structure
- boost::optional<MeshLib::PropertyVector<double*> &> group_properties(
- mesh->getProperties().createNewPropertyVector<double*>(
- prop_name, n_prop_val_groups, prop_item2group_mapping,
- MeshLib::MeshItemType::Cell
- )
- );
- // initialize the property values
- for (std::size_t i(0); i<n_prop_val_groups; i++) {
- (*group_properties).initPropertyValue(i, static_cast<double>(i+1));
- }
-
- // create a copy from the original Properties object
- MeshLib::Properties properties_copy(mesh->getProperties());
- // check if the Properties have a PropertyVector with the correct name
- ASSERT_TRUE(properties_copy.hasPropertyVector(prop_name));
- // fetch the PropertyVector from the copy of the Properties object
- boost::optional<MeshLib::PropertyVector<double*> const&>
- group_properties_cpy(properties_copy.getPropertyVector<double*>(
- prop_name));
- ASSERT_FALSE(!group_properties_cpy);
-
- // check if the values in the PropertyVector of the copy of the Properties
- // are the same
- for (std::size_t k(0); k<n_items; k++) {
- EXPECT_EQ(*(*group_properties)[k], *(*group_properties_cpy)[k]);
- }
+ ASSERT_TRUE(mesh != nullptr);
+ std::string const& prop_name("GroupProperty");
+ // data needed for the property
+ const std::size_t n_prop_val_groups(10);
+ const std::size_t n_items(mesh_size*mesh_size*mesh_size);
+ std::vector<std::size_t> prop_item2group_mapping(n_items);
+ // create simple mat_group to index mapping
+ for (std::size_t j(0); j<n_prop_val_groups; j++) {
+ std::size_t const lower(
+ static_cast<std::size_t>(
+ (static_cast<double>(j)/n_prop_val_groups)*n_items
+ )
+ );
+ std::size_t const upper(
+ static_cast<std::size_t>(
+ (static_cast<double>(j+1)/n_prop_val_groups)*n_items
+ )
+ );
+ for (std::size_t k(lower); k<upper; k++) {
+ prop_item2group_mapping[k] = j;
+ }
+ }
+ // obtain PropertyVector data structure
+ boost::optional<MeshLib::PropertyVector<double*> &> group_properties(
+ mesh->getProperties().createNewPropertyVector<double*>(
+ prop_name, n_prop_val_groups, prop_item2group_mapping,
+ MeshLib::MeshItemType::Cell
+ )
+ );
+ // initialize the property values
+ for (std::size_t i(0); i<n_prop_val_groups; i++) {
+ (*group_properties).initPropertyValue(i, static_cast<double>(i+1));
+ }
+
+ // create a copy from the original Properties object
+ MeshLib::Properties properties_copy(mesh->getProperties());
+ // check if the Properties have a PropertyVector with the correct name
+ ASSERT_TRUE(properties_copy.hasPropertyVector(prop_name));
+ // fetch the PropertyVector from the copy of the Properties object
+ boost::optional<MeshLib::PropertyVector<double*> const&>
+ group_properties_cpy(properties_copy.getPropertyVector<double*>(
+ prop_name));
+ ASSERT_FALSE(!group_properties_cpy);
+
+ // check if the values in the PropertyVector of the copy of the Properties
+ // are the same
+ for (std::size_t k(0); k<n_items; k++) {
+ EXPECT_EQ(*(*group_properties)[k], *(*group_properties_cpy)[k]);
+ }
}
TEST_F(MeshLibProperties, AddDoublePropertiesTupleSize2)
{
- ASSERT_TRUE(mesh != nullptr);
- const std::size_t number_of_tuples(mesh_size*mesh_size*mesh_size);
-
- std::string const prop_name("TestProperty");
- boost::optional<MeshLib::PropertyVector<double> &> opt_pv(
- mesh->getProperties().createNewPropertyVector<double>(prop_name,
- MeshLib::MeshItemType::Cell, 2)
- );
- // PropertyVector should be created in a correct way
- ASSERT_TRUE(!(!opt_pv));
-
- MeshLib::PropertyVector<double> & pv(opt_pv.get());
-
- ASSERT_EQ(0u, pv.getPropertyName().compare(prop_name));
- ASSERT_EQ(MeshLib::MeshItemType::Cell, pv.getMeshItemType());
- ASSERT_EQ(2u, pv.getNumberOfComponents());
- ASSERT_EQ(0u, pv.getNumberOfTuples());
- ASSERT_EQ(0u, pv.size());
-
- // push some values (2 tuples) into the vector
- for (std::size_t k(0); k<number_of_tuples; k++) {
- pv.push_back(static_cast<double>(k));
- pv.push_back(static_cast<double>(k));
- }
- // check the number of tuples
- ASSERT_EQ(number_of_tuples, pv.getNumberOfTuples());
- ASSERT_EQ(pv.getNumberOfTuples()*pv.getNumberOfComponents(), pv.size());
- // check the values
- for (std::size_t k(0); k<number_of_tuples; k++) {
- ASSERT_EQ(static_cast<double>(k), pv[2*k]);
- ASSERT_EQ(static_cast<double>(k), pv[2*k+1]);
- }
+ ASSERT_TRUE(mesh != nullptr);
+ const std::size_t number_of_tuples(mesh_size*mesh_size*mesh_size);
+
+ std::string const prop_name("TestProperty");
+ boost::optional<MeshLib::PropertyVector<double> &> opt_pv(
+ mesh->getProperties().createNewPropertyVector<double>(prop_name,
+ MeshLib::MeshItemType::Cell, 2)
+ );
+ // PropertyVector should be created in a correct way
+ ASSERT_TRUE(!(!opt_pv));
+
+ MeshLib::PropertyVector<double> & pv(opt_pv.get());
+
+ ASSERT_EQ(0u, pv.getPropertyName().compare(prop_name));
+ ASSERT_EQ(MeshLib::MeshItemType::Cell, pv.getMeshItemType());
+ ASSERT_EQ(2u, pv.getNumberOfComponents());
+ ASSERT_EQ(0u, pv.getNumberOfTuples());
+ ASSERT_EQ(0u, pv.size());
+
+ // push some values (2 tuples) into the vector
+ for (std::size_t k(0); k<number_of_tuples; k++) {
+ pv.push_back(static_cast<double>(k));
+ pv.push_back(static_cast<double>(k));
+ }
+ // check the number of tuples
+ ASSERT_EQ(number_of_tuples, pv.getNumberOfTuples());
+ ASSERT_EQ(pv.getNumberOfTuples()*pv.getNumberOfComponents(), pv.size());
+ // check the values
+ for (std::size_t k(0); k<number_of_tuples; k++) {
+ ASSERT_EQ(static_cast<double>(k), pv[2*k]);
+ ASSERT_EQ(static_cast<double>(k), pv[2*k+1]);
+ }
}
diff --git a/Tests/MeshLib/MeshSubsets.cpp b/Tests/MeshLib/MeshSubsets.cpp
index 526f1093ab9c77a26241c2a0821f6678e4584c1e..22f8d1278652100b348ba53c313d36452f87824a 100644
--- a/Tests/MeshLib/MeshSubsets.cpp
+++ b/Tests/MeshLib/MeshSubsets.cpp
@@ -18,47 +18,47 @@ using namespace MeshLib;
TEST(MeshLibMeshSubsets, UniqueMeshIds)
{
- // Create first mesh
- Mesh const m0("first", std::vector<Node*>(), std::vector<Element*>());
- Mesh const m1("second", std::vector<Node*>(), std::vector<Element*>());
+ // Create first mesh
+ Mesh const m0("first", std::vector<Node*>(), std::vector<Element*>());
+ Mesh const m1("second", std::vector<Node*>(), std::vector<Element*>());
- std::vector<Node*> const empty_node_ptr_vector(0);
+ std::vector<Node*> const empty_node_ptr_vector(0);
- MeshSubset const ms0(m0, &empty_node_ptr_vector);
- MeshSubset const ms1(m1, &empty_node_ptr_vector);
- MeshSubset const ms1a(m1, &empty_node_ptr_vector);
+ MeshSubset const ms0(m0, &empty_node_ptr_vector);
+ MeshSubset const ms1(m1, &empty_node_ptr_vector);
+ MeshSubset const ms1a(m1, &empty_node_ptr_vector);
- MeshSubset const* const mesh_subsets[3] = {&ms0, &ms1, &ms1a};
+ MeshSubset const* const mesh_subsets[3] = {&ms0, &ms1, &ms1a};
- // EXPECT_NO_DEATH
- MeshSubsets(&mesh_subsets[0], &mesh_subsets[0] + 2);
+ // EXPECT_NO_DEATH
+ MeshSubsets(&mesh_subsets[0], &mesh_subsets[0] + 2);
- EXPECT_DEATH(MeshSubsets(&mesh_subsets[1], &mesh_subsets[1] + 2), "");
- EXPECT_DEATH(MeshSubsets(&mesh_subsets[0], &mesh_subsets[0] + 3), "");
+ EXPECT_DEATH(MeshSubsets(&mesh_subsets[1], &mesh_subsets[1] + 2), "");
+ EXPECT_DEATH(MeshSubsets(&mesh_subsets[0], &mesh_subsets[0] + 3), "");
}
TEST(MeshLibMeshSubsets, GetIntersectionByNodes)
{
- auto mesh = std::unique_ptr<Mesh>{MeshGenerator::generateLineMesh(1., 10)};
- MeshSubset all_nodes_mesh_subset(*mesh, &mesh->getNodes());
-
- // Select nodes
- std::vector<Node*> some_nodes;
- some_nodes.assign({
- const_cast<Node*>(mesh->getNode(0)),
- const_cast<Node*>(mesh->getNode(2)),
- const_cast<Node*>(mesh->getNode(5)),
- const_cast<Node*>(mesh->getNode(7)) });
- auto some_nodes_mesh_subset = std::unique_ptr<MeshSubset>
- {all_nodes_mesh_subset.getIntersectionByNodes(some_nodes)};
-
- // Check sizes.
- ASSERT_EQ(some_nodes.size(), some_nodes_mesh_subset->getNNodes());
-
- // Check ids.
- std::size_t nnodes = some_nodes.size();
- for (std::size_t i = 0; i < nnodes; ++i)
- ASSERT_EQ(some_nodes[i]->getID(), some_nodes_mesh_subset->getNodeID(i));
+ auto mesh = std::unique_ptr<Mesh>{MeshGenerator::generateLineMesh(1., 10)};
+ MeshSubset all_nodes_mesh_subset(*mesh, &mesh->getNodes());
+
+ // Select nodes
+ std::vector<Node*> some_nodes;
+ some_nodes.assign({
+ const_cast<Node*>(mesh->getNode(0)),
+ const_cast<Node*>(mesh->getNode(2)),
+ const_cast<Node*>(mesh->getNode(5)),
+ const_cast<Node*>(mesh->getNode(7)) });
+ auto some_nodes_mesh_subset = std::unique_ptr<MeshSubset>
+ {all_nodes_mesh_subset.getIntersectionByNodes(some_nodes)};
+
+ // Check sizes.
+ ASSERT_EQ(some_nodes.size(), some_nodes_mesh_subset->getNNodes());
+
+ // Check ids.
+ std::size_t nnodes = some_nodes.size();
+ for (std::size_t i = 0; i < nnodes; ++i)
+ ASSERT_EQ(some_nodes[i]->getID(), some_nodes_mesh_subset->getNodeID(i));
}
diff --git a/Tests/MeshLib/TestAddLayerToMesh.cpp b/Tests/MeshLib/TestAddLayerToMesh.cpp
index 131564e7cb0c29950d8d9d8a8f9353a2abae051b..77668c3a17d054bbb007fc9cd8c5966349c49409 100644
--- a/Tests/MeshLib/TestAddLayerToMesh.cpp
+++ b/Tests/MeshLib/TestAddLayerToMesh.cpp
@@ -21,261 +21,261 @@
namespace AddLayerValidation
{
- // validates mesh. for line meshes, node order tests will fail because vertical elements are
- // created during the extrusion. Therefore node order tests are switched off for line meshes.
- void validate(MeshLib::Mesh const& mesh, bool testNodeOrder)
- {
- int const reduce_tests = (testNodeOrder) ? 0 : 1;
-
- std::size_t const nErrorFlags (static_cast<std::size_t>(ElementErrorFlag::MaxValue));
- ElementErrorFlag const flags[nErrorFlags] = {ElementErrorFlag::ZeroVolume,
- ElementErrorFlag::NonCoplanar, ElementErrorFlag::NonConvex, ElementErrorFlag::NodeOrder};
- std::vector<ElementErrorCode> const codes (MeshLib::MeshValidation::testElementGeometry(mesh));
- for (std::size_t i=0; i<codes.size(); ++i)
- for (std::size_t j=0; j<nErrorFlags-reduce_tests; ++j)
- ASSERT_FALSE(codes[i][flags[j]]);
- }
-
- void testZCoords2D(MeshLib::Mesh const& input, MeshLib::Mesh const& output, double height)
- {
- std::size_t const nNodes (input.getNNodes());
- for (std::size_t i=0; i<nNodes; ++i)
- {
- ASSERT_EQ((*input.getNode(i))[2], (*output.getNode(i))[2]);
- ASSERT_EQ((*input.getNode(i))[2] + height, (*output.getNode(nNodes+i))[2]);
- }
- }
-
- void testZCoords3D(MeshLib::Mesh const& input, MeshLib::Mesh const& output, double height)
- {
- std::size_t const nNodes (input.getNNodes());
- for (std::size_t i=0; i<nNodes; ++i)
- ASSERT_EQ((*input.getNode(i))[2] + height, (*output.getNode(i))[2]);
- }
+ // validates mesh. for line meshes, node order tests will fail because vertical elements are
+ // created during the extrusion. Therefore node order tests are switched off for line meshes.
+ void validate(MeshLib::Mesh const& mesh, bool testNodeOrder)
+ {
+ int const reduce_tests = (testNodeOrder) ? 0 : 1;
+
+ std::size_t const nErrorFlags (static_cast<std::size_t>(ElementErrorFlag::MaxValue));
+ ElementErrorFlag const flags[nErrorFlags] = {ElementErrorFlag::ZeroVolume,
+ ElementErrorFlag::NonCoplanar, ElementErrorFlag::NonConvex, ElementErrorFlag::NodeOrder};
+ std::vector<ElementErrorCode> const codes (MeshLib::MeshValidation::testElementGeometry(mesh));
+ for (std::size_t i=0; i<codes.size(); ++i)
+ for (std::size_t j=0; j<nErrorFlags-reduce_tests; ++j)
+ ASSERT_FALSE(codes[i][flags[j]]);
+ }
+
+ void testZCoords2D(MeshLib::Mesh const& input, MeshLib::Mesh const& output, double height)
+ {
+ std::size_t const nNodes (input.getNNodes());
+ for (std::size_t i=0; i<nNodes; ++i)
+ {
+ ASSERT_EQ((*input.getNode(i))[2], (*output.getNode(i))[2]);
+ ASSERT_EQ((*input.getNode(i))[2] + height, (*output.getNode(nNodes+i))[2]);
+ }
+ }
+
+ void testZCoords3D(MeshLib::Mesh const& input, MeshLib::Mesh const& output, double height)
+ {
+ std::size_t const nNodes (input.getNNodes());
+ for (std::size_t i=0; i<nNodes; ++i)
+ ASSERT_EQ((*input.getNode(i))[2] + height, (*output.getNode(i))[2]);
+ }
};
TEST(MeshLib, AddTopLayerToLineMesh)
{
- std::unique_ptr<MeshLib::Mesh> const mesh (MeshLib::MeshGenerator::generateLineMesh(1.0, 5));
- double const height (1);
- std::unique_ptr<MeshLib::Mesh> const result (MeshLib::addLayerToMesh(*mesh, height, "mesh", true));
+ std::unique_ptr<MeshLib::Mesh> const mesh (MeshLib::MeshGenerator::generateLineMesh(1.0, 5));
+ double const height (1);
+ std::unique_ptr<MeshLib::Mesh> const result (MeshLib::addLayerToMesh(*mesh, height, "mesh", true));
- ASSERT_EQ(2*mesh->getNNodes(), result->getNNodes());
- ASSERT_EQ(2*mesh->getNElements(), result->getNElements());
+ ASSERT_EQ(2*mesh->getNNodes(), result->getNNodes());
+ ASSERT_EQ(2*mesh->getNElements(), result->getNElements());
- std::array<unsigned, 7> const n_elems (MeshLib::MeshInformation::getNumberOfElementTypes(*result));
- ASSERT_EQ(5, n_elems[0]); // tests if 5 lines are present
- ASSERT_EQ(5, n_elems[2]); // tests if 5 quads are present
+ std::array<unsigned, 7> const n_elems (MeshLib::MeshInformation::getNumberOfElementTypes(*result));
+ ASSERT_EQ(5, n_elems[0]); // tests if 5 lines are present
+ ASSERT_EQ(5, n_elems[2]); // tests if 5 quads are present
- AddLayerValidation::testZCoords2D(*mesh, *result, height);
- AddLayerValidation::validate(*result, false);
+ AddLayerValidation::testZCoords2D(*mesh, *result, height);
+ AddLayerValidation::validate(*result, false);
}
TEST(MeshLib, AddBottomLayerToLineMesh)
{
- std::unique_ptr<MeshLib::Mesh> const mesh (MeshLib::MeshGenerator::generateLineMesh(1.0, 5));
- double const height (1);
- std::unique_ptr<MeshLib::Mesh> const result (MeshLib::addLayerToMesh(*mesh, height, "mesh", false));
+ std::unique_ptr<MeshLib::Mesh> const mesh (MeshLib::MeshGenerator::generateLineMesh(1.0, 5));
+ double const height (1);
+ std::unique_ptr<MeshLib::Mesh> const result (MeshLib::addLayerToMesh(*mesh, height, "mesh", false));
- ASSERT_EQ(2*mesh->getNNodes(), result->getNNodes());
- ASSERT_EQ(2*mesh->getNElements(), result->getNElements());
+ ASSERT_EQ(2*mesh->getNNodes(), result->getNNodes());
+ ASSERT_EQ(2*mesh->getNElements(), result->getNElements());
- std::array<unsigned, 7> const n_elems (MeshLib::MeshInformation::getNumberOfElementTypes(*result));
- ASSERT_EQ(5, n_elems[0]); // tests if 5 lines are present
- ASSERT_EQ(5, n_elems[2]); // tests if 5 quads are present
+ std::array<unsigned, 7> const n_elems (MeshLib::MeshInformation::getNumberOfElementTypes(*result));
+ ASSERT_EQ(5, n_elems[0]); // tests if 5 lines are present
+ ASSERT_EQ(5, n_elems[2]); // tests if 5 quads are present
- AddLayerValidation::testZCoords2D(*mesh, *result, -1 * height);
- AddLayerValidation::validate(*result, false);
+ AddLayerValidation::testZCoords2D(*mesh, *result, -1 * height);
+ AddLayerValidation::validate(*result, false);
}
TEST(MeshLib, AddTopLayerToTriMesh)
{
- std::unique_ptr<MeshLib::Mesh> const mesh (MeshLib::MeshGenerator::generateRegularTriMesh(5, 5));
- std::string const& mat_name ("MaterialIDs");
- boost::optional<MeshLib::PropertyVector<int>&> mats =
- mesh->getProperties().createNewPropertyVector<int>(mat_name, MeshLib::MeshItemType::Cell);
- if (mats)
- {
- mats->resize(mesh->getNElements());
- std::fill_n(mats->begin(), mesh->getNElements(), 0);
- }
- boost::optional<MeshLib::PropertyVector<double>&> test =
- mesh->getProperties().createNewPropertyVector<double>("test", MeshLib::MeshItemType::Cell);
- if (test)
- {
- test->resize(mesh->getNElements());
- std::fill_n(test->begin(), mesh->getNElements(), 0.1);
- }
- ASSERT_EQ(2, mesh->getProperties().getPropertyVectorNames().size());
- double const height (1);
- std::unique_ptr<MeshLib::Mesh> const result (MeshLib::addLayerToMesh(*mesh, height, "mesh", true));
-
- ASSERT_EQ(2*mesh->getNNodes(), result->getNNodes());
- ASSERT_EQ(2*mesh->getNElements(), result->getNElements());
-
- std::array<unsigned, 7> const n_elems (MeshLib::MeshInformation::getNumberOfElementTypes(*result));
- ASSERT_EQ(mesh->getNElements(), n_elems[1]); // tests if 50 tris are present
- ASSERT_EQ(mesh->getNElements(), n_elems[6]); // tests if 50 prisms are present
-
- ASSERT_EQ(1, result->getProperties().getPropertyVectorNames().size());
- boost::optional<MeshLib::PropertyVector<int>&> new_mats =
- result->getProperties().getPropertyVector<int>(mat_name);
- ASSERT_EQ(result->getNElements(), new_mats->size());
- ASSERT_EQ(mesh->getNElements(), std::count(new_mats->cbegin(), new_mats->cend(), 0));
- ASSERT_EQ(mesh->getNElements(), std::count(new_mats->cbegin(), new_mats->cend(), 1));
- AddLayerValidation::testZCoords2D(*mesh, *result, height);
- AddLayerValidation::validate(*result, true);
+ std::unique_ptr<MeshLib::Mesh> const mesh (MeshLib::MeshGenerator::generateRegularTriMesh(5, 5));
+ std::string const& mat_name ("MaterialIDs");
+ boost::optional<MeshLib::PropertyVector<int>&> mats =
+ mesh->getProperties().createNewPropertyVector<int>(mat_name, MeshLib::MeshItemType::Cell);
+ if (mats)
+ {
+ mats->resize(mesh->getNElements());
+ std::fill_n(mats->begin(), mesh->getNElements(), 0);
+ }
+ boost::optional<MeshLib::PropertyVector<double>&> test =
+ mesh->getProperties().createNewPropertyVector<double>("test", MeshLib::MeshItemType::Cell);
+ if (test)
+ {
+ test->resize(mesh->getNElements());
+ std::fill_n(test->begin(), mesh->getNElements(), 0.1);
+ }
+ ASSERT_EQ(2, mesh->getProperties().getPropertyVectorNames().size());
+ double const height (1);
+ std::unique_ptr<MeshLib::Mesh> const result (MeshLib::addLayerToMesh(*mesh, height, "mesh", true));
+
+ ASSERT_EQ(2*mesh->getNNodes(), result->getNNodes());
+ ASSERT_EQ(2*mesh->getNElements(), result->getNElements());
+
+ std::array<unsigned, 7> const n_elems (MeshLib::MeshInformation::getNumberOfElementTypes(*result));
+ ASSERT_EQ(mesh->getNElements(), n_elems[1]); // tests if 50 tris are present
+ ASSERT_EQ(mesh->getNElements(), n_elems[6]); // tests if 50 prisms are present
+
+ ASSERT_EQ(1, result->getProperties().getPropertyVectorNames().size());
+ boost::optional<MeshLib::PropertyVector<int>&> new_mats =
+ result->getProperties().getPropertyVector<int>(mat_name);
+ ASSERT_EQ(result->getNElements(), new_mats->size());
+ ASSERT_EQ(mesh->getNElements(), std::count(new_mats->cbegin(), new_mats->cend(), 0));
+ ASSERT_EQ(mesh->getNElements(), std::count(new_mats->cbegin(), new_mats->cend(), 1));
+ AddLayerValidation::testZCoords2D(*mesh, *result, height);
+ AddLayerValidation::validate(*result, true);
}
TEST(MeshLib, AddBottomLayerToTriMesh)
{
- std::unique_ptr<MeshLib::Mesh> const mesh (MeshLib::MeshGenerator::generateRegularTriMesh(5, 5));
- double const height (1);
- std::unique_ptr<MeshLib::Mesh> const result (MeshLib::addLayerToMesh(*mesh, height, "mesh", false));
+ std::unique_ptr<MeshLib::Mesh> const mesh (MeshLib::MeshGenerator::generateRegularTriMesh(5, 5));
+ double const height (1);
+ std::unique_ptr<MeshLib::Mesh> const result (MeshLib::addLayerToMesh(*mesh, height, "mesh", false));
- ASSERT_EQ(2*mesh->getNNodes(), result->getNNodes());
- ASSERT_EQ(2*mesh->getNElements(), result->getNElements());
+ ASSERT_EQ(2*mesh->getNNodes(), result->getNNodes());
+ ASSERT_EQ(2*mesh->getNElements(), result->getNElements());
- std::array<unsigned, 7> const n_elems (MeshLib::MeshInformation::getNumberOfElementTypes(*result));
- ASSERT_EQ(50, n_elems[1]); // tests if 50 tris are present
- ASSERT_EQ(50, n_elems[6]); // tests if 50 prisms are present
+ std::array<unsigned, 7> const n_elems (MeshLib::MeshInformation::getNumberOfElementTypes(*result));
+ ASSERT_EQ(50, n_elems[1]); // tests if 50 tris are present
+ ASSERT_EQ(50, n_elems[6]); // tests if 50 prisms are present
- AddLayerValidation::testZCoords2D(*mesh, *result, -1 * height);
- AddLayerValidation::validate(*result, true);
+ AddLayerValidation::testZCoords2D(*mesh, *result, -1 * height);
+ AddLayerValidation::validate(*result, true);
}
TEST(MeshLib, AddTopLayerToQuadMesh)
{
- std::unique_ptr<MeshLib::Mesh> const mesh (MeshLib::MeshGenerator::generateRegularQuadMesh(5, 5));
- double const height (1);
- std::unique_ptr<MeshLib::Mesh> const result (MeshLib::addLayerToMesh(*mesh, height, "mesh", true));
+ std::unique_ptr<MeshLib::Mesh> const mesh (MeshLib::MeshGenerator::generateRegularQuadMesh(5, 5));
+ double const height (1);
+ std::unique_ptr<MeshLib::Mesh> const result (MeshLib::addLayerToMesh(*mesh, height, "mesh", true));
- ASSERT_EQ(2*mesh->getNNodes(), result->getNNodes());
- ASSERT_EQ(2*mesh->getNElements(), result->getNElements());
+ ASSERT_EQ(2*mesh->getNNodes(), result->getNNodes());
+ ASSERT_EQ(2*mesh->getNElements(), result->getNElements());
- std::array<unsigned, 7> const n_elems (MeshLib::MeshInformation::getNumberOfElementTypes(*result));
- ASSERT_EQ(25, n_elems[2]); // tests if 25 quads are present
- ASSERT_EQ(25, n_elems[4]); // tests if 25 hexes are present
+ std::array<unsigned, 7> const n_elems (MeshLib::MeshInformation::getNumberOfElementTypes(*result));
+ ASSERT_EQ(25, n_elems[2]); // tests if 25 quads are present
+ ASSERT_EQ(25, n_elems[4]); // tests if 25 hexes are present
- AddLayerValidation::testZCoords2D(*mesh, *result, height);
- AddLayerValidation::validate(*result, true);
+ AddLayerValidation::testZCoords2D(*mesh, *result, height);
+ AddLayerValidation::validate(*result, true);
}
TEST(MeshLib, AddBottomLayerToQuadMesh)
{
- std::unique_ptr<MeshLib::Mesh> const mesh (MeshLib::MeshGenerator::generateRegularQuadMesh(5, 5));
- double const height (1);
- std::unique_ptr<MeshLib::Mesh> const result (MeshLib::addLayerToMesh(*mesh, height, "mesh", false));
+ std::unique_ptr<MeshLib::Mesh> const mesh (MeshLib::MeshGenerator::generateRegularQuadMesh(5, 5));
+ double const height (1);
+ std::unique_ptr<MeshLib::Mesh> const result (MeshLib::addLayerToMesh(*mesh, height, "mesh", false));
- ASSERT_EQ(2*mesh->getNNodes(), result->getNNodes());
- ASSERT_EQ(2*mesh->getNElements(), result->getNElements());
+ ASSERT_EQ(2*mesh->getNNodes(), result->getNNodes());
+ ASSERT_EQ(2*mesh->getNElements(), result->getNElements());
- std::array<unsigned, 7> const n_elems (MeshLib::MeshInformation::getNumberOfElementTypes(*result));
- ASSERT_EQ(25, n_elems[2]); // tests if 25 quads are present
- ASSERT_EQ(25, n_elems[4]); // tests if 25 hexes are present
+ std::array<unsigned, 7> const n_elems (MeshLib::MeshInformation::getNumberOfElementTypes(*result));
+ ASSERT_EQ(25, n_elems[2]); // tests if 25 quads are present
+ ASSERT_EQ(25, n_elems[4]); // tests if 25 hexes are present
- AddLayerValidation::testZCoords2D(*mesh, *result, -1 * height);
- AddLayerValidation::validate(*result, true);
+ AddLayerValidation::testZCoords2D(*mesh, *result, -1 * height);
+ AddLayerValidation::validate(*result, true);
}
TEST(MeshLib, AddTopLayerToHexMesh)
{
- std::unique_ptr<MeshLib::Mesh> const mesh (MeshLib::MeshGenerator::generateRegularHexMesh(5, 5));
- double const height (1);
- std::unique_ptr<MeshLib::Mesh> const result (MeshLib::addLayerToMesh(*mesh, height, "mesh", true));
-
- ASSERT_EQ(mesh->getNNodes(), result->getNNodes()-36);
- ASSERT_EQ(mesh->getNElements(), result->getNElements()-25);
-
- std::array<unsigned, 7> const n_elems (MeshLib::MeshInformation::getNumberOfElementTypes(*result));
- ASSERT_EQ(150, n_elems[4]); // tests if 150 hexes are present
-
- MathLib::Vector3 const dir(0, 0, -1);
- std::unique_ptr<MeshLib::Mesh> const test_input (
- MeshLib::MeshSurfaceExtraction::getMeshSurface(*mesh, dir, 90));
- std::unique_ptr<MeshLib::Mesh> const test_output (
- MeshLib::MeshSurfaceExtraction::getMeshSurface(*result, dir, 90));
- AddLayerValidation::testZCoords3D(*test_input, *test_output, height);
- AddLayerValidation::validate(*result, true);
+ std::unique_ptr<MeshLib::Mesh> const mesh (MeshLib::MeshGenerator::generateRegularHexMesh(5, 5));
+ double const height (1);
+ std::unique_ptr<MeshLib::Mesh> const result (MeshLib::addLayerToMesh(*mesh, height, "mesh", true));
+
+ ASSERT_EQ(mesh->getNNodes(), result->getNNodes()-36);
+ ASSERT_EQ(mesh->getNElements(), result->getNElements()-25);
+
+ std::array<unsigned, 7> const n_elems (MeshLib::MeshInformation::getNumberOfElementTypes(*result));
+ ASSERT_EQ(150, n_elems[4]); // tests if 150 hexes are present
+
+ MathLib::Vector3 const dir(0, 0, -1);
+ std::unique_ptr<MeshLib::Mesh> const test_input (
+ MeshLib::MeshSurfaceExtraction::getMeshSurface(*mesh, dir, 90));
+ std::unique_ptr<MeshLib::Mesh> const test_output (
+ MeshLib::MeshSurfaceExtraction::getMeshSurface(*result, dir, 90));
+ AddLayerValidation::testZCoords3D(*test_input, *test_output, height);
+ AddLayerValidation::validate(*result, true);
}
TEST(MeshLib, AddBottomLayerToHexMesh)
{
- std::unique_ptr<MeshLib::Mesh> const mesh (MeshLib::MeshGenerator::generateRegularHexMesh(5, 5));
- double const height (1);
- std::unique_ptr<MeshLib::Mesh> const result (MeshLib::addLayerToMesh(*mesh, height, "mesh", false));
-
- ASSERT_EQ(mesh->getNNodes(), result->getNNodes()-36);
- ASSERT_EQ(mesh->getNElements(), result->getNElements()-25);
-
- std::array<unsigned, 7> const n_elems (MeshLib::MeshInformation::getNumberOfElementTypes(*result));
- ASSERT_EQ(150, n_elems[4]); // tests if 150 hexes are present
-
- MathLib::Vector3 const dir(0, 0, 1);
- std::unique_ptr<MeshLib::Mesh> const test_input (
- MeshLib::MeshSurfaceExtraction::getMeshSurface(*mesh, dir, 90));
- std::unique_ptr<MeshLib::Mesh> const test_output (
- MeshLib::MeshSurfaceExtraction::getMeshSurface(*result, dir, 90));
- AddLayerValidation::testZCoords3D(*test_input, *test_output, -1 * height);
- AddLayerValidation::validate(*result, true);
+ std::unique_ptr<MeshLib::Mesh> const mesh (MeshLib::MeshGenerator::generateRegularHexMesh(5, 5));
+ double const height (1);
+ std::unique_ptr<MeshLib::Mesh> const result (MeshLib::addLayerToMesh(*mesh, height, "mesh", false));
+
+ ASSERT_EQ(mesh->getNNodes(), result->getNNodes()-36);
+ ASSERT_EQ(mesh->getNElements(), result->getNElements()-25);
+
+ std::array<unsigned, 7> const n_elems (MeshLib::MeshInformation::getNumberOfElementTypes(*result));
+ ASSERT_EQ(150, n_elems[4]); // tests if 150 hexes are present
+
+ MathLib::Vector3 const dir(0, 0, 1);
+ std::unique_ptr<MeshLib::Mesh> const test_input (
+ MeshLib::MeshSurfaceExtraction::getMeshSurface(*mesh, dir, 90));
+ std::unique_ptr<MeshLib::Mesh> const test_output (
+ MeshLib::MeshSurfaceExtraction::getMeshSurface(*result, dir, 90));
+ AddLayerValidation::testZCoords3D(*test_input, *test_output, -1 * height);
+ AddLayerValidation::validate(*result, true);
}
TEST(MeshLib, AddTopLayerToPrismMesh)
{
- std::unique_ptr<MeshLib::Mesh> const mesh (MeshLib::MeshGenerator::generateRegularTriMesh(5, 5));
- std::unique_ptr<MeshLib::Mesh> const mesh2 (MeshLib::addLayerToMesh(*mesh, 5, "mesh", true));
- double const height (1);
- std::unique_ptr<MeshLib::Mesh> const result (MeshLib::addLayerToMesh(*mesh2, height, "mesh", true));
-
- ASSERT_EQ(mesh2->getNNodes()/2.0 * 3, result->getNNodes());
- ASSERT_EQ(mesh2->getNElements()/2.0 * 3, result->getNElements());
-
- std::array<unsigned, 7> const n_elems (MeshLib::MeshInformation::getNumberOfElementTypes(*result));
- ASSERT_EQ(50, n_elems[1]); // tests if 50 tris are present
- ASSERT_EQ(100, n_elems[6]); // tests if 50 prisms are present
-
- MathLib::Vector3 const dir(0, 0, -1);
- std::unique_ptr<MeshLib::Mesh> test_input (
- MeshLib::MeshSurfaceExtraction::getMeshSurface(*mesh2, dir, 90));
- std::unique_ptr<MeshLib::Mesh> test_output (
- MeshLib::MeshSurfaceExtraction::getMeshSurface(*result, dir, 90));
- AddLayerValidation::testZCoords3D(*test_input, *test_output, height);
- AddLayerValidation::validate(*result, true);
+ std::unique_ptr<MeshLib::Mesh> const mesh (MeshLib::MeshGenerator::generateRegularTriMesh(5, 5));
+ std::unique_ptr<MeshLib::Mesh> const mesh2 (MeshLib::addLayerToMesh(*mesh, 5, "mesh", true));
+ double const height (1);
+ std::unique_ptr<MeshLib::Mesh> const result (MeshLib::addLayerToMesh(*mesh2, height, "mesh", true));
+
+ ASSERT_EQ(mesh2->getNNodes()/2.0 * 3, result->getNNodes());
+ ASSERT_EQ(mesh2->getNElements()/2.0 * 3, result->getNElements());
+
+ std::array<unsigned, 7> const n_elems (MeshLib::MeshInformation::getNumberOfElementTypes(*result));
+ ASSERT_EQ(50, n_elems[1]); // tests if 50 tris are present
+ ASSERT_EQ(100, n_elems[6]); // tests if 50 prisms are present
+
+ MathLib::Vector3 const dir(0, 0, -1);
+ std::unique_ptr<MeshLib::Mesh> test_input (
+ MeshLib::MeshSurfaceExtraction::getMeshSurface(*mesh2, dir, 90));
+ std::unique_ptr<MeshLib::Mesh> test_output (
+ MeshLib::MeshSurfaceExtraction::getMeshSurface(*result, dir, 90));
+ AddLayerValidation::testZCoords3D(*test_input, *test_output, height);
+ AddLayerValidation::validate(*result, true);
}
TEST(MeshLib, AddBottomLayerToPrismMesh)
{
- std::unique_ptr<MeshLib::Mesh> const mesh (MeshLib::MeshGenerator::generateRegularTriMesh(5, 5));
- std::unique_ptr<MeshLib::Mesh> const mesh2 (MeshLib::addLayerToMesh(*mesh, 5, "mesh", true));
- double const height (1);
- std::string const& mat_name ("MaterialIDs");
- boost::optional<MeshLib::PropertyVector<int>&> mats =
- mesh2->getProperties().createNewPropertyVector<int>(mat_name, MeshLib::MeshItemType::Cell);
- if (mats)
- {
- mats->resize(mesh2->getNElements());
- std::fill_n(mats->begin(), mesh2->getNElements(), 0);
- }
-
- std::unique_ptr<MeshLib::Mesh> const result (MeshLib::addLayerToMesh(*mesh2, height, "mesh", false));
- ASSERT_EQ(mesh2->getNNodes()/2.0 * 3, result->getNNodes());
- ASSERT_EQ(mesh2->getNElements()/2.0 * 3, result->getNElements());
-
- std::array<unsigned, 7> const n_elems (MeshLib::MeshInformation::getNumberOfElementTypes(*result));
- ASSERT_EQ(mesh->getNElements(), n_elems[1]); // tests if 50 tris are present
- ASSERT_EQ(2 * mesh->getNElements(), n_elems[6]); // tests if 50 prisms are present
- ASSERT_EQ(1, result->getProperties().getPropertyVectorNames().size());
- boost::optional<MeshLib::PropertyVector<int>&> new_mats =
- result->getProperties().getPropertyVector<int>(mat_name);
- ASSERT_EQ(result->getNElements(), new_mats->size());
- ASSERT_EQ(mesh2->getNElements(), std::count(new_mats->cbegin(), new_mats->cend(), 0));
- ASSERT_EQ(mesh->getNElements(), std::count(new_mats->cbegin(), new_mats->cend(), 1));
-
- MathLib::Vector3 const dir(0, 0, 1);
- std::unique_ptr<MeshLib::Mesh> test_input (
- MeshLib::MeshSurfaceExtraction::getMeshSurface(*mesh2, dir, 90));
- std::unique_ptr<MeshLib::Mesh> test_output (
- MeshLib::MeshSurfaceExtraction::getMeshSurface(*result, dir, 90));
- AddLayerValidation::testZCoords3D(*test_input, *test_output, -1 * height);
- AddLayerValidation::validate(*result, true);
+ std::unique_ptr<MeshLib::Mesh> const mesh (MeshLib::MeshGenerator::generateRegularTriMesh(5, 5));
+ std::unique_ptr<MeshLib::Mesh> const mesh2 (MeshLib::addLayerToMesh(*mesh, 5, "mesh", true));
+ double const height (1);
+ std::string const& mat_name ("MaterialIDs");
+ boost::optional<MeshLib::PropertyVector<int>&> mats =
+ mesh2->getProperties().createNewPropertyVector<int>(mat_name, MeshLib::MeshItemType::Cell);
+ if (mats)
+ {
+ mats->resize(mesh2->getNElements());
+ std::fill_n(mats->begin(), mesh2->getNElements(), 0);
+ }
+
+ std::unique_ptr<MeshLib::Mesh> const result (MeshLib::addLayerToMesh(*mesh2, height, "mesh", false));
+ ASSERT_EQ(mesh2->getNNodes()/2.0 * 3, result->getNNodes());
+ ASSERT_EQ(mesh2->getNElements()/2.0 * 3, result->getNElements());
+
+ std::array<unsigned, 7> const n_elems (MeshLib::MeshInformation::getNumberOfElementTypes(*result));
+ ASSERT_EQ(mesh->getNElements(), n_elems[1]); // tests if 50 tris are present
+ ASSERT_EQ(2 * mesh->getNElements(), n_elems[6]); // tests if 50 prisms are present
+ ASSERT_EQ(1, result->getProperties().getPropertyVectorNames().size());
+ boost::optional<MeshLib::PropertyVector<int>&> new_mats =
+ result->getProperties().getPropertyVector<int>(mat_name);
+ ASSERT_EQ(result->getNElements(), new_mats->size());
+ ASSERT_EQ(mesh2->getNElements(), std::count(new_mats->cbegin(), new_mats->cend(), 0));
+ ASSERT_EQ(mesh->getNElements(), std::count(new_mats->cbegin(), new_mats->cend(), 1));
+
+ MathLib::Vector3 const dir(0, 0, 1);
+ std::unique_ptr<MeshLib::Mesh> test_input (
+ MeshLib::MeshSurfaceExtraction::getMeshSurface(*mesh2, dir, 90));
+ std::unique_ptr<MeshLib::Mesh> test_output (
+ MeshLib::MeshSurfaceExtraction::getMeshSurface(*result, dir, 90));
+ AddLayerValidation::testZCoords3D(*test_input, *test_output, -1 * height);
+ AddLayerValidation::validate(*result, true);
}
diff --git a/Tests/MeshLib/TestBoundaryElementSearch.cpp b/Tests/MeshLib/TestBoundaryElementSearch.cpp
index e42fe9ff0e6f7b2117209994132cae219eb08df5..c2d852ec8d44da482d2a7998ab09dc7fce3a3014 100644
--- a/Tests/MeshLib/TestBoundaryElementSearch.cpp
+++ b/Tests/MeshLib/TestBoundaryElementSearch.cpp
@@ -28,149 +28,149 @@ using namespace MeshLib;
class MeshLibBoundaryElementSearchInSimpleQuadMesh : public testing::Test
{
public:
- MeshLibBoundaryElementSearchInSimpleQuadMesh() :
- _geometric_size(10.0), _number_of_subdivisions_per_direction(10),
- _quad_mesh(MeshGenerator::generateRegularQuadMesh(_geometric_size, _number_of_subdivisions_per_direction))
- {}
+ MeshLibBoundaryElementSearchInSimpleQuadMesh() :
+ _geometric_size(10.0), _number_of_subdivisions_per_direction(10),
+ _quad_mesh(MeshGenerator::generateRegularQuadMesh(_geometric_size, _number_of_subdivisions_per_direction))
+ {}
protected:
- const double _geometric_size;
- const std::size_t _number_of_subdivisions_per_direction;
- std::unique_ptr<Mesh> _quad_mesh;
+ const double _geometric_size;
+ const std::size_t _number_of_subdivisions_per_direction;
+ std::unique_ptr<Mesh> _quad_mesh;
};
class MeshLibBoundaryElementSearchInSimpleHexMesh : public testing::Test
{
public:
- MeshLibBoundaryElementSearchInSimpleHexMesh() :
- _geometric_size(10.0), _number_of_subdivisions_per_direction(10),
- _hex_mesh(MeshGenerator::generateRegularHexMesh(_geometric_size, _number_of_subdivisions_per_direction))
- {}
+ MeshLibBoundaryElementSearchInSimpleHexMesh() :
+ _geometric_size(10.0), _number_of_subdivisions_per_direction(10),
+ _hex_mesh(MeshGenerator::generateRegularHexMesh(_geometric_size, _number_of_subdivisions_per_direction))
+ {}
- ~MeshLibBoundaryElementSearchInSimpleHexMesh()
- {
- delete _hex_mesh;
- }
+ ~MeshLibBoundaryElementSearchInSimpleHexMesh()
+ {
+ delete _hex_mesh;
+ }
protected:
- const double _geometric_size;
- const std::size_t _number_of_subdivisions_per_direction;
- Mesh* _hex_mesh;
+ const double _geometric_size;
+ const std::size_t _number_of_subdivisions_per_direction;
+ Mesh* _hex_mesh;
};
TEST_F(MeshLibBoundaryElementSearchInSimpleQuadMesh, PolylineSearch)
{
- ASSERT_TRUE(_quad_mesh != nullptr);
- const unsigned n_eles_per_dir = _number_of_subdivisions_per_direction;
- const unsigned n_nodes_per_dir = _number_of_subdivisions_per_direction + 1;
-
- // create a polyline (closed)
- 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));
- GeoLib::Polyline ply0(pnts);
- ply0.addPoint(0);
- ply0.addPoint(1);
- ply0.addPoint(2);
- ply0.addPoint(3);
- ply0.addPoint(0);
-
- // perform search on the polyline
- MeshGeoToolsLib::MeshNodeSearcher mesh_node_searcher(*_quad_mesh,
- MeshGeoToolsLib::HeuristicSearchLength(*_quad_mesh));
- MeshGeoToolsLib::BoundaryElementsSearcher boundary_element_searcher(*_quad_mesh, mesh_node_searcher);
- std::vector<MeshLib::Element*> const& found_edges_ply0(boundary_element_searcher.getBoundaryElements(ply0));
-
- // check the total number of found edges
- ASSERT_EQ(n_eles_per_dir*4u, found_edges_ply0.size());
- // check node IDs of edges
- for (unsigned i=0; i<n_eles_per_dir; i++) {
- // edge found on a bottom line
- auto* edge0 = found_edges_ply0[i];
- ASSERT_EQ(2u, edge0->getNBaseNodes());
- ASSERT_EQ(i, edge0->getNodeIndex(0));
- ASSERT_EQ(i+1, edge0->getNodeIndex(1));
- // edge found on a right line
- auto* edge1 = found_edges_ply0[i+n_eles_per_dir];
- ASSERT_EQ(2u, edge1->getNBaseNodes());
- ASSERT_EQ(n_nodes_per_dir*i+n_nodes_per_dir-1, edge1->getNodeIndex(0));
- ASSERT_EQ(n_nodes_per_dir*(i+1)+n_nodes_per_dir-1, edge1->getNodeIndex(1));
- // edge found on a top line
- auto* edge2 = found_edges_ply0[i+n_eles_per_dir*2];
- ASSERT_EQ(2u, edge2->getNBaseNodes());
- ASSERT_EQ(n_nodes_per_dir*n_nodes_per_dir-1-i, edge2->getNodeIndex(0));
- ASSERT_EQ(n_nodes_per_dir*n_nodes_per_dir-1-(i+1), edge2->getNodeIndex(1));
- // edge found on a left line
- auto* edge3 = found_edges_ply0[i+n_eles_per_dir*3];
- ASSERT_EQ(2u, edge3->getNBaseNodes());
- ASSERT_EQ(n_nodes_per_dir*(n_nodes_per_dir-1)-n_nodes_per_dir*i, edge3->getNodeIndex(0));
- ASSERT_EQ(n_nodes_per_dir*(n_nodes_per_dir-1)-n_nodes_per_dir*(i+1), edge3->getNodeIndex(1));
- }
-
- for (auto p : pnts)
- delete p;
+ ASSERT_TRUE(_quad_mesh != nullptr);
+ const unsigned n_eles_per_dir = _number_of_subdivisions_per_direction;
+ const unsigned n_nodes_per_dir = _number_of_subdivisions_per_direction + 1;
+
+ // create a polyline (closed)
+ 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));
+ GeoLib::Polyline ply0(pnts);
+ ply0.addPoint(0);
+ ply0.addPoint(1);
+ ply0.addPoint(2);
+ ply0.addPoint(3);
+ ply0.addPoint(0);
+
+ // perform search on the polyline
+ MeshGeoToolsLib::MeshNodeSearcher mesh_node_searcher(*_quad_mesh,
+ MeshGeoToolsLib::HeuristicSearchLength(*_quad_mesh));
+ MeshGeoToolsLib::BoundaryElementsSearcher boundary_element_searcher(*_quad_mesh, mesh_node_searcher);
+ std::vector<MeshLib::Element*> const& found_edges_ply0(boundary_element_searcher.getBoundaryElements(ply0));
+
+ // check the total number of found edges
+ ASSERT_EQ(n_eles_per_dir*4u, found_edges_ply0.size());
+ // check node IDs of edges
+ for (unsigned i=0; i<n_eles_per_dir; i++) {
+ // edge found on a bottom line
+ auto* edge0 = found_edges_ply0[i];
+ ASSERT_EQ(2u, edge0->getNBaseNodes());
+ ASSERT_EQ(i, edge0->getNodeIndex(0));
+ ASSERT_EQ(i+1, edge0->getNodeIndex(1));
+ // edge found on a right line
+ auto* edge1 = found_edges_ply0[i+n_eles_per_dir];
+ ASSERT_EQ(2u, edge1->getNBaseNodes());
+ ASSERT_EQ(n_nodes_per_dir*i+n_nodes_per_dir-1, edge1->getNodeIndex(0));
+ ASSERT_EQ(n_nodes_per_dir*(i+1)+n_nodes_per_dir-1, edge1->getNodeIndex(1));
+ // edge found on a top line
+ auto* edge2 = found_edges_ply0[i+n_eles_per_dir*2];
+ ASSERT_EQ(2u, edge2->getNBaseNodes());
+ ASSERT_EQ(n_nodes_per_dir*n_nodes_per_dir-1-i, edge2->getNodeIndex(0));
+ ASSERT_EQ(n_nodes_per_dir*n_nodes_per_dir-1-(i+1), edge2->getNodeIndex(1));
+ // edge found on a left line
+ auto* edge3 = found_edges_ply0[i+n_eles_per_dir*3];
+ ASSERT_EQ(2u, edge3->getNBaseNodes());
+ ASSERT_EQ(n_nodes_per_dir*(n_nodes_per_dir-1)-n_nodes_per_dir*i, edge3->getNodeIndex(0));
+ ASSERT_EQ(n_nodes_per_dir*(n_nodes_per_dir-1)-n_nodes_per_dir*(i+1), edge3->getNodeIndex(1));
+ }
+
+ for (auto p : pnts)
+ delete p;
}
TEST_F(MeshLibBoundaryElementSearchInSimpleHexMesh, SurfaceSearch)
{
- ASSERT_TRUE(_hex_mesh != nullptr);
- 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_eles_2d = (n_nodes_1d-1) * (n_nodes_1d-1);
-
- // create bottom and front surfaces of a cubic
- 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.0, _geometric_size));
- pnts.push_back(new GeoLib::Point(0.0, 0.0, _geometric_size));
-
- 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));
-
- GeoLib::Polyline ply_front(pnts);
- ply_front.addPoint(0);
- ply_front.addPoint(1);
- ply_front.addPoint(4);
- ply_front.addPoint(5);
- ply_front.addPoint(0);
- std::unique_ptr<GeoLib::Surface> sfc_front(GeoLib::Surface::createSurface(ply_front));
-
- // perform search on the bottom surface
- MeshGeoToolsLib::MeshNodeSearcher mesh_node_searcher(*_hex_mesh,
- MeshGeoToolsLib::HeuristicSearchLength(*_hex_mesh));
- MeshGeoToolsLib::BoundaryElementsSearcher boundary_element_searcher(*_hex_mesh, mesh_node_searcher);
- std::vector<MeshLib::Element*> const& found_faces_sfc_b(boundary_element_searcher.getBoundaryElements(*sfc_bottom));
- ASSERT_EQ(n_eles_2d, found_faces_sfc_b.size());
- double sum_area_b = std::accumulate(found_faces_sfc_b.begin(), found_faces_sfc_b.end(), 0.0,
- [](double v, MeshLib::Element*e){return v+e->getContent();});
- ASSERT_EQ(_geometric_size*_geometric_size, sum_area_b);
- auto connected_nodes_b = MeshLib::getUniqueNodes(found_faces_sfc_b);
- ASSERT_EQ(n_nodes_2d, connected_nodes_b.size());
- for (auto node : connected_nodes_b)
- ASSERT_EQ(0.0, (*node)[2]); // check z coordinates
-
- // perform search on the front surface
- std::vector<MeshLib::Element*> const& found_faces_sfc_f(boundary_element_searcher.getBoundaryElements(*sfc_front));
- ASSERT_EQ(n_eles_2d, found_faces_sfc_f.size());
- double sum_area_f = std::accumulate(found_faces_sfc_f.begin(), found_faces_sfc_f.end(), 0.0,
- [](double v, MeshLib::Element*e){return v+e->getContent();});
- ASSERT_EQ(_geometric_size*_geometric_size, sum_area_f);
+ ASSERT_TRUE(_hex_mesh != nullptr);
+ 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_eles_2d = (n_nodes_1d-1) * (n_nodes_1d-1);
+
+ // create bottom and front surfaces of a cubic
+ 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.0, _geometric_size));
+ pnts.push_back(new GeoLib::Point(0.0, 0.0, _geometric_size));
+
+ 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));
+
+ GeoLib::Polyline ply_front(pnts);
+ ply_front.addPoint(0);
+ ply_front.addPoint(1);
+ ply_front.addPoint(4);
+ ply_front.addPoint(5);
+ ply_front.addPoint(0);
+ std::unique_ptr<GeoLib::Surface> sfc_front(GeoLib::Surface::createSurface(ply_front));
+
+ // perform search on the bottom surface
+ MeshGeoToolsLib::MeshNodeSearcher mesh_node_searcher(*_hex_mesh,
+ MeshGeoToolsLib::HeuristicSearchLength(*_hex_mesh));
+ MeshGeoToolsLib::BoundaryElementsSearcher boundary_element_searcher(*_hex_mesh, mesh_node_searcher);
+ std::vector<MeshLib::Element*> const& found_faces_sfc_b(boundary_element_searcher.getBoundaryElements(*sfc_bottom));
+ ASSERT_EQ(n_eles_2d, found_faces_sfc_b.size());
+ double sum_area_b = std::accumulate(found_faces_sfc_b.begin(), found_faces_sfc_b.end(), 0.0,
+ [](double v, MeshLib::Element*e){return v+e->getContent();});
+ ASSERT_EQ(_geometric_size*_geometric_size, sum_area_b);
+ auto connected_nodes_b = MeshLib::getUniqueNodes(found_faces_sfc_b);
+ ASSERT_EQ(n_nodes_2d, connected_nodes_b.size());
+ for (auto node : connected_nodes_b)
+ ASSERT_EQ(0.0, (*node)[2]); // check z coordinates
+
+ // perform search on the front surface
+ std::vector<MeshLib::Element*> const& found_faces_sfc_f(boundary_element_searcher.getBoundaryElements(*sfc_front));
+ ASSERT_EQ(n_eles_2d, found_faces_sfc_f.size());
+ double sum_area_f = std::accumulate(found_faces_sfc_f.begin(), found_faces_sfc_f.end(), 0.0,
+ [](double v, MeshLib::Element*e){return v+e->getContent();});
+ ASSERT_EQ(_geometric_size*_geometric_size, sum_area_f);
auto connected_nodes_f = MeshLib::getUniqueNodes(found_faces_sfc_f);
- ASSERT_EQ(n_nodes_2d, connected_nodes_f.size());
- for (auto node : connected_nodes_f)
- ASSERT_EQ(0.0, (*node)[1]); // check y coordinates
+ ASSERT_EQ(n_nodes_2d, connected_nodes_f.size());
+ for (auto node : connected_nodes_f)
+ ASSERT_EQ(0.0, (*node)[1]); // check y coordinates
- for (auto p : pnts)
- delete p;
+ for (auto p : pnts)
+ delete p;
}
diff --git a/Tests/MeshLib/TestDuplicate.cpp b/Tests/MeshLib/TestDuplicate.cpp
index f837fb5bd52b8ad574c7df17fd1b8d1d9c4d9bda..348f5961319a0b84d6791a681f8ec56af5c76286 100644
--- a/Tests/MeshLib/TestDuplicate.cpp
+++ b/Tests/MeshLib/TestDuplicate.cpp
@@ -26,26 +26,26 @@
TEST(MeshLib, Duplicate)
{
- auto mesh = std::unique_ptr<MeshLib::Mesh>{
- MeshLib::MeshGenerator::generateRegularQuadMesh(10, 5, 1)};
+ auto mesh = std::unique_ptr<MeshLib::Mesh>{
+ MeshLib::MeshGenerator::generateRegularQuadMesh(10, 5, 1)};
- std::vector<MeshLib::Node*> new_nodes (MeshLib::copyNodeVector(mesh->getNodes()));
- std::vector<MeshLib::Element*> new_elements (MeshLib::copyElementVector(mesh->getElements(), new_nodes));
+ std::vector<MeshLib::Node*> new_nodes (MeshLib::copyNodeVector(mesh->getNodes()));
+ std::vector<MeshLib::Element*> new_elements (MeshLib::copyElementVector(mesh->getElements(), new_nodes));
- MeshLib::Mesh new_mesh ("new", new_nodes, new_elements);
+ MeshLib::Mesh new_mesh ("new", new_nodes, new_elements);
- ASSERT_EQ (mesh->getNElements(), new_mesh.getNElements());
- ASSERT_EQ (mesh->getNNodes(), new_mesh.getNNodes());
+ ASSERT_EQ (mesh->getNElements(), new_mesh.getNElements());
+ ASSERT_EQ (mesh->getNNodes(), new_mesh.getNNodes());
- std::vector<std::size_t> del_idx(1,1);
- std::unique_ptr<MeshLib::Mesh> mesh2(MeshLib::removeNodes(*mesh, del_idx, "mesh2"));
+ std::vector<std::size_t> del_idx(1,1);
+ std::unique_ptr<MeshLib::Mesh> mesh2(MeshLib::removeNodes(*mesh, del_idx, "mesh2"));
- ASSERT_EQ (mesh2->getNElements(), new_mesh.getNElements()-2);
- ASSERT_EQ (mesh2->getNNodes(), new_mesh.getNNodes()-2);
+ ASSERT_EQ (mesh2->getNElements(), new_mesh.getNElements()-2);
+ ASSERT_EQ (mesh2->getNNodes(), new_mesh.getNNodes()-2);
- ASSERT_DOUBLE_EQ (4.0, MathLib::sqrDist(*mesh2->getNode(0), *new_mesh.getNode(0)));
- ASSERT_DOUBLE_EQ (0.0, MathLib::sqrDist(*mesh2->getNode(0), *new_mesh.getNode(2)));
+ ASSERT_DOUBLE_EQ (4.0, MathLib::sqrDist(*mesh2->getNode(0), *new_mesh.getNode(0)));
+ ASSERT_DOUBLE_EQ (0.0, MathLib::sqrDist(*mesh2->getNode(0), *new_mesh.getNode(2)));
- ASSERT_DOUBLE_EQ (4.0, MathLib::sqrDist(*mesh2->getElement(0)->getNode(0), *new_mesh.getElement(0)->getNode(0)));
- ASSERT_DOUBLE_EQ (0.0, MathLib::sqrDist(*mesh2->getElement(0)->getNode(0), *new_mesh.getElement(2)->getNode(0)));
+ ASSERT_DOUBLE_EQ (4.0, MathLib::sqrDist(*mesh2->getElement(0)->getNode(0), *new_mesh.getElement(0)->getNode(0)));
+ ASSERT_DOUBLE_EQ (0.0, MathLib::sqrDist(*mesh2->getElement(0)->getNode(0), *new_mesh.getElement(2)->getNode(0)));
}
diff --git a/Tests/MeshLib/TestElementConstants.cpp b/Tests/MeshLib/TestElementConstants.cpp
index e5eb124c90c3bc1b44f086cce3f2b13d5744f847..c18c1696a2110c093371705fb83ddb6a43ff669d 100644
--- a/Tests/MeshLib/TestElementConstants.cpp
+++ b/Tests/MeshLib/TestElementConstants.cpp
@@ -16,188 +16,188 @@ using namespace MeshLib;
TEST(MeshLib, ElementConstantsQuad4)
{
- ASSERT_EQ(2u, Quad::dimension);
- ASSERT_EQ(4u, Quad::n_all_nodes);
- ASSERT_EQ(4u, Quad::n_base_nodes);
-
- std::array<Node*, 4> nodes;
- nodes[0] = new Node(0.0, 0.0, 0.0);
- nodes[1] = new Node(0.0, 1.0, 0.0);
- nodes[2] = new Node(1.0, 1.0, 0.0);
- nodes[3] = new Node(1.0, 0.0, 0.0);
- Quad quad(nodes);
-
- ASSERT_EQ(2u, quad.getDimension());
- ASSERT_EQ(4u, quad.getNNodes());
- ASSERT_EQ(4u, quad.getNBaseNodes());
-
- for (auto n : nodes)
- delete n;
+ ASSERT_EQ(2u, Quad::dimension);
+ ASSERT_EQ(4u, Quad::n_all_nodes);
+ ASSERT_EQ(4u, Quad::n_base_nodes);
+
+ std::array<Node*, 4> nodes;
+ nodes[0] = new Node(0.0, 0.0, 0.0);
+ nodes[1] = new Node(0.0, 1.0, 0.0);
+ nodes[2] = new Node(1.0, 1.0, 0.0);
+ nodes[3] = new Node(1.0, 0.0, 0.0);
+ Quad quad(nodes);
+
+ ASSERT_EQ(2u, quad.getDimension());
+ ASSERT_EQ(4u, quad.getNNodes());
+ ASSERT_EQ(4u, quad.getNBaseNodes());
+
+ for (auto n : nodes)
+ delete n;
}
TEST(MeshLib, ElementConstantsQuad8)
{
- ASSERT_EQ(2u, Quad8::dimension);
- ASSERT_EQ(8u, Quad8::n_all_nodes);
- ASSERT_EQ(4u, Quad8::n_base_nodes);
+ ASSERT_EQ(2u, Quad8::dimension);
+ ASSERT_EQ(8u, Quad8::n_all_nodes);
+ ASSERT_EQ(4u, Quad8::n_base_nodes);
- std::array<Node*, 8> nodes;
- nodes[0] = new Node(0.0, 0.0, 0.0);
- nodes[1] = new Node(0.0, 1.0, 0.0);
- nodes[2] = new Node(1.0, 1.0, 0.0);
- nodes[3] = new Node(1.0, 0.0, 0.0);
+ std::array<Node*, 8> nodes;
+ nodes[0] = new Node(0.0, 0.0, 0.0);
+ nodes[1] = new Node(0.0, 1.0, 0.0);
+ nodes[2] = new Node(1.0, 1.0, 0.0);
+ nodes[3] = new Node(1.0, 0.0, 0.0);
- nodes[4] = new Node(0.5, 0.0, 0.0);
- nodes[5] = new Node(1.0, 0.5, 0.0);
- nodes[6] = new Node(0.5, 1.0, 0.0);
- nodes[7] = new Node(0.5, 0.0, 0.0);
+ nodes[4] = new Node(0.5, 0.0, 0.0);
+ nodes[5] = new Node(1.0, 0.5, 0.0);
+ nodes[6] = new Node(0.5, 1.0, 0.0);
+ nodes[7] = new Node(0.5, 0.0, 0.0);
- Quad8 quad8(nodes);
+ Quad8 quad8(nodes);
- ASSERT_EQ(2u, quad8.getDimension());
- ASSERT_EQ(8u, quad8.getNNodes());
- ASSERT_EQ(4u, quad8.getNBaseNodes());
+ ASSERT_EQ(2u, quad8.getDimension());
+ ASSERT_EQ(8u, quad8.getNNodes());
+ ASSERT_EQ(4u, quad8.getNBaseNodes());
- for (auto n : nodes)
- delete n;
+ for (auto n : nodes)
+ delete n;
}
TEST(MeshLib, ElementConstantsQuad9)
{
- ASSERT_EQ(2u, Quad9::dimension);
- ASSERT_EQ(9u, Quad9::n_all_nodes);
- ASSERT_EQ(4u, Quad9::n_base_nodes);
-
- std::array<Node*, 9> nodes;
- nodes[0] = new Node(0.0, 0.0, 0.0);
- nodes[1] = new Node(0.0, 1.0, 0.0);
- nodes[2] = new Node(1.0, 1.0, 0.0);
- nodes[3] = new Node(1.0, 0.0, 0.0);
-
- nodes[4] = new Node(0.5, 0.0, 0.0);
- nodes[5] = new Node(1.0, 0.5, 0.0);
- nodes[6] = new Node(0.5, 1.0, 0.0);
- nodes[7] = new Node(0.5, 0.0, 0.0);
-
- nodes[8] = new Node(0.5, 0.5, 0.0);
- Quad9 quad9(nodes);
-
- ASSERT_EQ(2u, quad9.getDimension());
- ASSERT_EQ(9u, quad9.getNNodes());
- ASSERT_EQ(4u, quad9.getNBaseNodes());
-
- for (auto n : nodes)
- delete n;
+ ASSERT_EQ(2u, Quad9::dimension);
+ ASSERT_EQ(9u, Quad9::n_all_nodes);
+ ASSERT_EQ(4u, Quad9::n_base_nodes);
+
+ std::array<Node*, 9> nodes;
+ nodes[0] = new Node(0.0, 0.0, 0.0);
+ nodes[1] = new Node(0.0, 1.0, 0.0);
+ nodes[2] = new Node(1.0, 1.0, 0.0);
+ nodes[3] = new Node(1.0, 0.0, 0.0);
+
+ nodes[4] = new Node(0.5, 0.0, 0.0);
+ nodes[5] = new Node(1.0, 0.5, 0.0);
+ nodes[6] = new Node(0.5, 1.0, 0.0);
+ nodes[7] = new Node(0.5, 0.0, 0.0);
+
+ nodes[8] = new Node(0.5, 0.5, 0.0);
+ Quad9 quad9(nodes);
+
+ ASSERT_EQ(2u, quad9.getDimension());
+ ASSERT_EQ(9u, quad9.getNNodes());
+ ASSERT_EQ(4u, quad9.getNBaseNodes());
+
+ for (auto n : nodes)
+ delete n;
}
TEST(MeshLib, ElementConstantsHex8)
{
- ASSERT_EQ(3u, Hex::dimension);
- ASSERT_EQ(8u, Hex::n_all_nodes);
- ASSERT_EQ(8u, Hex::n_base_nodes);
-
- std::array<Node*, 8> nodes;
- nodes[0] = new Node(0.0, 0.0, 0.0);
- nodes[1] = new Node(0.0, 1.0, 0.0);
- nodes[2] = new Node(1.0, 1.0, 0.0);
- nodes[3] = new Node(1.0, 0.0, 0.0);
- nodes[4] = new Node(0.0, 0.0, 1.0);
- nodes[5] = new Node(0.0, 1.0, 1.0);
- nodes[6] = new Node(1.0, 1.0, 1.0);
- nodes[7] = new Node(1.0, 0.0, 1.0);
- Hex ele(nodes);
-
- ASSERT_EQ(3u, ele.getDimension());
- ASSERT_EQ(8u, ele.getNNodes());
- ASSERT_EQ(8u, ele.getNBaseNodes());
-
- for (auto n : nodes)
- delete n;
+ ASSERT_EQ(3u, Hex::dimension);
+ ASSERT_EQ(8u, Hex::n_all_nodes);
+ ASSERT_EQ(8u, Hex::n_base_nodes);
+
+ std::array<Node*, 8> nodes;
+ nodes[0] = new Node(0.0, 0.0, 0.0);
+ nodes[1] = new Node(0.0, 1.0, 0.0);
+ nodes[2] = new Node(1.0, 1.0, 0.0);
+ nodes[3] = new Node(1.0, 0.0, 0.0);
+ nodes[4] = new Node(0.0, 0.0, 1.0);
+ nodes[5] = new Node(0.0, 1.0, 1.0);
+ nodes[6] = new Node(1.0, 1.0, 1.0);
+ nodes[7] = new Node(1.0, 0.0, 1.0);
+ Hex ele(nodes);
+
+ ASSERT_EQ(3u, ele.getDimension());
+ ASSERT_EQ(8u, ele.getNNodes());
+ ASSERT_EQ(8u, ele.getNBaseNodes());
+
+ for (auto n : nodes)
+ delete n;
}
TEST(MeshLib, ElementConstantsHex20)
{
- ASSERT_EQ( 3u, Hex20::dimension);
- ASSERT_EQ(20u, Hex20::n_all_nodes);
- ASSERT_EQ( 8u, Hex20::n_base_nodes);
-
- std::array<Node*, 20> nodes;
- nodes[0] = new Node(0.0, 0.0, 0.0);
- nodes[1] = new Node(1.0, 0.0, 0.0);
- nodes[2] = new Node(1.0, 1.0, 0.0);
- nodes[3] = new Node(0.0, 1.0, 0.0);
- nodes[4] = new Node(0.0, 0.0, 1.0);
- nodes[5] = new Node(1.0, 0.0, 1.0);
- nodes[6] = new Node(1.0, 1.0, 1.0);
- nodes[7] = new Node(0.0, 1.0, 1.0);
- nodes[8] = new Node(0.5, 0.0, 0.0);
- nodes[9] = new Node(1.0, 0.5, 0.0);
- nodes[10] = new Node(0.5, 1.0, 0.0);
- nodes[11] = new Node(0.0, 0.5, 0.0);
- nodes[12] = new Node(0.5, 0.0, 1.0);
- nodes[13] = new Node(1.0, 0.5, 1.0);
- nodes[14] = new Node(0.5, 1.0, 1.0);
- nodes[15] = new Node(0.0, 0.5, 1.0);
- nodes[16] = new Node(0.0, 0.0, 0.5);
- nodes[17] = new Node(1.0, 0.0, 0.5);
- nodes[18] = new Node(1.0, 1.0, 0.5);
- nodes[19] = new Node(0.0, 1.0, 0.5);
- Hex20 ele(nodes);
-
- ASSERT_EQ( 3u, ele.getDimension());
- ASSERT_EQ(20u, ele.getNNodes());
- ASSERT_EQ( 8u, ele.getNBaseNodes());
-
- for (auto n : nodes)
- delete n;
+ ASSERT_EQ( 3u, Hex20::dimension);
+ ASSERT_EQ(20u, Hex20::n_all_nodes);
+ ASSERT_EQ( 8u, Hex20::n_base_nodes);
+
+ std::array<Node*, 20> nodes;
+ nodes[0] = new Node(0.0, 0.0, 0.0);
+ nodes[1] = new Node(1.0, 0.0, 0.0);
+ nodes[2] = new Node(1.0, 1.0, 0.0);
+ nodes[3] = new Node(0.0, 1.0, 0.0);
+ nodes[4] = new Node(0.0, 0.0, 1.0);
+ nodes[5] = new Node(1.0, 0.0, 1.0);
+ nodes[6] = new Node(1.0, 1.0, 1.0);
+ nodes[7] = new Node(0.0, 1.0, 1.0);
+ nodes[8] = new Node(0.5, 0.0, 0.0);
+ nodes[9] = new Node(1.0, 0.5, 0.0);
+ nodes[10] = new Node(0.5, 1.0, 0.0);
+ nodes[11] = new Node(0.0, 0.5, 0.0);
+ nodes[12] = new Node(0.5, 0.0, 1.0);
+ nodes[13] = new Node(1.0, 0.5, 1.0);
+ nodes[14] = new Node(0.5, 1.0, 1.0);
+ nodes[15] = new Node(0.0, 0.5, 1.0);
+ nodes[16] = new Node(0.0, 0.0, 0.5);
+ nodes[17] = new Node(1.0, 0.0, 0.5);
+ nodes[18] = new Node(1.0, 1.0, 0.5);
+ nodes[19] = new Node(0.0, 1.0, 0.5);
+ Hex20 ele(nodes);
+
+ ASSERT_EQ( 3u, ele.getDimension());
+ ASSERT_EQ(20u, ele.getNNodes());
+ ASSERT_EQ( 8u, ele.getNBaseNodes());
+
+ for (auto n : nodes)
+ delete n;
}
TEST(MeshLib, ElementConstantsTet4)
{
- ASSERT_EQ(3u, Tet::dimension);
- ASSERT_EQ(4u, Tet::n_all_nodes);
- ASSERT_EQ(4u, Tet::n_base_nodes);
-
- std::array<Node*, 4> nodes;
- nodes[0] = new Node(0.0, 0.0, 0.0);
- nodes[1] = new Node(1.0, 0.0, 0.0);
- nodes[2] = new Node(0.0, 1.0, 0.0);
- nodes[3] = new Node(0.0, 0.0, 1.0);
- Tet ele(nodes);
-
- ASSERT_EQ(3u, ele.getDimension());
- ASSERT_EQ(4u, ele.getNNodes());
- ASSERT_EQ(4u, ele.getNBaseNodes());
-
- for (auto n : nodes)
- delete n;
+ ASSERT_EQ(3u, Tet::dimension);
+ ASSERT_EQ(4u, Tet::n_all_nodes);
+ ASSERT_EQ(4u, Tet::n_base_nodes);
+
+ std::array<Node*, 4> nodes;
+ nodes[0] = new Node(0.0, 0.0, 0.0);
+ nodes[1] = new Node(1.0, 0.0, 0.0);
+ nodes[2] = new Node(0.0, 1.0, 0.0);
+ nodes[3] = new Node(0.0, 0.0, 1.0);
+ Tet ele(nodes);
+
+ ASSERT_EQ(3u, ele.getDimension());
+ ASSERT_EQ(4u, ele.getNNodes());
+ ASSERT_EQ(4u, ele.getNBaseNodes());
+
+ for (auto n : nodes)
+ delete n;
}
TEST(MeshLib, ElementConstantsTet10)
{
- ASSERT_EQ( 3u, Tet10::dimension);
- ASSERT_EQ(10u, Tet10::n_all_nodes);
- ASSERT_EQ( 4u, Tet10::n_base_nodes);
-
- std::array<Node*, 10> nodes;
- nodes[0] = new Node(0.0, 0.0, 0.0);
- nodes[1] = new Node(1.0, 0.0, 0.0);
- nodes[2] = new Node(0.0, 1.0, 0.0);
- nodes[3] = new Node(0.0, 0.0, 1.0);
-
- nodes[4] = new Node(0.5, 0.0, 0.0);
- nodes[5] = new Node(0.5, 0.5, 0.0);
- nodes[6] = new Node(0.0, 0.5, 0.0);
- nodes[7] = new Node(0.0, 0.0, 0.5);
- nodes[8] = new Node(0.5, 0.0, 0.5);
- nodes[9] = new Node(0.0, 0.5, 0.5);
- Tet10 ele(nodes);
-
- ASSERT_EQ( 3u, ele.getDimension());
- ASSERT_EQ(10u, ele.getNNodes());
- ASSERT_EQ( 4u, ele.getNBaseNodes());
-
- for (auto n : nodes)
- delete n;
+ ASSERT_EQ( 3u, Tet10::dimension);
+ ASSERT_EQ(10u, Tet10::n_all_nodes);
+ ASSERT_EQ( 4u, Tet10::n_base_nodes);
+
+ std::array<Node*, 10> nodes;
+ nodes[0] = new Node(0.0, 0.0, 0.0);
+ nodes[1] = new Node(1.0, 0.0, 0.0);
+ nodes[2] = new Node(0.0, 1.0, 0.0);
+ nodes[3] = new Node(0.0, 0.0, 1.0);
+
+ nodes[4] = new Node(0.5, 0.0, 0.0);
+ nodes[5] = new Node(0.5, 0.5, 0.0);
+ nodes[6] = new Node(0.0, 0.5, 0.0);
+ nodes[7] = new Node(0.0, 0.0, 0.5);
+ nodes[8] = new Node(0.5, 0.0, 0.5);
+ nodes[9] = new Node(0.0, 0.5, 0.5);
+ Tet10 ele(nodes);
+
+ ASSERT_EQ( 3u, ele.getDimension());
+ ASSERT_EQ(10u, ele.getNNodes());
+ ASSERT_EQ( 4u, ele.getNBaseNodes());
+
+ for (auto n : nodes)
+ delete n;
}
diff --git a/Tests/MeshLib/TestElementStatus.cpp b/Tests/MeshLib/TestElementStatus.cpp
index 35fa365a80a8587c043cf0f10488436a4581eb1a..d5acec27f63342dc50cbeda41a25ef0b8dbec946 100644
--- a/Tests/MeshLib/TestElementStatus.cpp
+++ b/Tests/MeshLib/TestElementStatus.cpp
@@ -24,52 +24,52 @@
TEST(MeshLib, ElementStatus)
{
- const unsigned width (100);
- const unsigned elements_per_side (20);
- auto const mesh = std::unique_ptr<MeshLib::Mesh>{
- MeshLib::MeshGenerator::generateRegularQuadMesh(width, elements_per_side)};
+ const unsigned width (100);
+ const unsigned elements_per_side (20);
+ auto const mesh = std::unique_ptr<MeshLib::Mesh>{
+ MeshLib::MeshGenerator::generateRegularQuadMesh(width, elements_per_side)};
- boost::optional<MeshLib::PropertyVector<int> &> material_id_properties(
- mesh->getProperties().createNewPropertyVector<int>("MaterialIDs",
- MeshLib::MeshItemType::Cell)
- );
- ASSERT_TRUE(bool(material_id_properties));
- (*material_id_properties).resize(mesh->getNElements());
+ boost::optional<MeshLib::PropertyVector<int> &> material_id_properties(
+ mesh->getProperties().createNewPropertyVector<int>("MaterialIDs",
+ MeshLib::MeshItemType::Cell)
+ );
+ ASSERT_TRUE(bool(material_id_properties));
+ (*material_id_properties).resize(mesh->getNElements());
- const std::vector<MeshLib::Element*> elements (mesh->getElements());
+ const std::vector<MeshLib::Element*> elements (mesh->getElements());
- for (unsigned i=0; i<elements_per_side; ++i)
- {
- for (unsigned j=0; j<elements_per_side; ++j)
- (*material_id_properties)[elements[i*elements_per_side + j]->getID()] = i;
- }
+ for (unsigned i=0; i<elements_per_side; ++i)
+ {
+ for (unsigned j=0; j<elements_per_side; ++j)
+ (*material_id_properties)[elements[i*elements_per_side + j]->getID()] = i;
+ }
- {
- // all elements and nodes active
- MeshLib::ElementStatus status(mesh.get());
- ASSERT_EQ (elements.size(), status.getNActiveElements());
- ASSERT_EQ (mesh->getNNodes(), status.getNActiveNodes());
- }
+ {
+ // all elements and nodes active
+ MeshLib::ElementStatus status(mesh.get());
+ ASSERT_EQ (elements.size(), status.getNActiveElements());
+ ASSERT_EQ (mesh->getNNodes(), status.getNActiveNodes());
+ }
- {
- // set material 1 to false
- std::vector<int> inactiveMat{1};
- MeshLib::ElementStatus status(mesh.get(), inactiveMat);
- ASSERT_EQ (elements.size()-elements_per_side, status.getNActiveElements());
- }
+ {
+ // set material 1 to false
+ std::vector<int> inactiveMat{1};
+ MeshLib::ElementStatus status(mesh.get(), inactiveMat);
+ ASSERT_EQ (elements.size()-elements_per_side, status.getNActiveElements());
+ }
- {
- // set material 0 and 1 to false
- std::vector<int> inactiveMat{0, 1};
- MeshLib::ElementStatus status(mesh.get(), inactiveMat);
- ASSERT_EQ (elements.size()-(2*elements_per_side), status.getNActiveElements());
+ {
+ // set material 0 and 1 to false
+ std::vector<int> inactiveMat{0, 1};
+ MeshLib::ElementStatus status(mesh.get(), inactiveMat);
+ ASSERT_EQ (elements.size()-(2*elements_per_side), status.getNActiveElements());
- // active elements
- auto &active_elements (status.getActiveElements());
- ASSERT_EQ (active_elements.size(), status.getNActiveElements());
+ // active elements
+ auto &active_elements (status.getActiveElements());
+ ASSERT_EQ (active_elements.size(), status.getNActiveElements());
- // active nodes
- auto& active_nodes (status.getActiveNodes());
- ASSERT_EQ (active_nodes.size(), status.getNActiveNodes());
- }
+ // active nodes
+ auto& active_nodes (status.getActiveNodes());
+ ASSERT_EQ (active_nodes.size(), status.getNActiveNodes());
+ }
}
diff --git a/Tests/MeshLib/TestFlipElements.cpp b/Tests/MeshLib/TestFlipElements.cpp
index af3fda98ba076220b5acfa8ee954f1cb47cc7935..5da3f028fab43620290ab02ba83768d74634b635 100644
--- a/Tests/MeshLib/TestFlipElements.cpp
+++ b/Tests/MeshLib/TestFlipElements.cpp
@@ -19,86 +19,86 @@
TEST(MeshLib, FlipLineMesh)
{
- std::unique_ptr<MeshLib::Mesh> mesh (MeshLib::MeshGenerator::generateLineMesh(1.0, 5));
- std::unique_ptr<MeshLib::Mesh> result (MeshLib::createFlippedMesh(*mesh));
+ std::unique_ptr<MeshLib::Mesh> mesh (MeshLib::MeshGenerator::generateLineMesh(1.0, 5));
+ std::unique_ptr<MeshLib::Mesh> result (MeshLib::createFlippedMesh(*mesh));
- ASSERT_EQ(mesh->getNNodes(), result->getNNodes());
- ASSERT_EQ(mesh->getNElements(), result->getNElements());
- for (std::size_t i=0; i<result->getNElements(); ++i)
- {
- ASSERT_EQ(mesh->getElement(i)->getNode(0)->getID(),
- result->getElement(i)->getNode(1)->getID());
- ASSERT_EQ(mesh->getElement(i)->getNode(1)->getID(),
- result->getElement(i)->getNode(0)->getID());
- }
+ ASSERT_EQ(mesh->getNNodes(), result->getNNodes());
+ ASSERT_EQ(mesh->getNElements(), result->getNElements());
+ for (std::size_t i=0; i<result->getNElements(); ++i)
+ {
+ ASSERT_EQ(mesh->getElement(i)->getNode(0)->getID(),
+ result->getElement(i)->getNode(1)->getID());
+ ASSERT_EQ(mesh->getElement(i)->getNode(1)->getID(),
+ result->getElement(i)->getNode(0)->getID());
+ }
}
TEST(MeshLib, FlipTriMesh)
{
- std::unique_ptr<MeshLib::Mesh> mesh (MeshLib::MeshGenerator::generateRegularTriMesh(5, 5));
- std::unique_ptr<MeshLib::Mesh> result (MeshLib::createFlippedMesh(*mesh));
+ std::unique_ptr<MeshLib::Mesh> mesh (MeshLib::MeshGenerator::generateRegularTriMesh(5, 5));
+ std::unique_ptr<MeshLib::Mesh> result (MeshLib::createFlippedMesh(*mesh));
- ASSERT_EQ(mesh->getNNodes(), result->getNNodes());
- ASSERT_EQ(mesh->getNElements(), result->getNElements());
- for (std::size_t i=0; i<result->getNElements(); ++i)
- {
- ASSERT_EQ(mesh->getElement(i)->getNode(0)->getID(),
- result->getElement(i)->getNode(1)->getID());
- ASSERT_EQ(mesh->getElement(i)->getNode(1)->getID(),
- result->getElement(i)->getNode(0)->getID());
- ASSERT_EQ(mesh->getElement(i)->getNode(2)->getID(),
- result->getElement(i)->getNode(2)->getID());
- ASSERT_EQ(1.0, MeshLib::FaceRule::getSurfaceNormal(result->getElement(i))[2]);
- }
+ ASSERT_EQ(mesh->getNNodes(), result->getNNodes());
+ ASSERT_EQ(mesh->getNElements(), result->getNElements());
+ for (std::size_t i=0; i<result->getNElements(); ++i)
+ {
+ ASSERT_EQ(mesh->getElement(i)->getNode(0)->getID(),
+ result->getElement(i)->getNode(1)->getID());
+ ASSERT_EQ(mesh->getElement(i)->getNode(1)->getID(),
+ result->getElement(i)->getNode(0)->getID());
+ ASSERT_EQ(mesh->getElement(i)->getNode(2)->getID(),
+ result->getElement(i)->getNode(2)->getID());
+ ASSERT_EQ(1.0, MeshLib::FaceRule::getSurfaceNormal(result->getElement(i))[2]);
+ }
}
TEST(MeshLib, FlipQuadMesh)
{
- std::unique_ptr<MeshLib::Mesh> mesh(MeshLib::MeshGenerator::generateRegularQuadMesh(5, 5));
- std::unique_ptr<MeshLib::Mesh> result (MeshLib::createFlippedMesh(*mesh));
+ std::unique_ptr<MeshLib::Mesh> mesh(MeshLib::MeshGenerator::generateRegularQuadMesh(5, 5));
+ std::unique_ptr<MeshLib::Mesh> result (MeshLib::createFlippedMesh(*mesh));
- ASSERT_EQ(mesh->getNNodes(), result->getNNodes());
- ASSERT_EQ(mesh->getNElements(), result->getNElements());
- for (std::size_t i=0; i<result->getNElements(); ++i)
- {
- ASSERT_EQ(mesh->getElement(i)->getNode(0)->getID(),
- result->getElement(i)->getNode(1)->getID());
- ASSERT_EQ(mesh->getElement(i)->getNode(1)->getID(),
- result->getElement(i)->getNode(0)->getID());
- ASSERT_EQ(mesh->getElement(i)->getNode(2)->getID(),
- result->getElement(i)->getNode(3)->getID());
- ASSERT_EQ(mesh->getElement(i)->getNode(3)->getID(),
- result->getElement(i)->getNode(2)->getID());
- ASSERT_EQ(1.0, MeshLib::FaceRule::getSurfaceNormal(result->getElement(i))[2]);
- }
+ ASSERT_EQ(mesh->getNNodes(), result->getNNodes());
+ ASSERT_EQ(mesh->getNElements(), result->getNElements());
+ for (std::size_t i=0; i<result->getNElements(); ++i)
+ {
+ ASSERT_EQ(mesh->getElement(i)->getNode(0)->getID(),
+ result->getElement(i)->getNode(1)->getID());
+ ASSERT_EQ(mesh->getElement(i)->getNode(1)->getID(),
+ result->getElement(i)->getNode(0)->getID());
+ ASSERT_EQ(mesh->getElement(i)->getNode(2)->getID(),
+ result->getElement(i)->getNode(3)->getID());
+ ASSERT_EQ(mesh->getElement(i)->getNode(3)->getID(),
+ result->getElement(i)->getNode(2)->getID());
+ ASSERT_EQ(1.0, MeshLib::FaceRule::getSurfaceNormal(result->getElement(i))[2]);
+ }
}
TEST(MeshLib, FlipHexMesh)
{
- std::unique_ptr<MeshLib::Mesh> mesh (MeshLib::MeshGenerator::generateRegularHexMesh(2, 2));
- std::unique_ptr<MeshLib::Mesh> result (MeshLib::createFlippedMesh(*mesh));
+ std::unique_ptr<MeshLib::Mesh> mesh (MeshLib::MeshGenerator::generateRegularHexMesh(2, 2));
+ std::unique_ptr<MeshLib::Mesh> result (MeshLib::createFlippedMesh(*mesh));
- ASSERT_EQ(nullptr, result);
- std::vector<MeshLib::Node*> nodes;
- for (std::size_t i=0; i<mesh->getNNodes(); ++i)
- nodes.push_back(new MeshLib::Node(*mesh->getNode(i)));
- std::unique_ptr<MeshLib::Element> elem (MeshLib::createFlippedElement(*mesh->getElement(0), nodes));
- ASSERT_EQ(nullptr, elem);
- for (MeshLib::Node* n : nodes)
- delete n;
+ ASSERT_EQ(nullptr, result);
+ std::vector<MeshLib::Node*> nodes;
+ for (std::size_t i=0; i<mesh->getNNodes(); ++i)
+ nodes.push_back(new MeshLib::Node(*mesh->getNode(i)));
+ std::unique_ptr<MeshLib::Element> elem (MeshLib::createFlippedElement(*mesh->getElement(0), nodes));
+ ASSERT_EQ(nullptr, elem);
+ for (MeshLib::Node* n : nodes)
+ delete n;
}
TEST(MeshLib, DoubleFlipQuadMesh)
{
- std::unique_ptr<MeshLib::Mesh> mesh(MeshLib::MeshGenerator::generateRegularQuadMesh(5, 5));
- std::unique_ptr<MeshLib::Mesh> result (MeshLib::createFlippedMesh(*mesh));
- std::unique_ptr<MeshLib::Mesh> result2 (MeshLib::createFlippedMesh(*result));
+ std::unique_ptr<MeshLib::Mesh> mesh(MeshLib::MeshGenerator::generateRegularQuadMesh(5, 5));
+ std::unique_ptr<MeshLib::Mesh> result (MeshLib::createFlippedMesh(*mesh));
+ std::unique_ptr<MeshLib::Mesh> result2 (MeshLib::createFlippedMesh(*result));
- ASSERT_EQ(mesh->getNNodes(), result2->getNNodes());
- ASSERT_EQ(mesh->getNElements(), result2->getNElements());
- for (std::size_t i=0; i<result2->getNElements(); ++i)
- for (std::size_t j=0; j<4; ++j)
- ASSERT_EQ(mesh->getElement(i)->getNode(j)->getID(),
- result2->getElement(i)->getNode(j)->getID());
+ ASSERT_EQ(mesh->getNNodes(), result2->getNNodes());
+ ASSERT_EQ(mesh->getNElements(), result2->getNElements());
+ for (std::size_t i=0; i<result2->getNElements(); ++i)
+ for (std::size_t j=0; j<4; ++j)
+ ASSERT_EQ(mesh->getElement(i)->getNode(j)->getID(),
+ result2->getElement(i)->getNode(j)->getID());
}
diff --git a/Tests/MeshLib/TestMeshGenerator.cpp b/Tests/MeshLib/TestMeshGenerator.cpp
index 19d1a8213d158cef83853c32aaae5cf7008baa79..ab3edf8263fb71fd39616d3c5a3681f921baf2d7 100644
--- a/Tests/MeshLib/TestMeshGenerator.cpp
+++ b/Tests/MeshLib/TestMeshGenerator.cpp
@@ -22,117 +22,117 @@ using namespace MeshLib;
TEST(MeshLib, MeshGeneratorRegularHex)
{
- const double L = 10.0;
- const std::size_t n_subdivisions = 9;
- const double dL = L / static_cast<double>(n_subdivisions);
- std::unique_ptr<Mesh> msh(MeshGenerator::generateRegularHexMesh(L, n_subdivisions));
+ const double L = 10.0;
+ const std::size_t n_subdivisions = 9;
+ const double dL = L / static_cast<double>(n_subdivisions);
+ std::unique_ptr<Mesh> msh(MeshGenerator::generateRegularHexMesh(L, n_subdivisions));
- ASSERT_EQ(std::pow(n_subdivisions, 3), msh->getNElements());
- ASSERT_EQ(std::pow(n_subdivisions+1, 3), msh->getNNodes());
+ ASSERT_EQ(std::pow(n_subdivisions, 3), msh->getNElements());
+ ASSERT_EQ(std::pow(n_subdivisions+1, 3), msh->getNNodes());
- // check nodes
- const Node& node0 = *msh->getNode(0);
- const Node& node1 = *msh->getNode(1);
- const Node& node_n = *msh->getNode(msh->getNNodes()-2);
- const Node& node_n1 = *msh->getNode(msh->getNNodes()-1);
- ASSERT_DOUBLE_EQ(.0, node0[0]);
- ASSERT_DOUBLE_EQ(.0, node0[1]);
- ASSERT_DOUBLE_EQ(.0, node0[2]);
- ASSERT_DOUBLE_EQ(dL, node1[0]);
- ASSERT_DOUBLE_EQ(.0, node1[1]);
- ASSERT_DOUBLE_EQ(.0, node1[2]);
- ASSERT_DOUBLE_EQ(L-dL, node_n[0]);
- ASSERT_DOUBLE_EQ(L, node_n[1]);
- ASSERT_DOUBLE_EQ(L, node_n[2]);
- ASSERT_DOUBLE_EQ(L, node_n1[0]);
- ASSERT_DOUBLE_EQ(L, node_n1[1]);
- ASSERT_DOUBLE_EQ(L, node_n1[2]);
+ // check nodes
+ const Node& node0 = *msh->getNode(0);
+ const Node& node1 = *msh->getNode(1);
+ const Node& node_n = *msh->getNode(msh->getNNodes()-2);
+ const Node& node_n1 = *msh->getNode(msh->getNNodes()-1);
+ ASSERT_DOUBLE_EQ(.0, node0[0]);
+ ASSERT_DOUBLE_EQ(.0, node0[1]);
+ ASSERT_DOUBLE_EQ(.0, node0[2]);
+ ASSERT_DOUBLE_EQ(dL, node1[0]);
+ ASSERT_DOUBLE_EQ(.0, node1[1]);
+ ASSERT_DOUBLE_EQ(.0, node1[2]);
+ ASSERT_DOUBLE_EQ(L-dL, node_n[0]);
+ ASSERT_DOUBLE_EQ(L, node_n[1]);
+ ASSERT_DOUBLE_EQ(L, node_n[2]);
+ ASSERT_DOUBLE_EQ(L, node_n1[0]);
+ ASSERT_DOUBLE_EQ(L, node_n1[1]);
+ ASSERT_DOUBLE_EQ(L, node_n1[2]);
- // check elements
- const Element& ele0 = *msh->getElement(0);
- const Element& ele_n = *msh->getElement(msh->getNElements()-1);
- const std::size_t offset_y0 = (n_subdivisions+1);
- const std::size_t offset_z0 = (n_subdivisions+1)*(n_subdivisions+1);
- ASSERT_EQ(0u, ele0.getNodeIndex(0));
- ASSERT_EQ(1u, ele0.getNodeIndex(1));
- ASSERT_EQ(offset_y0+1, ele0.getNodeIndex(2));
- ASSERT_EQ(offset_y0, ele0.getNodeIndex(3));
- ASSERT_EQ(offset_z0, ele0.getNodeIndex(4));
- ASSERT_EQ(offset_z0+1, ele0.getNodeIndex(5));
- ASSERT_EQ(offset_z0+offset_y0+1, ele0.getNodeIndex(6));
- ASSERT_EQ(offset_z0+offset_y0, ele0.getNodeIndex(7));
- const std::size_t offset_yn0 = (n_subdivisions+1)*(n_subdivisions-1);
- const std::size_t offset_yn1 = (n_subdivisions+1)*n_subdivisions;
- const std::size_t offset_zn0 = (n_subdivisions+1)*(n_subdivisions+1)*(n_subdivisions-1);
- const std::size_t offset_zn1 = (n_subdivisions+1)*(n_subdivisions+1)*n_subdivisions;
- ASSERT_EQ(offset_zn0+offset_yn0+n_subdivisions-1, ele_n.getNodeIndex(0));
- ASSERT_EQ(offset_zn0+offset_yn0+n_subdivisions, ele_n.getNodeIndex(1));
- ASSERT_EQ(offset_zn0+offset_yn1+n_subdivisions, ele_n.getNodeIndex(2));
- ASSERT_EQ(offset_zn0+offset_yn1+n_subdivisions-1, ele_n.getNodeIndex(3));
- ASSERT_EQ(offset_zn1+offset_yn0+n_subdivisions-1, ele_n.getNodeIndex(4));
- ASSERT_EQ(offset_zn1+offset_yn0+n_subdivisions, ele_n.getNodeIndex(5));
- ASSERT_EQ(offset_zn1+offset_yn1+n_subdivisions, ele_n.getNodeIndex(6));
- ASSERT_EQ(offset_zn1+offset_yn1+n_subdivisions-1, ele_n.getNodeIndex(7));
+ // check elements
+ const Element& ele0 = *msh->getElement(0);
+ const Element& ele_n = *msh->getElement(msh->getNElements()-1);
+ const std::size_t offset_y0 = (n_subdivisions+1);
+ const std::size_t offset_z0 = (n_subdivisions+1)*(n_subdivisions+1);
+ ASSERT_EQ(0u, ele0.getNodeIndex(0));
+ ASSERT_EQ(1u, ele0.getNodeIndex(1));
+ ASSERT_EQ(offset_y0+1, ele0.getNodeIndex(2));
+ ASSERT_EQ(offset_y0, ele0.getNodeIndex(3));
+ ASSERT_EQ(offset_z0, ele0.getNodeIndex(4));
+ ASSERT_EQ(offset_z0+1, ele0.getNodeIndex(5));
+ ASSERT_EQ(offset_z0+offset_y0+1, ele0.getNodeIndex(6));
+ ASSERT_EQ(offset_z0+offset_y0, ele0.getNodeIndex(7));
+ const std::size_t offset_yn0 = (n_subdivisions+1)*(n_subdivisions-1);
+ const std::size_t offset_yn1 = (n_subdivisions+1)*n_subdivisions;
+ const std::size_t offset_zn0 = (n_subdivisions+1)*(n_subdivisions+1)*(n_subdivisions-1);
+ const std::size_t offset_zn1 = (n_subdivisions+1)*(n_subdivisions+1)*n_subdivisions;
+ ASSERT_EQ(offset_zn0+offset_yn0+n_subdivisions-1, ele_n.getNodeIndex(0));
+ ASSERT_EQ(offset_zn0+offset_yn0+n_subdivisions, ele_n.getNodeIndex(1));
+ ASSERT_EQ(offset_zn0+offset_yn1+n_subdivisions, ele_n.getNodeIndex(2));
+ ASSERT_EQ(offset_zn0+offset_yn1+n_subdivisions-1, ele_n.getNodeIndex(3));
+ ASSERT_EQ(offset_zn1+offset_yn0+n_subdivisions-1, ele_n.getNodeIndex(4));
+ ASSERT_EQ(offset_zn1+offset_yn0+n_subdivisions, ele_n.getNodeIndex(5));
+ ASSERT_EQ(offset_zn1+offset_yn1+n_subdivisions, ele_n.getNodeIndex(6));
+ ASSERT_EQ(offset_zn1+offset_yn1+n_subdivisions-1, ele_n.getNodeIndex(7));
- std::unique_ptr<Mesh> msh2 (MeshGenerator::generateRegularHexMesh(n_subdivisions, n_subdivisions, n_subdivisions, L/n_subdivisions));
- ASSERT_EQ(msh->getNNodes(), msh2->getNNodes());
- ASSERT_DOUBLE_EQ(0, MathLib::sqrDist(*(msh->getNode(msh->getNNodes()-1)), *(msh2->getNode(msh->getNNodes()-1))));
+ std::unique_ptr<Mesh> msh2 (MeshGenerator::generateRegularHexMesh(n_subdivisions, n_subdivisions, n_subdivisions, L/n_subdivisions));
+ ASSERT_EQ(msh->getNNodes(), msh2->getNNodes());
+ ASSERT_DOUBLE_EQ(0, MathLib::sqrDist(*(msh->getNode(msh->getNNodes()-1)), *(msh2->getNode(msh->getNNodes()-1))));
- unsigned n_x (10);
- unsigned n_y (5);
- unsigned n_z (2);
- double delta (1.2);
- std::unique_ptr<Mesh> hex_mesh (MeshGenerator::generateRegularHexMesh(n_x, n_y, n_z, delta));
- ASSERT_EQ(n_x * n_y * n_z, hex_mesh->getNElements());
- ASSERT_EQ((n_x+1) * (n_y+1) * (n_z+1), hex_mesh->getNNodes());
- const MeshLib::Node* node (hex_mesh->getNode(hex_mesh->getNNodes()-1));
- ASSERT_DOUBLE_EQ(n_x*delta, (*node)[0]);
- ASSERT_DOUBLE_EQ(n_y*delta, (*node)[1]);
- ASSERT_DOUBLE_EQ(n_z*delta, (*node)[2]);
+ unsigned n_x (10);
+ unsigned n_y (5);
+ unsigned n_z (2);
+ double delta (1.2);
+ std::unique_ptr<Mesh> hex_mesh (MeshGenerator::generateRegularHexMesh(n_x, n_y, n_z, delta));
+ ASSERT_EQ(n_x * n_y * n_z, hex_mesh->getNElements());
+ ASSERT_EQ((n_x+1) * (n_y+1) * (n_z+1), hex_mesh->getNNodes());
+ const MeshLib::Node* node (hex_mesh->getNode(hex_mesh->getNNodes()-1));
+ ASSERT_DOUBLE_EQ(n_x*delta, (*node)[0]);
+ ASSERT_DOUBLE_EQ(n_y*delta, (*node)[1]);
+ ASSERT_DOUBLE_EQ(n_z*delta, (*node)[2]);
}
TEST(MeshLib, MeshGeneratorRegularQuad)
{
- unsigned n_x (10);
- unsigned n_y (5);
- double delta (1.2);
- std::unique_ptr<Mesh> quad_mesh (MeshGenerator::generateRegularQuadMesh(n_x, n_y,delta));
- ASSERT_EQ(n_x * n_y, quad_mesh->getNElements());
- ASSERT_EQ((n_x+1) * (n_y+1), quad_mesh->getNNodes());
- const MeshLib::Node* node (quad_mesh->getNode(quad_mesh->getNNodes()-1));
- ASSERT_DOUBLE_EQ(n_x*delta, (*node)[0]);
- ASSERT_DOUBLE_EQ(n_y*delta, (*node)[1]);
- ASSERT_DOUBLE_EQ(0, (*node)[2]);
+ unsigned n_x (10);
+ unsigned n_y (5);
+ double delta (1.2);
+ std::unique_ptr<Mesh> quad_mesh (MeshGenerator::generateRegularQuadMesh(n_x, n_y,delta));
+ ASSERT_EQ(n_x * n_y, quad_mesh->getNElements());
+ ASSERT_EQ((n_x+1) * (n_y+1), quad_mesh->getNNodes());
+ const MeshLib::Node* node (quad_mesh->getNode(quad_mesh->getNNodes()-1));
+ ASSERT_DOUBLE_EQ(n_x*delta, (*node)[0]);
+ ASSERT_DOUBLE_EQ(n_y*delta, (*node)[1]);
+ ASSERT_DOUBLE_EQ(0, (*node)[2]);
- const double L = 10.0;
- const std::size_t n_subdivisions = 9;
- std::unique_ptr<Mesh> quad_mesh2(MeshGenerator::generateRegularQuadMesh(L, n_subdivisions));
- ASSERT_EQ(n_subdivisions * n_subdivisions, quad_mesh2->getNElements());
- node = quad_mesh2->getNode(quad_mesh2->getNNodes()-1);
- ASSERT_DOUBLE_EQ(L, (*node)[0]);
- ASSERT_DOUBLE_EQ(L, (*node)[1]);
+ const double L = 10.0;
+ const std::size_t n_subdivisions = 9;
+ std::unique_ptr<Mesh> quad_mesh2(MeshGenerator::generateRegularQuadMesh(L, n_subdivisions));
+ ASSERT_EQ(n_subdivisions * n_subdivisions, quad_mesh2->getNElements());
+ node = quad_mesh2->getNode(quad_mesh2->getNNodes()-1);
+ ASSERT_DOUBLE_EQ(L, (*node)[0]);
+ ASSERT_DOUBLE_EQ(L, (*node)[1]);
}
TEST(MeshLib, MeshGeneratorRegularPrism)
{
- double const l_x(10);
- double const l_y(10);
- double const l_z(8);
- unsigned n_x (10);
- unsigned n_y (5);
- unsigned n_z (4);
- std::unique_ptr<Mesh> mesh (MeshGenerator::generateRegularPrismMesh(l_x, l_y, l_z, n_x, n_y, n_z));
- ASSERT_EQ(2 * n_x * n_y * n_z, mesh->getNElements());
- ASSERT_EQ((n_x+1) * (n_y+1) * (n_z+1), mesh->getNNodes());
+ double const l_x(10);
+ double const l_y(10);
+ double const l_z(8);
+ unsigned n_x (10);
+ unsigned n_y (5);
+ unsigned n_z (4);
+ std::unique_ptr<Mesh> mesh (MeshGenerator::generateRegularPrismMesh(l_x, l_y, l_z, n_x, n_y, n_z));
+ ASSERT_EQ(2 * n_x * n_y * n_z, mesh->getNElements());
+ ASSERT_EQ((n_x+1) * (n_y+1) * (n_z+1), mesh->getNNodes());
- std::size_t count (0);
- for (std::size_t k=0; k<(n_z+1); ++k)
- for (std::size_t j=0; j<(n_y+1); ++j)
- for (std::size_t i=0; i<(n_x+1); ++i)
- {
- const MeshLib::Node* node (mesh->getNode(count++));
- ASSERT_DOUBLE_EQ(static_cast<double>(i), (*node)[0]);
- ASSERT_DOUBLE_EQ(static_cast<double>(j*2), (*node)[1]);
- ASSERT_DOUBLE_EQ(static_cast<double>(k*2), (*node)[2]);
- }
+ std::size_t count (0);
+ for (std::size_t k=0; k<(n_z+1); ++k)
+ for (std::size_t j=0; j<(n_y+1); ++j)
+ for (std::size_t i=0; i<(n_x+1); ++i)
+ {
+ const MeshLib::Node* node (mesh->getNode(count++));
+ ASSERT_DOUBLE_EQ(static_cast<double>(i), (*node)[0]);
+ ASSERT_DOUBLE_EQ(static_cast<double>(j*2), (*node)[1]);
+ ASSERT_DOUBLE_EQ(static_cast<double>(k*2), (*node)[2]);
+ }
}
diff --git a/Tests/MeshLib/TestMeshNodeSearch.cpp b/Tests/MeshLib/TestMeshNodeSearch.cpp
index cb6e0cd2f4780bf3e58d9a8611f5fa3382233408..306add28a4c335a911325eba32e2a8c7df4f7051 100644
--- a/Tests/MeshLib/TestMeshNodeSearch.cpp
+++ b/Tests/MeshLib/TestMeshNodeSearch.cpp
@@ -29,361 +29,361 @@ 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() :
+ _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;
- }
+ ~MeshLibMeshNodeSearchInSimpleQuadMesh()
+ {
+ delete _quad_mesh;
+ }
protected:
- const double _geometric_size;
- const std::size_t _number_of_subdivisions_per_direction;
- Mesh* _quad_mesh;
+ 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() :
+ _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;
- }
+ ~MeshLibMeshNodeSearchInSimpleHexMesh()
+ {
+ delete _hex_mesh;
+ }
protected:
- const double _geometric_size;
- const std::size_t _number_of_subdivisions_per_direction;
- Mesh* _hex_mesh;
+ const double _geometric_size;
+ const std::size_t _number_of_subdivisions_per_direction;
+ Mesh* _hex_mesh;
};
TEST_F(MeshLibMeshNodeSearchInSimpleQuadMesh, PointSearchEpsHalfEdge)
{
- double _dx = _geometric_size / _number_of_subdivisions_per_direction;
- double dx_half = _dx*0.5;
+ double _dx = _geometric_size / _number_of_subdivisions_per_direction;
+ double dx_half = _dx*0.5;
- ASSERT_TRUE(_quad_mesh != nullptr);
+ ASSERT_TRUE(_quad_mesh != nullptr);
- // 2 perform search and compare results with expected vals
- MeshGeoToolsLib::SearchLength search_length(dx_half);
- MeshGeoToolsLib::MeshNodeSearcher mesh_node_searcher(*_quad_mesh,
- search_length);
+ // 2 perform search and compare results with expected vals
+ MeshGeoToolsLib::SearchLength search_length(dx_half);
+ MeshGeoToolsLib::MeshNodeSearcher mesh_node_searcher(*_quad_mesh,
+ search_length);
- GeoLib::Point p1(0.0, 0.0, 0.0);
- EXPECT_EQ(1u, mesh_node_searcher.getMeshNodeIDsForPoint(p1).size());
- EXPECT_EQ(0u, mesh_node_searcher.getMeshNodeIDsForPoint(p1)[0]);
+ GeoLib::Point p1(0.0, 0.0, 0.0);
+ EXPECT_EQ(1u, mesh_node_searcher.getMeshNodeIDsForPoint(p1).size());
+ EXPECT_EQ(0u, mesh_node_searcher.getMeshNodeIDsForPoint(p1)[0]);
- GeoLib::Point p2(dx_half*0.99, 0.0, 0.0);
- EXPECT_EQ(1u, mesh_node_searcher.getMeshNodeIDsForPoint(p2).size());
- EXPECT_EQ(0u, mesh_node_searcher.getMeshNodeIDsForPoint(p2)[0]);
+ GeoLib::Point p2(dx_half*0.99, 0.0, 0.0);
+ EXPECT_EQ(1u, mesh_node_searcher.getMeshNodeIDsForPoint(p2).size());
+ EXPECT_EQ(0u, mesh_node_searcher.getMeshNodeIDsForPoint(p2)[0]);
- GeoLib::Point p3(dx_half, 0.0, 0.0);
- EXPECT_EQ(0u, mesh_node_searcher.getMeshNodeIDsForPoint(p3).size());
+ GeoLib::Point p3(dx_half, 0.0, 0.0);
+ EXPECT_EQ(0u, mesh_node_searcher.getMeshNodeIDsForPoint(p3).size());
- GeoLib::Point p4(dx_half*1.01, 0.0, 0.0);
- ASSERT_EQ(1u, mesh_node_searcher.getMeshNodeIDsForPoint(p4).size());
- ASSERT_EQ(1u, mesh_node_searcher.getMeshNodeIDsForPoint(p4)[0]);
+ GeoLib::Point p4(dx_half*1.01, 0.0, 0.0);
+ ASSERT_EQ(1u, mesh_node_searcher.getMeshNodeIDsForPoint(p4).size());
+ ASSERT_EQ(1u, mesh_node_searcher.getMeshNodeIDsForPoint(p4)[0]);
}
TEST_F(MeshLibMeshNodeSearchInSimpleQuadMesh, PointSearchZeroEps)
{
- ASSERT_TRUE(_quad_mesh != nullptr);
- // 1 create a geometry
+ ASSERT_TRUE(_quad_mesh != nullptr);
+ // 1 create a geometry
- // 2 perform search and compare results with expected vals
- MeshGeoToolsLib::SearchLength search_length;
- MeshGeoToolsLib::MeshNodeSearcher mesh_node_searcher(*_quad_mesh,
- search_length);
+ // 2 perform search and compare results with expected vals
+ MeshGeoToolsLib::SearchLength search_length;
+ MeshGeoToolsLib::MeshNodeSearcher mesh_node_searcher(*_quad_mesh,
+ search_length);
- // find ORIGIN
- GeoLib::Point pnt1(0.0, 0.0, 0.0);
- ASSERT_EQ(0u, mesh_node_searcher.getMeshNodeIDsForPoint(pnt1)[0]);
+ // find ORIGIN
+ GeoLib::Point pnt1(0.0, 0.0, 0.0);
+ ASSERT_EQ(0u, mesh_node_searcher.getMeshNodeIDsForPoint(pnt1)[0]);
- GeoLib::Point pnt2(0.049, 0.049, 0.0);
- ASSERT_EQ(0u, mesh_node_searcher.getMeshNodeIDsForPoint(pnt2).size());
+ GeoLib::Point pnt2(0.049, 0.049, 0.0);
+ ASSERT_EQ(0u, mesh_node_searcher.getMeshNodeIDsForPoint(pnt2).size());
- GeoLib::Point pnt3(0.051, 0.049, 0.0);
- ASSERT_EQ(0u, mesh_node_searcher.getMeshNodeIDsForPoint(pnt3).size());
+ GeoLib::Point pnt3(0.051, 0.049, 0.0);
+ ASSERT_EQ(0u, mesh_node_searcher.getMeshNodeIDsForPoint(pnt3).size());
- GeoLib::Point pnt4(0.049, 0.051, 0.0);
- ASSERT_EQ(0u, mesh_node_searcher.getMeshNodeIDsForPoint(pnt4).size());
+ GeoLib::Point pnt4(0.049, 0.051, 0.0);
+ ASSERT_EQ(0u, mesh_node_searcher.getMeshNodeIDsForPoint(pnt4).size());
- GeoLib::Point pnt5(0.051, 0.051, 0.0);
- ASSERT_EQ(0u, mesh_node_searcher.getMeshNodeIDsForPoint(pnt5).size());
+ GeoLib::Point pnt5(0.051, 0.051, 0.0);
+ ASSERT_EQ(0u, mesh_node_searcher.getMeshNodeIDsForPoint(pnt5).size());
- GeoLib::Point pnt6(10, 10, 0.0);
- ASSERT_EQ(1u, mesh_node_searcher.getMeshNodeIDsForPoint(pnt6).size());
- EXPECT_EQ(
- pow(_number_of_subdivisions_per_direction+1,2)-1,
- mesh_node_searcher.getMeshNodeIDsForPoint(pnt6)[0]);
+ GeoLib::Point pnt6(10, 10, 0.0);
+ ASSERT_EQ(1u, mesh_node_searcher.getMeshNodeIDsForPoint(pnt6).size());
+ EXPECT_EQ(
+ pow(_number_of_subdivisions_per_direction+1,2)-1,
+ mesh_node_searcher.getMeshNodeIDsForPoint(pnt6)[0]);
}
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; });
+ 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; });
+ 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; });
+ 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; });
}
diff --git a/Tests/MeshLib/TestMeshRevision.cpp b/Tests/MeshLib/TestMeshRevision.cpp
index c5c906d8c0ebf7efe6bbca52fef2229710fae60e..9e0aa5b92183e25fd09a5735b432ccac8da0a51c 100644
--- a/Tests/MeshLib/TestMeshRevision.cpp
+++ b/Tests/MeshLib/TestMeshRevision.cpp
@@ -27,451 +27,451 @@
TEST(MeshEditing, Tri)
{
- std::vector<MeshLib::Node*> nodes;
- nodes.push_back(new MeshLib::Node(1,0,0));
- nodes.push_back(new MeshLib::Node(0,0,0));
- nodes.push_back(new MeshLib::Node(0,0,0.1));
-
- std::array<MeshLib::Node*, 3> nodes_array = {{nodes[0], nodes[1], nodes[2]}};
- std::vector<MeshLib::Element*> elements;
- MeshLib::Element* elem(new MeshLib::Tri(nodes_array));
- elements.push_back(elem);
- MeshLib::Mesh mesh ("testmesh", nodes, elements);
-
- MeshLib::MeshRevision rev(mesh);
- MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
-
- ASSERT_EQ(MeshLib::MeshElemType::LINE, result->getElement(0)->getGeomType());
- ASSERT_EQ(1, result->getElement(0)->getContent());
- ASSERT_EQ(2u, result->getNNodes());
- delete result;
-
- result = rev.simplifyMesh("new_mesh", 0.0999);
- ASSERT_EQ(MeshLib::MeshElemType::TRIANGLE, result->getElement(0)->getGeomType());
- ASSERT_EQ(0.05, result->getElement(0)->getContent());
- ASSERT_EQ(3u, result->getNNodes());
- delete result;
+ std::vector<MeshLib::Node*> nodes;
+ nodes.push_back(new MeshLib::Node(1,0,0));
+ nodes.push_back(new MeshLib::Node(0,0,0));
+ nodes.push_back(new MeshLib::Node(0,0,0.1));
+
+ std::array<MeshLib::Node*, 3> nodes_array = {{nodes[0], nodes[1], nodes[2]}};
+ std::vector<MeshLib::Element*> elements;
+ MeshLib::Element* elem(new MeshLib::Tri(nodes_array));
+ elements.push_back(elem);
+ MeshLib::Mesh mesh ("testmesh", nodes, elements);
+
+ MeshLib::MeshRevision rev(mesh);
+ MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
+
+ ASSERT_EQ(MeshLib::MeshElemType::LINE, result->getElement(0)->getGeomType());
+ ASSERT_EQ(1, result->getElement(0)->getContent());
+ ASSERT_EQ(2u, result->getNNodes());
+ delete result;
+
+ result = rev.simplifyMesh("new_mesh", 0.0999);
+ ASSERT_EQ(MeshLib::MeshElemType::TRIANGLE, result->getElement(0)->getGeomType());
+ ASSERT_EQ(0.05, result->getElement(0)->getContent());
+ ASSERT_EQ(3u, result->getNNodes());
+ delete result;
}
TEST(MeshEditing, NonPlanarQuad)
{
- std::vector<MeshLib::Node*> nodes;
- nodes.push_back(new MeshLib::Node(0,0,0));
- nodes.push_back(new MeshLib::Node(0,1,0));
- nodes.push_back(new MeshLib::Node(1,1,0.1));
- nodes.push_back(new MeshLib::Node(1,0,0));
-
- std::array<MeshLib::Node*, 4> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3]}};
- std::vector<MeshLib::Element*> elements;
- MeshLib::Element* elem (new MeshLib::Quad(nodes_array));
- elements.push_back(elem);
- MeshLib::Mesh mesh("testmesh", nodes, elements);
- MeshLib::MeshRevision rev(mesh);
- MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
-
- ASSERT_EQ(2u, result->getNElements());
- ASSERT_EQ(MeshLib::MeshElemType::TRIANGLE, result->getElement(1)->getGeomType());
-
- delete result;
+ std::vector<MeshLib::Node*> nodes;
+ nodes.push_back(new MeshLib::Node(0,0,0));
+ nodes.push_back(new MeshLib::Node(0,1,0));
+ nodes.push_back(new MeshLib::Node(1,1,0.1));
+ nodes.push_back(new MeshLib::Node(1,0,0));
+
+ std::array<MeshLib::Node*, 4> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3]}};
+ std::vector<MeshLib::Element*> elements;
+ MeshLib::Element* elem (new MeshLib::Quad(nodes_array));
+ elements.push_back(elem);
+ MeshLib::Mesh mesh("testmesh", nodes, elements);
+ MeshLib::MeshRevision rev(mesh);
+ MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
+
+ ASSERT_EQ(2u, result->getNElements());
+ ASSERT_EQ(MeshLib::MeshElemType::TRIANGLE, result->getElement(1)->getGeomType());
+
+ delete result;
}
TEST(MeshEditing, Quad2Line)
{
- std::vector<MeshLib::Node*> nodes;
- nodes.push_back(new MeshLib::Node(1,0,0));
- nodes.push_back(new MeshLib::Node(0,1,0));
- nodes.push_back(new MeshLib::Node(0,1,0.1));
- nodes.push_back(new MeshLib::Node(1,0,0.1));
-
- std::array<MeshLib::Node*, 4> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3]}};
- std::vector<MeshLib::Element*> elements;
- MeshLib::Element* elem (new MeshLib::Quad(nodes_array));
- elements.push_back(elem);
- MeshLib::Mesh mesh("testmesh", nodes, elements);
-
- MeshLib::MeshRevision rev(mesh);
- MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
-
- ASSERT_EQ(MeshLib::MeshElemType::LINE, result->getElement(0)->getGeomType());
- ASSERT_NEAR(1.414213562373095, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
- ASSERT_EQ(2u, result->getNNodes());
-
- delete result;
+ std::vector<MeshLib::Node*> nodes;
+ nodes.push_back(new MeshLib::Node(1,0,0));
+ nodes.push_back(new MeshLib::Node(0,1,0));
+ nodes.push_back(new MeshLib::Node(0,1,0.1));
+ nodes.push_back(new MeshLib::Node(1,0,0.1));
+
+ std::array<MeshLib::Node*, 4> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3]}};
+ std::vector<MeshLib::Element*> elements;
+ MeshLib::Element* elem (new MeshLib::Quad(nodes_array));
+ elements.push_back(elem);
+ MeshLib::Mesh mesh("testmesh", nodes, elements);
+
+ MeshLib::MeshRevision rev(mesh);
+ MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
+
+ ASSERT_EQ(MeshLib::MeshElemType::LINE, result->getElement(0)->getGeomType());
+ ASSERT_NEAR(1.414213562373095, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
+ ASSERT_EQ(2u, result->getNNodes());
+
+ delete result;
}
TEST(MeshEditing, Quad2Tri)
{
- std::vector<MeshLib::Node*> nodes;
- nodes.push_back(new MeshLib::Node(1,0,0));
- nodes.push_back(new MeshLib::Node(0,1,0));
- nodes.push_back(new MeshLib::Node(0,1,0.1));
- nodes.push_back(new MeshLib::Node(1,1,0.1));
-
- std::array<MeshLib::Node*, 4> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3]}};
- std::vector<MeshLib::Element*> elements;
- MeshLib::Element* elem (new MeshLib::Quad(nodes_array));
- elements.push_back(elem);
- MeshLib::Mesh mesh("testmesh", nodes, elements);
-
- MeshLib::MeshRevision rev(mesh);
- MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
-
- ASSERT_EQ(MeshLib::MeshElemType::TRIANGLE, result->getElement(0)->getGeomType());
- ASSERT_NEAR(0.5049752469181039, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
- ASSERT_EQ(3u, result->getNNodes());
-
- delete result;
+ std::vector<MeshLib::Node*> nodes;
+ nodes.push_back(new MeshLib::Node(1,0,0));
+ nodes.push_back(new MeshLib::Node(0,1,0));
+ nodes.push_back(new MeshLib::Node(0,1,0.1));
+ nodes.push_back(new MeshLib::Node(1,1,0.1));
+
+ std::array<MeshLib::Node*, 4> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3]}};
+ std::vector<MeshLib::Element*> elements;
+ MeshLib::Element* elem (new MeshLib::Quad(nodes_array));
+ elements.push_back(elem);
+ MeshLib::Mesh mesh("testmesh", nodes, elements);
+
+ MeshLib::MeshRevision rev(mesh);
+ MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
+
+ ASSERT_EQ(MeshLib::MeshElemType::TRIANGLE, result->getElement(0)->getGeomType());
+ ASSERT_NEAR(0.5049752469181039, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
+ ASSERT_EQ(3u, result->getNNodes());
+
+ delete result;
}
TEST(MeshEditing, NonPlanarHex)
{
- std::vector<MeshLib::Node*> nodes;
- nodes.push_back(new MeshLib::Node(0,0,-0.5));
- nodes.push_back(new MeshLib::Node(1,0,0));
- nodes.push_back(new MeshLib::Node(1,1,0));
- nodes.push_back(new MeshLib::Node(0,1,0));
- nodes.push_back(new MeshLib::Node(0,0,1));
- nodes.push_back(new MeshLib::Node(1,0,1));
- nodes.push_back(new MeshLib::Node(1,1,1));
- nodes.push_back(new MeshLib::Node(0,1,1));
-
- std::array<MeshLib::Node*, 8> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5], nodes[6], nodes[7]}};
- std::vector<MeshLib::Element*> elements;
- MeshLib::Element* elem (new MeshLib::Hex(nodes_array));
- elements.push_back(elem);
- MeshLib::Mesh mesh("testmesh", nodes, elements);
-
- MeshLib::MeshRevision rev(mesh);
- MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
-
- ASSERT_EQ(6u, result->getNElements());
- ASSERT_EQ(MeshLib::MeshElemType::TETRAHEDRON, result->getElement(4)->getGeomType());
- ASSERT_NEAR(0.25, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(0.1666666666666667, result->getElement(5)->getContent(), std::numeric_limits<double>::epsilon());
-
- delete result;
+ std::vector<MeshLib::Node*> nodes;
+ nodes.push_back(new MeshLib::Node(0,0,-0.5));
+ nodes.push_back(new MeshLib::Node(1,0,0));
+ nodes.push_back(new MeshLib::Node(1,1,0));
+ nodes.push_back(new MeshLib::Node(0,1,0));
+ nodes.push_back(new MeshLib::Node(0,0,1));
+ nodes.push_back(new MeshLib::Node(1,0,1));
+ nodes.push_back(new MeshLib::Node(1,1,1));
+ nodes.push_back(new MeshLib::Node(0,1,1));
+
+ std::array<MeshLib::Node*, 8> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5], nodes[6], nodes[7]}};
+ std::vector<MeshLib::Element*> elements;
+ MeshLib::Element* elem (new MeshLib::Hex(nodes_array));
+ elements.push_back(elem);
+ MeshLib::Mesh mesh("testmesh", nodes, elements);
+
+ MeshLib::MeshRevision rev(mesh);
+ MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
+
+ ASSERT_EQ(6u, result->getNElements());
+ ASSERT_EQ(MeshLib::MeshElemType::TETRAHEDRON, result->getElement(4)->getGeomType());
+ ASSERT_NEAR(0.25, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(0.1666666666666667, result->getElement(5)->getContent(), std::numeric_limits<double>::epsilon());
+
+ delete result;
}
TEST(MeshEditing, Hex2PyramidPrism)
{
- std::vector<MeshLib::Node*> nodes;
- nodes.push_back(new MeshLib::Node(0,0,0));
- nodes.push_back(new MeshLib::Node(1,0,0));
- nodes.push_back(new MeshLib::Node(1,1,0));
- nodes.push_back(new MeshLib::Node(0,1,0));
- nodes.push_back(new MeshLib::Node(0,0,1));
- nodes.push_back(new MeshLib::Node(1,0,.1));
- nodes.push_back(new MeshLib::Node(1,1,1));
- nodes.push_back(new MeshLib::Node(0,1,1));
-
- std::array<MeshLib::Node*, 8> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5], nodes[6], nodes[7]}};
- std::vector<MeshLib::Element*> elements;
- MeshLib::Element* elem (new MeshLib::Hex(nodes_array));
- elements.push_back(elem);
- MeshLib::Mesh mesh("testmesh", nodes, elements);
-
- MeshLib::MeshRevision rev(mesh);
- MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
-
- ASSERT_EQ(2u, result->getNElements());
- ASSERT_EQ(MeshLib::MeshElemType::PYRAMID, result->getElement(0)->getGeomType());
- ASSERT_EQ(MeshLib::MeshElemType::PRISM, result->getElement(1)->getGeomType());
- ASSERT_NEAR(0.3333333333333333, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(0.5, result->getElement(1)->getContent(), std::numeric_limits<double>::epsilon());
-
- delete result;
+ std::vector<MeshLib::Node*> nodes;
+ nodes.push_back(new MeshLib::Node(0,0,0));
+ nodes.push_back(new MeshLib::Node(1,0,0));
+ nodes.push_back(new MeshLib::Node(1,1,0));
+ nodes.push_back(new MeshLib::Node(0,1,0));
+ nodes.push_back(new MeshLib::Node(0,0,1));
+ nodes.push_back(new MeshLib::Node(1,0,.1));
+ nodes.push_back(new MeshLib::Node(1,1,1));
+ nodes.push_back(new MeshLib::Node(0,1,1));
+
+ std::array<MeshLib::Node*, 8> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5], nodes[6], nodes[7]}};
+ std::vector<MeshLib::Element*> elements;
+ MeshLib::Element* elem (new MeshLib::Hex(nodes_array));
+ elements.push_back(elem);
+ MeshLib::Mesh mesh("testmesh", nodes, elements);
+
+ MeshLib::MeshRevision rev(mesh);
+ MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
+
+ ASSERT_EQ(2u, result->getNElements());
+ ASSERT_EQ(MeshLib::MeshElemType::PYRAMID, result->getElement(0)->getGeomType());
+ ASSERT_EQ(MeshLib::MeshElemType::PRISM, result->getElement(1)->getGeomType());
+ ASSERT_NEAR(0.3333333333333333, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(0.5, result->getElement(1)->getContent(), std::numeric_limits<double>::epsilon());
+
+ delete result;
}
TEST(MeshEditing, Hex2FourTets)
{
- std::vector<MeshLib::Node*> nodes;
- nodes.push_back(new MeshLib::Node(0,0,0));
- nodes.push_back(new MeshLib::Node(1,1,0));
- nodes.push_back(new MeshLib::Node(1,1,0));
- nodes.push_back(new MeshLib::Node(0,1,0));
- nodes.push_back(new MeshLib::Node(1,0,1));
- nodes.push_back(new MeshLib::Node(1,0,1));
- nodes.push_back(new MeshLib::Node(1,1,1));
- nodes.push_back(new MeshLib::Node(0,1,1));
-
- std::array<MeshLib::Node*, 8> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5], nodes[6], nodes[7]}};
- std::vector<MeshLib::Element*> elements;
- MeshLib::Element* elem (new MeshLib::Hex(nodes_array));
- elements.push_back(elem);
- MeshLib::Mesh mesh("testmesh", nodes, elements);
-
- MeshLib::MeshRevision rev(mesh);
- MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
-
- ASSERT_EQ(4u, result->getNElements());
- ASSERT_EQ(MeshLib::MeshElemType::TETRAHEDRON, result->getElement(1)->getGeomType());
- ASSERT_NEAR(0.1666666666666667, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(0.1666666666666667, result->getElement(1)->getContent(), std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(0.1666666666666667, result->getElement(2)->getContent(), std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(0.1666666666666667, result->getElement(3)->getContent(), std::numeric_limits<double>::epsilon());
-
- delete result;
+ std::vector<MeshLib::Node*> nodes;
+ nodes.push_back(new MeshLib::Node(0,0,0));
+ nodes.push_back(new MeshLib::Node(1,1,0));
+ nodes.push_back(new MeshLib::Node(1,1,0));
+ nodes.push_back(new MeshLib::Node(0,1,0));
+ nodes.push_back(new MeshLib::Node(1,0,1));
+ nodes.push_back(new MeshLib::Node(1,0,1));
+ nodes.push_back(new MeshLib::Node(1,1,1));
+ nodes.push_back(new MeshLib::Node(0,1,1));
+
+ std::array<MeshLib::Node*, 8> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5], nodes[6], nodes[7]}};
+ std::vector<MeshLib::Element*> elements;
+ MeshLib::Element* elem (new MeshLib::Hex(nodes_array));
+ elements.push_back(elem);
+ MeshLib::Mesh mesh("testmesh", nodes, elements);
+
+ MeshLib::MeshRevision rev(mesh);
+ MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
+
+ ASSERT_EQ(4u, result->getNElements());
+ ASSERT_EQ(MeshLib::MeshElemType::TETRAHEDRON, result->getElement(1)->getGeomType());
+ ASSERT_NEAR(0.1666666666666667, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(0.1666666666666667, result->getElement(1)->getContent(), std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(0.1666666666666667, result->getElement(2)->getContent(), std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(0.1666666666666667, result->getElement(3)->getContent(), std::numeric_limits<double>::epsilon());
+
+ delete result;
}
TEST(MeshEditing, Hex2TwoTets)
{
- std::vector<MeshLib::Node*> nodes;
- nodes.push_back(new MeshLib::Node(0,0,0));
- nodes.push_back(new MeshLib::Node(1,0,0));
- nodes.push_back(new MeshLib::Node(1,1,0));
- nodes.push_back(new MeshLib::Node(0,1,0));
- nodes.push_back(new MeshLib::Node(1,1,1));
- nodes.push_back(new MeshLib::Node(1,1,1));
- nodes.push_back(new MeshLib::Node(1,1,1));
- nodes.push_back(new MeshLib::Node(1,1,1));
-
- std::array<MeshLib::Node*, 8> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5], nodes[6], nodes[7]}};
- std::vector<MeshLib::Element*> elements;
- MeshLib::Element* elem (new MeshLib::Hex(nodes_array));
- elements.push_back(elem);
- MeshLib::Mesh mesh("testmesh", nodes, elements);
-
- MeshLib::MeshRevision rev(mesh);
- MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
-
- ASSERT_EQ(2u, result->getNElements());
- ASSERT_EQ(MeshLib::MeshElemType::TETRAHEDRON, result->getElement(1)->getGeomType());
- ASSERT_NEAR(0.1666666666666667, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(0.1666666666666667, result->getElement(1)->getContent(), std::numeric_limits<double>::epsilon());
-
- delete result;
+ std::vector<MeshLib::Node*> nodes;
+ nodes.push_back(new MeshLib::Node(0,0,0));
+ nodes.push_back(new MeshLib::Node(1,0,0));
+ nodes.push_back(new MeshLib::Node(1,1,0));
+ nodes.push_back(new MeshLib::Node(0,1,0));
+ nodes.push_back(new MeshLib::Node(1,1,1));
+ nodes.push_back(new MeshLib::Node(1,1,1));
+ nodes.push_back(new MeshLib::Node(1,1,1));
+ nodes.push_back(new MeshLib::Node(1,1,1));
+
+ std::array<MeshLib::Node*, 8> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5], nodes[6], nodes[7]}};
+ std::vector<MeshLib::Element*> elements;
+ MeshLib::Element* elem (new MeshLib::Hex(nodes_array));
+ elements.push_back(elem);
+ MeshLib::Mesh mesh("testmesh", nodes, elements);
+
+ MeshLib::MeshRevision rev(mesh);
+ MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
+
+ ASSERT_EQ(2u, result->getNElements());
+ ASSERT_EQ(MeshLib::MeshElemType::TETRAHEDRON, result->getElement(1)->getGeomType());
+ ASSERT_NEAR(0.1666666666666667, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(0.1666666666666667, result->getElement(1)->getContent(), std::numeric_limits<double>::epsilon());
+
+ delete result;
}
TEST(MeshEditing, NonPlanarPyramid)
{
- std::vector<MeshLib::Node*> nodes;
- nodes.push_back(new MeshLib::Node(0,0,0));
- nodes.push_back(new MeshLib::Node(1,0,-.5));
- nodes.push_back(new MeshLib::Node(1,1,0));
- nodes.push_back(new MeshLib::Node(0,1,0));
- nodes.push_back(new MeshLib::Node(1,0,1));
-
- std::array<MeshLib::Node*, 5> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4]}};
- std::vector<MeshLib::Element*> elements;
- MeshLib::Element* elem (new MeshLib::Pyramid(nodes_array));
- elements.push_back(elem);
- MeshLib::Mesh mesh("testmesh", nodes, elements);
-
- MeshLib::MeshRevision rev(mesh);
- MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
-
- ASSERT_EQ(2u, result->getNElements());
- ASSERT_EQ(MeshLib::MeshElemType::TETRAHEDRON, result->getElement(1)->getGeomType());
- ASSERT_NEAR(0.25, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(0.1666666666666667, result->getElement(1)->getContent(), std::numeric_limits<double>::epsilon());
-
- delete result;
+ std::vector<MeshLib::Node*> nodes;
+ nodes.push_back(new MeshLib::Node(0,0,0));
+ nodes.push_back(new MeshLib::Node(1,0,-.5));
+ nodes.push_back(new MeshLib::Node(1,1,0));
+ nodes.push_back(new MeshLib::Node(0,1,0));
+ nodes.push_back(new MeshLib::Node(1,0,1));
+
+ std::array<MeshLib::Node*, 5> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4]}};
+ std::vector<MeshLib::Element*> elements;
+ MeshLib::Element* elem (new MeshLib::Pyramid(nodes_array));
+ elements.push_back(elem);
+ MeshLib::Mesh mesh("testmesh", nodes, elements);
+
+ MeshLib::MeshRevision rev(mesh);
+ MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
+
+ ASSERT_EQ(2u, result->getNElements());
+ ASSERT_EQ(MeshLib::MeshElemType::TETRAHEDRON, result->getElement(1)->getGeomType());
+ ASSERT_NEAR(0.25, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(0.1666666666666667, result->getElement(1)->getContent(), std::numeric_limits<double>::epsilon());
+
+ delete result;
}
TEST(MeshEditing, Pyramid2Tet)
{
- std::vector<MeshLib::Node*> nodes;
- nodes.push_back(new MeshLib::Node(1,0,0));
- nodes.push_back(new MeshLib::Node(0,1,0));
- nodes.push_back(new MeshLib::Node(1,1,0));
- nodes.push_back(new MeshLib::Node(1,0,0));
- nodes.push_back(new MeshLib::Node(1,0,1));
-
- std::array<MeshLib::Node*, 5> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4]}};
- std::vector<MeshLib::Element*> elements;
- MeshLib::Element* elem (new MeshLib::Pyramid(nodes_array));
- elements.push_back(elem);
- MeshLib::Mesh mesh("testmesh", nodes, elements);
-
- MeshLib::MeshRevision rev(mesh);
- MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
-
- ASSERT_EQ(1u, result->getNElements());
- ASSERT_EQ(MeshLib::MeshElemType::TETRAHEDRON, result->getElement(0)->getGeomType());
- ASSERT_NEAR(0.16666666666666666, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
-
- delete result;
+ std::vector<MeshLib::Node*> nodes;
+ nodes.push_back(new MeshLib::Node(1,0,0));
+ nodes.push_back(new MeshLib::Node(0,1,0));
+ nodes.push_back(new MeshLib::Node(1,1,0));
+ nodes.push_back(new MeshLib::Node(1,0,0));
+ nodes.push_back(new MeshLib::Node(1,0,1));
+
+ std::array<MeshLib::Node*, 5> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4]}};
+ std::vector<MeshLib::Element*> elements;
+ MeshLib::Element* elem (new MeshLib::Pyramid(nodes_array));
+ elements.push_back(elem);
+ MeshLib::Mesh mesh("testmesh", nodes, elements);
+
+ MeshLib::MeshRevision rev(mesh);
+ MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
+
+ ASSERT_EQ(1u, result->getNElements());
+ ASSERT_EQ(MeshLib::MeshElemType::TETRAHEDRON, result->getElement(0)->getGeomType());
+ ASSERT_NEAR(0.16666666666666666, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
+
+ delete result;
}
TEST(MeshEditing, Pyramid2Quad)
{
- std::vector<MeshLib::Node*> nodes;
- nodes.push_back(new MeshLib::Node(1,0,0));
- nodes.push_back(new MeshLib::Node(1,1,0));
- nodes.push_back(new MeshLib::Node(0,1,0));
- nodes.push_back(new MeshLib::Node(0,0,0));
- nodes.push_back(new MeshLib::Node(1,0,0.1));
-
- std::array<MeshLib::Node*, 5> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4]}};
- std::vector<MeshLib::Element*> elements;
- MeshLib::Element* elem (new MeshLib::Pyramid(nodes_array));
- elements.push_back(elem);
- MeshLib::Mesh mesh("testmesh", nodes, elements);
-
- MeshLib::MeshRevision rev(mesh);
- MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
-
- ASSERT_EQ(1u, result->getNElements());
- ASSERT_EQ(MeshLib::MeshElemType::QUAD, result->getElement(0)->getGeomType());
- ASSERT_NEAR(1, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
-
- delete result;
+ std::vector<MeshLib::Node*> nodes;
+ nodes.push_back(new MeshLib::Node(1,0,0));
+ nodes.push_back(new MeshLib::Node(1,1,0));
+ nodes.push_back(new MeshLib::Node(0,1,0));
+ nodes.push_back(new MeshLib::Node(0,0,0));
+ nodes.push_back(new MeshLib::Node(1,0,0.1));
+
+ std::array<MeshLib::Node*, 5> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4]}};
+ std::vector<MeshLib::Element*> elements;
+ MeshLib::Element* elem (new MeshLib::Pyramid(nodes_array));
+ elements.push_back(elem);
+ MeshLib::Mesh mesh("testmesh", nodes, elements);
+
+ MeshLib::MeshRevision rev(mesh);
+ MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
+
+ ASSERT_EQ(1u, result->getNElements());
+ ASSERT_EQ(MeshLib::MeshElemType::QUAD, result->getElement(0)->getGeomType());
+ ASSERT_NEAR(1, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
+
+ delete result;
}
TEST(MeshEditing, Pyramid2Tri)
{
- std::vector<MeshLib::Node*> nodes;
- nodes.push_back(new MeshLib::Node(1,0,0));
- nodes.push_back(new MeshLib::Node(1,0.1,0));
- nodes.push_back(new MeshLib::Node(0,1,0));
- nodes.push_back(new MeshLib::Node(0,0,0));
- nodes.push_back(new MeshLib::Node(1,0,0.1));
-
- std::array<MeshLib::Node*, 5> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4]}};
- std::vector<MeshLib::Element*> elements;
- MeshLib::Element* elem (new MeshLib::Pyramid(nodes_array));
- elements.push_back(elem);
- MeshLib::Mesh mesh("testmesh", nodes, elements);
-
- MeshLib::MeshRevision rev(mesh);
- MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
-
- ASSERT_EQ(3u, result->getNNodes());
- ASSERT_EQ(1u, result->getNElements());
- ASSERT_EQ(MeshLib::MeshElemType::TRIANGLE, result->getElement(0)->getGeomType());
- ASSERT_NEAR(0.5, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
-
- delete result;
+ std::vector<MeshLib::Node*> nodes;
+ nodes.push_back(new MeshLib::Node(1,0,0));
+ nodes.push_back(new MeshLib::Node(1,0.1,0));
+ nodes.push_back(new MeshLib::Node(0,1,0));
+ nodes.push_back(new MeshLib::Node(0,0,0));
+ nodes.push_back(new MeshLib::Node(1,0,0.1));
+
+ std::array<MeshLib::Node*, 5> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4]}};
+ std::vector<MeshLib::Element*> elements;
+ MeshLib::Element* elem (new MeshLib::Pyramid(nodes_array));
+ elements.push_back(elem);
+ MeshLib::Mesh mesh("testmesh", nodes, elements);
+
+ MeshLib::MeshRevision rev(mesh);
+ MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
+
+ ASSERT_EQ(3u, result->getNNodes());
+ ASSERT_EQ(1u, result->getNElements());
+ ASSERT_EQ(MeshLib::MeshElemType::TRIANGLE, result->getElement(0)->getGeomType());
+ ASSERT_NEAR(0.5, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
+
+ delete result;
}
TEST(MeshEditing, NonPlanarPrism)
{
- std::vector<MeshLib::Node*> nodes;
- nodes.push_back(new MeshLib::Node(1,0,0));
- nodes.push_back(new MeshLib::Node(1,1,0));
- nodes.push_back(new MeshLib::Node(0,0,0));
- nodes.push_back(new MeshLib::Node(1,0,1));
- nodes.push_back(new MeshLib::Node(1,1,1));
- nodes.push_back(new MeshLib::Node(0,-0.5,2));
-
- std::array<MeshLib::Node*, 6> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5]}};
- std::vector<MeshLib::Element*> elements;
- MeshLib::Element* elem (new MeshLib::Prism(nodes_array));
- elements.push_back(elem);
- MeshLib::Mesh mesh("testmesh", nodes, elements);
-
- MeshLib::MeshRevision rev(mesh);
- MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
-
- ASSERT_EQ(3u, result->getNElements());
- ASSERT_EQ(MeshLib::MeshElemType::TETRAHEDRON, result->getElement(2)->getGeomType());
- ASSERT_NEAR(0.1666666666666667, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
-
- delete result;
+ std::vector<MeshLib::Node*> nodes;
+ nodes.push_back(new MeshLib::Node(1,0,0));
+ nodes.push_back(new MeshLib::Node(1,1,0));
+ nodes.push_back(new MeshLib::Node(0,0,0));
+ nodes.push_back(new MeshLib::Node(1,0,1));
+ nodes.push_back(new MeshLib::Node(1,1,1));
+ nodes.push_back(new MeshLib::Node(0,-0.5,2));
+
+ std::array<MeshLib::Node*, 6> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5]}};
+ std::vector<MeshLib::Element*> elements;
+ MeshLib::Element* elem (new MeshLib::Prism(nodes_array));
+ elements.push_back(elem);
+ MeshLib::Mesh mesh("testmesh", nodes, elements);
+
+ MeshLib::MeshRevision rev(mesh);
+ MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
+
+ ASSERT_EQ(3u, result->getNElements());
+ ASSERT_EQ(MeshLib::MeshElemType::TETRAHEDRON, result->getElement(2)->getGeomType());
+ ASSERT_NEAR(0.1666666666666667, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
+
+ delete result;
}
TEST(MeshEditing, Prism2TwoTets)
{
- std::vector<MeshLib::Node*> nodes;
- nodes.push_back(new MeshLib::Node(1,0,0));
- nodes.push_back(new MeshLib::Node(1,1,0));
- nodes.push_back(new MeshLib::Node(0,0,0));
- nodes.push_back(new MeshLib::Node(1,0.9,1));
- nodes.push_back(new MeshLib::Node(1,1,1));
- nodes.push_back(new MeshLib::Node(0,0,1));
-
- std::array<MeshLib::Node*, 6> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5]}};
- std::vector<MeshLib::Element*> elements;
- MeshLib::Element* elem (new MeshLib::Prism(nodes_array));
- elements.push_back(elem);
- MeshLib::Mesh mesh("testmesh", nodes, elements);
-
- MeshLib::MeshRevision rev(mesh);
- MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
-
- ASSERT_EQ(5u, result->getNNodes());
- ASSERT_EQ(2u, result->getNElements());
- ASSERT_EQ(MeshLib::MeshElemType::TETRAHEDRON, result->getElement(1)->getGeomType());
- ASSERT_NEAR(0.1666666666666667, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
- ASSERT_NEAR(0.15, result->getElement(1)->getContent(), std::numeric_limits<double>::epsilon());
-
- delete result;
+ std::vector<MeshLib::Node*> nodes;
+ nodes.push_back(new MeshLib::Node(1,0,0));
+ nodes.push_back(new MeshLib::Node(1,1,0));
+ nodes.push_back(new MeshLib::Node(0,0,0));
+ nodes.push_back(new MeshLib::Node(1,0.9,1));
+ nodes.push_back(new MeshLib::Node(1,1,1));
+ nodes.push_back(new MeshLib::Node(0,0,1));
+
+ std::array<MeshLib::Node*, 6> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5]}};
+ std::vector<MeshLib::Element*> elements;
+ MeshLib::Element* elem (new MeshLib::Prism(nodes_array));
+ elements.push_back(elem);
+ MeshLib::Mesh mesh("testmesh", nodes, elements);
+
+ MeshLib::MeshRevision rev(mesh);
+ MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
+
+ ASSERT_EQ(5u, result->getNNodes());
+ ASSERT_EQ(2u, result->getNElements());
+ ASSERT_EQ(MeshLib::MeshElemType::TETRAHEDRON, result->getElement(1)->getGeomType());
+ ASSERT_NEAR(0.1666666666666667, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
+ ASSERT_NEAR(0.15, result->getElement(1)->getContent(), std::numeric_limits<double>::epsilon());
+
+ delete result;
}
TEST(MeshEditing, Prism2Quad)
{
- std::vector<MeshLib::Node*> nodes;
- nodes.push_back(new MeshLib::Node(1,0.9,0));
- nodes.push_back(new MeshLib::Node(1,1,0));
- nodes.push_back(new MeshLib::Node(0,0,0));
- nodes.push_back(new MeshLib::Node(1,0.9,1));
- nodes.push_back(new MeshLib::Node(1,1,1));
- nodes.push_back(new MeshLib::Node(0,0,1));
-
- std::array<MeshLib::Node*, 6> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5]}};
- std::vector<MeshLib::Element*> elements;
- MeshLib::Element* elem (new MeshLib::Prism(nodes_array));
- elements.push_back(elem);
- MeshLib::Mesh mesh("testmesh", nodes, elements);
-
- MeshLib::MeshRevision rev(mesh);
- MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
-
- ASSERT_EQ(1u, result->getNElements());
- ASSERT_EQ(MeshLib::MeshElemType::QUAD, result->getElement(0)->getGeomType());
- ASSERT_NEAR(1.345362404707371, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
-
- delete result;
+ std::vector<MeshLib::Node*> nodes;
+ nodes.push_back(new MeshLib::Node(1,0.9,0));
+ nodes.push_back(new MeshLib::Node(1,1,0));
+ nodes.push_back(new MeshLib::Node(0,0,0));
+ nodes.push_back(new MeshLib::Node(1,0.9,1));
+ nodes.push_back(new MeshLib::Node(1,1,1));
+ nodes.push_back(new MeshLib::Node(0,0,1));
+
+ std::array<MeshLib::Node*, 6> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5]}};
+ std::vector<MeshLib::Element*> elements;
+ MeshLib::Element* elem (new MeshLib::Prism(nodes_array));
+ elements.push_back(elem);
+ MeshLib::Mesh mesh("testmesh", nodes, elements);
+
+ MeshLib::MeshRevision rev(mesh);
+ MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
+
+ ASSERT_EQ(1u, result->getNElements());
+ ASSERT_EQ(MeshLib::MeshElemType::QUAD, result->getElement(0)->getGeomType());
+ ASSERT_NEAR(1.345362404707371, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
+
+ delete result;
}
TEST(MeshEditing, Prism2Tet)
{
- std::vector<MeshLib::Node*> nodes;
- nodes.push_back(new MeshLib::Node(1,0,0));
- nodes.push_back(new MeshLib::Node(1,1,0));
- nodes.push_back(new MeshLib::Node(0.9,0,0));
- nodes.push_back(new MeshLib::Node(1,0.9,1));
- nodes.push_back(new MeshLib::Node(1,1,1));
- nodes.push_back(new MeshLib::Node(0,0,1));
-
- std::array<MeshLib::Node*, 6> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5]}};
- std::vector<MeshLib::Element*> elements;
- MeshLib::Element* elem (new MeshLib::Prism(nodes_array));
- elements.push_back(elem);
- MeshLib::Mesh mesh("testmesh", nodes, elements);
-
- MeshLib::MeshRevision rev(mesh);
- MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
-
- ASSERT_EQ(1u, result->getNElements());
- ASSERT_EQ(MeshLib::MeshElemType::TETRAHEDRON, result->getElement(0)->getGeomType());
- ASSERT_NEAR(0.1666666666666667, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
-
- delete result;
+ std::vector<MeshLib::Node*> nodes;
+ nodes.push_back(new MeshLib::Node(1,0,0));
+ nodes.push_back(new MeshLib::Node(1,1,0));
+ nodes.push_back(new MeshLib::Node(0.9,0,0));
+ nodes.push_back(new MeshLib::Node(1,0.9,1));
+ nodes.push_back(new MeshLib::Node(1,1,1));
+ nodes.push_back(new MeshLib::Node(0,0,1));
+
+ std::array<MeshLib::Node*, 6> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5]}};
+ std::vector<MeshLib::Element*> elements;
+ MeshLib::Element* elem (new MeshLib::Prism(nodes_array));
+ elements.push_back(elem);
+ MeshLib::Mesh mesh("testmesh", nodes, elements);
+
+ MeshLib::MeshRevision rev(mesh);
+ MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
+
+ ASSERT_EQ(1u, result->getNElements());
+ ASSERT_EQ(MeshLib::MeshElemType::TETRAHEDRON, result->getElement(0)->getGeomType());
+ ASSERT_NEAR(0.1666666666666667, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
+
+ delete result;
}
TEST(MeshEditing, Prism2Tri)
{
- std::vector<MeshLib::Node*> nodes;
- nodes.push_back(new MeshLib::Node(1,0,0));
- nodes.push_back(new MeshLib::Node(1,1,0));
- nodes.push_back(new MeshLib::Node(1,1,0));
- nodes.push_back(new MeshLib::Node(1,1,1));
- nodes.push_back(new MeshLib::Node(1,1,1));
- nodes.push_back(new MeshLib::Node(0.9,0.9,1));
-
- std::array<MeshLib::Node*, 6> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5]}};
- std::vector<MeshLib::Element*> elements;
- MeshLib::Element* elem (new MeshLib::Prism(nodes_array));
- elements.push_back(elem);
- MeshLib::Mesh mesh("testmesh", nodes, elements);
-
- MeshLib::MeshRevision rev(mesh);
- MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
-
- ASSERT_EQ(1u, result->getNElements());
- ASSERT_EQ(MeshLib::MeshElemType::TRIANGLE, result->getElement(0)->getGeomType());
- ASSERT_NEAR(0.5, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
-
- delete result;
+ std::vector<MeshLib::Node*> nodes;
+ nodes.push_back(new MeshLib::Node(1,0,0));
+ nodes.push_back(new MeshLib::Node(1,1,0));
+ nodes.push_back(new MeshLib::Node(1,1,0));
+ nodes.push_back(new MeshLib::Node(1,1,1));
+ nodes.push_back(new MeshLib::Node(1,1,1));
+ nodes.push_back(new MeshLib::Node(0.9,0.9,1));
+
+ std::array<MeshLib::Node*, 6> nodes_array = {{nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5]}};
+ std::vector<MeshLib::Element*> elements;
+ MeshLib::Element* elem (new MeshLib::Prism(nodes_array));
+ elements.push_back(elem);
+ MeshLib::Mesh mesh("testmesh", nodes, elements);
+
+ MeshLib::MeshRevision rev(mesh);
+ MeshLib::Mesh* result = rev.simplifyMesh("new_mesh", 0.2);
+
+ ASSERT_EQ(1u, result->getNElements());
+ ASSERT_EQ(MeshLib::MeshElemType::TRIANGLE, result->getElement(0)->getGeomType());
+ ASSERT_NEAR(0.5, result->getElement(0)->getContent(), std::numeric_limits<double>::epsilon());
+
+ delete result;
}
diff --git a/Tests/MeshLib/TestMeshValidation.cpp b/Tests/MeshLib/TestMeshValidation.cpp
index 5b5b6abf84a0104cc7f1edb83250db2178bf9734..ce94da6e95be40ea92348779176ae233ad567308 100644
--- a/Tests/MeshLib/TestMeshValidation.cpp
+++ b/Tests/MeshLib/TestMeshValidation.cpp
@@ -27,45 +27,45 @@
void
detectHoles(MeshLib::Mesh const& mesh,
- std::vector<std::size_t> erase_elems,
- std::size_t const expected_n_holes)
+ std::vector<std::size_t> erase_elems,
+ std::size_t const expected_n_holes)
{
- std::vector<MeshLib::Node*> nodes = MeshLib::copyNodeVector(mesh.getNodes());
- std::vector<MeshLib::Element*> elems = MeshLib::copyElementVector(mesh.getElements(),nodes);
- for (auto pos : erase_elems)
- {
- delete elems[pos];
- elems.erase(elems.begin()+pos);
- }
- MeshLib::Mesh mesh2("mesh2", nodes, elems);
- ASSERT_EQ(expected_n_holes, MeshLib::MeshValidation::detectHoles(mesh2));
+ std::vector<MeshLib::Node*> nodes = MeshLib::copyNodeVector(mesh.getNodes());
+ std::vector<MeshLib::Element*> elems = MeshLib::copyElementVector(mesh.getElements(),nodes);
+ for (auto pos : erase_elems)
+ {
+ delete elems[pos];
+ elems.erase(elems.begin()+pos);
+ }
+ MeshLib::Mesh mesh2("mesh2", nodes, elems);
+ ASSERT_EQ(expected_n_holes, MeshLib::MeshValidation::detectHoles(mesh2));
};
TEST(MeshValidation, DetectHolesTri)
{
- std::array<double, 12> pix = {{0,0.1,0.2,0.1,0,0,0.1,0,0,0,-0.1,0}};
- GeoLib::RasterHeader const header =
- {4,3,MathLib::Point3d(std::array<double,3>{{0,0,0}}),1,-9999};
- GeoLib::Raster const raster(header ,pix.begin(), pix.end());
- std::unique_ptr<MeshLib::Mesh> mesh (MeshLib::RasterToMesh::convert(
- raster, MeshLib::MeshElemType::TRIANGLE, MeshLib::UseIntensityAs::ELEVATION));
- ASSERT_EQ(0, MeshLib::MeshValidation::detectHoles(*mesh));
+ std::array<double, 12> pix = {{0,0.1,0.2,0.1,0,0,0.1,0,0,0,-0.1,0}};
+ GeoLib::RasterHeader const header =
+ {4,3,MathLib::Point3d(std::array<double,3>{{0,0,0}}),1,-9999};
+ GeoLib::Raster const raster(header ,pix.begin(), pix.end());
+ std::unique_ptr<MeshLib::Mesh> mesh (MeshLib::RasterToMesh::convert(
+ raster, MeshLib::MeshElemType::TRIANGLE, MeshLib::UseIntensityAs::ELEVATION));
+ ASSERT_EQ(0, MeshLib::MeshValidation::detectHoles(*mesh));
- detectHoles(*mesh, {12}, 1);
- detectHoles(*mesh, {11, 11}, 1);
- detectHoles(*mesh, {10, 12}, 2);
+ detectHoles(*mesh, {12}, 1);
+ detectHoles(*mesh, {11, 11}, 1);
+ detectHoles(*mesh, {10, 12}, 2);
}
TEST(MeshValidation, DetectHolesHex)
{
- auto mesh = std::unique_ptr<MeshLib::Mesh>{
- MeshLib::MeshGenerator::generateRegularHexMesh(
- 5,4,4,1.0,1.0,1.0,GeoLib::ORIGIN, "mesh")};
- ASSERT_EQ(0, MeshLib::MeshValidation::detectHoles(*mesh));
+ auto mesh = std::unique_ptr<MeshLib::Mesh>{
+ MeshLib::MeshGenerator::generateRegularHexMesh(
+ 5,4,4,1.0,1.0,1.0,GeoLib::ORIGIN, "mesh")};
+ ASSERT_EQ(0, MeshLib::MeshValidation::detectHoles(*mesh));
- detectHoles(*mesh, {27}, 1);
- detectHoles(*mesh, {28, 27}, 1);
- detectHoles(*mesh, {29, 27}, 1);
+ detectHoles(*mesh, {27}, 1);
+ detectHoles(*mesh, {28, 27}, 1);
+ detectHoles(*mesh, {29, 27}, 1);
}
diff --git a/Tests/MeshLib/TestMoveMeshNodes.cpp b/Tests/MeshLib/TestMoveMeshNodes.cpp
index eacbae3dccc39a55c307dbda84310f36fbf825f1..ace87a909ac74f8d67cccb48de54ad7d025e2244 100644
--- a/Tests/MeshLib/TestMoveMeshNodes.cpp
+++ b/Tests/MeshLib/TestMoveMeshNodes.cpp
@@ -18,46 +18,46 @@
TEST(MeshLib, moveMeshNodes)
{
- /* initialize random seed: */
- srand ( static_cast<unsigned>(time(NULL)) );
-
- std::size_t const size (16384);
-
- std::vector<MeshLib::Node*> nodes, nodes_copy;
- nodes.resize(size);
- nodes_copy.resize(size);
-
- /* put nodes with random coords into vectors */
- for (std::size_t k(0); k<size; k++) {
- nodes[k] = new MeshLib::Node(rand(), rand(), rand());
- nodes_copy[k] = new MeshLib::Node(* nodes[k]);
- }
-
- /* create random displacement */
- MeshLib::Node displacement(rand(), rand(), rand());
-
- /* move the mesh node */
- MeshLib::moveMeshNodes(nodes.begin(), nodes.end(), displacement);
-
- /* reverse the direction of displacement */
- displacement[0] *= -1.0;
- displacement[1] *= -1.0;
- displacement[2] *= -1.0;
-
- /* move the mesh node back */
- MeshLib::moveMeshNodes(nodes.begin(), nodes.end(), displacement);
-
- /* check the result */
- double const eps(std::numeric_limits<double>::epsilon());
- for (std::size_t k(0); k<size; k++) {
- EXPECT_NEAR((*nodes_copy[0])[0], (*nodes[0])[0], eps);
- EXPECT_NEAR((*nodes_copy[0])[1], (*nodes[0])[1], eps);
- EXPECT_NEAR((*nodes_copy[0])[2], (*nodes[0])[2], eps);
- }
-
- for (auto n : nodes)
- delete n;
- for (auto n : nodes_copy)
- delete n;
+ /* initialize random seed: */
+ srand ( static_cast<unsigned>(time(NULL)) );
+
+ std::size_t const size (16384);
+
+ std::vector<MeshLib::Node*> nodes, nodes_copy;
+ nodes.resize(size);
+ nodes_copy.resize(size);
+
+ /* put nodes with random coords into vectors */
+ for (std::size_t k(0); k<size; k++) {
+ nodes[k] = new MeshLib::Node(rand(), rand(), rand());
+ nodes_copy[k] = new MeshLib::Node(* nodes[k]);
+ }
+
+ /* create random displacement */
+ MeshLib::Node displacement(rand(), rand(), rand());
+
+ /* move the mesh node */
+ MeshLib::moveMeshNodes(nodes.begin(), nodes.end(), displacement);
+
+ /* reverse the direction of displacement */
+ displacement[0] *= -1.0;
+ displacement[1] *= -1.0;
+ displacement[2] *= -1.0;
+
+ /* move the mesh node back */
+ MeshLib::moveMeshNodes(nodes.begin(), nodes.end(), displacement);
+
+ /* check the result */
+ double const eps(std::numeric_limits<double>::epsilon());
+ for (std::size_t k(0); k<size; k++) {
+ EXPECT_NEAR((*nodes_copy[0])[0], (*nodes[0])[0], eps);
+ EXPECT_NEAR((*nodes_copy[0])[1], (*nodes[0])[1], eps);
+ EXPECT_NEAR((*nodes_copy[0])[2], (*nodes[0])[2], eps);
+ }
+
+ for (auto n : nodes)
+ delete n;
+ for (auto n : nodes_copy)
+ delete n;
}
diff --git a/Tests/MeshLib/TestNodeSearch.cpp b/Tests/MeshLib/TestNodeSearch.cpp
index d9d8d31aa71a02aa52c8d8b4e7959b10add4a9c9..631f393c6d36ff90f85e0cc642a30df37c2b7b9d 100644
--- a/Tests/MeshLib/TestNodeSearch.cpp
+++ b/Tests/MeshLib/TestNodeSearch.cpp
@@ -21,27 +21,27 @@
TEST(NodeSearch, UnusedNodes)
{
- std::array<double, 12> pix = {{0,0.1,0.2,0.1,0,0,0.1,0,0,0,-0.1,0}};
- GeoLib::RasterHeader const header =
- {4,3,MathLib::Point3d(std::array<double,3>{{0,0,0}}),1,-9999};
- GeoLib::Raster const raster(header,pix.begin(), pix.end());
- MeshLib::Mesh* mesh (MeshLib::RasterToMesh::convert(raster, MeshLib::MeshElemType::TRIANGLE, MeshLib::UseIntensityAs::ELEVATION));
- MeshLib::NodeSearch ns(*mesh);
- ns.searchUnused();
- std::vector<std::size_t> u_nodes = ns.getSearchedNodeIDs();
- ASSERT_EQ(0, u_nodes.size());
-
- std::vector<MeshLib::Node*> nodes = MeshLib::copyNodeVector(mesh->getNodes());
- nodes.push_back(new MeshLib::Node(-1,-1,-1));
- std::vector<MeshLib::Element*> elems = MeshLib::copyElementVector(mesh->getElements(),nodes);
- MeshLib::Mesh mesh2("mesh2", nodes, elems);
- MeshLib::NodeSearch ns2(mesh2);
- ns2.searchUnused();
- u_nodes = ns2.getSearchedNodeIDs();
- ASSERT_EQ(1, u_nodes.size());
- ASSERT_EQ(nodes.back()->getID(), u_nodes[0]);
-
- delete mesh;
+ std::array<double, 12> pix = {{0,0.1,0.2,0.1,0,0,0.1,0,0,0,-0.1,0}};
+ GeoLib::RasterHeader const header =
+ {4,3,MathLib::Point3d(std::array<double,3>{{0,0,0}}),1,-9999};
+ GeoLib::Raster const raster(header,pix.begin(), pix.end());
+ MeshLib::Mesh* mesh (MeshLib::RasterToMesh::convert(raster, MeshLib::MeshElemType::TRIANGLE, MeshLib::UseIntensityAs::ELEVATION));
+ MeshLib::NodeSearch ns(*mesh);
+ ns.searchUnused();
+ std::vector<std::size_t> u_nodes = ns.getSearchedNodeIDs();
+ ASSERT_EQ(0, u_nodes.size());
+
+ std::vector<MeshLib::Node*> nodes = MeshLib::copyNodeVector(mesh->getNodes());
+ nodes.push_back(new MeshLib::Node(-1,-1,-1));
+ std::vector<MeshLib::Element*> elems = MeshLib::copyElementVector(mesh->getElements(),nodes);
+ MeshLib::Mesh mesh2("mesh2", nodes, elems);
+ MeshLib::NodeSearch ns2(mesh2);
+ ns2.searchUnused();
+ u_nodes = ns2.getSearchedNodeIDs();
+ ASSERT_EQ(1, u_nodes.size());
+ ASSERT_EQ(nodes.back()->getID(), u_nodes[0]);
+
+ delete mesh;
}
diff --git a/Tests/MeshLib/TestProjectMeshOnPlane.cpp b/Tests/MeshLib/TestProjectMeshOnPlane.cpp
index b72428d1a87d07ce5b4f195a0237f6c75ff33065..873310180081e72ec412c363659f402ed425ee4d 100644
--- a/Tests/MeshLib/TestProjectMeshOnPlane.cpp
+++ b/Tests/MeshLib/TestProjectMeshOnPlane.cpp
@@ -24,98 +24,98 @@
class ProjectionTest : public ::testing::Test
{
public:
- ProjectionTest()
- : _mesh(nullptr)
- {
- std::size_t const n_nodes (100);
- std::vector<MeshLib::Node*> nodes;
- for (std::size_t i=1; i<=n_nodes; i++)
- nodes.push_back(new MeshLib::Node(static_cast<double>(i), static_cast<double>(i), i*0.5));
+ ProjectionTest()
+ : _mesh(nullptr)
+ {
+ std::size_t const n_nodes (100);
+ std::vector<MeshLib::Node*> nodes;
+ for (std::size_t i=1; i<=n_nodes; i++)
+ nodes.push_back(new MeshLib::Node(static_cast<double>(i), static_cast<double>(i), i*0.5));
- std::vector<MeshLib::Element*> elements;
- for (std::size_t i=0; i<n_nodes-1; i++)
- elements.push_back(new MeshLib::Line(std::array<MeshLib::Node*,2>{{nodes[i], nodes[i+1]}}));
+ std::vector<MeshLib::Element*> elements;
+ for (std::size_t i=0; i<n_nodes-1; i++)
+ elements.push_back(new MeshLib::Line(std::array<MeshLib::Node*,2>{{nodes[i], nodes[i+1]}}));
- _mesh = std::unique_ptr<MeshLib::Mesh>{new MeshLib::Mesh{"TestMesh", nodes, elements}};
- }
+ _mesh = std::unique_ptr<MeshLib::Mesh>{new MeshLib::Mesh{"TestMesh", nodes, elements}};
+ }
protected:
- std::unique_ptr<MeshLib::Mesh> _mesh;
+ std::unique_ptr<MeshLib::Mesh> _mesh;
};
// Project to parallels of XY plane
TEST_F(ProjectionTest, ProjectToXY)
{
- MathLib::Vector3 normal (0,0,1);
- std::size_t const n_nodes (_mesh->getNNodes());
- for (std::size_t p=0; p<10; p++)
- {
- MathLib::Point3d origin (std::array<double,3>{{0,0,static_cast<double>(p)}});
- MeshLib::Mesh* result = MeshLib::projectMeshOntoPlane(*_mesh, origin, normal);
- for (std::size_t i=0; i<n_nodes; i++)
- ASSERT_NEAR(static_cast<double>(p), (*result->getNode(i))[2], std::numeric_limits<double>::epsilon());
- delete result;
- }
+ MathLib::Vector3 normal (0,0,1);
+ std::size_t const n_nodes (_mesh->getNNodes());
+ for (std::size_t p=0; p<10; p++)
+ {
+ MathLib::Point3d origin (std::array<double,3>{{0,0,static_cast<double>(p)}});
+ MeshLib::Mesh* result = MeshLib::projectMeshOntoPlane(*_mesh, origin, normal);
+ for (std::size_t i=0; i<n_nodes; i++)
+ ASSERT_NEAR(static_cast<double>(p), (*result->getNode(i))[2], std::numeric_limits<double>::epsilon());
+ delete result;
+ }
}
// Project to parallels of XZ plane
TEST_F(ProjectionTest, ProjectToXZ)
{
- MathLib::Vector3 normal (0,1,0);
- std::size_t const n_nodes (_mesh->getNNodes());
- for (std::size_t p=0; p<10; p++)
- {
- MathLib::Point3d origin (std::array<double,3>{{0,static_cast<double>(p),0}});
- MeshLib::Mesh* result = MeshLib::projectMeshOntoPlane(*_mesh, origin, normal);
- for (std::size_t i=0; i<n_nodes; i++)
- ASSERT_NEAR(static_cast<double>(p), (*result->getNode(i))[1], std::numeric_limits<double>::epsilon());
- delete result;
- }
+ MathLib::Vector3 normal (0,1,0);
+ std::size_t const n_nodes (_mesh->getNNodes());
+ for (std::size_t p=0; p<10; p++)
+ {
+ MathLib::Point3d origin (std::array<double,3>{{0,static_cast<double>(p),0}});
+ MeshLib::Mesh* result = MeshLib::projectMeshOntoPlane(*_mesh, origin, normal);
+ for (std::size_t i=0; i<n_nodes; i++)
+ ASSERT_NEAR(static_cast<double>(p), (*result->getNode(i))[1], std::numeric_limits<double>::epsilon());
+ delete result;
+ }
}
// Project to parallels of YZ plane
TEST_F(ProjectionTest, ProjectToYZ)
{
- MathLib::Vector3 normal (1,0,0);
- std::size_t const n_nodes (_mesh->getNNodes());
- for (std::size_t p=0; p<10; p++)
- {
- MathLib::Point3d origin (std::array<double,3>{{static_cast<double>(p),0,0}});
- MeshLib::Mesh* result = MeshLib::projectMeshOntoPlane(*_mesh, origin, normal);
- for (std::size_t i=0; i<n_nodes; i++)
- ASSERT_NEAR(static_cast<double>(p), (*result->getNode(i))[0], std::numeric_limits<double>::epsilon());
- delete result;
- }
+ MathLib::Vector3 normal (1,0,0);
+ std::size_t const n_nodes (_mesh->getNNodes());
+ for (std::size_t p=0; p<10; p++)
+ {
+ MathLib::Point3d origin (std::array<double,3>{{static_cast<double>(p),0,0}});
+ MeshLib::Mesh* result = MeshLib::projectMeshOntoPlane(*_mesh, origin, normal);
+ for (std::size_t i=0; i<n_nodes; i++)
+ ASSERT_NEAR(static_cast<double>(p), (*result->getNode(i))[0], std::numeric_limits<double>::epsilon());
+ delete result;
+ }
}
// Sign of normal vector does not matter.
TEST_F(ProjectionTest, NormalDirection)
{
- MathLib::Vector3 normal_p (0,0,1);
- MathLib::Vector3 normal_n (0,0,-1);
- std::size_t const n_nodes (_mesh->getNNodes());
- MathLib::Point3d origin (std::array<double,3>{{0,0,0}});
- MeshLib::Mesh* result_p = MeshLib::projectMeshOntoPlane(*_mesh, origin, normal_p);
- MeshLib::Mesh* result_n = MeshLib::projectMeshOntoPlane(*_mesh, origin, normal_n);
- for (std::size_t i=0; i<n_nodes; i++)
- ASSERT_EQ((*result_p->getNode(i))[2], (*result_n->getNode(i))[2]);
- delete result_p;
- delete result_n;
+ MathLib::Vector3 normal_p (0,0,1);
+ MathLib::Vector3 normal_n (0,0,-1);
+ std::size_t const n_nodes (_mesh->getNNodes());
+ MathLib::Point3d origin (std::array<double,3>{{0,0,0}});
+ MeshLib::Mesh* result_p = MeshLib::projectMeshOntoPlane(*_mesh, origin, normal_p);
+ MeshLib::Mesh* result_n = MeshLib::projectMeshOntoPlane(*_mesh, origin, normal_n);
+ for (std::size_t i=0; i<n_nodes; i++)
+ ASSERT_EQ((*result_p->getNode(i))[2], (*result_n->getNode(i))[2]);
+ delete result_p;
+ delete result_n;
}
// Length of normal does not matter (it's normalised within the method)
TEST_F(ProjectionTest, NormalLength)
{
- MathLib::Point3d origin (std::array<double,3>{{0,0,0}});
- MathLib::Vector3 normal (0,0,1);
- std::size_t const n_nodes (_mesh->getNNodes());
- MeshLib::Mesh* result = MeshLib::projectMeshOntoPlane(*_mesh, origin, normal);
- for (std::size_t p=2; p<10; p++)
- {
- normal[2] = static_cast<double>(p);
- MeshLib::Mesh* result_p = MeshLib::projectMeshOntoPlane(*_mesh, origin, normal);
- for (std::size_t i=0; i<n_nodes; i++)
- ASSERT_EQ((*result->getNode(i))[2], (*result_p->getNode(i))[2]);
- delete result_p;
- }
- delete result;
+ MathLib::Point3d origin (std::array<double,3>{{0,0,0}});
+ MathLib::Vector3 normal (0,0,1);
+ std::size_t const n_nodes (_mesh->getNNodes());
+ MeshLib::Mesh* result = MeshLib::projectMeshOntoPlane(*_mesh, origin, normal);
+ for (std::size_t p=2; p<10; p++)
+ {
+ normal[2] = static_cast<double>(p);
+ MeshLib::Mesh* result_p = MeshLib::projectMeshOntoPlane(*_mesh, origin, normal);
+ for (std::size_t i=0; i<n_nodes; i++)
+ ASSERT_EQ((*result->getNode(i))[2], (*result_p->getNode(i))[2]);
+ delete result_p;
+ }
+ delete result;
}
diff --git a/Tests/MeshLib/TestRemove.cpp b/Tests/MeshLib/TestRemove.cpp
index b2513e060d8b99263226f6a7034c5cdd562836b5..8b15b1a98ac5e2c580140014c97d65ad14f40983 100644
--- a/Tests/MeshLib/TestRemove.cpp
+++ b/Tests/MeshLib/TestRemove.cpp
@@ -26,38 +26,38 @@
TEST(MeshLib, RemoveNodes)
{
- auto mesh = std::unique_ptr<MeshLib::Mesh>{
- MeshLib::MeshGenerator::generateLineMesh(1.0, 9)};
+ auto mesh = std::unique_ptr<MeshLib::Mesh>{
+ MeshLib::MeshGenerator::generateLineMesh(1.0, 9)};
- std::vector<std::size_t> removed_node_ids;
- for (std::size_t i=0; i<5; i++)
- removed_node_ids.push_back(i);
+ std::vector<std::size_t> removed_node_ids;
+ for (std::size_t i=0; i<5; i++)
+ removed_node_ids.push_back(i);
- auto new_mesh = std::unique_ptr<MeshLib::Mesh>{
- MeshLib::removeNodes(*mesh, removed_node_ids, "")};
+ auto new_mesh = std::unique_ptr<MeshLib::Mesh>{
+ MeshLib::removeNodes(*mesh, removed_node_ids, "")};
- ASSERT_EQ(5u, new_mesh->getNNodes());
- ASSERT_EQ(5u, new_mesh->getNBaseNodes());
- ASSERT_EQ(4u, new_mesh->getNElements());
- for (std::size_t i=0; i<new_mesh->getNNodes(); i++)
- ASSERT_TRUE(*mesh->getNode(5+i) == *new_mesh->getNode(i));
+ ASSERT_EQ(5u, new_mesh->getNNodes());
+ ASSERT_EQ(5u, new_mesh->getNBaseNodes());
+ ASSERT_EQ(4u, new_mesh->getNElements());
+ for (std::size_t i=0; i<new_mesh->getNNodes(); i++)
+ ASSERT_TRUE(*mesh->getNode(5+i) == *new_mesh->getNode(i));
}
TEST(MeshLib, RemoveElements)
{
- auto mesh = std::unique_ptr<MeshLib::Mesh>{
- MeshLib::MeshGenerator::generateLineMesh(1.0, 9)};
+ auto mesh = std::unique_ptr<MeshLib::Mesh>{
+ MeshLib::MeshGenerator::generateLineMesh(1.0, 9)};
- std::vector<std::size_t> removed_ele_ids;
- for (std::size_t i=0; i<5; i++)
- removed_ele_ids.push_back(i);
+ std::vector<std::size_t> removed_ele_ids;
+ for (std::size_t i=0; i<5; i++)
+ removed_ele_ids.push_back(i);
- auto new_mesh = std::unique_ptr<MeshLib::Mesh>{
- MeshLib::removeElements(*mesh, removed_ele_ids, "")};
+ auto new_mesh = std::unique_ptr<MeshLib::Mesh>{
+ MeshLib::removeElements(*mesh, removed_ele_ids, "")};
- ASSERT_EQ(5u, new_mesh->getNNodes());
- ASSERT_EQ(5u, new_mesh->getNBaseNodes());
- ASSERT_EQ(4u, new_mesh->getNElements());
- for (std::size_t i=0; i<new_mesh->getNNodes(); i++)
- ASSERT_TRUE(*mesh->getNode(5+i) == *new_mesh->getNode(i));
+ ASSERT_EQ(5u, new_mesh->getNNodes());
+ ASSERT_EQ(5u, new_mesh->getNBaseNodes());
+ ASSERT_EQ(4u, new_mesh->getNElements());
+ for (std::size_t i=0; i<new_mesh->getNNodes(); i++)
+ ASSERT_TRUE(*mesh->getNode(5+i) == *new_mesh->getNode(i));
}
diff --git a/Tests/MeshLib/TestUniqueMeshId.cpp b/Tests/MeshLib/TestUniqueMeshId.cpp
index 4a55f9036a4b6e8f7d24f07157e8a49254ecde9b..96fd77bde6be073f24e3d1b63e772dce89255450 100644
--- a/Tests/MeshLib/TestUniqueMeshId.cpp
+++ b/Tests/MeshLib/TestUniqueMeshId.cpp
@@ -14,30 +14,30 @@ using namespace MeshLib;
TEST(MeshLib, UniqueMeshId)
{
- // Create first mesh and get the current counter value.
- Mesh m0("first", std::vector<Node*>(), std::vector<Element*>());
- std::size_t const counter_value = m0.getID();
+ // Create first mesh and get the current counter value.
+ Mesh m0("first", std::vector<Node*>(), std::vector<Element*>());
+ std::size_t const counter_value = m0.getID();
- EXPECT_GE(counter_value, 0u);
+ EXPECT_GE(counter_value, 0u);
- //
- // Test mesh counter increments.
- //
- Mesh* m1 = new Mesh("second", std::vector<Node*>(), std::vector<Element*>());
- ASSERT_EQ(counter_value + std::size_t(1), m1->getID());
+ //
+ // Test mesh counter increments.
+ //
+ Mesh* m1 = new Mesh("second", std::vector<Node*>(), std::vector<Element*>());
+ ASSERT_EQ(counter_value + std::size_t(1), m1->getID());
- Mesh m2("third", std::vector<Node*>(), std::vector<Element*>());
- ASSERT_EQ(counter_value + std::size_t(2), m2.getID());
+ Mesh m2("third", std::vector<Node*>(), std::vector<Element*>());
+ ASSERT_EQ(counter_value + std::size_t(2), m2.getID());
- delete m1;
- ASSERT_EQ(counter_value + std::size_t(2), m2.getID());
+ delete m1;
+ ASSERT_EQ(counter_value + std::size_t(2), m2.getID());
- Mesh m3("fourth", std::vector<Node*>(), std::vector<Element*>());
- ASSERT_EQ(counter_value + std::size_t(3), m3.getID());
+ Mesh m3("fourth", std::vector<Node*>(), std::vector<Element*>());
+ ASSERT_EQ(counter_value + std::size_t(3), m3.getID());
- // Copy mesh keeps also increments the counter.
- Mesh m4(m0);
- ASSERT_EQ(counter_value + std::size_t(4), m4.getID());
+ // Copy mesh keeps also increments the counter.
+ Mesh m4(m0);
+ ASSERT_EQ(counter_value + std::size_t(4), m4.getID());
}
diff --git a/Tests/MeshLib/TestVtkMeshConverter.cpp b/Tests/MeshLib/TestVtkMeshConverter.cpp
index 94b5c1ac820e8dc60df52a052f5cd56ffb874f6d..0629b473c10336c9405677fb27e8c05a2f605b8c 100644
--- a/Tests/MeshLib/TestVtkMeshConverter.cpp
+++ b/Tests/MeshLib/TestVtkMeshConverter.cpp
@@ -1,9 +1,9 @@
/**
* \copyright
* Copyright (c) 2012-2016, OpenGeoSys Community (http://www.opengeosys.org)
- * Distributed under a Modified BSD License.
- * See accompanying file LICENSE.txt or
- * http://www.opengeosys.org/LICENSE.txt
+ * Distributed under a Modified BSD License.
+ * See accompanying file LICENSE.txt or
+ * http://www.opengeosys.org/LICENSE.txt
*/
#include <memory>
@@ -27,85 +27,85 @@
class TestVtkMeshConverter : public ::testing::Test
{
public:
- TestVtkMeshConverter()
- : vtu(nullptr)
- {
- // Points and cells
- auto points = vtkSmartPointer<vtkPoints>::New();
- points->InsertNextPoint(703.875, 758.75, 0.9971);
- points->InsertNextPoint(767.625, 679.5, 6.2356);
- points->InsertNextPoint(835.25, 602.50, 11.2227);
- points->InsertNextPoint(608.75, 629.375, 10.3723);
- points->InsertNextPoint(672, 549.375, 17.4011);
- points->InsertNextPoint(739.75, 472.5, 20.9258);
- points->InsertNextPoint(703.875, 758.75, 101.07145);
- points->InsertNextPoint(767.625, 679.5, 106.2616);
- points->InsertNextPoint(835.25, 602.5, 111.2233);
- points->InsertNextPoint(608.75, 629.375, 110.4138);
- points->InsertNextPoint(672, 549.375, 117.4165);
- points->InsertNextPoint(739.75, 472.5, 120.92995);
+ TestVtkMeshConverter()
+ : vtu(nullptr)
+ {
+ // Points and cells
+ auto points = vtkSmartPointer<vtkPoints>::New();
+ points->InsertNextPoint(703.875, 758.75, 0.9971);
+ points->InsertNextPoint(767.625, 679.5, 6.2356);
+ points->InsertNextPoint(835.25, 602.50, 11.2227);
+ points->InsertNextPoint(608.75, 629.375, 10.3723);
+ points->InsertNextPoint(672, 549.375, 17.4011);
+ points->InsertNextPoint(739.75, 472.5, 20.9258);
+ points->InsertNextPoint(703.875, 758.75, 101.07145);
+ points->InsertNextPoint(767.625, 679.5, 106.2616);
+ points->InsertNextPoint(835.25, 602.5, 111.2233);
+ points->InsertNextPoint(608.75, 629.375, 110.4138);
+ points->InsertNextPoint(672, 549.375, 117.4165);
+ points->InsertNextPoint(739.75, 472.5, 120.92995);
- auto cells = vtkSmartPointer<vtkCellArray>::New();
- auto cell1 = vtkSmartPointer<vtkIdList>::New();
- cell1->InsertNextId(4);
- cell1->InsertNextId(1);
- cell1->InsertNextId(0);
- cell1->InsertNextId(3);
- cell1->InsertNextId(10);
- cell1->InsertNextId(7);
- cell1->InsertNextId(6);
- cell1->InsertNextId(9);
- auto cell2 = vtkSmartPointer<vtkIdList>::New();
- cell2->InsertNextId(5);
- cell2->InsertNextId(2);
- cell2->InsertNextId(1);
- cell2->InsertNextId(4);
- cell2->InsertNextId(11);
- cell2->InsertNextId(8);
- cell2->InsertNextId(7);
- cell2->InsertNextId(10);
- cells->InsertNextCell(cell1);
- cells->InsertNextCell(cell2);
+ auto cells = vtkSmartPointer<vtkCellArray>::New();
+ auto cell1 = vtkSmartPointer<vtkIdList>::New();
+ cell1->InsertNextId(4);
+ cell1->InsertNextId(1);
+ cell1->InsertNextId(0);
+ cell1->InsertNextId(3);
+ cell1->InsertNextId(10);
+ cell1->InsertNextId(7);
+ cell1->InsertNextId(6);
+ cell1->InsertNextId(9);
+ auto cell2 = vtkSmartPointer<vtkIdList>::New();
+ cell2->InsertNextId(5);
+ cell2->InsertNextId(2);
+ cell2->InsertNextId(1);
+ cell2->InsertNextId(4);
+ cell2->InsertNextId(11);
+ cell2->InsertNextId(8);
+ cell2->InsertNextId(7);
+ cell2->InsertNextId(10);
+ cells->InsertNextCell(cell1);
+ cells->InsertNextCell(cell2);
- vtu = vtkSmartPointer<vtkUnstructuredGrid>::New();
- vtu->SetPoints(points);
- vtu->SetCells(12, cells);
+ vtu = vtkSmartPointer<vtkUnstructuredGrid>::New();
+ vtu->SetPoints(points);
+ vtu->SetCells(12, cells);
- // Data arrays
- auto pointIds = vtkSmartPointer<vtkIntArray>::New();
- pointIds->SetNumberOfComponents(1);
- pointIds->SetName("PointIDs");
- for (int i = 0; i < 12; ++i)
- pointIds->InsertNextTuple1(i);
- vtu->GetPointData()->AddArray(pointIds);
+ // Data arrays
+ auto pointIds = vtkSmartPointer<vtkIntArray>::New();
+ pointIds->SetNumberOfComponents(1);
+ pointIds->SetName("PointIDs");
+ for (int i = 0; i < 12; ++i)
+ pointIds->InsertNextTuple1(i);
+ vtu->GetPointData()->AddArray(pointIds);
- auto materialIds = vtkSmartPointer<vtkUnsignedIntArray>::New();
- materialIds->SetNumberOfComponents(1);
- materialIds->SetName("MaterialIDs");
- materialIds->InsertNextTuple1(0);
- materialIds->InsertNextTuple1(1);
- vtu->GetCellData()->AddArray(materialIds);
- }
+ auto materialIds = vtkSmartPointer<vtkUnsignedIntArray>::New();
+ materialIds->SetNumberOfComponents(1);
+ materialIds->SetName("MaterialIDs");
+ materialIds->InsertNextTuple1(0);
+ materialIds->InsertNextTuple1(1);
+ vtu->GetCellData()->AddArray(materialIds);
+ }
- static std::size_t const mesh_size = 5;
- vtkSmartPointer<vtkUnstructuredGrid> vtu;
+ static std::size_t const mesh_size = 5;
+ vtkSmartPointer<vtkUnstructuredGrid> vtu;
};
TEST_F(TestVtkMeshConverter, Conversion)
{
- auto mesh = std::unique_ptr<MeshLib::Mesh>(
- MeshLib::VtkMeshConverter::convertUnstructuredGrid(vtu));
- ASSERT_EQ(mesh->getNNodes(), vtu->GetNumberOfPoints());
- ASSERT_EQ(mesh->getNElements(), vtu->GetNumberOfCells());
- ASSERT_EQ(mesh->getElement(0)->getCellType(), MeshLib::CellType::HEX8);
+ auto mesh = std::unique_ptr<MeshLib::Mesh>(
+ MeshLib::VtkMeshConverter::convertUnstructuredGrid(vtu));
+ ASSERT_EQ(mesh->getNNodes(), vtu->GetNumberOfPoints());
+ ASSERT_EQ(mesh->getNElements(), vtu->GetNumberOfCells());
+ ASSERT_EQ(mesh->getElement(0)->getCellType(), MeshLib::CellType::HEX8);
- auto meshProperties = mesh->getProperties();
+ auto meshProperties = mesh->getProperties();
- // MaterialIDs are converted to an int property
- auto materialIds = meshProperties.getPropertyVector<int>("MaterialIDs");
- ASSERT_TRUE(static_cast<bool>(materialIds));
- auto vtkMaterialIds = vtu->GetCellData()->GetArray("MaterialIDs");
- ASSERT_EQ((*materialIds).size(), vtkMaterialIds->GetNumberOfTuples());
- for(std::size_t i = 0; i < (*materialIds).size(); i++)
- ASSERT_EQ((*materialIds)[i], vtkMaterialIds->GetTuple1(i));
+ // MaterialIDs are converted to an int property
+ auto materialIds = meshProperties.getPropertyVector<int>("MaterialIDs");
+ ASSERT_TRUE(static_cast<bool>(materialIds));
+ auto vtkMaterialIds = vtu->GetCellData()->GetArray("MaterialIDs");
+ ASSERT_EQ((*materialIds).size(), vtkMaterialIds->GetNumberOfTuples());
+ for(std::size_t i = 0; i < (*materialIds).size(); i++)
+ ASSERT_EQ((*materialIds)[i], vtkMaterialIds->GetTuple1(i));
}
diff --git a/Tests/NumLib/TestCoordinatesMapping.cpp b/Tests/NumLib/TestCoordinatesMapping.cpp
index 8f5ee23fc01a3dddcc36798b406505b1a6cb376a..10834d39e887513bb53dd148dfbd0e06631e6cf9 100644
--- a/Tests/NumLib/TestCoordinatesMapping.cpp
+++ b/Tests/NumLib/TestCoordinatesMapping.cpp
@@ -283,35 +283,35 @@ TYPED_TEST(NumLibFemNaturalCoordinatesMappingTest, CheckZeroVolume)
TEST(NumLib, FemNaturalCoordinatesMappingLineY)
{
#ifdef OGS_USE_EIGEN
- typedef Eigen::Matrix<double, 2, 1> NodalVector;
- typedef Eigen::Matrix<double, 1, 2, Eigen::RowMajor> DimNodalMatrix;
- typedef Eigen::Matrix<double, 1, 1, Eigen::RowMajor> DimMatrix;
- typedef Eigen::Matrix<double, 2, 2, Eigen::RowMajor> GlobalDimNodalMatrix;
+ typedef Eigen::Matrix<double, 2, 1> NodalVector;
+ typedef Eigen::Matrix<double, 1, 2, Eigen::RowMajor> DimNodalMatrix;
+ typedef Eigen::Matrix<double, 1, 1, Eigen::RowMajor> DimMatrix;
+ typedef Eigen::Matrix<double, 2, 2, Eigen::RowMajor> GlobalDimNodalMatrix;
#endif
- // Shape data type
- typedef ShapeMatrices<NodalVector,DimNodalMatrix,DimMatrix,GlobalDimNodalMatrix> ShapeMatricesType;
- typedef NaturalCoordinatesMapping<MeshLib::Line, ShapeLine2, ShapeMatricesType> MappingType;
- double r[] = {0.5};
- auto line = TestLine2::createY();
- static const unsigned dim = 1;
- static const unsigned e_nnodes = 2;
- ShapeMatricesType shape(dim, 2, e_nnodes);
- MappingType::computeShapeMatrices(*line, r, shape);
-
- double exp_J[dim*dim]= {0.0};
- for (unsigned i=0; i<dim; i++)
- exp_J[i+dim*i] = 1.0;
-
- const double eps(std::numeric_limits<double>::epsilon());
- ASSERT_ARRAY_NEAR(TestLine2::nat_exp_N, shape.N.data(), shape.N.size(), eps);
- ASSERT_ARRAY_NEAR(TestLine2::nat_exp_dNdr, shape.dNdr.data(), shape.dNdr.size(), eps);
- ASSERT_ARRAY_NEAR(exp_J, shape.J.data(), shape.J.size(), eps);
- ASSERT_ARRAY_NEAR(exp_J, shape.invJ.data(), shape.invJ.size(), eps);
- ASSERT_NEAR(1.0, shape.detJ, eps);
- double exp_dNdx[2*e_nnodes] = {0, 0, -0.5, 0.5};
- ASSERT_ARRAY_NEAR(exp_dNdx, shape.dNdx.data(), shape.dNdx.size(), eps);
-
- for (auto n = 0u; n < line->getNNodes(); ++n)
- delete line->getNode(n);
- delete line;
+ // Shape data type
+ typedef ShapeMatrices<NodalVector,DimNodalMatrix,DimMatrix,GlobalDimNodalMatrix> ShapeMatricesType;
+ typedef NaturalCoordinatesMapping<MeshLib::Line, ShapeLine2, ShapeMatricesType> MappingType;
+ double r[] = {0.5};
+ auto line = TestLine2::createY();
+ static const unsigned dim = 1;
+ static const unsigned e_nnodes = 2;
+ ShapeMatricesType shape(dim, 2, e_nnodes);
+ MappingType::computeShapeMatrices(*line, r, shape);
+
+ double exp_J[dim*dim]= {0.0};
+ for (unsigned i=0; i<dim; i++)
+ exp_J[i+dim*i] = 1.0;
+
+ const double eps(std::numeric_limits<double>::epsilon());
+ ASSERT_ARRAY_NEAR(TestLine2::nat_exp_N, shape.N.data(), shape.N.size(), eps);
+ ASSERT_ARRAY_NEAR(TestLine2::nat_exp_dNdr, shape.dNdr.data(), shape.dNdr.size(), eps);
+ ASSERT_ARRAY_NEAR(exp_J, shape.J.data(), shape.J.size(), eps);
+ ASSERT_ARRAY_NEAR(exp_J, shape.invJ.data(), shape.invJ.size(), eps);
+ ASSERT_NEAR(1.0, shape.detJ, eps);
+ double exp_dNdx[2*e_nnodes] = {0, 0, -0.5, 0.5};
+ ASSERT_ARRAY_NEAR(exp_dNdx, shape.dNdx.data(), shape.dNdx.size(), eps);
+
+ for (auto n = 0u; n < line->getNNodes(); ++n)
+ delete line->getNode(n);
+ delete line;
}
diff --git a/Tests/NumLib/TestDistribution.cpp b/Tests/NumLib/TestDistribution.cpp
index 72030c01b0c6b9f93c9b5d3b23f7562563c74af6..85ec29bfb6d5cf951e109a6d9d4ae91a28928755 100644
--- a/Tests/NumLib/TestDistribution.cpp
+++ b/Tests/NumLib/TestDistribution.cpp
@@ -29,207 +29,207 @@
class NumLibDistributionQuad : public testing::Test
{
public:
- NumLibDistributionQuad() :
- _geometric_size(10.0), _number_of_subdivisions_per_direction(10),
- _msh(MeshLib::MeshGenerator::generateRegularQuadMesh(_geometric_size, _number_of_subdivisions_per_direction)),
- _project_name("test"),
- _mshNodesSearcher(*_msh,MeshGeoToolsLib::SearchLength()),
- _ply0(nullptr)
- {
- // create geometry
- auto pnts = std::unique_ptr<std::vector<GeoLib::Point*>>(
- new std::vector<GeoLib::Point*>);
- 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));
-
- auto plys = std::unique_ptr<std::vector<GeoLib::Polyline*>>(
- new std::vector<GeoLib::Polyline*>);
- _ply0 = new GeoLib::Polyline(*pnts);
- _ply0->addPoint(0);
- _ply0->addPoint(1);
- plys->push_back(_ply0);
-
- GeoLib::Polyline* ply1 = new GeoLib::Polyline(*pnts);
- ply1->addPoint(0);
- ply1->addPoint(1);
- ply1->addPoint(2);
- ply1->addPoint(3);
- ply1->addPoint(0);
- plys->push_back(ply1);
-
- auto sfcs = std::unique_ptr<std::vector<GeoLib::Surface*>>(
- new std::vector<GeoLib::Surface*>);
- _sfc1 = GeoLib::Surface::createSurface(*ply1);
- sfcs->push_back(_sfc1);
-
- _geo_objs.addPointVec(std::move(pnts), _project_name);
- _geo_objs.addPolylineVec(std::move(plys), _project_name);
- _geo_objs.addSurfaceVec(std::move(sfcs), _project_name);
- }
+ NumLibDistributionQuad() :
+ _geometric_size(10.0), _number_of_subdivisions_per_direction(10),
+ _msh(MeshLib::MeshGenerator::generateRegularQuadMesh(_geometric_size, _number_of_subdivisions_per_direction)),
+ _project_name("test"),
+ _mshNodesSearcher(*_msh,MeshGeoToolsLib::SearchLength()),
+ _ply0(nullptr)
+ {
+ // create geometry
+ auto pnts = std::unique_ptr<std::vector<GeoLib::Point*>>(
+ new std::vector<GeoLib::Point*>);
+ 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));
+
+ auto plys = std::unique_ptr<std::vector<GeoLib::Polyline*>>(
+ new std::vector<GeoLib::Polyline*>);
+ _ply0 = new GeoLib::Polyline(*pnts);
+ _ply0->addPoint(0);
+ _ply0->addPoint(1);
+ plys->push_back(_ply0);
+
+ GeoLib::Polyline* ply1 = new GeoLib::Polyline(*pnts);
+ ply1->addPoint(0);
+ ply1->addPoint(1);
+ ply1->addPoint(2);
+ ply1->addPoint(3);
+ ply1->addPoint(0);
+ plys->push_back(ply1);
+
+ auto sfcs = std::unique_ptr<std::vector<GeoLib::Surface*>>(
+ new std::vector<GeoLib::Surface*>);
+ _sfc1 = GeoLib::Surface::createSurface(*ply1);
+ sfcs->push_back(_sfc1);
+
+ _geo_objs.addPointVec(std::move(pnts), _project_name);
+ _geo_objs.addPolylineVec(std::move(plys), _project_name);
+ _geo_objs.addSurfaceVec(std::move(sfcs), _project_name);
+ }
protected:
- const double _geometric_size;
- const std::size_t _number_of_subdivisions_per_direction;
- std::unique_ptr<MeshLib::Mesh> _msh;
- GeoLib::GEOObjects _geo_objs;
- std::string _project_name;
- MeshGeoToolsLib::MeshNodeSearcher _mshNodesSearcher;
- GeoLib::Polyline* _ply0;
- GeoLib::Surface* _sfc1;
+ const double _geometric_size;
+ const std::size_t _number_of_subdivisions_per_direction;
+ std::unique_ptr<MeshLib::Mesh> _msh;
+ GeoLib::GEOObjects _geo_objs;
+ std::string _project_name;
+ MeshGeoToolsLib::MeshNodeSearcher _mshNodesSearcher;
+ GeoLib::Polyline* _ply0;
+ GeoLib::Surface* _sfc1;
};
class NumLibDistributionHex : public testing::Test
{
public:
- NumLibDistributionHex() :
- _geometric_size(10.0), _number_of_subdivisions_per_direction(10),
- _msh(MeshLib::MeshGenerator::generateRegularHexMesh(_geometric_size, _number_of_subdivisions_per_direction)),
- _project_name("test"),
- _mshNodesSearcher(*_msh,MeshGeoToolsLib::SearchLength()),
- _ply0(nullptr)
- {
- // create geometry
- auto pnts = std::unique_ptr<std::vector<GeoLib::Point*>>(
- new std::vector<GeoLib::Point*>);
- 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));
-
- auto plys = std::unique_ptr<std::vector<GeoLib::Polyline*>>(
- new std::vector<GeoLib::Polyline*>);
- _ply0 = new GeoLib::Polyline(*pnts); // vertical polyline
- _ply0->addPoint(0);
- _ply0->addPoint(4);
- plys->push_back(_ply0);
- GeoLib::Polyline* ply1 = new GeoLib::Polyline(*pnts); // polygon for left surface
- ply1->addPoint(0);
- ply1->addPoint(3);
- ply1->addPoint(7);
- ply1->addPoint(4);
- ply1->addPoint(0);
- plys->push_back(ply1);
-
- auto sfcs = std::unique_ptr<std::vector<GeoLib::Surface*>>(
- new std::vector<GeoLib::Surface*>);
- _sfc1 = GeoLib::Surface::createSurface(*ply1);
- sfcs->push_back(_sfc1);
-
- _geo_objs.addPointVec(std::move(pnts) ,_project_name);
- _geo_objs.addPolylineVec(std::move(plys), _project_name);
- _geo_objs.addSurfaceVec(std::move(sfcs), _project_name);
- }
+ NumLibDistributionHex() :
+ _geometric_size(10.0), _number_of_subdivisions_per_direction(10),
+ _msh(MeshLib::MeshGenerator::generateRegularHexMesh(_geometric_size, _number_of_subdivisions_per_direction)),
+ _project_name("test"),
+ _mshNodesSearcher(*_msh,MeshGeoToolsLib::SearchLength()),
+ _ply0(nullptr)
+ {
+ // create geometry
+ auto pnts = std::unique_ptr<std::vector<GeoLib::Point*>>(
+ new std::vector<GeoLib::Point*>);
+ 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));
+
+ auto plys = std::unique_ptr<std::vector<GeoLib::Polyline*>>(
+ new std::vector<GeoLib::Polyline*>);
+ _ply0 = new GeoLib::Polyline(*pnts); // vertical polyline
+ _ply0->addPoint(0);
+ _ply0->addPoint(4);
+ plys->push_back(_ply0);
+ GeoLib::Polyline* ply1 = new GeoLib::Polyline(*pnts); // polygon for left surface
+ ply1->addPoint(0);
+ ply1->addPoint(3);
+ ply1->addPoint(7);
+ ply1->addPoint(4);
+ ply1->addPoint(0);
+ plys->push_back(ply1);
+
+ auto sfcs = std::unique_ptr<std::vector<GeoLib::Surface*>>(
+ new std::vector<GeoLib::Surface*>);
+ _sfc1 = GeoLib::Surface::createSurface(*ply1);
+ sfcs->push_back(_sfc1);
+
+ _geo_objs.addPointVec(std::move(pnts) ,_project_name);
+ _geo_objs.addPolylineVec(std::move(plys), _project_name);
+ _geo_objs.addSurfaceVec(std::move(sfcs), _project_name);
+ }
protected:
- const double _geometric_size;
- const std::size_t _number_of_subdivisions_per_direction;
- std::unique_ptr<MeshLib::Mesh> _msh;
- GeoLib::GEOObjects _geo_objs;
- std::string _project_name;
- MeshGeoToolsLib::MeshNodeSearcher _mshNodesSearcher;
- GeoLib::Polyline* _ply0;
- GeoLib::Surface* _sfc1;
+ const double _geometric_size;
+ const std::size_t _number_of_subdivisions_per_direction;
+ std::unique_ptr<MeshLib::Mesh> _msh;
+ GeoLib::GEOObjects _geo_objs;
+ std::string _project_name;
+ MeshGeoToolsLib::MeshNodeSearcher _mshNodesSearcher;
+ GeoLib::Polyline* _ply0;
+ GeoLib::Surface* _sfc1;
};
TEST_F(NumLibDistributionQuad, Linear)
{
- // f(x,y,z) = 1 + 2x + 3y + 4z
- std::array<double,4> f_coeff = {{1, 2, 3, 4}};
- MathLib::LinearFunction<double,3> linear_f(f_coeff);
- std::vector<double> expected = {{1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21}};
-
- NumLib::SpatialFunctionLinear f(linear_f);
- const std::vector<std::size_t>& vec_node_ids = _mshNodesSearcher.getMeshNodesAlongPolyline(*_ply0).getNodeIDs();
- std::vector<double> interpolated_values = NumLib::generateNodeValueDistribution(f, *_msh, vec_node_ids);
- ASSERT_ARRAY_NEAR(expected, interpolated_values, expected.size(), std::numeric_limits<double>::epsilon());
+ // f(x,y,z) = 1 + 2x + 3y + 4z
+ std::array<double,4> f_coeff = {{1, 2, 3, 4}};
+ MathLib::LinearFunction<double,3> linear_f(f_coeff);
+ std::vector<double> expected = {{1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21}};
+
+ NumLib::SpatialFunctionLinear f(linear_f);
+ const std::vector<std::size_t>& vec_node_ids = _mshNodesSearcher.getMeshNodesAlongPolyline(*_ply0).getNodeIDs();
+ std::vector<double> interpolated_values = NumLib::generateNodeValueDistribution(f, *_msh, vec_node_ids);
+ ASSERT_ARRAY_NEAR(expected, interpolated_values, expected.size(), std::numeric_limits<double>::epsilon());
}
TEST_F(NumLibDistributionHex, Linear)
{
- // f(x,y,z) = 1 + 2x + 3y + 4z
- std::array<double,4> f_coeff = {{1, 2, 3, 4}};
- MathLib::LinearFunction<double,3> linear_f(f_coeff);
- std::vector<double> expected(static_cast<std::size_t>(std::pow(_number_of_subdivisions_per_direction+1, 2)));
- const double dL = _geometric_size / _number_of_subdivisions_per_direction;
- for (std::size_t i=0; i<expected.size(); i++) {
- double x = 0;
- double y = (i%(_number_of_subdivisions_per_direction+1)) * dL;
- double z = (i/(_number_of_subdivisions_per_direction+1)) * dL;
- expected[i] = f_coeff[0] + f_coeff[1]*x + f_coeff[2]*y + f_coeff[3]*z;
- }
-
- NumLib::SpatialFunctionLinear f(linear_f);
- const std::vector<std::size_t>& vec_node_ids = _mshNodesSearcher.getMeshNodesAlongSurface(*_sfc1).getNodeIDs();
- std::vector<double> interpolated_values = NumLib::generateNodeValueDistribution(f, *_msh, vec_node_ids);
-
- ASSERT_ARRAY_NEAR(expected, interpolated_values, expected.size(), std::numeric_limits<double>::epsilon());
+ // f(x,y,z) = 1 + 2x + 3y + 4z
+ std::array<double,4> f_coeff = {{1, 2, 3, 4}};
+ MathLib::LinearFunction<double,3> linear_f(f_coeff);
+ std::vector<double> expected(static_cast<std::size_t>(std::pow(_number_of_subdivisions_per_direction+1, 2)));
+ const double dL = _geometric_size / _number_of_subdivisions_per_direction;
+ for (std::size_t i=0; i<expected.size(); i++) {
+ double x = 0;
+ double y = (i%(_number_of_subdivisions_per_direction+1)) * dL;
+ double z = (i/(_number_of_subdivisions_per_direction+1)) * dL;
+ expected[i] = f_coeff[0] + f_coeff[1]*x + f_coeff[2]*y + f_coeff[3]*z;
+ }
+
+ NumLib::SpatialFunctionLinear f(linear_f);
+ const std::vector<std::size_t>& vec_node_ids = _mshNodesSearcher.getMeshNodesAlongSurface(*_sfc1).getNodeIDs();
+ std::vector<double> interpolated_values = NumLib::generateNodeValueDistribution(f, *_msh, vec_node_ids);
+
+ ASSERT_ARRAY_NEAR(expected, interpolated_values, expected.size(), std::numeric_limits<double>::epsilon());
}
TEST_F(NumLibDistributionQuad, InterpolationPolyline)
{
- const std::vector<std::size_t> vec_point_ids = {{0, 1}};
- const std::vector<double> vec_point_values = {{0., 100.}};
- std::vector<double> expected = {{0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100}};
+ const std::vector<std::size_t> vec_point_ids = {{0, 1}};
+ const std::vector<double> vec_point_values = {{0., 100.}};
+ std::vector<double> expected = {{0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100}};
- NumLib::LinearInterpolationAlongPolyline interpolate(
- *_ply0, vec_point_ids, vec_point_values, std::numeric_limits<double>::epsilon(), std::numeric_limits<double>::max());
- const std::vector<std::size_t>& vec_node_ids = _mshNodesSearcher.getMeshNodesAlongPolyline(*_ply0).getNodeIDs();
- std::vector<double> interpolated_values = NumLib::generateNodeValueDistribution(interpolate, *_msh, vec_node_ids);
+ NumLib::LinearInterpolationAlongPolyline interpolate(
+ *_ply0, vec_point_ids, vec_point_values, std::numeric_limits<double>::epsilon(), std::numeric_limits<double>::max());
+ const std::vector<std::size_t>& vec_node_ids = _mshNodesSearcher.getMeshNodesAlongPolyline(*_ply0).getNodeIDs();
+ std::vector<double> interpolated_values = NumLib::generateNodeValueDistribution(interpolate, *_msh, vec_node_ids);
- ASSERT_ARRAY_NEAR(expected, interpolated_values, expected.size(), std::numeric_limits<double>::epsilon());
+ ASSERT_ARRAY_NEAR(expected, interpolated_values, expected.size(), std::numeric_limits<double>::epsilon());
}
TEST_F(NumLibDistributionHex, InterpolationPolyline)
{
- const std::vector<std::size_t> vec_point_ids = {{0, 4}};
- const std::vector<double> vec_point_values = {{0., 100.}};
- std::vector<double> expected = {{0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100}};
+ const std::vector<std::size_t> vec_point_ids = {{0, 4}};
+ const std::vector<double> vec_point_values = {{0., 100.}};
+ std::vector<double> expected = {{0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100}};
- NumLib::LinearInterpolationAlongPolyline interpolate(
- *_ply0, vec_point_ids, vec_point_values, std::numeric_limits<double>::epsilon(), std::numeric_limits<double>::max());
- const std::vector<std::size_t>& vec_node_ids = _mshNodesSearcher.getMeshNodesAlongPolyline(*_ply0).getNodeIDs();
- std::vector<double> interpolated_values = NumLib::generateNodeValueDistribution(interpolate, *_msh, vec_node_ids);
+ NumLib::LinearInterpolationAlongPolyline interpolate(
+ *_ply0, vec_point_ids, vec_point_values, std::numeric_limits<double>::epsilon(), std::numeric_limits<double>::max());
+ const std::vector<std::size_t>& vec_node_ids = _mshNodesSearcher.getMeshNodesAlongPolyline(*_ply0).getNodeIDs();
+ std::vector<double> interpolated_values = NumLib::generateNodeValueDistribution(interpolate, *_msh, vec_node_ids);
- ASSERT_ARRAY_NEAR(expected, interpolated_values, expected.size(), std::numeric_limits<double>::epsilon());
+ ASSERT_ARRAY_NEAR(expected, interpolated_values, expected.size(), std::numeric_limits<double>::epsilon());
}
TEST_F(NumLibDistributionQuad, InterpolationSurface)
{
- const std::vector<std::size_t> vec_point_ids = {{0, 1, 2, 3}};
- const std::vector<double> vec_point_values = {{0., 100., 100., 0.}};
- std::vector<double> expected(_msh->getNNodes());
- for (std::size_t i=0; i<_msh->getNNodes(); i++) {
- expected[i] = static_cast<double>((i%(_number_of_subdivisions_per_direction+1)) * 10);
- }
-
- NumLib::LinearInterpolationOnSurface interpolate(*_sfc1, vec_point_ids, vec_point_values, std::numeric_limits<double>::max());
- const std::vector<std::size_t>& vec_node_ids = _mshNodesSearcher.getMeshNodesAlongSurface(*_sfc1).getNodeIDs();
- std::vector<double> interpolated_values = NumLib::generateNodeValueDistribution(interpolate, *_msh, vec_node_ids);
-
- // the machine epsilon for double is too small for this test
- ASSERT_ARRAY_NEAR(expected, interpolated_values, expected.size(), std::numeric_limits<float>::epsilon());
+ const std::vector<std::size_t> vec_point_ids = {{0, 1, 2, 3}};
+ const std::vector<double> vec_point_values = {{0., 100., 100., 0.}};
+ std::vector<double> expected(_msh->getNNodes());
+ for (std::size_t i=0; i<_msh->getNNodes(); i++) {
+ expected[i] = static_cast<double>((i%(_number_of_subdivisions_per_direction+1)) * 10);
+ }
+
+ NumLib::LinearInterpolationOnSurface interpolate(*_sfc1, vec_point_ids, vec_point_values, std::numeric_limits<double>::max());
+ const std::vector<std::size_t>& vec_node_ids = _mshNodesSearcher.getMeshNodesAlongSurface(*_sfc1).getNodeIDs();
+ std::vector<double> interpolated_values = NumLib::generateNodeValueDistribution(interpolate, *_msh, vec_node_ids);
+
+ // the machine epsilon for double is too small for this test
+ ASSERT_ARRAY_NEAR(expected, interpolated_values, expected.size(), std::numeric_limits<float>::epsilon());
}
TEST_F(NumLibDistributionHex, InterpolationSurface)
{
- const std::vector<std::size_t> vec_point_ids = {{0, 3, 7, 4}};
- const std::vector<double> vec_point_values = {{0., 100., 100., 0.}};
- std::vector<double> expected(static_cast<std::size_t>(std::pow(_number_of_subdivisions_per_direction+1, 2)));
- for (std::size_t i=0; i<expected.size(); i++) {
- expected[i] = static_cast<double>((i%(_number_of_subdivisions_per_direction+1)) * 10);
- }
-
- NumLib::LinearInterpolationOnSurface interpolate(*_sfc1, vec_point_ids, vec_point_values, std::numeric_limits<double>::max());
- const std::vector<std::size_t>& vec_node_ids = _mshNodesSearcher.getMeshNodesAlongSurface(*_sfc1).getNodeIDs();
- std::vector<double> interpolated_values = NumLib::generateNodeValueDistribution(interpolate, *_msh, vec_node_ids);
-
- ASSERT_ARRAY_NEAR(expected, interpolated_values, expected.size(), std::numeric_limits<float>::epsilon());
+ const std::vector<std::size_t> vec_point_ids = {{0, 3, 7, 4}};
+ const std::vector<double> vec_point_values = {{0., 100., 100., 0.}};
+ std::vector<double> expected(static_cast<std::size_t>(std::pow(_number_of_subdivisions_per_direction+1, 2)));
+ for (std::size_t i=0; i<expected.size(); i++) {
+ expected[i] = static_cast<double>((i%(_number_of_subdivisions_per_direction+1)) * 10);
+ }
+
+ NumLib::LinearInterpolationOnSurface interpolate(*_sfc1, vec_point_ids, vec_point_values, std::numeric_limits<double>::max());
+ const std::vector<std::size_t>& vec_node_ids = _mshNodesSearcher.getMeshNodesAlongSurface(*_sfc1).getNodeIDs();
+ std::vector<double> interpolated_values = NumLib::generateNodeValueDistribution(interpolate, *_msh, vec_node_ids);
+
+ ASSERT_ARRAY_NEAR(expected, interpolated_values, expected.size(), std::numeric_limits<float>::epsilon());
}
diff --git a/Tests/NumLib/TestFemIntegration.cpp b/Tests/NumLib/TestFemIntegration.cpp
index 82f2a92c711193ee7b9ace6de5dd56f1ce74ffd1..e2cfdacbe422ba6490bbd978f013410735d9a93d 100644
--- a/Tests/NumLib/TestFemIntegration.cpp
+++ b/Tests/NumLib/TestFemIntegration.cpp
@@ -21,113 +21,113 @@ using namespace NumLib;
TEST(NumLib, FemIntegrationGaussRegular)
{
- const std::size_t integrationOrder = 2;
- const double eps = std::numeric_limits<double>::epsilon();
+ const std::size_t integrationOrder = 2;
+ const double eps = std::numeric_limits<double>::epsilon();
- // check position indices
- // dim = 1
- {
- std::size_t expected[1] = { 0u };
- ASSERT_ARRAY_EQ(expected,
- IntegrationGaussRegular<1>::getPositionIndices(integrationOrder, 0).data(), 1u);
- expected[0] = 1u;
- ASSERT_ARRAY_EQ(expected,
- IntegrationGaussRegular<1>::getPositionIndices(integrationOrder, 1).data(), 1u);
- }
- // dim = 2
- {
- std::size_t expected[2] = { 0u, 0u };
- ASSERT_ARRAY_EQ(expected,
- IntegrationGaussRegular<2>::getPositionIndices(integrationOrder, 0).data(), 2);
- expected[1] = 1u;
- ASSERT_ARRAY_EQ(expected,
- IntegrationGaussRegular<2>::getPositionIndices(integrationOrder, 1).data(), 2);
- expected[0] = 1u;
- expected[1] = 0u;
- ASSERT_ARRAY_EQ(expected,
- IntegrationGaussRegular<2>::getPositionIndices(integrationOrder, 2).data(), 2);
- expected[0] = 1u;
- expected[1] = 1u;
- ASSERT_ARRAY_EQ(expected,
- IntegrationGaussRegular<2>::getPositionIndices(integrationOrder, 3).data(), 2);
- }
- // dim = 3
- {
- std::size_t expected[3] = { 0u, 0u, 0u };
- for (std::size_t i(0); i <= 1; i++) {
- expected[0] = i;
- for (std::size_t j(0); j <= 1; j++) {
- expected[1] = j;
- for (std::size_t k(0); k <= 1; k++) {
- expected[2] = k;
- const std::size_t l(i * 4 + j * 2 + k);
- ASSERT_ARRAY_EQ(expected,
- IntegrationGaussRegular<3>::getPositionIndices(integrationOrder, l).data(),
- 3);
- }
- }
- }
- }
- // check coordinates
- // dim = 1
- // weight
- ASSERT_NEAR(1.0,
- IntegrationGaussRegular<1>::getWeightedPoint(integrationOrder, 0).getWeight(), eps);
- // pos
- ASSERT_NEAR(0.577350269189626,
- IntegrationGaussRegular<1>::getWeightedPoint(integrationOrder, 0)[0], eps);
- // weight
- ASSERT_NEAR(1.0,
- IntegrationGaussRegular<1>::getWeightedPoint(integrationOrder, 1).getWeight(), eps);
- // pos
- ASSERT_NEAR(-0.577350269189626,
- IntegrationGaussRegular<1>::getWeightedPoint(integrationOrder, 1)[0], eps);
+ // check position indices
+ // dim = 1
+ {
+ std::size_t expected[1] = { 0u };
+ ASSERT_ARRAY_EQ(expected,
+ IntegrationGaussRegular<1>::getPositionIndices(integrationOrder, 0).data(), 1u);
+ expected[0] = 1u;
+ ASSERT_ARRAY_EQ(expected,
+ IntegrationGaussRegular<1>::getPositionIndices(integrationOrder, 1).data(), 1u);
+ }
+ // dim = 2
+ {
+ std::size_t expected[2] = { 0u, 0u };
+ ASSERT_ARRAY_EQ(expected,
+ IntegrationGaussRegular<2>::getPositionIndices(integrationOrder, 0).data(), 2);
+ expected[1] = 1u;
+ ASSERT_ARRAY_EQ(expected,
+ IntegrationGaussRegular<2>::getPositionIndices(integrationOrder, 1).data(), 2);
+ expected[0] = 1u;
+ expected[1] = 0u;
+ ASSERT_ARRAY_EQ(expected,
+ IntegrationGaussRegular<2>::getPositionIndices(integrationOrder, 2).data(), 2);
+ expected[0] = 1u;
+ expected[1] = 1u;
+ ASSERT_ARRAY_EQ(expected,
+ IntegrationGaussRegular<2>::getPositionIndices(integrationOrder, 3).data(), 2);
+ }
+ // dim = 3
+ {
+ std::size_t expected[3] = { 0u, 0u, 0u };
+ for (std::size_t i(0); i <= 1; i++) {
+ expected[0] = i;
+ for (std::size_t j(0); j <= 1; j++) {
+ expected[1] = j;
+ for (std::size_t k(0); k <= 1; k++) {
+ expected[2] = k;
+ const std::size_t l(i * 4 + j * 2 + k);
+ ASSERT_ARRAY_EQ(expected,
+ IntegrationGaussRegular<3>::getPositionIndices(integrationOrder, l).data(),
+ 3);
+ }
+ }
+ }
+ }
+ // check coordinates
+ // dim = 1
+ // weight
+ ASSERT_NEAR(1.0,
+ IntegrationGaussRegular<1>::getWeightedPoint(integrationOrder, 0).getWeight(), eps);
+ // pos
+ ASSERT_NEAR(0.577350269189626,
+ IntegrationGaussRegular<1>::getWeightedPoint(integrationOrder, 0)[0], eps);
+ // weight
+ ASSERT_NEAR(1.0,
+ IntegrationGaussRegular<1>::getWeightedPoint(integrationOrder, 1).getWeight(), eps);
+ // pos
+ ASSERT_NEAR(-0.577350269189626,
+ IntegrationGaussRegular<1>::getWeightedPoint(integrationOrder, 1)[0], eps);
- // dim = 2
- ASSERT_NEAR(1.0,
- IntegrationGaussRegular<2>::getWeightedPoint(integrationOrder, 0).getWeight(), eps);
- ASSERT_NEAR(0.577350269189626,
- IntegrationGaussRegular<2>::getWeightedPoint(integrationOrder, 0)[0], eps);
- ASSERT_NEAR(0.577350269189626,
- IntegrationGaussRegular<2>::getWeightedPoint(integrationOrder, 0)[1], eps);
- ASSERT_NEAR(1.0,
- IntegrationGaussRegular<2>::getWeightedPoint(integrationOrder, 1).getWeight(), eps);
- ASSERT_NEAR(0.577350269189626,
- IntegrationGaussRegular<2>::getWeightedPoint(integrationOrder, 1)[0], eps);
- ASSERT_NEAR(-0.577350269189626,
- IntegrationGaussRegular<2>::getWeightedPoint(integrationOrder, 1)[1], eps);
+ // dim = 2
+ ASSERT_NEAR(1.0,
+ IntegrationGaussRegular<2>::getWeightedPoint(integrationOrder, 0).getWeight(), eps);
+ ASSERT_NEAR(0.577350269189626,
+ IntegrationGaussRegular<2>::getWeightedPoint(integrationOrder, 0)[0], eps);
+ ASSERT_NEAR(0.577350269189626,
+ IntegrationGaussRegular<2>::getWeightedPoint(integrationOrder, 0)[1], eps);
+ ASSERT_NEAR(1.0,
+ IntegrationGaussRegular<2>::getWeightedPoint(integrationOrder, 1).getWeight(), eps);
+ ASSERT_NEAR(0.577350269189626,
+ IntegrationGaussRegular<2>::getWeightedPoint(integrationOrder, 1)[0], eps);
+ ASSERT_NEAR(-0.577350269189626,
+ IntegrationGaussRegular<2>::getWeightedPoint(integrationOrder, 1)[1], eps);
- // dim = 3
- ASSERT_NEAR(1.0,
- IntegrationGaussRegular<3>::getWeightedPoint(integrationOrder, 0).getWeight(), eps);
- ASSERT_NEAR(0.577350269189626,
- IntegrationGaussRegular<3>::getWeightedPoint(integrationOrder, 0)[0], eps);
- ASSERT_NEAR(0.577350269189626,
- IntegrationGaussRegular<3>::getWeightedPoint(integrationOrder, 0)[1], eps);
- ASSERT_NEAR(0.577350269189626,
- IntegrationGaussRegular<3>::getWeightedPoint(integrationOrder, 0)[2], eps);
- ASSERT_NEAR(1.0,
- IntegrationGaussRegular<3>::getWeightedPoint(integrationOrder, 1).getWeight(), eps);
- ASSERT_NEAR(0.577350269189626,
- IntegrationGaussRegular<3>::getWeightedPoint(integrationOrder, 1)[0], eps);
- ASSERT_NEAR(0.577350269189626,
- IntegrationGaussRegular<3>::getWeightedPoint(integrationOrder, 1)[1], eps);
- ASSERT_NEAR(-0.577350269189626,
- IntegrationGaussRegular<3>::getWeightedPoint(integrationOrder, 1)[2], eps);
+ // dim = 3
+ ASSERT_NEAR(1.0,
+ IntegrationGaussRegular<3>::getWeightedPoint(integrationOrder, 0).getWeight(), eps);
+ ASSERT_NEAR(0.577350269189626,
+ IntegrationGaussRegular<3>::getWeightedPoint(integrationOrder, 0)[0], eps);
+ ASSERT_NEAR(0.577350269189626,
+ IntegrationGaussRegular<3>::getWeightedPoint(integrationOrder, 0)[1], eps);
+ ASSERT_NEAR(0.577350269189626,
+ IntegrationGaussRegular<3>::getWeightedPoint(integrationOrder, 0)[2], eps);
+ ASSERT_NEAR(1.0,
+ IntegrationGaussRegular<3>::getWeightedPoint(integrationOrder, 1).getWeight(), eps);
+ ASSERT_NEAR(0.577350269189626,
+ IntegrationGaussRegular<3>::getWeightedPoint(integrationOrder, 1)[0], eps);
+ ASSERT_NEAR(0.577350269189626,
+ IntegrationGaussRegular<3>::getWeightedPoint(integrationOrder, 1)[1], eps);
+ ASSERT_NEAR(-0.577350269189626,
+ IntegrationGaussRegular<3>::getWeightedPoint(integrationOrder, 1)[2], eps);
- // check other member functions
- IntegrationGaussRegular<1> q1;
- ASSERT_EQ(2u, q1.getIntegrationOrder());
- ASSERT_EQ(2u, q1.getNPoints());
- q1.setIntegrationOrder(3u);
- ASSERT_EQ(3u, q1.getIntegrationOrder());
- ASSERT_EQ(3u, q1.getNPoints());
- IntegrationGaussRegular<2> q2;
- ASSERT_EQ(2u, q2.getIntegrationOrder());
- ASSERT_EQ(4u, q2.getNPoints());
- IntegrationGaussRegular<3> q3;
- ASSERT_EQ(2u, q3.getIntegrationOrder());
- ASSERT_EQ(8u, q3.getNPoints());
+ // check other member functions
+ IntegrationGaussRegular<1> q1;
+ ASSERT_EQ(2u, q1.getIntegrationOrder());
+ ASSERT_EQ(2u, q1.getNPoints());
+ q1.setIntegrationOrder(3u);
+ ASSERT_EQ(3u, q1.getIntegrationOrder());
+ ASSERT_EQ(3u, q1.getNPoints());
+ IntegrationGaussRegular<2> q2;
+ ASSERT_EQ(2u, q2.getIntegrationOrder());
+ ASSERT_EQ(4u, q2.getNPoints());
+ IntegrationGaussRegular<3> q3;
+ ASSERT_EQ(2u, q3.getIntegrationOrder());
+ ASSERT_EQ(8u, q3.getNPoints());
}
diff --git a/Tests/NumLib/TestSpatialFunction.cpp b/Tests/NumLib/TestSpatialFunction.cpp
index c38a89fee535454bf104d458388dc8259ae761d1..df71535e0efc28393d526ce821b440b52eac55e0 100644
--- a/Tests/NumLib/TestSpatialFunction.cpp
+++ b/Tests/NumLib/TestSpatialFunction.cpp
@@ -23,93 +23,93 @@
TEST(NumLib, SpatialFunctionLinear)
{
- // f(x,y,z) = 1 + 2x + 3y + 4z
- std::array<double,4> f_coeff = {{1, 2, 3, 4}};
- MathLib::LinearFunction<double,3> linear_f(f_coeff);
-
- NumLib::SpatialFunctionLinear f(linear_f);
-
- ASSERT_DOUBLE_EQ(1., f(GeoLib::Point(0,0,0)));
- ASSERT_DOUBLE_EQ(10., f(GeoLib::Point(1,1,1)));
- ASSERT_DOUBLE_EQ(-8, f(GeoLib::Point(-1,-1,-1)));
- for (std::size_t k(0); k < 5; ++k)
- {
- GeoLib::Point pt(0, 0, 0);
- for (unsigned i = 0; i < 3; ++i)
- pt[i] = (double) rand() - (RAND_MAX / 2.0);
- double expected = 1+2*pt[0]+3*pt[1]+4*pt[2];
- ASSERT_DOUBLE_EQ(expected, f(pt));
- }
+ // f(x,y,z) = 1 + 2x + 3y + 4z
+ std::array<double,4> f_coeff = {{1, 2, 3, 4}};
+ MathLib::LinearFunction<double,3> linear_f(f_coeff);
+
+ NumLib::SpatialFunctionLinear f(linear_f);
+
+ ASSERT_DOUBLE_EQ(1., f(GeoLib::Point(0,0,0)));
+ ASSERT_DOUBLE_EQ(10., f(GeoLib::Point(1,1,1)));
+ ASSERT_DOUBLE_EQ(-8, f(GeoLib::Point(-1,-1,-1)));
+ for (std::size_t k(0); k < 5; ++k)
+ {
+ GeoLib::Point pt(0, 0, 0);
+ for (unsigned i = 0; i < 3; ++i)
+ pt[i] = (double) rand() - (RAND_MAX / 2.0);
+ double expected = 1+2*pt[0]+3*pt[1]+4*pt[2];
+ ASSERT_DOUBLE_EQ(expected, f(pt));
+ }
}
TEST(NumLib, SpatialFunctionInterpolationPolyline)
{
- // create geometry
- GeoLib::Point pt1(0.0, 0.0, 0.0);
- GeoLib::Point pt2(10.0, 0.0, 0.0);
- std::vector<GeoLib::Point*> pnts = {&pt1, &pt2};
- GeoLib::Polyline ply0(pnts);
- ply0.addPoint(0);
- ply0.addPoint(1);
-
- // define a function
- const std::vector<std::size_t> vec_point_ids = {{0, 1}};
- const std::vector<double> vec_point_values = {{0., 100.}};
- NumLib::LinearInterpolationAlongPolyline interpolate(
- ply0, vec_point_ids, vec_point_values, std::numeric_limits<double>::epsilon(), std::numeric_limits<double>::max());
-
- // normal
- for (unsigned k=0; k<10; k++)
- ASSERT_DOUBLE_EQ(k*10., interpolate(GeoLib::Point(k,0,0)));
-
- // failure
- // x
- ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(-1,0,0)));
- ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(11,0,0)));
- // y
- ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(0,1,0)));
- ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(0,-1,0)));
- // z
- ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(0,0,1)));
- ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(0,0,-1)));
+ // create geometry
+ GeoLib::Point pt1(0.0, 0.0, 0.0);
+ GeoLib::Point pt2(10.0, 0.0, 0.0);
+ std::vector<GeoLib::Point*> pnts = {&pt1, &pt2};
+ GeoLib::Polyline ply0(pnts);
+ ply0.addPoint(0);
+ ply0.addPoint(1);
+
+ // define a function
+ const std::vector<std::size_t> vec_point_ids = {{0, 1}};
+ const std::vector<double> vec_point_values = {{0., 100.}};
+ NumLib::LinearInterpolationAlongPolyline interpolate(
+ ply0, vec_point_ids, vec_point_values, std::numeric_limits<double>::epsilon(), std::numeric_limits<double>::max());
+
+ // normal
+ for (unsigned k=0; k<10; k++)
+ ASSERT_DOUBLE_EQ(k*10., interpolate(GeoLib::Point(k,0,0)));
+
+ // failure
+ // x
+ ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(-1,0,0)));
+ ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(11,0,0)));
+ // y
+ ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(0,1,0)));
+ ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(0,-1,0)));
+ // z
+ ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(0,0,1)));
+ ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(0,0,-1)));
}
TEST(NumLib, SpatialFunctionInterpolationSurface)
{
- // create geometry
- GeoLib::Point pt1(0.0, 0.0, 0.0);
- GeoLib::Point pt2(10.0, 0.0, 0.0);
- GeoLib::Point pt3(10.0, 10.0, 0.0);
- GeoLib::Point pt4(0.0, 10.0, 0.0);
- std::vector<GeoLib::Point*> pnts = {&pt1, &pt2, &pt3, &pt4};
- GeoLib::Polyline ply0(pnts);
- ply0.addPoint(0);
- ply0.addPoint(1);
- ply0.addPoint(2);
- ply0.addPoint(3);
- ply0.addPoint(0);
- std::unique_ptr<GeoLib::Surface> sfc1(GeoLib::Surface::createSurface(ply0));
-
- // define a function
- const std::vector<std::size_t> vec_point_ids = {{0, 1, 2, 3}};
- const std::vector<double> vec_point_values = {{0., 100., 100., 0.}};
- NumLib::LinearInterpolationOnSurface interpolate(*sfc1, vec_point_ids, vec_point_values, std::numeric_limits<double>::max());
-
- // normal
- for (unsigned k=0; k<10; k++) {
- ASSERT_DOUBLE_EQ(k*10., interpolate(GeoLib::Point(k,0,0)));
- ASSERT_DOUBLE_EQ(k*10., interpolate(GeoLib::Point(k,5,0)));
- ASSERT_DOUBLE_EQ(k*10., interpolate(GeoLib::Point(k,10,0)));
- }
-
- // failure
- // x, y
- ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(-1,-1,0)));
- ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(11,-1,0)));
- ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(11,11,0)));
- ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(-1,11,0)));
- // z
- ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(0,0,1)));
- ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(0,0,-1)));
+ // create geometry
+ GeoLib::Point pt1(0.0, 0.0, 0.0);
+ GeoLib::Point pt2(10.0, 0.0, 0.0);
+ GeoLib::Point pt3(10.0, 10.0, 0.0);
+ GeoLib::Point pt4(0.0, 10.0, 0.0);
+ std::vector<GeoLib::Point*> pnts = {&pt1, &pt2, &pt3, &pt4};
+ GeoLib::Polyline ply0(pnts);
+ ply0.addPoint(0);
+ ply0.addPoint(1);
+ ply0.addPoint(2);
+ ply0.addPoint(3);
+ ply0.addPoint(0);
+ std::unique_ptr<GeoLib::Surface> sfc1(GeoLib::Surface::createSurface(ply0));
+
+ // define a function
+ const std::vector<std::size_t> vec_point_ids = {{0, 1, 2, 3}};
+ const std::vector<double> vec_point_values = {{0., 100., 100., 0.}};
+ NumLib::LinearInterpolationOnSurface interpolate(*sfc1, vec_point_ids, vec_point_values, std::numeric_limits<double>::max());
+
+ // normal
+ for (unsigned k=0; k<10; k++) {
+ ASSERT_DOUBLE_EQ(k*10., interpolate(GeoLib::Point(k,0,0)));
+ ASSERT_DOUBLE_EQ(k*10., interpolate(GeoLib::Point(k,5,0)));
+ ASSERT_DOUBLE_EQ(k*10., interpolate(GeoLib::Point(k,10,0)));
+ }
+
+ // failure
+ // x, y
+ ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(-1,-1,0)));
+ ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(11,-1,0)));
+ ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(11,11,0)));
+ ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(-1,11,0)));
+ // z
+ ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(0,0,1)));
+ ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(0,0,-1)));
}
diff --git a/Tests/NumLib/TimeSteppingTestingTools.h b/Tests/NumLib/TimeSteppingTestingTools.h
index 831e808bc2c4556398284a6b68f5763b274a2e6d..b1275114c075e863d426e323bf677669a37e633c 100644
--- a/Tests/NumLib/TimeSteppingTestingTools.h
+++ b/Tests/NumLib/TimeSteppingTestingTools.h
@@ -22,8 +22,8 @@ namespace
struct Dummy
{
- template <class T>
- void operator()(T &/*obj*/) {}
+ template <class T>
+ void operator()(T &/*obj*/) {}
};
template <class T_TIME_STEPPING, class T=Dummy>