Index: src/Fragmentation/Exporters/SphericalPointDistribution.cpp
===================================================================
--- src/Fragmentation/Exporters/SphericalPointDistribution.cpp	(revision 64cafb2cea4919e67a64a683c7bfb1682edd240f)
+++ src/Fragmentation/Exporters/SphericalPointDistribution.cpp	(revision cdac1dec22b8e27ee050f890677c8946a0ac6c71)
@@ -39,4 +39,5 @@
 #include "CodePatterns/Assert.hpp"
 #include "CodePatterns/IteratorAdaptors.hpp"
+#include "CodePatterns/Log.hpp"
 #include "CodePatterns/toString.hpp"
 
@@ -57,6 +58,9 @@
 typedef std::vector<double> DistanceArray_t;
 
+// static instances
+const double SphericalPointDistribution::SQRT_3(sqrt(3.0));
+
 DistanceArray_t calculatePairwiseDistances(
-    const std::vector<Vector> &_points,
+    const std::vector<Vector> &_returnpolygon,
     const IndexList_t &_indices
     )
@@ -69,5 +73,5 @@
       if (firstiter == seconditer)
         continue;
-      const double distance = (_points[*firstiter] - _points[*seconditer]).NormSquared();
+      const double distance = (_returnpolygon[*firstiter] - _returnpolygon[*seconditer]).NormSquared();
       result.push_back(distance);
     }
@@ -89,6 +93,6 @@
  * \a _new.
  *
- * \param _old first set of points (fewer or equal to \a _new)
- * \param _new second set of points
+ * \param _old first set of returnpolygon (fewer or equal to \a _new)
+ * \param _new second set of returnpolygon
  * \param _Matching matching between the two sets
  * \return pair with L1 and squared L2 error
