Changeset 158ecb for src/Fragmentation/Exporters/unittests/SphericalPointDistributionUnitTest.cpp

Timestamp:

Sep 12, 2016, 2:03:15 PM (9 years ago)

Author:

Frederik Heber <heber@…>

Branches:

Action_Thermostats, Add_AtomRandomPerturbation, Add_FitFragmentPartialChargesAction, Add_RotateAroundBondAction, Add_SelectAtomByNameAction, Adding_Graph_to_ChangeBondActions, Adding_MD_integration_tests, Adding_StructOpt_integration_tests, Automaking_mpqc_open, AutomationFragmentation_failures, Candidate_v1.5.4, Candidate_v1.6.0, Candidate_v1.6.1, ChangeBugEmailaddress, ChangingTestPorts, ChemicalSpaceEvaluator, Combining_Subpackages, Debian_Package_split, Debian_package_split_molecuildergui_only, Disabling_MemDebug, Docu_Python_wait, EmpiricalPotential_contain_HomologyGraph, EmpiricalPotential_contain_HomologyGraph_documentation, Enable_parallel_make_install, Enhance_userguide, Enhanced_StructuralOptimization, Enhanced_StructuralOptimization_continued, Example_ManyWaysToTranslateAtom, Exclude_Hydrogens_annealWithBondGraph, FitPartialCharges_GlobalError, Fix_ChargeSampling_PBC, Fix_ChronosMutex, Fix_FitPartialCharges, Fix_FitPotential_needs_atomicnumbers, Fix_ForceAnnealing, Fix_IndependentFragmentGrids, Fix_ParseParticles, Fix_ParseParticles_split_forward_backward_Actions, Fix_StatusMsg, Fix_StepWorldTime_single_argument, Fix_Verbose_Codepatterns, ForceAnnealing_goodresults, ForceAnnealing_oldresults, ForceAnnealing_tocheck, ForceAnnealing_with_BondGraph, ForceAnnealing_with_BondGraph_continued, ForceAnnealing_with_BondGraph_continued_betteresults, ForceAnnealing_with_BondGraph_contraction-expansion, GeometryObjects, Gui_displays_atomic_force_velocity, IndependentFragmentGrids, IndependentFragmentGrids_IndividualZeroInstances, IndependentFragmentGrids_IntegrationTest, IndependentFragmentGrids_Sole_NN_Calculation, JobMarket_RobustOnKillsSegFaults, JobMarket_StableWorkerPool, JobMarket_unresolvable_hostname_fix, ODR_violation_mpqc_open, PartialCharges_OrthogonalSummation, PythonUI_with_named_parameters, QtGui_reactivate_TimeChanged_changes, Recreated_GuiChecks, RotateToPrincipalAxisSystem_UndoRedo, SaturateAtoms_findBestMatching, StoppableMakroAction, Subpackage_CodePatterns, Subpackage_JobMarket, Subpackage_LinearAlgebra, Subpackage_levmar, Subpackage_mpqc_open, Subpackage_vmg, ThirdParty_MPQC_rebuilt_buildsystem, TrajectoryDependenant_MaxOrder, TremoloParser_IncreasedPrecision, TremoloParser_MultipleTimesteps, Ubuntu_1604_changes, stable

Children:

b67d89

Parents:

b3c052

git-author:

Frederik Heber <heber@…> (06/05/14 17:58:13)

git-committer:

Frederik Heber <heber@…> (09/12/16 14:03:15)

Message:

Extended SphericalPointDistributionUnitTest to two and three matching points for all functions.

• marked test as XFAIL for the moment.

File:

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

src/Fragmentation/Exporters/unittests/SphericalPointDistributionUnitTest.cpp

@@ -74 +74 @@
   ASSERT_DO(Assert::Throw);
 
-  setVerbosity(5);
+  setVerbosity(6);
 }
 
@@ -190 +190 @@
     CPPUNIT_ASSERT_EQUAL( expected, remaining );
   }
