Index: src/Fragmentation/Exporters/unittests/SphericalPointDistributionUnitTest.cpp
===================================================================
--- src/Fragmentation/Exporters/unittests/SphericalPointDistributionUnitTest.cpp	(revision b67d89f3c210e09d45c1656a8b372c96edc73f25)
+++ src/Fragmentation/Exporters/unittests/SphericalPointDistributionUnitTest.cpp	(revision 2199c270b5bb1c4a866b5b3db213f32babe7c222)
@@ -90,6 +90,6 @@
   // test with one point, matching trivially
   {
-    SphericalPointDistribution::Polygon_t polygon;
-    polygon += Vector(1.,0.,0.);
+    SphericalPointDistribution::WeightedPolygon_t polygon;
+    polygon += std::make_pair(Vector(1.,0.,0.), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<2>();
@@ -105,6 +105,6 @@
   // test with one point, just a flip of axis
   {
-    SphericalPointDistribution::Polygon_t polygon;
-    polygon += Vector(0.,1.,0.);
+    SphericalPointDistribution::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(0.,1.,0.), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<2>();
@@ -120,6 +120,6 @@
   // test with one point, just a flip to another axis
   {
-    SphericalPointDistribution::Polygon_t polygon;
-    polygon += Vector(0.,0.,-1.);
+    SphericalPointDistribution::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(0.,0.,-1.), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<2>();
@@ -136,6 +136,6 @@
   {
     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);
+    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>();
@@ -151,15 +151,15 @@
 
 void perturbPolygon(
-    SphericalPointDistribution::Polygon_t &_polygon,
+    SphericalPointDistribution::WeightedPolygon_t &_polygon,
     double _amplitude
     )
 {
-  for (SphericalPointDistribution::Polygon_t::iterator iter = _polygon.begin();
+  for (SphericalPointDistribution::WeightedPolygon_t::iterator iter = _polygon.begin();
       iter != _polygon.end(); ++iter) {
     Vector perturber;
-    perturber.GetOneNormalVector((*iter));
+    perturber.GetOneNormalVector(iter->first);
     perturber.Scale(_amplitude);
-    *iter = *iter + perturber;
-    (*iter).Normalize();
+    iter->first = iter->first + perturber;
+    (iter->first).Normalize();
   }
 }
@@ -254,6 +254,6 @@
   // test with one point, matching trivially
   {
-    SphericalPointDistribution::Polygon_t polygon;
-    polygon += Vector(1.,0.,0.);
+    SphericalPointDistribution::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(1.,0.,0.), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<3>();
@@ -269,6 +269,6 @@
   // test with one point, just a flip of x and y axis
   {
-    SphericalPointDistribution::Polygon_t polygon;
-    polygon += Vector(0.,1.,0.);
+    SphericalPointDistribution::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(0.,1.,0.), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<3>();
@@ -289,6 +289,7 @@
   // test with two points, matching trivially
   {
-    SphericalPointDistribution::Polygon_t polygon;
-    polygon += Vector(1.,0.,0.), Vector(-0.5, sqrt(3)*0.5,0.);
+    SphericalPointDistribution::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(1.,0.,0.), 1);
+    polygon += std::make_pair( Vector(-0.5, sqrt(3)*0.5,0.), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<3>();
@@ -310,8 +311,7 @@
   {
     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::WeightedPolygon_t polygon;
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI), 1);
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(-0.5, sqrt(3)*0.5,0.), 47.6/180*M_PI), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<3>();
@@ -335,6 +335,8 @@
   // 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::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(1.,0.,0.), 1);
+    polygon += std::make_pair( Vector(-0.5, sqrt(3)*0.5,0.), 1);
+    polygon += std::make_pair( Vector(-0.5, -sqrt(3)*0.5,0.), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<3>();
@@ -355,9 +357,8 @@
   {
     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::WeightedPolygon_t polygon;
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI), 1);
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(-0.5, sqrt(3)*0.5,0.), 47.6/180*M_PI), 1);
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(-0.5, -sqrt(3)*0.5,0.), 47.6/180*M_PI), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<3>();
@@ -383,6 +384,6 @@
   // test with one point, matching trivially
   {
-    SphericalPointDistribution::Polygon_t polygon;
-    polygon += Vector(1.,0.,0.);
+    SphericalPointDistribution::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(1.,0.,0.), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<4>();
@@ -398,6 +399,6 @@
   // test with one point, just a flip of axis
   {
-    SphericalPointDistribution::Polygon_t polygon;
-    polygon += Vector(0.,1.,0.);
+    SphericalPointDistribution::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(0.,1.,0.), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<4>();
@@ -418,6 +419,7 @@
   // 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::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(1.,0.,0.), 1);
+    polygon += std::make_pair( Vector(-1./3.0, 2.0*M_SQRT2/3.0,0.), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<4>();
@@ -438,6 +440,7 @@
   // test with two points, matching trivially, also with slightly perturbed
   {
-    SphericalPointDistribution::Polygon_t polygon;
-    polygon += Vector(1.,0.,0.), Vector(-1./3.0, 2.0*M_SQRT2/3.0,0.);
+    SphericalPointDistribution::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(1.,0.,0.), 1);
+    polygon += std::make_pair( Vector(-1./3.0, 2.0*M_SQRT2/3.0,0.), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<4>();
@@ -459,8 +462,7 @@
   {
     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::WeightedPolygon_t polygon;
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI), 1);
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(-1./3.0, 2.0*M_SQRT2/3.0,0.), 47.6/180*M_PI), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<4>();
@@ -484,9 +486,8 @@
   // 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::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(1.,0.,0.), 1);
+    polygon += std::make_pair( Vector(-1./3.0, 2.0*M_SQRT2/3.0,0.), 1);
+    polygon += std::make_pair( Vector(-1./3.0, -M_SQRT2/3.0, M_SQRT2/sqrt(3)), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<4>();
@@ -509,9 +510,8 @@
   {
     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::WeightedPolygon_t polygon;
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI), 1);
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(-1./3.0, 2.0*M_SQRT2/3.0,0.), 47.6/180*M_PI), 1);
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(-1./3.0, -M_SQRT2/3.0, M_SQRT2/sqrt(3)), 47.6/180*M_PI), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<4>();
@@ -543,6 +543,6 @@
   // test with one point, matching trivially
   {
-    SphericalPointDistribution::Polygon_t polygon;
-    polygon += Vector(1.,0.,0.);
+    SphericalPointDistribution::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(1.,0.,0.), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<5>();
@@ -558,6 +558,6 @@
   // test with one point, just a flip of axis
   {
-    SphericalPointDistribution::Polygon_t polygon;
-    polygon += Vector(0.,1.,0.);
+    SphericalPointDistribution::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(0.,1.,0.), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<5>();
@@ -578,6 +578,7 @@
   // test with two points, matching trivially
   {
-    SphericalPointDistribution::Polygon_t polygon;
-    polygon += Vector(1.,0.,0.), Vector(-1.,0.,0.);
+    SphericalPointDistribution::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(1.,0.,0.), 1);
+    polygon += std::make_pair( Vector(-1.,0.,0.), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<5>();
@@ -599,8 +600,7 @@
   {
     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::WeightedPolygon_t polygon;
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180.*M_PI), 1);
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(-1.,0.,0.), 47.6/180.*M_PI), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<5>();
@@ -619,9 +619,9 @@
     // 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();
+    for (SphericalPointDistribution::WeightedPolygon_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) );
+        CPPUNIT_ASSERT( (fixiter->first).IsNormalTo(*iter) );
       }
     }
