Changeset 42c742 for src/Fragmentation/Exporters/unittests/SphericalPointDistributionUnitTest.cpp

Timestamp:

Aug 20, 2014, 1:06:16 PM (11 years ago)

Author:

Frederik Heber <heber@…>

Children:

0b517b

Parents:

ef3885

git-author:

Frederik Heber <heber@…> (07/12/14 11:57:54)

git-committer:

Frederik Heber <heber@…> (08/20/14 13:06:16)

Message:

Added getConnections() to SphericalPointDistribution.

• we use tesselation in order to extract the connection information between nearest neighboring points from the BoundaryLines of the tesselation. The triangles are ideal as they assure that no point lies within a triangle, hence all these points may be safely combined.
• functions reside in extra module as with get().
• added extensive unit tests.
• TESTS: Removed XFAIL from SphericalPointDistributionUnitTest.

File:

• src/Fragmentation/Exporters/unittests/SphericalPointDistributionUnitTest.cpp (modified) (5 diffs)

src/Fragmentation/Exporters/unittests/SphericalPointDistributionUnitTest.cpp

@@ -45 +45 @@
 #include "SphericalPointDistributionUnitTest.hpp"
 
+#include <algorithm>
 #include <boost/assign.hpp>
 #include <boost/math/quaternion.hpp>
@@ -53 +54 @@
 #include "LinearAlgebra/Line.hpp"
 
+#include "Atom/TesselPoint.hpp"
 #include "Fragmentation/Exporters/SphericalPointDistribution.hpp"
-
-#include "LinearAlgebra/Line.hpp"
+#include "LinkedCell/linkedcell.hpp"
+#include "LinkedCell/PointCloudAdaptor.hpp"
+#include "Tesselation/BoundaryLineSet.hpp"
+#include "Tesselation/tesselation.hpp"
 
 #ifdef HAVE_TESTRUNNER
@@ -78 +82 @@
   ASSERT_DO(Assert::Throw);
 
-  setVerbosity(6);
+  setVerbosity(2);
 }
 
@@ -270 +274 @@
 }
 
-/** UnitTest for matchSphericalPointDistributions() with two points
- */
-void SphericalPointDistributionTest::matchSphericalPointDistributionsTest_2()
-{
+/** UnitTest for getConnections()
+ */
+template <>
+void SphericalPointDistributionTest_assistant::getConnectionTest<0>()
+{
+  const int N=0;
   SphericalPointDistribution SPD(1.);
-  // test with one point, matching trivially
-  {
-    SphericalPointDistribution::WeightedPolygon_t polygon;
-    polygon += std::make_pair(Vector(1.,0.,0.), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
-        SPD.get<2>();
-    SphericalPointDistribution::Polygon_t expected;
-    expected += Vector(-1.,0.,0.);
-    SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
-//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
-    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
-  }
-
-  // test with one point, just a flip of axis
-  {
-    SphericalPointDistribution::WeightedPolygon_t polygon;
-    polygon += std::make_pair( Vector(0.,1.,0.), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
-        SPD.get<2>();
-    SphericalPointDistribution::Polygon_t expected;
-    expected += Vector(0.,-1.,0.);
-    SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
-//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
-    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
-  }
-
-  // test with one point, just a flip to another axis
-  {
-    SphericalPointDistribution::WeightedPolygon_t polygon;
-    polygon += std::make_pair( Vector(0.,0.,-1.), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
-        SPD.get<2>();
-    SphericalPointDistribution::Polygon_t expected;
-    expected += Vector(0.,0.,1.);
-    SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
-//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
-    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
-  }
-
-  // test with one point, full rotation
-  {
-    Line RotationAxis(zeroVec, Vector(0.2, 0.43, 0.6893248));
-    SphericalPointDistribution::WeightedPolygon_t polygon;
-    polygon += std::make_pair(RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
-        SPD.get<2>();
-    SphericalPointDistribution::Polygon_t expected;
-    expected += RotationAxis.rotateVector(Vector(-1.,0.,0.), 47.6/180*M_PI);
-    SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
-//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
-    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
-  }
+
+  // create empty adjacency
+  SphericalPointDistribution::adjacency_t adjacency;
+
+  // get the implemented connections
+  SphericalPointDistribution::adjacency_t expected =
+      SPD.getConnections<N>();
+
+  // and compare the two
+  CPPUNIT_ASSERT_EQUAL( expected, adjacency );
+}
+
+/** UnitTest for getConnections()
+ */
+template <>
+void SphericalPointDistributionTest_assistant::getConnectionTest<1>()
+{
+  const int N=1;
+  SphericalPointDistribution SPD(1.);
+
+  // create empty adjacency
+  SphericalPointDistribution::adjacency_t adjacency;
+
+  // get the implemented connections
+  SphericalPointDistribution::adjacency_t expected =
+      SPD.getConnections<N>();
+
+  // and compare the two
+  CPPUNIT_ASSERT_EQUAL( expected, adjacency );
+}
+
+/** UnitTest for getConnections()
+ */
+template <>
+void SphericalPointDistributionTest_assistant::getConnectionTest<2>()
+{
+  const int N=2;
+  SphericalPointDistribution SPD(1.);
+
+  // create empty adjacency
+  SphericalPointDistribution::adjacency_t adjacency;
+  adjacency +=
+      make_pair<
+      unsigned int,
+      SphericalPointDistribution::IndexSet_t >
+        (0, list_of<unsigned int>(1));
+  adjacency +=
+      make_pair<
+      unsigned int,
+      SphericalPointDistribution::IndexSet_t >
+        (1, list_of<unsigned int>(0));
+
+  // get the implemented connections
+  SphericalPointDistribution::adjacency_t expected =
+      SPD.getConnections<N>();
+
+  // and compare the two
+  CPPUNIT_ASSERT_EQUAL( expected, adjacency );
 }
 
@@ -460 +460 @@
 }
 
+/** UnitTest for matchSphericalPointDistributions() with two points
+ */
+void SphericalPointDistributionTest::matchSphericalPointDistributionsTest_2()
+{
+  SphericalPointDistribution SPD(1.);
+  // test with one point, matching trivially
+  {
+    SphericalPointDistribution::WeightedPolygon_t polygon;
+    polygon += std::make_pair(Vector(1.,0.,0.), 1);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<2>();
+    SphericalPointDistribution::Polygon_t expected;
+    expected += Vector(-1.,0.,0.);
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
+  }
+
+  // test with one point, just a flip of axis
+  {
+    SphericalPointDistribution::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(0.,1.,0.), 1);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<2>();
+    SphericalPointDistribution::Polygon_t expected;
+    expected += Vector(0.,-1.,0.);
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
+  }
+
+  // test with one point, just a flip to another axis
+  {
+    SphericalPointDistribution::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(0.,0.,-1.), 1);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<2>();
+    SphericalPointDistribution::Polygon_t expected;
+    expected += Vector(0.,0.,1.);
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
+  }
+
+  // test with one point, full rotation
+  {
+    Line RotationAxis(zeroVec, Vector(0.2, 0.43, 0.6893248));
+    SphericalPointDistribution::WeightedPolygon_t polygon;
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI), 1);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<2>();
+    SphericalPointDistribution::Polygon_t expected;
+    expected += RotationAxis.rotateVector(Vector(-1.,0.,0.), 47.6/180*M_PI);
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
+  }
+}
+
 /** UnitTest for matchSphericalPointDistributions() with three points
  */