+
+  // test with two points, matching trivially
+  {
+    SphericalPointDistribution::Polygon_t polygon;
+    polygon += Vector(1.,0.,0.), Vector(-0.5, sqrt(3)*0.5,0.);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<3>();
+    SphericalPointDistribution::Polygon_t expected = newpolygon;
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+  }
+
+  // test with two points, full rotation
+  {
+    Line RotationAxis(zeroVec, Vector(0.2, 0.43, 0.6893248));
+    SphericalPointDistribution::Polygon_t polygon;
+    polygon +=
+        RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI),
+        RotationAxis.rotateVector(Vector(-0.5, sqrt(3)*0.5,0.), 47.6/180*M_PI);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<3>();
+    SphericalPointDistribution::Polygon_t expected = newpolygon;
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    for (SphericalPointDistribution::Polygon_t::iterator iter = expected.begin();
+        iter != expected.end(); ++iter)
+      *iter = RotationAxis.rotateVector(*iter, 47.6/180*M_PI);
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+  }
+
+  // test with three points, matching trivially
+  {
+    SphericalPointDistribution::Polygon_t polygon;
+    polygon += Vector(1.,0.,0.), Vector(-0.5, sqrt(3)*0.5,0.), Vector(-0.5, -sqrt(3)*0.5,0.);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<3>();
+    SphericalPointDistribution::Polygon_t expected; // empty cause none are vacant
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+  }
+
+
+  // test with three points, full rotation
+  {
+    Line RotationAxis(zeroVec, Vector(0.2, 0.43, 0.6893248));
+    SphericalPointDistribution::Polygon_t polygon;
+    polygon +=
+        RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI),
+        RotationAxis.rotateVector(Vector(-0.5, sqrt(3)*0.5,0.), 47.6/180*M_PI),
+        RotationAxis.rotateVector(Vector(-0.5, -sqrt(3)*0.5,0.), 47.6/180*M_PI);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<3>();
+    SphericalPointDistribution::Polygon_t expected; // empty cause none are vacant
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+  }
 }
 
@@ -232 +303 @@
     CPPUNIT_ASSERT_EQUAL( expected, remaining );
   }
+
+  // test with two points, matching trivially
+  {
+    SphericalPointDistribution::Polygon_t polygon;
+    polygon += Vector(1.,0.,0.), Vector(-1./3.0, 2.0*M_SQRT2/3.0,0.);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<4>();
+    SphericalPointDistribution::Polygon_t expected = newpolygon;
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+  }
+
+  // test with two points, full rotation
+  {
+    Line RotationAxis(zeroVec, Vector(0.2, 0.43, 0.6893248));
+    SphericalPointDistribution::Polygon_t polygon;
+    polygon +=
+        RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI),
+        RotationAxis.rotateVector(Vector(-1./3.0, 2.0*M_SQRT2/3.0,0.), 47.6/180*M_PI);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<4>();
+    SphericalPointDistribution::Polygon_t expected = newpolygon;
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    for (SphericalPointDistribution::Polygon_t::iterator iter = expected.begin();
+        iter != expected.end(); ++iter)
+      *iter = RotationAxis.rotateVector(*iter, 47.6/180*M_PI);
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+  }
+
+  // test with three points, matching trivially
+  {
+    SphericalPointDistribution::Polygon_t polygon;
+    polygon +=
+        Vector(1.,0.,0.),
+        Vector(-1./3.0, 2.0*M_SQRT2/3.0,0.),
+        Vector(-1./3.0, -M_SQRT2/3.0, M_SQRT2/sqrt(3));
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<4>();
+    SphericalPointDistribution::Polygon_t expected = newpolygon;
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    expected.pop_front(); // remove third point
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+  }
+
+  // test with three points, full rotation
+  {
+    Line RotationAxis(zeroVec, Vector(0.2, 0.43, 0.6893248));
+    SphericalPointDistribution::Polygon_t polygon;
+    polygon +=
+        RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI),
+        RotationAxis.rotateVector(Vector(-1./3.0, 2.0*M_SQRT2/3.0,0.), 47.6/180*M_PI),
+        RotationAxis.rotateVector(Vector(-1./3.0, -M_SQRT2/3.0, M_SQRT2/sqrt(3)), 47.6/180*M_PI);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<4>();
+    SphericalPointDistribution::Polygon_t expected = newpolygon;
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    expected.pop_front(); // remove third point
+    for (SphericalPointDistribution::Polygon_t::iterator iter = expected.begin();
+        iter != expected.end(); ++iter)
+      *iter = RotationAxis.rotateVector(*iter, 47.6/180*M_PI);
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+  }
 }
 