@@ -630,9 +630,8 @@
   // 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::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(1.,0.,0.), 1);
+    polygon += std::make_pair( Vector(-1., 0.0, 0.0), 1);
+    polygon += std::make_pair( Vector(0.0, 1., 0.0), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<5>();
@@ -655,9 +654,8 @@
   {
     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::WeightedPolygon_t polygon;
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI), 1);
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(-1., 0.0, 0.0), 47.6/180*M_PI), 1);
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(0.0, 1., 0.0), 47.6/180*M_PI), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<5>();
@@ -689,6 +687,6 @@
   // test with one point, matching trivially
   {
-    SphericalPointDistribution::Polygon_t polygon;
-    polygon += Vector(1.,0.,0.);
+    SphericalPointDistribution::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(1.,0.,0.), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<6>();
@@ -704,6 +702,6 @@
   // test with one point, just a flip of axis
   {
-    SphericalPointDistribution::Polygon_t polygon;
-    polygon += Vector(0.,1.,0.);
+    SphericalPointDistribution::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(0.,1.,0.), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<6>();
@@ -724,6 +722,7 @@
   // test with two points, matching trivially
   {
-    SphericalPointDistribution::Polygon_t polygon;
-    polygon += Vector(1.,0.,0.), Vector(-1.,0.,0.);
+    SphericalPointDistribution::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(1.,0.,0.), 1);
+    polygon += std::make_pair( Vector(-1.,0.,0.), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<6>();
@@ -745,8 +744,7 @@
   {
     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::WeightedPolygon_t polygon;
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI), 1);
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(-1.,0.,0.), 47.6/180*M_PI), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<6>();
@@ -765,9 +763,9 @@
     // 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();
+    for (SphericalPointDistribution::WeightedPolygon_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) );
+        CPPUNIT_ASSERT( (fixiter->first).IsNormalTo(*iter) );
       }
     }
@@ -776,9 +774,8 @@
   // 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::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(1.,0.,0.), 1);