@@ -129,33 +133,33 @@
 
 SphericalPointDistribution::Polygon_t removeMatchingPoints(
-    const SphericalPointDistribution::Polygon_t &_points,
+    const SphericalPointDistribution::Polygon_t &_returnpolygon,
     const IndexList_t &_matchingindices
     )
 {
-  SphericalPointDistribution::Polygon_t remainingpoints;
+  SphericalPointDistribution::Polygon_t remainingreturnpolygon;
   IndexArray_t indices(_matchingindices.begin(), _matchingindices.end());
   std::sort(indices.begin(), indices.end());
   IndexArray_t::const_iterator valueiter = indices.begin();
   SphericalPointDistribution::Polygon_t::const_iterator pointiter =
-      _points.begin();
-  for (unsigned int i=0; i< _points.size(); ++i, ++pointiter) {
+      _returnpolygon.begin();
+  for (unsigned int i=0; i< _returnpolygon.size(); ++i, ++pointiter) {
     // skip all those in values
     if (*valueiter == i)
       ++valueiter;
     else
-      remainingpoints.push_back(*pointiter);
-  }
-
-  return remainingpoints;
+      remainingreturnpolygon.push_back(*pointiter);
+  }
+
+  return remainingreturnpolygon;
 }
 
 /** Rotates a given polygon around x, y, and z axis by the given angles.
  *
- * Essentially, we concentrate on the three points of the polygon to rotate
+ * Essentially, we concentrate on the three returnpolygon of the polygon to rotate
  * to the correct position. First, we rotate its center via \a angles,
  * then we rotate the "triangle" around itself/\a _RotationAxis by
  * \a _RotationAngle.
  *
- * \param _polygon polygon whose points to rotate
+ * \param _polygon polygon whose returnpolygon to rotate
  * \param _angles vector with rotation angles for x,y,z axis
  * \param _RotationAxis
@@ -188,6 +192,6 @@
   double bestL2;
   IndexList_t bestmatching;
-  VectorArray_t oldpoints;
-  VectorArray_t newpoints;
+  VectorArray_t oldreturnpolygon;
+  VectorArray_t newreturnpolygon;
 };
 
@@ -229,5 +233,5 @@
       // calculate errors
       std::pair<double, double> errors = calculateErrorOfMatching(
-          _MCS.oldpoints, _MCS.newpoints, _matching);
+          _MCS.oldreturnpolygon, _MCS.newreturnpolygon, _matching);
       if (errors.first < L1THRESHOLD) {
         _MCS.bestmatching = _matching;
@@ -248,5 +252,5 @@
     )
 {
-  SphericalPointDistribution::Polygon_t remainingpoints;
+  SphericalPointDistribution::Polygon_t remainingreturnpolygon;
   VectorArray_t remainingold(_polygon.begin(), _polygon.end());
   VectorArray_t remainingnew(_newpolygon.begin(), _newpolygon.end());
@@ -256,6 +260,6 @@
     MCS.foundflag = false;
     MCS.bestL2 = std::numeric_limits<double>::max();
-    MCS.oldpoints.insert(MCS.oldpoints.begin(), _polygon.begin(),_polygon.end() );
-    MCS.newpoints.insert(MCS.newpoints.begin(), _newpolygon.begin(),_newpolygon.end() );
+    MCS.oldreturnpolygon.insert(MCS.oldreturnpolygon.begin(), _polygon.begin(),_polygon.end() );
+    MCS.newreturnpolygon.insert(MCS.newreturnpolygon.begin(), _newpolygon.begin(),_newpolygon.end() );
 
     // search for bestmatching combinatorially
@@ -269,5 +273,5 @@
       const unsigned int matchingsize = _polygon.size();
       ASSERT( matchingsize <= indices.size(),
-          "SphericalPointDistribution::matchSphericalPointDistributions() - not enough new points to choose for matching to old ones.");
+          "SphericalPointDistribution::matchSphericalPointDistributions() - not enough new returnpolygon to choose for matching to old ones.");
       recurseMatchings(MCS, matching, indices, matchingsize);
     }
@@ -278,5 +282,5 @@
     Vector newCenter;
     {
-      // calculate center of triangle/line/point consisting of first points of matching
+      // calculate center of triangle/line/point consisting of first returnpolygon of matching
       Vector oldCenter;
       IndexList_t::const_iterator iter = MCS.bestmatching.begin();
@@ -313,5 +317,5 @@
         rotatePolygon(_newpolygon, angles, RotationAxis, RotationAngle);
 
-    // remove all points in matching and return remaining ones
+    // remove all returnpolygon in matching and return remaining ones
     return removeMatchingPoints(rotated_newpolygon, MCS.bestmatching);
   } else
@@ -319,4 +323,59 @@
 }
 
-
-
+SphericalPointDistribution::Polygon_t
+SphericalPointDistribution::getSimplePolygon(const int _NumberOfPoints) const
+{
+  Polygon_t returnpolygon;
+
+	switch (_NumberOfPoints)
+	{
+	  case 0:
+	    returnpolygon = get<0>();
+	    break;
+	  case 1:
+	    returnpolygon = get<1>();
+	    break;
+	  case 2:
+	    returnpolygon = get<2>();
+	    break;
+	  case 3:
+	    returnpolygon = get<3>();
+	    break;
+	  case 4:
+	    returnpolygon = get<4>();
+	    break;
+	  case 5:
+	    returnpolygon = get<5>();
+	    break;
+	  case 6:
+	    returnpolygon = get<6>();
+	    break;
+	  case 7:
+	    returnpolygon = get<7>();
+	    break;
+	  case 8:
+	    returnpolygon = get<8>();
+	    break;
+	  case 9:
+	    returnpolygon = get<9>();
+	    break;
+	  case 10:
+	    returnpolygon = get<10>();
+	    break;
+	  case 11:
+	    returnpolygon = get<11>();
+	    break;
+	  case 12:
+	    returnpolygon = get<12>();
+	    break;
+	  case 14:
+	    returnpolygon = get<14>();
+	    break;
+	  default:
+	    ASSERT(0, "SphericalPointDistribution::initSelf() - cannot deal with the case "
+	        +toString(_NumberOfPoints)+".");
+	}
+
+	return returnpolygon;
+}
+
Index: src/Fragmentation/Exporters/SphericalPointDistribution.hpp
===================================================================
--- src/Fragmentation/Exporters/SphericalPointDistribution.hpp	(revision 64cafb2cea4919e67a64a683c7bfb1682edd240f)
+++ src/Fragmentation/Exporters/SphericalPointDistribution.hpp	(revision cdac1dec22b8e27ee050f890677c8946a0ac6c71)
@@ -39,6 +39,5 @@
    */
   SphericalPointDistribution(const double _Bondlength = 1.) :