@@ -274 +427 @@
     CPPUNIT_ASSERT_EQUAL( expected, remaining );
   }
+
+  // test with two points, matching trivially
+  {
+    SphericalPointDistribution::Polygon_t polygon;
+    polygon += Vector(1.,0.,0.), Vector(-1.,0.,0.);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<5>();
+    SphericalPointDistribution::Polygon_t expected = newpolygon;
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+  }
+
+  // test with two points, full rotation
+  {
+    Line RotationAxis(zeroVec, Vector(0.2, 0.43, 0.6893248));
+    SphericalPointDistribution::Polygon_t polygon;
+    polygon +=
+        RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180.*M_PI),
+        RotationAxis.rotateVector(Vector(-1.,0.,0.), 47.6/180.*M_PI);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<5>();
+    SphericalPointDistribution::Polygon_t expected = newpolygon;
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    for (SphericalPointDistribution::Polygon_t::iterator iter = expected.begin();
+        iter != expected.end(); ++iter)
+      *iter = RotationAxis.rotateVector(*iter, 47.6/180.*M_PI);
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+    // the three remaining points sit on a plane that may be rotated arbitrarily
+    // so we cannot simply check for equality between expected and remaining
+    // hence, we just check that they are orthogonal to the first two points
+    CPPUNIT_ASSERT_EQUAL( expected.size(), remaining.size() );
+    for (SphericalPointDistribution::Polygon_t::const_iterator fixiter = polygon.begin();
+        fixiter != polygon.end(); ++fixiter) {
+      for (SphericalPointDistribution::Polygon_t::const_iterator iter = remaining.begin();
+          iter != remaining.end(); ++iter) {
+        CPPUNIT_ASSERT( (*fixiter).IsNormalTo(*iter) );
+      }
+    }
+  }
+
+  // test with three points, matching trivially
+  {
+    SphericalPointDistribution::Polygon_t polygon;
+    polygon +=
+        Vector(1.,0.,0.),
+        Vector(-1., 0.0, 0.0),
+        Vector(0.0, 1., 0.0);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<5>();
+    SphericalPointDistribution::Polygon_t expected = newpolygon;
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    expected.pop_front(); // remove third point
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+  }
+
+  // test with three points, full rotation
+  {
+    Line RotationAxis(zeroVec, Vector(0.2, 0.43, 0.6893248));
+    SphericalPointDistribution::Polygon_t polygon;
+    polygon +=
+        RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI),
+        RotationAxis.rotateVector(Vector(-1., 0.0, 0.0), 47.6/180*M_PI),
+        RotationAxis.rotateVector(Vector(0.0, 1., 0.0), 47.6/180*M_PI);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<5>();
+    SphericalPointDistribution::Polygon_t expected = newpolygon;
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    expected.pop_front(); // remove third point
+    for (SphericalPointDistribution::Polygon_t::iterator iter = expected.begin();
+        iter != expected.end(); ++iter)
+      *iter = RotationAxis.rotateVector(*iter, 47.6/180*M_PI);
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+  }
 }
 
@@ -316 +561 @@
     CPPUNIT_ASSERT_EQUAL( expected, remaining );
   }