+    polygon += std::make_pair( Vector(-1., 0.0, 0.0), 1);
+    polygon += std::make_pair( Vector(0.0, 1., 0.0), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<6>();
@@ -801,9 +798,8 @@
   {
     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::WeightedPolygon_t polygon;
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI), 1);
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(-1., 0.0, 0.0), 47.6/180*M_PI), 1);
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(0.0, 1., 0.0), 47.6/180*M_PI), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<6>();
@@ -835,6 +831,6 @@
   // test with one point, matching trivially
   {
-    SphericalPointDistribution::Polygon_t polygon;
-    polygon += Vector(1.,0.,0.);
+    SphericalPointDistribution::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(1.,0.,0.), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<7>();
@@ -850,6 +846,6 @@
   // test with one point, just a flip of axis
   {
-    SphericalPointDistribution::Polygon_t polygon;
-    polygon += Vector(0.,1.,0.);
+    SphericalPointDistribution::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(0.,1.,0.), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<7>();
@@ -870,6 +866,7 @@
   // test with two points, matching trivially
   {
-    SphericalPointDistribution::Polygon_t polygon;
-    polygon += Vector(1.,0.,0.), Vector(-1.,0.,0.);
+    SphericalPointDistribution::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(1.,0.,0.), 1);
+    polygon += std::make_pair( Vector(-1.,0.,0.), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<7>();
@@ -891,8 +888,7 @@
   {
     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::WeightedPolygon_t polygon;
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI), 1);
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(-1.,0.,0.), 47.6/180*M_PI), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<7>();
@@ -911,9 +907,9 @@
     // 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();
+    for (SphericalPointDistribution::WeightedPolygon_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) );
+        CPPUNIT_ASSERT( (fixiter->first).IsNormalTo(*iter) );
       }
     }
@@ -922,9 +918,8 @@
   // 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::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(1.,0.,0.), 1);
+    polygon += std::make_pair( Vector(-1., 0.0, 0.0), 1);
+    polygon += std::make_pair( Vector(0.0, 1., 0.0), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<7>();
@@ -947,9 +942,8 @@
   {
     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::WeightedPolygon_t polygon;
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI), 1);
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(-1., 0.0, 0.0), 47.6/180*M_PI), 1);
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(0.0, 1., 0.0), 47.6/180*M_PI), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<7>();
@@ -981,6 +975,6 @@
   // test with one point, matching trivially
   {
-    SphericalPointDistribution::Polygon_t polygon;
-    polygon += Vector(1.,0.,0.);
+    SphericalPointDistribution::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(1.,0.,0.), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<8>();
@@ -996,6 +990,6 @@
   // test with one point, just a flip of axis
   {
-    SphericalPointDistribution::Polygon_t polygon;
-    polygon += Vector(0.,1.,0.);
+    SphericalPointDistribution::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(0.,1.,0.), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<8>();
@@ -1016,6 +1010,7 @@
   // test with two points, matching trivially
   {
-    SphericalPointDistribution::Polygon_t polygon;
-    polygon += Vector(1.,0.,0.), Vector(-1.,0.,0.);
+    SphericalPointDistribution::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(1.,0.,0.), 1);
+    polygon += std::make_pair( Vector(-1.,0.,0.), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<8>();
@@ -1037,8 +1032,7 @@
   {
     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::WeightedPolygon_t polygon;
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI), 1);
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(-1.,0.,0.), 47.6/180*M_PI), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<8>();
@@ -1057,5 +1051,5 @@
     // 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();
+    for (SphericalPointDistribution::WeightedPolygon_t::const_iterator fixiter = polygon.begin();
         fixiter != polygon.end(); ++fixiter) {
       SphericalPointDistribution::Polygon_t::const_iterator expectiter = expected.begin();
@@ -1064,5 +1058,5 @@
         // 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) )
+        CPPUNIT_ASSERT( fabs( (*expectiter).Angle(fixiter->first) - (*remainiter).Angle(fixiter->first) )
             < std::numeric_limits<double>::epsilon()*1e4 );
       }
@@ -1072,9 +1066,8 @@
   // 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::WeightedPolygon_t polygon;
+    polygon += std::make_pair( Vector(1.,0.,0.), 1);
+    polygon += std::make_pair( Vector(-1., 0.0, 0.0), 1);
+    polygon += std::make_pair( Vector(-1./3.0, 2.0*M_SQRT2/3.0, 0.0), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<8>();
@@ -1097,9 +1090,8 @@
   {
     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::WeightedPolygon_t polygon;
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI), 1);
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(-1., 0.0, 0.0), 47.6/180*M_PI), 1);
+    polygon += std::make_pair(RotationAxis.rotateVector(Vector(-1./3.0, 2.0*M_SQRT2/3.0, 0.0), 47.6/180*M_PI), 1);
     SphericalPointDistribution::Polygon_t newpolygon =
         SPD.get<8>();