-    Bondlength(_Bondlength),
-    SQRT_3(sqrt(3.0))
+    Bondlength(_Bondlength)
   {}
 
@@ -52,9 +51,14 @@
    * \return Polygon_t with points on the surface centered at (0,0,0)
    */
-  template <int N> Polygon_t get()
+  template <int N> Polygon_t get() const
   {
     ASSERT(0, "SphericalPointDistribution::get() - not specialized for "+toString(N)+".");
   }
 
+  /** Initializes the polygon with the given \a _NumberOfPoints.
+   *
+   * \param _NumberOfPoints number of points
+   */
+  Polygon_t getSimplePolygon(const int _NumberOfPoints) const;
 
   /** Matches a given spherical distribution with another containing more
@@ -78,23 +82,23 @@
   const double Bondlength;
   //!> precalculated value for root of 3
-  const double SQRT_3;
+  static const double SQRT_3;
 };
 
 // declare specializations
 
-template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<0>();
-template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<1>();
-template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<2>();
-template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<3>();
-template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<4>();
-template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<5>();
-template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<6>();
-template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<7>();
-template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<8>();
-template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<9>();
-template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<10>();
-template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<11>();
-template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<12>();
-template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<14>();
+template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<0>() const;
+template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<1>() const;
+template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<2>() const;
+template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<3>() const;
+template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<4>() const;
+template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<5>() const;
+template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<6>() const;
+template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<7>() const;
+template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<8>() const;
+template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<9>() const;
+template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<10>() const;
+template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<11>() const;
+template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<12>() const;
+template <> SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<14>() const;
 
 #endif /* SPHERICALPOINTDISTRIBUTION_HPP_ */
Index: src/Fragmentation/Exporters/SphericalPointDistribution_getPoints.cpp
===================================================================
--- src/Fragmentation/Exporters/SphericalPointDistribution_getPoints.cpp	(revision 64cafb2cea4919e67a64a683c7bfb1682edd240f)
+++ src/Fragmentation/Exporters/SphericalPointDistribution_getPoints.cpp	(revision cdac1dec22b8e27ee050f890677c8946a0ac6c71)
@@ -42,5 +42,5 @@
 
 template <>
-SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<0>()
+SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<0>() const
 {
   Polygon_t polygon;
@@ -51,5 +51,5 @@
 
 template <>
-SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<1>()
+SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<1>() const
 {
   Polygon_t polygon;
@@ -61,5 +61,5 @@
 
 template <>
-SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<2>()
+SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<2>() const
 {
   Polygon_t polygon;
@@ -72,5 +72,5 @@
 
 template <>
-SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<3>()
+SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<3>() const
 {
   Polygon_t polygon;
@@ -84,5 +84,5 @@
 
 template <>
-SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<4>()
+SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<4>() const
 {
   Polygon_t polygon;
@@ -97,5 +97,5 @@
 
 template <>
-SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<5>()
+SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<5>() const
 {
   Polygon_t polygon;
@@ -111,5 +111,5 @@
 
 template <>
-SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<6>()
+SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<6>() const
 {
   Polygon_t polygon;
@@ -126,5 +126,5 @@
 
 template <>
-SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<7>()
+SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<7>() const
 {
   Polygon_t polygon;
@@ -142,5 +142,5 @@
 
 template <>
-SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<8>()
+SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<8>() const
 {
   Polygon_t polygon;
@@ -159,5 +159,5 @@
 
 template <>
-SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<9>()
+SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<9>() const
 {
   Polygon_t polygon;
@@ -177,5 +177,5 @@
 
 template <>
-SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<10>()
+SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<10>() const
 {
   Polygon_t polygon;
@@ -197,5 +197,5 @@
 
 template <>
-SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<11>()
+SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<11>() const
 {
   Polygon_t polygon;
@@ -223,5 +223,5 @@
 
 template <>
-SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<12>()
+SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<12>() const
 {
   Polygon_t polygon;
@@ -245,5 +245,5 @@
 
 template <>
-SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<14>()
+SphericalPointDistribution::Polygon_t SphericalPointDistribution::get<14>() const
 {
   Polygon_t polygon;