+
+  // test with two points, matching trivially
+  {
+    SphericalPointDistribution::Polygon_t polygon;
+    polygon += Vector(1.,0.,0.), Vector(-1.,0.,0.);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<6>();
+    SphericalPointDistribution::Polygon_t expected = newpolygon;
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second spoint
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+  }
+
+  // test with two points, full rotation
+  {
+    Line RotationAxis(zeroVec, Vector(0.2, 0.43, 0.6893248));
+    SphericalPointDistribution::Polygon_t polygon;
+    polygon +=
+        RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI),
+        RotationAxis.rotateVector(Vector(-1.,0.,0.), 47.6/180*M_PI);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<6>();
+    SphericalPointDistribution::Polygon_t expected = newpolygon;
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second spoint
+    for (SphericalPointDistribution::Polygon_t::iterator iter = expected.begin();
+        iter != expected.end(); ++iter)
+      *iter = RotationAxis.rotateVector(*iter, 47.6/180*M_PI);
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+    // the four remaining points sit on a plane that may have been rotated arbitrarily
+    // so we cannot simply check for equality between expected and remaining
+    // hence, we just check that they are orthogonal to the first two points
+    CPPUNIT_ASSERT_EQUAL( expected.size(), remaining.size() );
+    for (SphericalPointDistribution::Polygon_t::const_iterator fixiter = polygon.begin();
+        fixiter != polygon.end(); ++fixiter) {
+      for (SphericalPointDistribution::Polygon_t::const_iterator iter = remaining.begin();
+          iter != remaining.end(); ++iter) {
+        CPPUNIT_ASSERT( (*fixiter).IsNormalTo(*iter) );
+      }
+    }
+  }
+
+  // test with three points, matching trivially
+  {
+    SphericalPointDistribution::Polygon_t polygon;
+    polygon +=
+        Vector(1.,0.,0.),
+        Vector(-1., 0.0, 0.0),
+        Vector(0.0, 1., 0.0);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<6>();
+    SphericalPointDistribution::Polygon_t expected = newpolygon;
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    expected.pop_front(); // remove third point
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+  }
+
+  // test with three points, full rotation
+  {
+    Line RotationAxis(zeroVec, Vector(0.2, 0.43, 0.6893248));
+    SphericalPointDistribution::Polygon_t polygon;
+    polygon +=
+        RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI),
+        RotationAxis.rotateVector(Vector(-1., 0.0, 0.0), 47.6/180*M_PI),
+        RotationAxis.rotateVector(Vector(0.0, 1., 0.0), 47.6/180*M_PI);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<6>();
+    SphericalPointDistribution::Polygon_t expected = newpolygon;
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    expected.pop_front(); // remove third point
+    for (SphericalPointDistribution::Polygon_t::iterator iter = expected.begin();
+        iter != expected.end(); ++iter)
+      *iter = RotationAxis.rotateVector(*iter, 47.6/180*M_PI);
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+  }
 }
 
@@ -358 +695 @@
     CPPUNIT_ASSERT_EQUAL( expected, remaining );
   }
+
+  // test with two points, matching trivially
+  {
+    SphericalPointDistribution::Polygon_t polygon;
+    polygon += Vector(1.,0.,0.), Vector(-1.,0.,0.);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<7>();
+    SphericalPointDistribution::Polygon_t expected = newpolygon;
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+  }
+
+  // test with two points, full rotation
+  {
+    Line RotationAxis(zeroVec, Vector(0.2, 0.43, 0.6893248));
+    SphericalPointDistribution::Polygon_t polygon;
+    polygon +=
+        RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI),
+        RotationAxis.rotateVector(Vector(-1.,0.,0.), 47.6/180*M_PI);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<7>();
+    SphericalPointDistribution::Polygon_t expected = newpolygon;
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    for (SphericalPointDistribution::Polygon_t::iterator iter = expected.begin();
+        iter != expected.end(); ++iter)
+      *iter = RotationAxis.rotateVector(*iter, 47.6/180*M_PI);
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+    // the five remaining points sit on a plane that may have been rotated arbitrarily
+    // so we cannot simply check for equality between expected and remaining
+    // hence, we just check that they are orthogonal to the first two points
+    CPPUNIT_ASSERT_EQUAL( expected.size(), remaining.size() );
+    for (SphericalPointDistribution::Polygon_t::const_iterator fixiter = polygon.begin();
+        fixiter != polygon.end(); ++fixiter) {
+      for (SphericalPointDistribution::Polygon_t::const_iterator iter = remaining.begin();
+          iter != remaining.end(); ++iter) {
+        CPPUNIT_ASSERT( (*fixiter).IsNormalTo(*iter) );
+      }
+    }
+  }
+
+  // test with three points, matching trivially
+  {
+    SphericalPointDistribution::Polygon_t polygon;
+    polygon +=
+        Vector(1.,0.,0.),
+        Vector(-1., 0.0, 0.0),
+        Vector(0.0, 1., 0.0);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<7>();
+    SphericalPointDistribution::Polygon_t expected = newpolygon;
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    expected.pop_front(); // remove third point
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+  }
+
+  // test with three points, full rotation
+  {
+    Line RotationAxis(zeroVec, Vector(0.2, 0.43, 0.6893248));
+    SphericalPointDistribution::Polygon_t polygon;
+    polygon +=
+        RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI),
+        RotationAxis.rotateVector(Vector(-1., 0.0, 0.0), 47.6/180*M_PI),
+        RotationAxis.rotateVector(Vector(0.0, 1., 0.0), 47.6/180*M_PI);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<7>();
+    SphericalPointDistribution::Polygon_t expected = newpolygon;
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    expected.pop_front(); // remove third point
+    for (SphericalPointDistribution::Polygon_t::iterator iter = expected.begin();
+        iter != expected.end(); ++iter)
+      *iter = RotationAxis.rotateVector(*iter, 47.6/180*M_PI);
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+  }
 }
 
@@ -400 +829 @@
     CPPUNIT_ASSERT_EQUAL( expected, remaining );
   }
+
+  // test with two points, matching trivially
+  {
+    SphericalPointDistribution::Polygon_t polygon;
+    polygon += Vector(1.,0.,0.), Vector(-1.,0.,0.);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<8>();
+    SphericalPointDistribution::Polygon_t expected = newpolygon;
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+  }
+
+  // test with two points, full rotation
+  {
+    Line RotationAxis(zeroVec, Vector(0.2, 0.43, 0.6893248));
+    SphericalPointDistribution::Polygon_t polygon;
+    polygon +=
+        RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI),
+        RotationAxis.rotateVector(Vector(-1.,0.,0.), 47.6/180*M_PI);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<8>();
+    SphericalPointDistribution::Polygon_t expected = newpolygon;
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    for (SphericalPointDistribution::Polygon_t::iterator iter = expected.begin();
+        iter != expected.end(); ++iter)
+      *iter = RotationAxis.rotateVector(*iter, 47.6/180*M_PI);
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+    // the six remaining points sit on two planes that may have been rotated arbitrarily
+    // so we cannot simply check for equality between expected and remaining
+    // hence, we just check that they are orthogonal to the first two points
+    CPPUNIT_ASSERT_EQUAL( expected.size(), remaining.size() );
+    for (SphericalPointDistribution::Polygon_t::const_iterator fixiter = polygon.begin();
+        fixiter != polygon.end(); ++fixiter) {
+      SphericalPointDistribution::Polygon_t::const_iterator expectiter = expected.begin();
+      SphericalPointDistribution::Polygon_t::const_iterator remainiter = remaining.begin();
+      for (;remainiter != remaining.end(); ++expectiter, ++remainiter) {
+        // check that points in expected/remaining have same angle to the given ones
+//        CPPUNIT_ASSERT_EQUAL( (*expectiter).Angle(*fixiter), (*remainiter).Angle(*fixiter) );
+        CPPUNIT_ASSERT( fabs( (*expectiter).Angle(*fixiter) - (*remainiter).Angle(*fixiter) )
+            < std::numeric_limits<double>::epsilon()*1e4 );
+      }
+    }
+  }
+
+  // test with three points, matching trivially
+  {
+    SphericalPointDistribution::Polygon_t polygon;
+    polygon +=
+        Vector(1.,0.,0.),
+        Vector(-1., 0.0, 0.0),
+        Vector(-1./3.0, 2.0*M_SQRT2/3.0, 0.0);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<8>();
+    SphericalPointDistribution::Polygon_t expected = newpolygon;
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    expected.pop_front(); // remove third point
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+  }
+
+  // test with three points, full rotation
+  {
+    Line RotationAxis(zeroVec, Vector(0.2, 0.43, 0.6893248));
+    SphericalPointDistribution::Polygon_t polygon;
+    polygon +=
+        RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI),
+        RotationAxis.rotateVector(Vector(-1., 0.0, 0.0), 47.6/180*M_PI),
+        RotationAxis.rotateVector(Vector(-1./3.0, 2.0*M_SQRT2/3.0, 0.0), 47.6/180*M_PI);
+    SphericalPointDistribution::Polygon_t newpolygon =
+        SPD.get<8>();
+    SphericalPointDistribution::Polygon_t expected = newpolygon;
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    expected.pop_front(); // remove third point
+    for (SphericalPointDistribution::Polygon_t::iterator iter = expected.begin();
+        iter != expected.end(); ++iter)
+      *iter = RotationAxis.rotateVector(*iter, 47.6/180*M_PI);
+    SphericalPointDistribution::Polygon_t remaining =
+        SphericalPointDistribution::matchSphericalPointDistributions(
+            polygon,
+            newpolygon);
+    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+  }
 }