Changes in / [51c910:36ec71]

Location:

src

Files:

• boundary.cpp (modified) (44 diffs)
• boundary.hpp (modified) (5 diffs)
• builder.cpp (modified) (20 diffs)
• config.cpp (modified) (28 diffs)
• datacreator.cpp (modified) (11 diffs)
• datacreator.hpp (modified) (1 diff)
• element.cpp (modified) (2 diffs)
• ellipsoid.cpp (modified) (8 diffs)
• ellipsoid.hpp (modified) (2 diffs)
• helpers.cpp (modified) (11 diffs)
• helpers.hpp (modified) (11 diffs)
• joiner.cpp (modified) (1 diff)
• linkedcell.cpp (modified) (7 diffs)
• linkedcell.hpp (modified) (1 diff)
• molecules.cpp (modified) (16 diffs)
• molecules.hpp (modified) (8 diffs)
• parser.cpp (modified) (5 diffs)
• parser.hpp (modified) (4 diffs)
• periodentafel.cpp (modified) (3 diffs)
• periodentafel.hpp (modified) (2 diffs)
• stackclass.hpp (modified) (13 diffs)
• vector.cpp (modified) (37 diffs)
• vector.hpp (modified) (1 diff)
• verbose.cpp (modified) (1 diff)

src/boundary.cpp

@@ -1 +1 @@
 #include "boundary.hpp"
+#include "linkedcell.hpp"
+#include "molecules.hpp"
+#include <gsl/gsl_matrix.h>
+#include <gsl/gsl_linalg.h>
+#include <gsl/gsl_multimin.h>
+#include <gsl/gsl_permutation.h>
 
 #define DEBUG 1
@@ -9 +15 @@
 #define Raster3DSuffix ".r3d"
 #define VRMLSUffix ".wrl"
-#define HULLEPSILON MYEPSILON
+#define HULLEPSILON 1e-7
 
 // ======================================== Points on Boundary =================================
@@ -34 +40 @@
     cerr << "WARNING: Memory Leak! I " << *this << " am still connected to some lines." << endl;
   node = NULL;
-  lines.clear();
 }
 ;
@@ -90 +95 @@
 BoundaryLineSet::~BoundaryLineSet()
 {
+  int Numbers[2];
+  Numbers[0] = endpoints[1]->Nr;
+  Numbers[1] = endpoints[0]->Nr;
   for (int i = 0; i < 2; i++) {
     cout << Verbose(5) << "Erasing Line Nr. " << Nr << " in boundary point " << *endpoints[i] << "." << endl;
-    endpoints[i]->lines.erase(Nr);
-    LineMap::iterator tester = endpoints[i]->lines.begin();
-    tester++;
-    if (tester == endpoints[i]->lines.end()) {
+    // as there may be multiple lines with same endpoints, we have to go through each and find in the endpoint's line list this line set
+    pair<LineMap::iterator, LineMap::iterator> erasor = endpoints[i]->lines.equal_range(Numbers[i]);
+    for (LineMap::iterator Runner = erasor.first; Runner != erasor.second; Runner++)
+      if ((*Runner).second == this) {
+        endpoints[i]->lines.erase(Runner);
+        break;
+      }
+    if (endpoints[i]->lines.empty()) {
       cout << Verbose(5) << *endpoints[i] << " has no more lines it's attached to, erasing." << endl;
       if (endpoints[i] != NULL) {
@@ -143 +155 @@
 ;
 
-BoundaryTriangleSet::BoundaryTriangleSet(class BoundaryLineSet *line[3],
-    int number)
+BoundaryTriangleSet::BoundaryTriangleSet(class BoundaryLineSet *line[3], int number)
 {
   // set number
@@ -191 +202 @@
     lines[i]->triangles.erase(Nr);
     if (lines[i]->triangles.empty()) {
-      cout << Verbose(5) << *lines[i] << " is no more attached to any triangle, erasing." << endl;
       if (lines[i] != NULL) {
+        cout << Verbose(5) << *lines[i] << " is no more attached to any triangle, erasing." << endl;
         delete (lines[i]);
         lines[i] = NULL;
@@ -198 +209 @@
         cerr << "ERROR: This line " << i << " has already been free'd." << endl;
     } else
-      cout << Verbose(5) << *lines[i] << " is still attached to a triangle." << endl;
+      cout << Verbose(5) << *lines[i] << " is still attached to another triangle." << endl;
   }
 }
@@ -224 +235 @@
 }
 ;
+
+
+// ============================ CandidateForTesselation =============================
+
+CandidateForTesselation::CandidateForTesselation(
+  atom *candidate, BoundaryLineSet* line, Vector OptCandidateCenter, Vector OtherOptCandidateCenter
+) {
+  point = candidate;
+  BaseLine = line;
+  OptCenter.CopyVector(&OptCandidateCenter);
+  OtherOptCenter.CopyVector(&OtherOptCandidateCenter);
+}
+
+CandidateForTesselation::~CandidateForTesselation() {
+  point = NULL;
+  BaseLine = NULL;
+}
 
 // ========================================== F U N C T I O N S =================================
@@ -672 +700 @@
       }
       *rasterfile << "1. 0. 0." << endl;  // red as colour
-      *rasterfile << "18" << endl << "  0.5 0.5 0.5" << endl;  // 18 is transparency type for previous object
+      //*rasterfile << "18" << endl << "  0.5 0.5 0.5" << endl;  // 18 is transparency type for previous object
     }
     *rasterfile << "9\n  terminating special property\n";
@@ -983 +1011 @@
       // set new box dimensions
       *out << Verbose(0) << "Translating to box with these boundaries." << endl;
-      mol->CenterInBox((ofstream *) &cout, &BoxLengths);
+      mol->SetBoxDimension(&BoxLengths);
+      mol->CenterInBox((ofstream *) &cout);
     }
   // update Box of atoms by boundary
@@ -1019 +1048 @@
     } else
       cerr << "ERROR: The triangle " << runner->first << " has already been free'd." << endl;
-  }
-  for (LineMap::iterator runner = LinesOnBoundary.begin(); runner != LinesOnBoundary.end(); runner++) {
-    if (runner->second != NULL) {
-      delete (runner->second);
-      runner->second = NULL;
-    } else
-      cerr << "ERROR: The line " << runner->first << " has already been free'd." << endl;
-  }
-  for (PointMap::iterator runner = PointsOnBoundary.begin(); runner != PointsOnBoundary.end(); runner++) {
-    if (runner->second != NULL) {
-      delete (runner->second);
-      runner->second = NULL;
-    } else
-      cerr << "ERROR: The point " << runner->first << " has already been free'd." << endl;
   }
 }
@@ -1464 +1479 @@
   TPS[n] = new class BoundaryPointSet(Candidate);
   InsertUnique = PointsOnBoundary.insert(PointPair(Candidate->nr, TPS[n]));
-  if (InsertUnique.second) // if new point was not present before, increase counter
-    {
-      PointsOnBoundaryCount++;
-    }
-  else
-    {
-      delete TPS[n];
-      cout << Verbose(2) << "Atom " << *((InsertUnique.first)->second->node)
-          << " gibt's schon in der PointMap." << endl;
-      TPS[n] = (InsertUnique.first)->second;
-    }
+  if (InsertUnique.second) { // if new point was not present before, increase counter
+    PointsOnBoundaryCount++;
+  } else {
+    delete TPS[n];
+    cout << Verbose(3) << "Atom " << *((InsertUnique.first)->second->node) << " is already present in PointsOnBoundary." << endl;
+    TPS[n] = (InsertUnique.first)->second;
+  }
 }
 ;
 
 /** Function tries to add line from current Points in BPS to BoundaryLineSet.
- * If succesful it raises the line count and inserts the new line into the BLS,
- * if unsuccesful, it writes the line which had been present into the BLS, deleting the new constructed one.
+ * If successful it raises the line count and inserts the new line into the BLS,
+ * if unsuccessful, it writes the line which had been present into the BLS, deleting the new constructed one.
  * @param *a first endpoint
  * @param *b second endpoint
  * @param n index of Tesselation::BLS giving the line with both endpoints
  */
-void
-Tesselation::AddTriangleLine(class BoundaryPointSet *a,
-    class BoundaryPointSet *b, int n)
-{
-  LineMap::iterator LineWalker;
-  //cout << "Manually checking endpoints for line." << endl;
-  if ((a->lines.find(b->node->nr)) != a->lines.end()) // ->first == b->node->nr)
-  //If a line is there, how do I recognize that beyond a shadow of a doubt?
-    {
-      //cout << Verbose(2) << "Line exists already, retrieving it from LinesOnBoundarySet" << endl;
-
-      LineWalker = LinesOnBoundary.end();
-      LineWalker--;
-
-      while (LineWalker->second->endpoints[0]->node->nr != min(a->node->nr,
-          b->node->nr) or LineWalker->second->endpoints[1]->node->nr != max(
-          a->node->nr, b->node->nr))
-        {
-          //cout << Verbose(1) << "Looking for line which already exists"<< endl;
-          LineWalker--;
-        }
-      BPS[0] = LineWalker->second->endpoints[0];
-      BPS[1] = LineWalker->second->endpoints[1];
-      BLS[n] = LineWalker->second;
-
-    }
-  else
-    {
-      cout << Verbose(2)
-          << "Adding line which has not been used before between "
-          << *(a->node) << " and " << *(b->node) << "." << endl;
-      BPS[0] = a;
-      BPS[1] = b;
-      BLS[n] = new class BoundaryLineSet(BPS, LinesOnBoundaryCount);
-
-      LinesOnBoundary.insert(LinePair(LinesOnBoundaryCount, BLS[n]));
-      LinesOnBoundaryCount++;
-
-    }
+void Tesselation::AddTriangleLine(class BoundaryPointSet *a, class BoundaryPointSet *b, int n) {
+  bool insertNewLine = true;
+
+  if (a->lines.find(b->node->nr) != a->lines.end()) {
+    LineMap::iterator FindLine;
+    pair<LineMap::iterator,LineMap::iterator> FindPair;
+    FindPair = a->lines.equal_range(b->node->nr);
+
+    for (FindLine = FindPair.first; FindLine != FindPair.second; ++FindLine) {
+      // If there is a line with less than two attached triangles, we don't need a new line.
+      if (FindLine->second->TrianglesCount < 2) {
+        insertNewLine = false;
+        cout << Verbose(3) << "Using existing line " << *FindLine->second << endl;
+
+        BPS[0] = FindLine->second->endpoints[0];
+        BPS[1] = FindLine->second->endpoints[1];
+        BLS[n] = FindLine->second;
+
+        break;
+      }
+    }
+  }
+
+  if (insertNewLine) {
+    AlwaysAddTriangleLine(a, b, n);
+  }
 }
 ;
+
+/**
+ * Adds lines from each of the current points in the BPS to BoundaryLineSet.
+ * Raises the line count and inserts the new line into the BLS.
+ *
+ * @param *a first endpoint
+ * @param *b second endpoint
+ * @param n index of Tesselation::BLS giving the line with both endpoints
+ */
+void Tesselation::AlwaysAddTriangleLine(class BoundaryPointSet *a, class BoundaryPointSet *b, int n)
+{
+  cout << Verbose(3) << "Adding line between " << *(a->node) << " and " << *(b->node) << "." << endl;
+  BPS[0] = a;
+  BPS[1] = b;
+  BLS[n] = new class BoundaryLineSet(BPS, LinesOnBoundaryCount);  // this also adds the line to the local maps
+  // add line to global map
+  LinesOnBoundary.insert(LinePair(LinesOnBoundaryCount, BLS[n]));
+  // increase counter
+  LinesOnBoundaryCount++;
+};
 
 /** Function tries to add Triangle just created to Triangle and remarks if already existent (Failure of algorithm).
@@ -1531 +1549 @@
  */
 void
-Tesselation::AddTriangleToLines()
-{
-
-  cout << Verbose(1) << "Adding triangle to its lines" << endl;
+Tesselation::AddTriangle()
+{
+  cout << Verbose(1) << "Adding triangle to global TrianglesOnBoundary map." << endl;
+
+  // add triangle to global map
   TrianglesOnBoundary.insert(TrianglePair(TrianglesOnBoundaryCount, BTS));
   TrianglesOnBoundaryCount++;
 
-  /*
-   * this is apparently done when constructing triangle
-
-   for (int i=0; i<3; i++)
-   {
-   BLS[i]->AddTriangle(BTS);
-   }
-   */
+  // NOTE: add triangle to local maps is done in constructor of BoundaryTriangleSet
 }
 ;
@@ -1632 +1644 @@
  * @param b vector second point of triangle
  * @param c vector third point of triangle
+ * @param *Umkreismittelpunkt new cneter point of circumference
  * @param Direction vector indicates up/down
  * @param AlternativeDirection vecotr, needed in case the triangles have 90 deg angle
@@ -1685 +1698 @@
         }
     }
+
   TempNormal.Normalize();
   Restradius = sqrt(RADIUS*RADIUS - Umkreisradius*Umkreisradius);
@@ -1697 +1711 @@
   cout << Verbose(3) << "End of Get_center_of_sphere.\n";
 };
-
-/** This recursive function finds a third point, to form a triangle with two given ones.
- * Two atoms are fixed, a candidate is supplied, additionally two vectors for direction distinction, a Storage area to \
- *  supply results to the calling function, the radius of the sphere which the triangle shall support and the molecule \
- *  upon which we operate.
- *  If the candidate is more fitting to support the sphere than the already stored atom is, then we write its general \
- *  direction and angle into Storage.
- *  We the determine the recursive level we have reached and if this is not on the threshold yet, call this function again, \
- *  with all neighbours of the candidate.
- * @param a first point
- * @param b second point
- * *param c atom old third point of old triangle
- * @param Candidate base point along whose bonds to start looking from
- * @param Parent point to avoid during search as its wrong direction
- * @param RecursionLevel contains current recursion depth
- * @param Chord baseline vector of first and second point
- * @param direction1 second in plane vector (along with \a Chord) of the triangle the baseline belongs to
- * @param OldNormal normal of the triangle which the baseline belongs to
- * @param ReferencePoint Vector of center of circumscribing circle from which we look towards center of sphere
- * @param Opt_Candidate candidate reference to return
- * @param Storage array containing two angles of current Opt_Candidate
- * @param RADIUS radius of ball
- * @param mol molecule structure with atoms and bonds
- */
-void Tesselation::Find_next_suitable_point_via_Angle_of_Sphere(atom* a, atom* b, atom* c, atom* Candidate, atom* Parent,
-    int RecursionLevel, Vector *Chord, Vector *direction1, Vector *OldNormal, Vector ReferencePoint,
-    atom*& Opt_Candidate, double *Storage, const double RADIUS, molecule* mol)
-{
-  cout << Verbose(2) << "Begin of Find_next_suitable_point_via_Angle_of_Sphere, recursion level " << RecursionLevel << ".\n";
-  cout << Verbose(3) << "Candidate is "<< *Candidate << endl;
-  cout << Verbose(4) << "Baseline vector is " << *Chord << "." << endl;
-  cout << Verbose(4) << "ReferencePoint is " << ReferencePoint << "." << endl;
-  cout << Verbose(4) << "Normal of base triangle is " << *OldNormal << "." << endl;
-  cout << Verbose(4) << "Search direction is " << *direction1 << "." << endl;
-  /* OldNormal is normal vector on the old triangle
-   * direction1 is normal on the triangle line, from which we come, as well as on OldNormal.
-   * Chord points from b to a!!!
-   */
-  Vector dif_a; //Vector from a to candidate
-  Vector dif_b; //Vector from b to candidate
-  Vector AngleCheck;
-  Vector TempNormal, Umkreismittelpunkt;
-  Vector Mittelpunkt;
-
-  double alpha, beta, gamma, SideA, SideB, SideC, sign, Umkreisradius;
-  double BallAngle, AlternativeSign;
-  atom *Walker; // variable atom point
-
-  Vector NewUmkreismittelpunkt;
-
-  if (a != Candidate and b != Candidate and c != Candidate) {
-    cout << Verbose(3) << "We have a unique candidate!" << endl;
-    dif_a.CopyVector(&(a->x));
-    dif_a.SubtractVector(&(Candidate->x));
-    dif_b.CopyVector(&(b->x));
-    dif_b.SubtractVector(&(Candidate->x));
-    AngleCheck.CopyVector(&(Candidate->x));
-    AngleCheck.SubtractVector(&(a->x));
-    AngleCheck.ProjectOntoPlane(Chord);
-
-    SideA = dif_b.Norm();
-    SideB = dif_a.Norm();
-    SideC = Chord->Norm();
-    //Chord->Scale(-1);
-
-    alpha = Chord->Angle(&dif_a);
-    beta = M_PI - Chord->Angle(&dif_b);
-    gamma = dif_a.Angle(&dif_b);
-
-    cout << Verbose(2) << "Base triangle has sides " << dif_a << ", " << dif_b << ", " << *Chord << " with angles " << alpha/M_PI*180. << ", " << beta/M_PI*180. << ", " << gamma/M_PI*180. << "." << endl;
-
-    if (fabs(M_PI - alpha - beta - gamma) > MYEPSILON) {
-      cerr << Verbose(0) << "WARNING: sum of angles for base triangle " << (alpha + beta + gamma)/M_PI*180. << " != 180.\n";
-      cout << Verbose(1) << "Base triangle has sides " << dif_a << ", " << dif_b << ", " << *Chord << " with angles " << alpha/M_PI*180. << ", " << beta/M_PI*180. << ", " << gamma/M_PI*180. << "." << endl;
-    }
-
-    if ((M_PI*179./180. > alpha) && (M_PI*179./180. > beta) && (M_PI*179./180. > gamma)) {
-      Umkreisradius = SideA / 2.0 / sin(alpha);
-      //cout << Umkreisradius << endl;
-      //cout << SideB / 2.0 / sin(beta) << endl;
-      //cout << SideC / 2.0 / sin(gamma) << endl;
-
-      if (Umkreisradius < RADIUS) { //Checking whether ball will at least rest on points.
-        cout << Verbose(3) << "Circle of circumference would fit: " << Umkreisradius << " < " << RADIUS << "." << endl;
-        cout << Verbose(2) << "Candidate is "<< *Candidate << endl;
-        sign = AngleCheck.ScalarProduct(direction1);
-        if (fabs(sign)<MYEPSILON) {
-          if (AngleCheck.ScalarProduct(OldNormal)<0) {
-            sign =0;
-            AlternativeSign=1;
-          } else {
-            sign =0;
-            AlternativeSign=-1;
-          }
-        } else {
-          sign /= fabs(sign);
-          cout << Verbose(3) << "Candidate is in search direction: " << sign << "." << endl;
-        }
-        if (sign >= 0) {
-          cout << Verbose(3) << "Candidate is in search direction: " << sign << "." << endl;
-          Get_center_of_sphere(&Mittelpunkt, (a->x), (b->x), (Candidate->x), &NewUmkreismittelpunkt, OldNormal, direction1, sign, AlternativeSign, alpha, beta, gamma, RADIUS, Umkreisradius);
-          Mittelpunkt.SubtractVector(&ReferencePoint);
-          cout << Verbose(3) << "Reference vector to sphere's center is " << Mittelpunkt << "." << endl;
-          BallAngle = Mittelpunkt.Angle(OldNormal);
-          cout << Verbose(3) << "Angle between normal of base triangle and center of ball sphere is :" << BallAngle << "." << endl;
-
-
-        cout << Verbose(3) << "BallAngle is " << BallAngle << " Sign is " << sign << endl;
-
-          if ((Mittelpunkt.ScalarProduct(direction1) >=0) || (fabs(NewUmkreismittelpunkt.Norm()) < MYEPSILON)) {
-            if (Storage[0]< -1.5) { // first Candidate at all
-              if (1) {//if (CheckPresenceOfTriangle((ofstream *)&cout,a,b,Candidate)) {
-                cout << Verbose(2) << "First good candidate is " << *Candidate << " with ";
-                Opt_Candidate = Candidate;
-                Storage[0] = sign;
-                Storage[1] = AlternativeSign;
-                Storage[2] = BallAngle;
-                cout << " angle " << Storage[2] << " and Up/Down " << Storage[0] << endl;
-              } else
-                cout << "Candidate " << *Candidate << " does not belong to a valid triangle." << endl;
-            } else {
-              if ( Storage[2] > BallAngle) {
-                if (1) { //if (CheckPresenceOfTriangle((ofstream *)&cout,a,b,Candidate)) {
-                  cout << Verbose(2) << "Next better candidate is " << *Candidate << " with ";
-                  Opt_Candidate = Candidate;
-                  Storage[0] = sign;
-                  Storage[1] = AlternativeSign;
-                  Storage[2] = BallAngle;
-                  cout << " angle " << Storage[2] << " and Up/Down " << Storage[0] << endl;
-                } else
-                  cout << "Candidate " << *Candidate << " does not belong to a valid triangle." << endl;
-              } else {
-                if (DEBUG) {
-                  cout << Verbose(3) << *Candidate << " looses against better candidate " << *Opt_Candidate << "." << endl;
-                }
-              }
-            }
-          } else {
-            if (DEBUG) {
-              cout << Verbose(3) << *Candidate << " refused due to Up/Down sign which is " << sign << endl;
-            }
-          }
-        } else {
-          if (DEBUG) {
-            cout << Verbose(3) << *Candidate << " is not in search direction." << endl;
-          }
-        }
-      } else {
-        if (DEBUG) {
-          cout << Verbose(3) << *Candidate << " would have circumference of " << Umkreisradius << " bigger than ball's radius " << RADIUS << "." << endl;
-        }
-      }
-    } else {
-      if (DEBUG) {
-        cout << Verbose(0) << "Triangle consisting of " << *Candidate << ", " << *a << " and " << *b << " has an angle >150!" << endl;
-      }
-    }
-  } else {
-    if (DEBUG) {
-      cout << Verbose(3) << *Candidate << " is either " << *a << " or " << *b << "." << endl;
-    }
-  }
-
-  if (RecursionLevel < 5) { // Seven is the recursion level threshold.
-    for (int i = 0; i < mol->NumberOfBondsPerAtom[Candidate->nr]; i++) { // go through all bond
-      Walker = mol->ListOfBondsPerAtom[Candidate->nr][i]->GetOtherAtom(Candidate);
-      if (Walker == Parent) { // don't go back the same bond
-        continue;
-      } else {
-        Find_next_suitable_point_via_Angle_of_Sphere(a, b, c, Walker, Candidate, RecursionLevel+1, Chord, direction1, OldNormal, ReferencePoint, Opt_Candidate, Storage, RADIUS, mol); //call function again
-      }
-    }
-  }
-  cout << Verbose(2) << "End of Find_next_suitable_point_via_Angle_of_Sphere, recursion level " << RecursionLevel << ".\n";
-}
-;
 
 
@@ -1895 +1733 @@
   beta = M_PI - SideC.Angle(&SideA);
   gamma = M_PI - SideA.Angle(&SideB);
-  cout << Verbose(3) << "INFO: alpha = " << alpha/M_PI*180. << ", beta = " << beta/M_PI*180. << ", gamma = " << gamma/M_PI*180. << "." << endl;
+  //cout << Verbose(3) << "INFO: alpha = " << alpha/M_PI*180. << ", beta = " << beta/M_PI*180. << ", gamma = " << gamma/M_PI*180. << "." << endl;
   if (fabs(M_PI - alpha - beta - gamma) > HULLEPSILON)
-    cerr << "Sum of angles " << (alpha+beta+gamma)/M_PI*180. << " > 180 degrees by " << fabs(M_PI - alpha - beta - gamma)/M_PI*180. << "!" << endl;
+    cerr << "GetCenterofCircumcircle: Sum of angles " << (alpha+beta+gamma)/M_PI*180. << " > 180 degrees by " << fabs(M_PI - alpha - beta - gamma)/M_PI*180. << "!" << endl;
 
   Center->Zero();
@@ -1944 +1782 @@
   if (helper.ScalarProduct(&SearchDirection) < -HULLEPSILON)  // acos is not unique on [0, 2.*M_PI), hence extra check to decide between two half intervals
     alpha = 2.*M_PI - alpha;
-  cout << Verbose(2) << "INFO: RelativeNewSphereCenter is " << helper << ", RelativeOldSphereCenter is " << OldSphereCenter << " and resulting angle is " << alpha << "." << endl;
+  //cout << Verbose(2) << "INFO: RelativeNewSphereCenter is " << helper << ", RelativeOldSphereCenter is " << OldSphereCenter << " and resulting angle is " << alpha << "." << endl;
   radius = helper.Distance(&OldSphereCenter);
   helper.ProjectOntoPlane(&NormalVector);
   // check whether new center is somewhat away or at least right over the current baseline to prevent intersecting triangles
   if ((radius > HULLEPSILON) || (helper.Norm() < HULLEPSILON)) {
-    cout << Verbose(2) << "INFO: Distance between old and new center is " << radius << " and between new center and baseline center is " << helper.Norm() << "." << endl;
+    //cout << Verbose(2) << "INFO: Distance between old and new center is " << radius << " and between new center and baseline center is " << helper.Norm() << "." << endl;
     return alpha;
   } else {
-    cout << Verbose(1) << "ERROR: NewSphereCenter " << helper << " is too close to OldSphereCenter" << OldSphereCenter << "." << endl;
+    //cout << Verbose(1) << "INFO: NewSphereCenter " << helper << " is too close to OldSphereCenter" << OldSphereCenter << "." << endl;
     return 2.*M_PI;
   }
@@ -1958 +1796 @@
 
 
-/** This recursive function finds a third point, to form a triangle with two given ones.
- * The idea is as follows: A sphere with fixed radius is (almost) uniquely defined in space by three points
- * that sit on its boundary. Hence, when two points are given and we look for the (next) third point, then
- * the center of the sphere is still fixed up to a single parameter. The band of possible values
- * describes a circle in 3D-space. The old center of the sphere for the current base triangle gives
- * us the "null" on this circle, the new center of the candidate point will be some way along this
- * circle. The shorter the way the better is the candidate. Note that the direction is clearly given
- * by the normal vector of the base triangle that always points outwards by construction.
- * Hence, we construct a Center of this circle which sits right in the middle of the current base line.
- * We construct the normal vector that defines the plane this circle lies in, it is just in the
- * direction of the baseline. And finally, we need the radius of the circle, which is given by the rest
- * with respect to the length of the baseline and the sphere's fixed \a RADIUS.
- * Note that there is one difficulty: The circumcircle is uniquely defined, but for the circumsphere's center
- * there are two possibilities which becomes clear from the construction as seen below. Hence, we must check
- * both.
- * Note also that the acos() function is not unique on [0, 2.*M_PI). Hence, we need an additional check
- * to decide for one of the two possible angles. Therefore we need a SearchDirection and to make this check
- * sensible we need OldSphereCenter to be orthogonal to it. Either we construct SearchDirection orthogonal
- * right away, or -- what we do here -- we rotate the relative sphere centers such that this orthogonality
- * holds. Then, the normalized projection onto the SearchDirection is either +1 or -1 and thus states whether
- * the angle is uniquely in either (0,M_PI] or [M_PI, 2.*M_PI).
- * @param BaseTriangle BoundaryTriangleSet of the current base triangle with all three points
- * @param BaseLine BoundaryLineSet of BaseTriangle with the current base line
- * @param OptCandidate candidate reference on return
- * @param OptCandidateCenter candidate's sphere center on return
- * @param ShortestAngle the current path length on this circle band for the current Opt_Candidate
- * @param RADIUS radius of sphere
- * @param *LC LinkedCell structure with neighbouring atoms
- */
-// void Find_next_suitable_point(class BoundaryTriangleSet *BaseTriangle, class BoundaryLineSet *BaseLine, atom*& OptCandidate, Vector *OptCandidateCenter, double *ShortestAngle, const double RADIUS, LinkedCell *LC)
-// {
-//   atom *Walker = NULL;
-//   Vector CircleCenter;  // center of the circle, i.e. of the band of sphere's centers
-//   Vector CirclePlaneNormal; // normal vector defining the plane this circle lives in
-//   Vector OldSphereCenter;   // center of the sphere defined by the three points of BaseTriangle
-//   Vector NewSphereCenter;   // center of the sphere defined by the two points of BaseLine and the one of Candidate, first possibility
-//   Vector OtherNewSphereCenter;   // center of the sphere defined by the two points of BaseLine and the one of Candidate, second possibility
-//   Vector NewNormalVector;   // normal vector of the Candidate's triangle
-//   Vector SearchDirection;   // vector that points out of BaseTriangle and is orthonormal to its NormalVector (i.e. the desired direction for the best Candidate)
-//   Vector helper;
-//   LinkedAtoms *List = NULL;
-//   double CircleRadius; // radius of this circle
-//   double radius;
-//   double alpha, Otheralpha; // angles (i.e. parameter for the circle).
-//   double Nullalpha; // angle between OldSphereCenter and NormalVector of base triangle
-//   int N[NDIM], Nlower[NDIM], Nupper[NDIM];
-//   atom *Candidate = NULL;
-//
-//   cout << Verbose(1) << "Begin of Find_next_suitable_point" << endl;
-//
-//   cout << Verbose(2) << "INFO: NormalVector of BaseTriangle is " << BaseTriangle->NormalVector << "." << endl;
-//
-//   // construct center of circle
-//   CircleCenter.CopyVector(&(BaseLine->endpoints[0]->node->x));
-//   CircleCenter.AddVector(&BaseLine->endpoints[1]->node->x);
-//   CircleCenter.Scale(0.5);
-//
-//   // construct normal vector of circle
-//   CirclePlaneNormal.CopyVector(&BaseLine->endpoints[0]->node->x);
-//   CirclePlaneNormal.SubtractVector(&BaseLine->endpoints[1]->node->x);
-//
-//   // calculate squared radius of circle
-//   radius = CirclePlaneNormal.ScalarProduct(&CirclePlaneNormal);
-//   if (radius/4. < RADIUS*RADIUS) {
-//     CircleRadius = RADIUS*RADIUS - radius/4.;
-//     CirclePlaneNormal.Normalize();
-//     cout << Verbose(2) << "INFO: CircleCenter is at " << CircleCenter << ", CirclePlaneNormal is " << CirclePlaneNormal << " with circle radius " << sqrt(CircleRadius) << "." << endl;
-//
-//     // construct old center
-//     GetCenterofCircumcircle(&OldSphereCenter, &(BaseTriangle->endpoints[0]->node->x), &(BaseTriangle->endpoints[1]->node->x), &(BaseTriangle->endpoints[2]->node->x));
-//     helper.CopyVector(&BaseTriangle->NormalVector);  // normal vector ensures that this is correct center of the two possible ones
-//     radius = BaseLine->endpoints[0]->node->x.DistanceSquared(&OldSphereCenter);
-//     helper.Scale(sqrt(RADIUS*RADIUS - radius));
-//     OldSphereCenter.AddVector(&helper);
-//     OldSphereCenter.SubtractVector(&CircleCenter);
-//     cout << Verbose(2) << "INFO: OldSphereCenter is at " << OldSphereCenter << "." << endl;
-//
-//     // test whether old center is on the band's plane
-//     if (fabs(OldSphereCenter.ScalarProduct(&CirclePlaneNormal)) > HULLEPSILON) {
-//       cerr << "ERROR: Something's very wrong here: OldSphereCenter is not on the band's plane as desired by " << fabs(OldSphereCenter.ScalarProduct(&CirclePlaneNormal)) << "!" << endl;
-//       OldSphereCenter.ProjectOntoPlane(&CirclePlaneNormal);
-//     }
-//     radius = OldSphereCenter.ScalarProduct(&OldSphereCenter);
-//     if (fabs(radius - CircleRadius) < HULLEPSILON) {
-//
-//       // construct SearchDirection
-//       SearchDirection.MakeNormalVector(&BaseTriangle->NormalVector, &CirclePlaneNormal);
-//       helper.CopyVector(&BaseLine->endpoints[0]->node->x);
-//       for(int i=0;i<3;i++)  // just take next different endpoint
-//         if ((BaseTriangle->endpoints[i]->node != BaseLine->endpoints[0]->node) && (BaseTriangle->endpoints[i]->node != BaseLine->endpoints[1]->node)) {
-//           helper.SubtractVector(&BaseTriangle->endpoints[i]->node->x);
-//         }
-//       if (helper.ScalarProduct(&SearchDirection) < -HULLEPSILON)  // ohoh, SearchDirection points inwards!
-//         SearchDirection.Scale(-1.);
-//       SearchDirection.ProjectOntoPlane(&OldSphereCenter);
-//       SearchDirection.Normalize();
-//       cout << Verbose(2) << "INFO: SearchDirection is " << SearchDirection << "." << endl;
-//       if (fabs(OldSphereCenter.ScalarProduct(&SearchDirection)) > HULLEPSILON) {  // rotated the wrong way!
-//         cerr << "ERROR: SearchDirection and RelativeOldSphereCenter are still not orthogonal!" << endl;
-//       }
-//
-//       if (LC->SetIndexToVector(&CircleCenter)) {  // get cell for the starting atom
-//         for(int i=0;i<NDIM;i++) // store indices of this cell
-//           N[i] = LC->n[i];
-//         cout << Verbose(2) << "INFO: Center cell is " << N[0] << ", " << N[1] << ", " << N[2] << " with No. " << LC->index << "." << endl;
-//       } else {
-//         cerr << "ERROR: Vector " << CircleCenter << " is outside of LinkedCell's bounding box." << endl;
-//         return;
-//       }
-//       // then go through the current and all neighbouring cells and check the contained atoms for possible candidates
-//       cout << Verbose(2) << "LC Intervals:";
-//       for (int i=0;i<NDIM;i++) {
-//         Nlower[i] = ((N[i]-1) >= 0) ? N[i]-1 : 0;
-//         Nupper[i] = ((N[i]+1) < LC->N[i]) ? N[i]+1 : LC->N[i]-1;
-//         cout << " [" << Nlower[i] << "," << Nupper[i] << "] ";
-//       }
-//       cout << endl;
-//       for (LC->n[0] = Nlower[0]; LC->n[0] <= Nupper[0]; LC->n[0]++)
-//         for (LC->n[1] = Nlower[1]; LC->n[1] <= Nupper[1]; LC->n[1]++)
-//           for (LC->n[2] = Nlower[2]; LC->n[2] <= Nupper[2]; LC->n[2]++) {
-//             List = LC->GetCurrentCell();
-//             cout << Verbose(2) << "Current cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << "." << endl;
-//             if (List != NULL) {
-//               for (LinkedAtoms::iterator Runner = List->begin(); Runner != List->end(); Runner++) {
-//                 Candidate = (*Runner);
-//
-//                 // check for three unique points
-//                 if ((Candidate != BaseTriangle->endpoints[0]->node) && (Candidate != BaseTriangle->endpoints[1]->node) && (Candidate != BaseTriangle->endpoints[2]->node)) {
-//                   cout << Verbose(1) << "INFO: Current Candidate is " << *Candidate << " at " << Candidate->x << "." << endl;
-//
-//                   // construct both new centers
-//                   GetCenterofCircumcircle(&NewSphereCenter, &(BaseLine->endpoints[0]->node->x), &(BaseLine->endpoints[1]->node->x), &(Candidate->x));
-//                   OtherNewSphereCenter.CopyVector(&NewSphereCenter);
-//
-//                   if ((NewNormalVector.MakeNormalVector(&(BaseLine->endpoints[0]->node->x), &(BaseLine->endpoints[1]->node->x), &(Candidate->x))) && (fabs(NewNormalVector.ScalarProduct(&NewNormalVector)) > HULLEPSILON)) {
-//                     helper.CopyVector(&NewNormalVector);
-//                     cout << Verbose(2) << "INFO: NewNormalVector is " << NewNormalVector << "." << endl;
-//                     radius = BaseLine->endpoints[0]->node->x.DistanceSquared(&NewSphereCenter);
-//                     if (radius < RADIUS*RADIUS) {
-//                       helper.Scale(sqrt(RADIUS*RADIUS - radius));
-//                       cout << Verbose(3) << "INFO: Distance of NewCircleCenter to NewSphereCenter is " << helper.Norm() << "." << endl;
-//                       NewSphereCenter.AddVector(&helper);
-//                       NewSphereCenter.SubtractVector(&CircleCenter);
-//                       cout << Verbose(2) << "INFO: NewSphereCenter is at " << NewSphereCenter << "." << endl;
-//
-//                       helper.Scale(-1.); // OtherNewSphereCenter is created by the same vector just in the other direction
-//                       OtherNewSphereCenter.AddVector(&helper);
-//                       OtherNewSphereCenter.SubtractVector(&CircleCenter);
-//                       cout << Verbose(2) << "INFO: OtherNewSphereCenter is at " << OtherNewSphereCenter << "." << endl;
-//
-//                       // check both possible centers
-//                       alpha = GetPathLengthonCircumCircle(CircleCenter, CirclePlaneNormal, CircleRadius, NewSphereCenter, OldSphereCenter, BaseTriangle->NormalVector, SearchDirection);
-//                       Otheralpha = GetPathLengthonCircumCircle(CircleCenter, CirclePlaneNormal, CircleRadius, OtherNewSphereCenter, OldSphereCenter, BaseTriangle->NormalVector, SearchDirection);
-//                       alpha = min(alpha, Otheralpha);
-//                       if (*ShortestAngle > alpha) {
-//                           OptCandidate = Candidate;
-//                           *ShortestAngle = alpha;
-//                           if (alpha != Otheralpha)
-//                             OptCandidateCenter->CopyVector(&NewSphereCenter);
-//                           else
-//                             OptCandidateCenter->CopyVector(&OtherNewSphereCenter);
-//                           cout << Verbose(1) << "We have found a better candidate: " << *OptCandidate << " with " << alpha << " and circumsphere's center at " << *OptCandidateCenter << "." << endl;
-//                       } else {
-//                         if (OptCandidate != NULL)
-//                           cout << Verbose(1) << "REJECT: Old candidate: " << *OptCandidate << " is better than " << alpha << " with " << *ShortestAngle << "." << endl;
-//                         else
-//                           cout << Verbose(2) << "REJECT: Candidate " << *Candidate << " with " << alpha << " was rejected." << endl;
-//                       }
-//
-//                     } else {
-//                       cout << Verbose(1) << "REJECT: NewSphereCenter " << NewSphereCenter << " is too far away: " << radius << "." << endl;
-//                     }
-//                   } else {
-//                     cout << Verbose(1) << "REJECT: Three points from " << *BaseLine << " and Candidate " << *Candidate << " are linear-dependent." << endl;
-//                   }
-//                 } else {
-//                   cout << Verbose(1) << "REJECT: Base triangle " << *BaseTriangle << " contains Candidate " << *Candidate << "." << endl;
-//                 }
-//               }
-//             }
-//           }
-//     } else {
-//       cerr << Verbose(1) << "ERROR: The projected center of the old sphere has radius " << radius << " instead of " << CircleRadius << "." << endl;
-//     }
-//   } else {
-//     cout << Verbose(1) << "Circumcircle for base line " << *BaseLine << " and base triangle " << *BaseTriangle << " is too big!" << endl;
-//   }
-//
-//   cout << Verbose(1) << "End of Find_next_suitable_point" << endl;
-// };
-
+/** Checks whether the triangle consisting of the three atoms is already present.
+ * Searches for the points in Tesselation::PointsOnBoundary and checks their
+ * lines. If any of the three edges already has two triangles attached, false is
+ * returned.
+ * \param *out output stream for debugging
+ * \param *Candidates endpoints of the triangle candidate
+ * \return integer 0 if no triangle exists, 1 if one triangle exists, 2 if two
+ *                 triangles exist which is the maximum for three points
+ */
+int Tesselation::CheckPresenceOfTriangle(ofstream *out, atom *Candidates[3]) {
+  LineMap::iterator FindLine;
+  PointMap::iterator FindPoint;
+  TriangleMap::iterator FindTriangle;
+  int adjacentTriangleCount = 0;
+  class BoundaryPointSet *Points[3];
+
+  //*out << Verbose(2) << "Begin of CheckPresenceOfTriangle" << endl;
+  // builds a triangle point set (Points) of the end points
+  for (int i = 0; i < 3; i++) {
+    FindPoint = PointsOnBoundary.find(Candidates[i]->nr);
+    if (FindPoint != PointsOnBoundary.end()) {
+      Points[i] = FindPoint->second;
+    } else {
+      Points[i] = NULL;
+    }
+  }
+
+  // checks lines between the points in the Points for their adjacent triangles
+  for (int i = 0; i < 3; i++) {
+    if (Points[i] != NULL) {
+      for (int j = i; j < 3; j++) {
+        if (Points[j] != NULL) {
+          FindLine = Points[i]->lines.find(Points[j]->node->nr);
+          if (FindLine != Points[i]->lines.end()) {
+            for (; FindLine->first == Points[j]->node->nr; FindLine++) {
+              FindTriangle = FindLine->second->triangles.begin();
+              for (; FindTriangle != FindLine->second->triangles.end(); FindTriangle++) {
+                if ((
+                  (FindTriangle->second->endpoints[0] == Points[0])
+                    || (FindTriangle->second->endpoints[0] == Points[1])
+                    || (FindTriangle->second->endpoints[0] == Points[2])
+                  ) && (
+                    (FindTriangle->second->endpoints[1] == Points[0])
+                    || (FindTriangle->second->endpoints[1] == Points[1])
+                    || (FindTriangle->second->endpoints[1] == Points[2])
+                  ) && (
+                    (FindTriangle->second->endpoints[2] == Points[0])
+                    || (FindTriangle->second->endpoints[2] == Points[1])
+                    || (FindTriangle->second->endpoints[2] == Points[2])
+                  )
+                ) {
+                  adjacentTriangleCount++;
+                }
+              }
+            }
+            // Only one of the triangle lines must be considered for the triangle count.
+            *out << Verbose(2) << "Found " << adjacentTriangleCount << " adjacent triangles for the point set." << endl;
+            return adjacentTriangleCount;
+
+          }
+        }
+      }
+    }
+  }
+
+  *out << Verbose(2) << "Found " << adjacentTriangleCount << " adjacent triangles for the point set." << endl;
+  return adjacentTriangleCount;
+};
 
 /** This recursive function finds a third point, to form a triangle with two given ones.
@@ -2177 +1892 @@
  * @param BaseLine BoundaryLineSet with the current base line
  * @param ThirdNode third atom to avoid in search
- * @param OptCandidate candidate reference on return
- * @param OptCandidateCenter candidate's sphere center on return
+ * @param candidates list of equally good candidates to return
  * @param ShortestAngle the current path length on this circle band for the current Opt_Candidate
  * @param RADIUS radius of sphere
  * @param *LC LinkedCell structure with neighbouring atoms
  */
-void Find_third_point_for_Tesselation(Vector NormalVector, Vector SearchDirection, Vector OldSphereCenter, class BoundaryLineSet *BaseLine, atom *ThirdNode, atom*& OptCandidate, Vector *OptCandidateCenter, double *ShortestAngle, const double RADIUS, LinkedCell *LC)
-{
+void Find_third_point_for_Tesselation(
+  Vector NormalVector, Vector SearchDirection, Vector OldSphereCenter,
+  class BoundaryLineSet *BaseLine, atom *ThirdNode, CandidateList* &candidates,
+  double *ShortestAngle, const double RADIUS, LinkedCell *LC
+) {
   Vector CircleCenter;  // center of the circle, i.e. of the band of sphere's centers
   Vector CirclePlaneNormal; // normal vector defining the plane this circle lives in
+  Vector SphereCenter;
   Vector NewSphereCenter;   // center of the sphere defined by the two points of BaseLine and the one of Candidate, first possibility
   Vector OtherNewSphereCenter;   // center of the sphere defined by the two points of BaseLine and the one of Candidate, second possibility
   Vector NewNormalVector;   // normal vector of the Candidate's triangle
-  Vector helper;
+  Vector helper, OptCandidateCenter, OtherOptCandidateCenter;
   LinkedAtoms *List = NULL;
   double CircleRadius; // radius of this circle
@@ -2197 +1915 @@
   int N[NDIM], Nlower[NDIM], Nupper[NDIM];
   atom *Candidate = NULL;
+  CandidateForTesselation *optCandidate = NULL;
 
   cout << Verbose(1) << "Begin of Find_third_point_for_Tesselation" << endl;
 
-  cout << Verbose(2) << "INFO: NormalVector of BaseTriangle is " << NormalVector << "." << endl;
+  //cout << Verbose(2) << "INFO: NormalVector of BaseTriangle is " << NormalVector << "." << endl;
 
   // construct center of circle
@@ -2211 +1930 @@
   CirclePlaneNormal.SubtractVector(&BaseLine->endpoints[1]->node->x);
 
-  // calculate squared radius of circle
+  // calculate squared radius atom *ThirdNode,f circle
   radius = CirclePlaneNormal.ScalarProduct(&CirclePlaneNormal);
   if (radius/4. < RADIUS*RADIUS) {
     CircleRadius = RADIUS*RADIUS - radius/4.;
     CirclePlaneNormal.Normalize();
-    cout << Verbose(2) << "INFO: CircleCenter is at " << CircleCenter << ", CirclePlaneNormal is " << CirclePlaneNormal << " with circle radius " << sqrt(CircleRadius) << "." << endl;
+    //cout << Verbose(2) << "INFO: CircleCenter is at " << CircleCenter << ", CirclePlaneNormal is " << CirclePlaneNormal << " with circle radius " << sqrt(CircleRadius) << "." << endl;
 
     // test whether old center is on the band's plane
@@ -2227 +1946 @@
 
       // check SearchDirection
-      cout << Verbose(2) << "INFO: SearchDirection is " << SearchDirection << "." << endl;
+      //cout << Verbose(2) << "INFO: SearchDirection is " << SearchDirection << "." << endl;
       if (fabs(OldSphereCenter.ScalarProduct(&SearchDirection)) > HULLEPSILON) {  // rotated the wrong way!
         cerr << "ERROR: SearchDirection and RelativeOldSphereCenter are not orthogonal!" << endl;
       }
+
       // get cell for the starting atom
       if (LC->SetIndexToVector(&CircleCenter)) {
-          for(int i=0;i<NDIM;i++) // store indices of this cell
-          N[i] = LC->n[i];
-        cout << Verbose(2) << "INFO: Center cell is " << N[0] << ", " << N[1] << ", " << N[2] << " with No. " << LC->index << "." << endl;
+        for(int i=0;i<NDIM;i++) // store indices of this cell
+        N[i] = LC->n[i];
+        //cout << Verbose(2) << "INFO: Center cell is " << N[0] << ", " << N[1] << ", " << N[2] << " with No. " << LC->index << "." << endl;
       } else {
         cerr << "ERROR: Vector " << CircleCenter << " is outside of LinkedCell's bounding box." << endl;
@@ -2241 +1961 @@
       }
       // then go through the current and all neighbouring cells and check the contained atoms for possible candidates
-      cout << Verbose(2) << "LC Intervals:";
+      //cout << Verbose(2) << "LC Intervals:";
       for (int i=0;i<NDIM;i++) {
         Nlower[i] = ((N[i]-1) >= 0) ? N[i]-1 : 0;
         Nupper[i] = ((N[i]+1) < LC->N[i]) ? N[i]+1 : LC->N[i]-1;
-        cout << " [" << Nlower[i] << "," << Nupper[i] << "] ";
+        //cout << " [" << Nlower[i] << "," << Nupper[i] << "] ";
       }
-      cout << endl;
+      //cout << endl;
       for (LC->n[0] = Nlower[0]; LC->n[0] <= Nupper[0]; LC->n[0]++)
         for (LC->n[1] = Nlower[1]; LC->n[1] <= Nupper[1]; LC->n[1]++)
@@ -2258 +1978 @@
 
                 // check for three unique points
-                if ((Candidate != BaseLine->endpoints[0]->node) && (Candidate != BaseLine->endpoints[1]->node) && (Candidate != ThirdNode)) {
-                  cout << Verbose(1) << "INFO: Current Candidate is " << *Candidate << " at " << Candidate->x << "." << endl;
+                //cout << Verbose(2) << "INFO: Current Candidate is " << *Candidate << " at " << Candidate->x << "." << endl;
+                if ((Candidate != BaseLine->endpoints[0]->node) && (Candidate != BaseLine->endpoints[1]->node) ){
 
                   // construct both new centers
@@ -2265 +1985 @@
                   OtherNewSphereCenter.CopyVector(&NewSphereCenter);
 
-                  if ((NewNormalVector.MakeNormalVector(&(BaseLine->endpoints[0]->node->x), &(BaseLine->endpoints[1]->node->x), &(Candidate->x))) && (fabs(NewNormalVector.ScalarProduct(&NewNormalVector)) > HULLEPSILON)) {
+                  if ((NewNormalVector.MakeNormalVector(&(BaseLine->endpoints[0]->node->x), &(BaseLine->endpoints[1]->node->x), &(Candidate->x)))
+                  && (fabs(NewNormalVector.ScalarProduct(&NewNormalVector)) > HULLEPSILON)
+                  ) {
                     helper.CopyVector(&NewNormalVector);
-                    cout << Verbose(2) << "INFO: NewNormalVector is " << NewNormalVector << "." << endl;
+                    //cout << Verbose(2) << "INFO: NewNormalVector is " << NewNormalVector << "." << endl;
                     radius = BaseLine->endpoints[0]->node->x.DistanceSquared(&NewSphereCenter);
                     if (radius < RADIUS*RADIUS) {
                       helper.Scale(sqrt(RADIUS*RADIUS - radius));
-                      cout << Verbose(3) << "INFO: Distance of NewCircleCenter to NewSphereCenter is " << helper.Norm() << "." << endl;
+                      //cout << Verbose(2) << "INFO: Distance of NewCircleCenter to NewSphereCenter is " << helper.Norm() << " with sphere radius " << RADIUS << "." << endl;
                       NewSphereCenter.AddVector(&helper);
                       NewSphereCenter.SubtractVector(&CircleCenter);
-                      cout << Verbose(2) << "INFO: NewSphereCenter is at " << NewSphereCenter << "." << endl;
-
-                      helper.Scale(-1.); // OtherNewSphereCenter is created by the same vector just in the other direction
+                      //cout << Verbose(2) << "INFO: NewSphereCenter is at " << NewSphereCenter << "." << endl;
+
+                      // OtherNewSphereCenter is created by the same vector just in the other direction
+                      helper.Scale(-1.);
                       OtherNewSphereCenter.AddVector(&helper);
                       OtherNewSphereCenter.SubtractVector(&CircleCenter);
-                      cout << Verbose(2) << "INFO: OtherNewSphereCenter is at " << OtherNewSphereCenter << "." << endl;
-
-                      // check both possible centers
+                      //cout << Verbose(2) << "INFO: OtherNewSphereCenter is at " << OtherNewSphereCenter << "." << endl;
+
                       alpha = GetPathLengthonCircumCircle(CircleCenter, CirclePlaneNormal, CircleRadius, NewSphereCenter, OldSphereCenter, NormalVector, SearchDirection);
                       Otheralpha = GetPathLengthonCircumCircle(CircleCenter, CirclePlaneNormal, CircleRadius, OtherNewSphereCenter, OldSphereCenter, NormalVector, SearchDirection);
                       alpha = min(alpha, Otheralpha);
-                      if (*ShortestAngle > alpha) {
-                          OptCandidate = Candidate;
-                          *ShortestAngle = alpha;
-                          if (alpha != Otheralpha)
-                            OptCandidateCenter->CopyVector(&NewSphereCenter);
-                          else
-                            OptCandidateCenter->CopyVector(&OtherNewSphereCenter);
-                          cout << Verbose(1) << "ACCEPT: We have found a better candidate: " << *OptCandidate << " with " << alpha << " and circumsphere's center at " << *OptCandidateCenter << "." << endl;
+                      // if there is a better candidate, drop the current list and add the new candidate
+                      // otherwise ignore the new candidate and keep the list
+                      if (*ShortestAngle > (alpha - HULLEPSILON)) {
+                        optCandidate = new CandidateForTesselation(Candidate, BaseLine, OptCandidateCenter, OtherOptCandidateCenter);
+                        if (fabs(alpha - Otheralpha) > MYEPSILON) {
+                          optCandidate->OptCenter.CopyVector(&NewSphereCenter);
+                          optCandidate->OtherOptCenter.CopyVector(&OtherNewSphereCenter);
+                        } else {
+                          optCandidate->OptCenter.CopyVector(&OtherNewSphereCenter);
+                          optCandidate->OtherOptCenter.CopyVector(&NewSphereCenter);
+                        }
+                        // if there is an equal candidate, add it to the list without clearing the list
+                        if ((*ShortestAngle - HULLEPSILON) < alpha) {
+                          candidates->push_back(optCandidate);
+                          cout << Verbose(2) << "ACCEPT: We have found an equally good candidate: " << *(optCandidate->point) << " with "
+                            << alpha << " and circumsphere's center at " << optCandidate->OptCenter << "." << endl;
+                        } else {
+                          // remove all candidates from the list and then the list itself
+                          class CandidateForTesselation *remover = NULL;
+                          for (CandidateList::iterator it = candidates->begin(); it != candidates->end(); ++it) {
+                            remover = *it;
+                            delete(remover);
+                          }
+                          candidates->clear();
+                          candidates->push_back(optCandidate);
+                          cout << Verbose(2) << "ACCEPT: We have found a better candidate: " << *(optCandidate->point) << " with "
+                            << alpha << " and circumsphere's center at " << optCandidate->OptCenter << "." << endl;
+                        }
+                        *ShortestAngle = alpha;
+                        //cout << Verbose(2) << "INFO: There are " << candidates->size() << " candidates in the list now." << endl;
                       } else {
-                        if (OptCandidate != NULL)
-                          cout << Verbose(1) << "REJECT: Old candidate: " << *OptCandidate << " is better than " << alpha << " with " << *ShortestAngle << "." << endl;
-                        else
-                          cout << Verbose(2) << "REJECT: Candidate " << *Candidate << " with " << alpha << " was rejected." << endl;
+                        if ((optCandidate != NULL) && (optCandidate->point != NULL)) {
+                          //cout << Verbose(2) << "REJECT: Old candidate: " << *(optCandidate->point) << " is better than " << alpha << " with " << *ShortestAngle << "." << endl;
+                        } else {
+                          //cout << Verbose(2) << "REJECT: Candidate " << *Candidate << " with " << alpha << " was rejected." << endl;
+                        }
                       }
 
                     } else {
-                      cout << Verbose(1) << "REJECT: NewSphereCenter " << NewSphereCenter << " is too far away: " << radius << "." << endl;
+                      //cout << Verbose(2) << "REJECT: NewSphereCenter " << NewSphereCenter << " is too far away: " << radius << "." << endl;
                     }
                   } else {
-                    cout << Verbose(1) << "REJECT: Three points from " << *BaseLine << " and Candidate " << *Candidate << " are linear-dependent." << endl;
+                    //cout << Verbose(2) << "REJECT: Three points from " << *BaseLine << " and Candidate " << *Candidate << " are linear-dependent." << endl;
                   }
                 } else {
-                  if (ThirdNode != NULL)
-                    cout << Verbose(1) << "REJECT: Base triangle " << *BaseLine << " and " << *ThirdNode << " contains Candidate " << *Candidate << "." << endl;
-                  else
-                    cout << Verbose(1) << "REJECT: Base triangle " << *BaseLine << " contains Candidate " << *Candidate << "." << endl;
+                  if (ThirdNode != NULL) {
+                    //cout << Verbose(2) << "REJECT: Base triangle " << *BaseLine << " and " << *ThirdNode << " contains Candidate " << *Candidate << "." << endl;
+                  } else {
+                    //cout << Verbose(2) << "REJECT: Base triangle " << *BaseLine << " contains Candidate " << *Candidate << "." << endl;
+                  }
                 }
               }
@@ -2316 +2062 @@
           }
     } else {
-      cerr << Verbose(1) << "ERROR: The projected center of the old sphere has radius " << radius << " instead of " << CircleRadius << "." << endl;
+      cerr << Verbose(2) << "ERROR: The projected center of the old sphere has radius " << radius << " instead of " << CircleRadius << "." << endl;
     }
   } else {
     if (ThirdNode != NULL)
-      cout << Verbose(1) << "Circumcircle for base line " << *BaseLine << " and third node " << *ThirdNode << " is too big!" << endl;
+      cout << Verbose(2) << "Circumcircle for base line " << *BaseLine << " and third node " << *ThirdNode << " is too big!" << endl;
     else
-      cout << Verbose(1) << "Circumcircle for base line " << *BaseLine << " is too big!" << endl;
-  }
-
+      cout << Verbose(2) << "Circumcircle for base line " << *BaseLine << " is too big!" << endl;
+  }
+
+  //cout << Verbose(2) << "INFO: Sorting candidate list ..." << endl;
+  if (candidates->size() > 1) {
+    candidates->unique();
+    candidates->sort(sortCandidates);
+  }
 
   cout << Verbose(1) << "End of Find_third_point_for_Tesselation" << endl;
 };
 
-/** Checks whether the triangle consisting of the three atoms is already present.
- * Searches for the points in Tesselation::PointsOnBoundary and checks their
- * lines. If any of the three edges already has two triangles attached, false is
- * returned.
- * \param *out output stream for debugging
- * \param *a first endpoint
- * \param *b second endpoint
- * \param *c third endpoint
- * \return false - triangle invalid due to edge criteria, true - triangle may be added.
- */
-bool Tesselation::CheckPresenceOfTriangle(ofstream *out, atom *a, atom *b, atom *c) {
-  LineMap::iterator TryAndError;
-  PointTestPair InsertPoint;
-  bool Present[3];
-
-  *out << Verbose(2) << "Begin of CheckPresenceOfTriangle" << endl;
-  TPS[0] = new class BoundaryPointSet(a);
-  TPS[1] = new class BoundaryPointSet(b);
-  TPS[2] = new class BoundaryPointSet(c);
-  for (int i=0;i<3;i++) { // check through all endpoints
-    InsertPoint = PointsOnBoundary.insert(PointPair(TPS[i]->node->nr, TPS[i]));
-    Present[i] = !InsertPoint.second;
-    if (Present[i]) { // if new point was not present before, increase counter
-      delete TPS[i];
-      *out << Verbose(2) << "Atom " << *((InsertPoint.first)->second->node) << " gibt's schon in der PointMap." << endl;
-      TPS[i] = (InsertPoint.first)->second;
-    }
-  }
-
-  // check lines
-  for (int i=0;i<3;i++)
-    if (Present[i])
-      for (int j=i;j<3;j++)
-        if (Present[j]) {
-          TryAndError = TPS[i]->lines.find(TPS[j]->node->nr);
-          if ((TryAndError != TPS[i]->lines.end()) && (TryAndError->second->TrianglesCount > 1)) {
-            *out << "WARNING: Line " << *TryAndError->second << " already present with " << TryAndError->second->TrianglesCount << " triangles attached." << endl;
-            *out << Verbose(2) << "End of CheckPresenceOfTriangle" << endl;
-            return false;
-          }
+struct Intersection {
+  Vector x1;
+  Vector x2;
+  Vector x3;
+  Vector x4;
+};
+
+/**
+ * Intersection calculation function.
+ *
+ * @param x to find the result for
+ * @param function parameter
+ */
+double MinIntersectDistance(const gsl_vector * x, void *params) {
+  double retval = 0;
+  struct Intersection *I = (struct Intersection *)params;
+  Vector intersection;
+  Vector SideA,SideB,HeightA, HeightB;
+  for (int i=0;i<NDIM;i++)
+    intersection.x[i] = gsl_vector_get(x, i);
+
+  SideA.CopyVector(&(I->x1));
+  SideA.SubtractVector(&I->x2);
+  HeightA.CopyVector(&intersection);
+  HeightA.SubtractVector(&I->x1);
+  HeightA.ProjectOntoPlane(&SideA);
+
+  SideB.CopyVector(&I->x3);
+  SideB.SubtractVector(&I->x4);
+  HeightB.CopyVector(&intersection);
+  HeightB.SubtractVector(&I->x3);
+  HeightB.ProjectOntoPlane(&SideB);
+
+  retval = HeightA.ScalarProduct(&HeightA) + HeightB.ScalarProduct(&HeightB);
+  //cout << Verbose(2) << "MinIntersectDistance called, result: " << retval << endl;
+
+  return retval;
+};
+
+
+/**
+ * Calculates whether there is an intersection between two lines. The first line
+ * always goes through point 1 and point 2 and the second line is given by the
+ * connection between point 4 and point 5.
+ *
+ * @param point 1 of line 1
+ * @param point 2 of line 1
+ * @param point 1 of line 2
+ * @param point 2 of line 2
+ *
+ * @return true if there is an intersection between the given lines, false otherwise
+ */
+bool existsIntersection(Vector point1, Vector point2, Vector point3, Vector point4) {
+  bool result;
+
+  struct Intersection par;
+    par.x1.CopyVector(&point1);
+    par.x2.CopyVector(&point2);
+    par.x3.CopyVector(&point3);
+    par.x4.CopyVector(&point4);
+
+    const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex;
+    gsl_multimin_fminimizer *s = NULL;
+    gsl_vector *ss, *x;
+    gsl_multimin_function minex_func;
+
+    size_t iter = 0;
+    int status;
+    double size;
+
+    /* Starting point */
+    x = gsl_vector_alloc(NDIM);
+    gsl_vector_set(x, 0, point1.x[0]);
+    gsl_vector_set(x, 1, point1.x[1]);
+    gsl_vector_set(x, 2, point1.x[2]);
+
+    /* Set initial step sizes to 1 */
+    ss = gsl_vector_alloc(NDIM);
+    gsl_vector_set_all(ss, 1.0);
+
+    /* Initialize method and iterate */
+    minex_func.n = NDIM;
+    minex_func.f = &MinIntersectDistance;
+    minex_func.params = (void *)&par;
+
+    s = gsl_multimin_fminimizer_alloc(T, NDIM);
+    gsl_multimin_fminimizer_set(s, &minex_func, x, ss);
+
+    do {
+        iter++;
+        status = gsl_multimin_fminimizer_iterate(s);
+
+        if (status) {
+          break;
         }
-  *out << Verbose(2) << "End of CheckPresenceOfTriangle" << endl;
-  return true;
-};
-
+
+        size = gsl_multimin_fminimizer_size(s);
+        status = gsl_multimin_test_size(size, 1e-2);
+
+        if (status == GSL_SUCCESS) {
+          cout << Verbose(2) << "converged to minimum" <<  endl;
+        }
+    } while (status == GSL_CONTINUE && iter < 100);
+
+    // check whether intersection is in between or not
+  Vector intersection, SideA, SideB, HeightA, HeightB;
+  double t1, t2;
+  for (int i = 0; i < NDIM; i++) {
+    intersection.x[i] = gsl_vector_get(s->x, i);
+  }
+
+  SideA.CopyVector(&par.x2);
+  SideA.SubtractVector(&par.x1);
+  HeightA.CopyVector(&intersection);
+  HeightA.SubtractVector(&par.x1);
+
+  t1 = HeightA.Projection(&SideA)/SideA.ScalarProduct(&SideA);
+
+  SideB.CopyVector(&par.x4);
+  SideB.SubtractVector(&par.x3);
+  HeightB.CopyVector(&intersection);
+  HeightB.SubtractVector(&par.x3);
+
+  t2 = HeightB.Projection(&SideB)/SideB.ScalarProduct(&SideB);
+
+  cout << Verbose(2) << "Intersection " << intersection << " is at "
+    << t1 << " for (" << point1 << "," << point2 << ") and at "
+    << t2 << " for (" << point3 << "," << point4 << "): ";
+
+  if (((t1 >= 0) && (t1 <= 1)) && ((t2 >= 0) && (t2 <= 1))) {
+    cout << "true intersection." << endl;
+    result = true;
+  } else {
+    cout << "intersection out of region of interest." << endl;
+    result = false;
+  }
+
+  // free minimizer stuff
+    gsl_vector_free(x);
+    gsl_vector_free(ss);
+    gsl_multimin_fminimizer_free(s);
+
+  return result;
+}
 
 /** Finds the second point of starting triangle.
@@ -2400 +2250 @@
   }
   // then go through the current and all neighbouring cells and check the contained atoms for possible candidates
-  cout << Verbose(2) << "LC Intervals:";
+  cout << Verbose(3) << "LC Intervals from [";
+  for (int i=0;i<NDIM;i++) {
+  cout << " " << N[i] << "<->" << LC->N[i];
+  }
+  cout << "] :";
   for (int i=0;i<NDIM;i++) {
     Nlower[i] = ((N[i]-1) >= 0) ? N[i]-1 : 0;
@@ -2407 +2261 @@
   }
   cout << endl;
+
+
   for (LC->n[0] = Nlower[0]; LC->n[0] <= Nupper[0]; LC->n[0]++)
     for (LC->n[1] = Nlower[1]; LC->n[1] <= Nupper[1]; LC->n[1]++)
@@ -2415 +2271 @@
           for (LinkedAtoms::iterator Runner = List->begin(); Runner != List->end(); Runner++) {
             Candidate = (*Runner);
-                // check if we only have one unique point yet ...
-                if (a != Candidate) {
-      cout << Verbose(3) << "Current candidate is " << *Candidate << ": ";
-      AngleCheck.CopyVector(&(Candidate->x));
-      AngleCheck.SubtractVector(&(a->x));
-      norm = AngleCheck.Norm();
+            // check if we only have one unique point yet ...
+            if (a != Candidate) {
+              // Calculate center of the circle with radius RADIUS through points a and Candidate
+              Vector OrthogonalizedOben, a_Candidate, Center;
+              double distance, scaleFactor;
+
+              OrthogonalizedOben.CopyVector(&Oben);
+              a_Candidate.CopyVector(&(a->x));
+              a_Candidate.SubtractVector(&(Candidate->x));
+              OrthogonalizedOben.ProjectOntoPlane(&a_Candidate);
+              OrthogonalizedOben.Normalize();
+              distance = 0.5 * a_Candidate.Norm();
+              scaleFactor = sqrt(((RADIUS * RADIUS) - (distance * distance)));
+              OrthogonalizedOben.Scale(scaleFactor);
+
+              Center.CopyVector(&(Candidate->x));
+              Center.AddVector(&(a->x));
+              Center.Scale(0.5);
+              Center.AddVector(&OrthogonalizedOben);
+
+              AngleCheck.CopyVector(&Center);
+              AngleCheck.SubtractVector(&(a->x));
+              norm = a_Candidate.Norm();
               // second point shall have smallest angle with respect to Oben vector
-              if (norm < RADIUS) {
+              if (norm < RADIUS*2.) {
                 angle = AngleCheck.Angle(&Oben);
                 if (angle < Storage[0]) {
-                  //cout << Verbose(1) << "Old values of Storage: %lf %lf \n", Storage[0], Storage[1]);
-                  cout << "Is a better candidate with distance " << norm << " and " << angle << ".\n";
+                  //cout << Verbose(3) << "Old values of Storage: %lf %lf \n", Storage[0], Storage[1]);
+                  cout << Verbose(3) << "Current candidate is " << *Candidate << ": Is a better candidate with distance " << norm << " and angle " << angle << " to oben " << Oben << ".\n";
                   Opt_Candidate = Candidate;
-                  Storage[0] = AngleCheck.Angle(&Oben);
-                  //cout << Verbose(1) << "Changing something in Storage: %lf %lf. \n", Storage[0], Storage[2]);
+                  Storage[0] = angle;
+                  //cout << Verbose(3) << "Changing something in Storage: %lf %lf. \n", Storage[0], Storage[2]);
                 } else {
-                  cout << "Looses with angle " << angle << " to a better candidate " << *Opt_Candidate << endl;
+                  //cout << Verbose(3) << "Current candidate is " << *Candidate << ": Looses with angle " << angle << " to a better candidate " << *Opt_Candidate << endl;
                 }
               } else {
-                cout << "Refused due to Radius " << norm << endl;
+                //cout << Verbose(3) << "Current candidate is " << *Candidate << ": Refused due to Radius " << norm << endl;
               }
+            } else {
+              //cout << Verbose(3) << "Current candidate is " << *Candidate << ": Candidate is equal to first endpoint." << *a << "." << endl;
             }
           }
+        } else {
+          cout << Verbose(3) << "Linked cell list is empty." << endl;
         }
       }
@@ -2455 +2332 @@
   int i = 0;
   LinkedAtoms *List = NULL;
-  atom* FirstPoint;
-  atom* SecondPoint;
+  atom* FirstPoint = NULL;
+  atom* SecondPoint = NULL;
   atom* MaxAtom[NDIM];
   double max_coordinate[NDIM];
@@ -2463 +2340 @@
   Vector Chord;
   Vector SearchDirection;
-  Vector OptCandidateCenter;
 
   Oben.Zero();
@@ -2481 +2357 @@
         if (List != NULL) {
           for (LinkedAtoms::iterator Runner = List->begin();Runner != List->end();Runner++) {
-            cout << Verbose(2) << "Current atom is " << *(*Runner) << "." << endl;
             if ((*Runner)->x.x[i] > max_coordinate[i]) {
+              cout << Verbose(2) << "New maximal for axis " << i << " atom is " << *(*Runner) << " at " << (*Runner)->x << "." << endl;
               max_coordinate[i] = (*Runner)->x.x[i];
               MaxAtom[i] = (*Runner);
@@ -2497 +2373 @@
     cout << i << ": " << *MaxAtom[i] << "\t";
   cout << endl;
-  const int k = 1;    // arbitrary choice
-  Oben.x[k] = 1.;
-  FirstPoint = MaxAtom[k];
-  cout << Verbose(1) << "Coordinates of start atom " << *FirstPoint << " at " << FirstPoint->x << "." << endl;
-
-  // add first point
-  AddTrianglePoint(FirstPoint, 0);
-
-  double ShortestAngle;
-  atom* Opt_Candidate = NULL;
-  ShortestAngle = 999999.; // This will contain the angle, which will be always positive (when looking for second point), when looking for third point this will be the quadrant.
-
-  Find_second_point_for_Tesselation(FirstPoint, NULL, Oben, Opt_Candidate, &ShortestAngle, RADIUS, LC); // we give same point as next candidate as its bonds are looked into in find_second_...
-  SecondPoint = Opt_Candidate;
-  cout << Verbose(1) << "Found second point is " << *SecondPoint << " at " << SecondPoint->x << ".\n";
-
-  // add second point and first baseline
-  AddTrianglePoint(SecondPoint, 1);
-  AddTriangleLine(TPS[0], TPS[1], 0);
-
-  helper.CopyVector(&(FirstPoint->x));
-  helper.SubtractVector(&(SecondPoint->x));
-  helper.Normalize();
-  Oben.ProjectOntoPlane(&helper);
-  Oben.Normalize();
-  helper.VectorProduct(&Oben);
-  ShortestAngle = 2.*M_PI; // This will indicate the quadrant.
-
-  Chord.CopyVector(&(FirstPoint->x)); // bring into calling function
-  Chord.SubtractVector(&(SecondPoint->x));
-  double radius = Chord.ScalarProduct(&Chord);
-  double CircleRadius = sqrt(RADIUS*RADIUS - radius/4.);
-  helper.CopyVector(&Oben);
-  helper.Scale(CircleRadius);
-  // Now, oben and helper are two orthonormalized vectors in the plane defined by Chord (not normalized)
-
-  cout << Verbose(2) << "Looking for third point candidates \n";
-  // look in one direction of baseline for initial candidate
-  Opt_Candidate = NULL;
-  SearchDirection.MakeNormalVector(&Chord, &Oben);  // whether we look "left" first or "right" first is not important ...
-
-  cout << Verbose(1) << "Looking for third point candidates ...\n";
-  Find_third_point_for_Tesselation(Oben, SearchDirection, helper, BLS[0], NULL, Opt_Candidate, &OptCandidateCenter, &ShortestAngle, RADIUS, LC);
-  cout << Verbose(1) << "Third Point is " << *Opt_Candidate << endl;
-
-  // add third point
-  AddTrianglePoint(Opt_Candidate, 2);
-
-  // FOUND Starting Triangle: FirstPoint, SecondPoint, Opt_Candidate
-
-  // Finally, we only have to add the found further lines
-  AddTriangleLine(TPS[1], TPS[2], 1);
-  AddTriangleLine(TPS[0], TPS[2], 2);
-  // ... and triangles to the Maps of the Tesselation class
-  BTS = new class BoundaryTriangleSet(BLS, TrianglesOnBoundaryCount);
-  AddTriangleToLines();
-  // ... and calculate its normal vector (with correct orientation)
-  OptCandidateCenter.Scale(-1.);
-  cout << Verbose(2) << "Oben is currently " << OptCandidateCenter << "." << endl;
-  BTS->GetNormalVector(OptCandidateCenter);
-  cout << Verbose(0) << "==> The found starting triangle consists of " << *FirstPoint << ", " << *SecondPoint << " and " << *Opt_Candidate << " with normal vector " << BTS->NormalVector << ".\n";
-  cout << Verbose(2) << "Projection is " << BTS->NormalVector.Projection(&Oben) << "." << endl;
+
+  BTS = NULL;
+  CandidateList *Opt_Candidates = new CandidateList();
+  for (int k=0;k<NDIM;k++) {
+    Oben.x[k] = 1.;
+    FirstPoint = MaxAtom[k];
+    cout << Verbose(1) << "Coordinates of start atom " << *FirstPoint << " at " << FirstPoint->x << "." << endl;
+
+    double ShortestAngle;
+    atom* Opt_Candidate = NULL;
+    ShortestAngle = 999999.; // This will contain the angle, which will be always positive (when looking for second point), when looking for third point this will be the quadrant.
+
+    Find_second_point_for_Tesselation(FirstPoint, NULL, Oben, Opt_Candidate, &ShortestAngle, RADIUS, LC); // we give same point as next candidate as its bonds are looked into in find_second_...
+    SecondPoint = Opt_Candidate;
+    if (SecondPoint == NULL)  // have we found a second point?
+      continue;
+    else
+      cout << Verbose(1) << "Found second point is " << *SecondPoint << " at " << SecondPoint->x << ".\n";
+
+    helper.CopyVector(&(FirstPoint->x));
+    helper.SubtractVector(&(SecondPoint->x));
+    helper.Normalize();
+    Oben.ProjectOntoPlane(&helper);
+    Oben.Normalize();
+    helper.VectorProduct(&Oben);
+    ShortestAngle = 2.*M_PI; // This will indicate the quadrant.
+
+    Chord.CopyVector(&(FirstPoint->x)); // bring into calling function
+    Chord.SubtractVector(&(SecondPoint->x));
+    double radius = Chord.ScalarProduct(&Chord);
+    double CircleRadius = sqrt(RADIUS*RADIUS - radius/4.);
+    helper.CopyVector(&Oben);
+    helper.Scale(CircleRadius);
+    // Now, oben and helper are two orthonormalized vectors in the plane defined by Chord (not normalized)
+
+    // look in one direction of baseline for initial candidate
+    SearchDirection.MakeNormalVector(&Chord, &Oben);  // whether we look "left" first or "right" first is not important ...
+
+    // adding point 1 and point 2 and the line between them
+    AddTrianglePoint(FirstPoint, 0);
+    AddTrianglePoint(SecondPoint, 1);
+    AddTriangleLine(TPS[0], TPS[1], 0);
+
+    //cout << Verbose(2) << "INFO: OldSphereCenter is at " << helper << ".\n";
+    Find_third_point_for_Tesselation(
+      Oben, SearchDirection, helper, BLS[0], NULL, *&Opt_Candidates, &ShortestAngle, RADIUS, LC
+    );
+    cout << Verbose(1) << "List of third Points is ";
+    for (CandidateList::iterator it = Opt_Candidates->begin(); it != Opt_Candidates->end(); ++it) {
+        cout << " " << *(*it)->point;
+    }
+    cout << endl;
+
+    for (CandidateList::iterator it = Opt_Candidates->begin(); it != Opt_Candidates->end(); ++it) {
+      // add third triangle point
+      AddTrianglePoint((*it)->point, 2);
+      // add the second and third line
+      AddTriangleLine(TPS[1], TPS[2], 1);
+      AddTriangleLine(TPS[0], TPS[2], 2);
+      // ... and triangles to the Maps of the Tesselation class
+      BTS = new class BoundaryTriangleSet(BLS, TrianglesOnBoundaryCount);
+      AddTriangle();
+      // ... and calculate its normal vector (with correct orientation)
+      (*it)->OptCenter.Scale(-1.);
+      cout << Verbose(2) << "Anti-Oben is currently " << (*it)->OptCenter << "." << endl;
+      BTS->GetNormalVector((*it)->OptCenter);  // vector to compare with should point inwards
+      cout << Verbose(0) << "==> Found starting triangle consists of " << *FirstPoint << ", " << *SecondPoint << " and "
+      << *(*it)->point << " with normal vector " << BTS->NormalVector << ".\n";
+
+      // if we do not reach the end with the next step of iteration, we need to setup a new first line
+      if (it != Opt_Candidates->end()--) {
+        FirstPoint = (*it)->BaseLine->endpoints[0]->node;
+        SecondPoint = (*it)->point;
+        // adding point 1 and point 2 and the line between them
+        AddTrianglePoint(FirstPoint, 0);
+        AddTrianglePoint(SecondPoint, 1);
+        AddTriangleLine(TPS[0], TPS[1], 0);
+      }
+      cout << Verbose(2) << "Projection is " << BTS->NormalVector.Projection(&Oben) << "." << endl;
+    }
+    if (BTS != NULL) // we have created one starting triangle
+      break;
+    else {
+      // remove all candidates from the list and then the list itself
+      class CandidateForTesselation *remover = NULL;
+      for (CandidateList::iterator it = Opt_Candidates->begin(); it != Opt_Candidates->end(); ++it) {
+        remover = *it;
+        delete(remover);
+      }
+      Opt_Candidates->clear();
+    }
+  }
+
+  // remove all candidates from the list and then the list itself
+  class CandidateForTesselation *remover = NULL;
+  for (CandidateList::iterator it = Opt_Candidates->begin(); it != Opt_Candidates->end(); ++it) {
+    remover = *it;
+    delete(remover);
+  }
+  delete(Opt_Candidates);
   cout << Verbose(1) << "End of Find_starting_triangle\n";
 };
+
+/** Checks for a new special triangle whether one of its edges is already present with one one triangle connected.
+ * This enforces that special triangles (i.e. degenerated ones) should at last close the open-edge frontier and not
+ * make it bigger (i.e. closing one (the baseline) and opening two new ones).
+ * \param TPS[3] nodes of the triangle
+ * \return true - there is such a line (i.e. creation of degenerated triangle is valid), false - no such line (don't create)
+ */
+bool CheckLineCriteriaforDegeneratedTriangle(class BoundaryPointSet *nodes[3])
+{
+  bool result = false;
+  int counter = 0;
+
+  // check all three points
+  for (int i=0;i<3;i++)
+    for (int j=i+1; j<3; j++) {
+      if (nodes[i]->lines.find(nodes[j]->node->nr) != nodes[i]->lines.end()) {  // there already is a line
+        LineMap::iterator FindLine;
+        pair<LineMap::iterator,LineMap::iterator> FindPair;
+        FindPair = nodes[i]->lines.equal_range(nodes[j]->node->nr);
+        for (FindLine = FindPair.first; FindLine != FindPair.second; ++FindLine) {
+          // If there is a line with less than two attached triangles, we don't need a new line.
+          if (FindLine->second->TrianglesCount < 2) {
+            counter++;
+            break;  // increase counter only once per edge
+          }
+        }
+      } else { // no line
+        cout << Verbose(1) << "ERROR: The line between " << nodes[i] << " and " << nodes[j] << " is not yet present, hence no need for a degenerate triangle!" << endl;
+        result = true;
+      }
+    }
+  if (counter > 1) {
+    cout << Verbose(2) << "INFO: Degenerate triangle is ok, at least two, here " << counter << ", existing lines are used." << endl;
+    result = true;
+  }
+  return result;
+};
+
 
 /** This function finds a triangle to a line, adjacent to an existing one.
@@ -2576 +2528 @@
     const double& RADIUS, int N, const char *tempbasename, LinkedCell *LC)
 {
-  cout << Verbose(1) << "Begin of Find_next_suitable_triangle\n";
+  cout << Verbose(0) << "Begin of Find_next_suitable_triangle\n";
   ofstream *tempstream = NULL;
   char NumberName[255];
-
-  atom* Opt_Candidate = NULL;
-  Vector OptCandidateCenter;
+  bool result = true;
+  CandidateList *Opt_Candidates = new CandidateList();
 
   Vector CircleCenter;
@@ -2589 +2540 @@
   Vector helper;
   atom *ThirdNode = NULL;
+  LineMap::iterator testline;
   double ShortestAngle = 2.*M_PI; // This will indicate the quadrant.
   double radius, CircleRadius;
@@ -2620 +2572 @@
     OldSphereCenter.AddVector(&helper);
     OldSphereCenter.SubtractVector(&CircleCenter);
-    cout << Verbose(2) << "INFO: OldSphereCenter is at " << OldSphereCenter << "." << endl;
+    //cout << Verbose(2) << "INFO: OldSphereCenter is at " << OldSphereCenter << "." << endl;
 
     // construct SearchDirection
@@ -2626 +2578 @@
     helper.CopyVector(&Line.endpoints[0]->node->x);
     helper.SubtractVector(&ThirdNode->x);
-    if (helper.ScalarProduct(&SearchDirection) < -HULLEPSILON)  // ohoh, SearchDirection points inwards!
+    if (helper.ScalarProduct(&SearchDirection) < -HULLEPSILON)// ohoh, SearchDirection points inwards!
       SearchDirection.Scale(-1.);
     SearchDirection.ProjectOntoPlane(&OldSphereCenter);
     SearchDirection.Normalize();
     cout << Verbose(2) << "INFO: SearchDirection is " << SearchDirection << "." << endl;
-    if (fabs(OldSphereCenter.ScalarProduct(&SearchDirection)) > HULLEPSILON) {  // rotated the wrong way!
+    if (fabs(OldSphereCenter.ScalarProduct(&SearchDirection)) > HULLEPSILON) {
+      // rotated the wrong way!
       cerr << "ERROR: SearchDirection and RelativeOldSphereCenter are still not orthogonal!" << endl;
     }
 
     // add third point
-    cout << Verbose(1) << "Looking for third point candidates for triangle ... " << endl;
-    Find_third_point_for_Tesselation(T.NormalVector, SearchDirection, OldSphereCenter, &Line, ThirdNode, Opt_Candidate, &OptCandidateCenter, &ShortestAngle, RADIUS, LC);
+    Find_third_point_for_Tesselation(
+      T.NormalVector, SearchDirection, OldSphereCenter, &Line, ThirdNode, Opt_Candidates,
+      &ShortestAngle, RADIUS, LC
+    );
 
   } else {
@@ -2643 +2598 @@
   }
 
-  if (Opt_Candidate == NULL) {
+  if (Opt_Candidates->begin() == Opt_Candidates->end()) {
     cerr << "WARNING: Could not find a suitable candidate." << endl;
     return false;
   }
-  cout << Verbose(1) << " Optimal candidate is " << *Opt_Candidate << " with circumsphere's center at " << OptCandidateCenter << "." << endl;
-
-  // check whether all edges of the new triangle still have space for one more triangle (i.e. TriangleCount <2)
-  bool flag = CheckPresenceOfTriangle(out, Opt_Candidate, Line.endpoints[0]->node, Line.endpoints[1]->node);
-
-  if (flag) { // if so, add
-    AddTrianglePoint(Opt_Candidate, 0);
-    AddTrianglePoint(Line.endpoints[0]->node, 1);
-    AddTrianglePoint(Line.endpoints[1]->node, 2);
-
-    AddTriangleLine(TPS[0], TPS[1], 0);
-    AddTriangleLine(TPS[0], TPS[2], 1);
-    AddTriangleLine(TPS[1], TPS[2], 2);
-
-    BTS = new class BoundaryTriangleSet(BLS, TrianglesOnBoundaryCount);
-    AddTriangleToLines();
-
-    OptCandidateCenter.Scale(-1.);
-    BTS->GetNormalVector(OptCandidateCenter);
-    OptCandidateCenter.Scale(-1.);
-
-    cout << "--> New triangle with " << *BTS << " and normal vector " << BTS->NormalVector << " for this triangle ... " << endl;
-    cout << Verbose(1) << "We have "<< TrianglesOnBoundaryCount << " for line " << Line << "." << endl;
-  } else { // else, yell and do nothing
-    cout << Verbose(1) << "This triangle consisting of ";
-    cout << *Opt_Candidate << ", ";
-    cout << *Line.endpoints[0]->node << " and ";
-    cout << *Line.endpoints[1]->node << " ";
-    cout << "is invalid!" << endl;
-    return false;
-  }
-
-  if (flag && (DoSingleStepOutput && (TrianglesOnBoundaryCount % 10 == 0))) { // if we have a new triangle and want to output each new triangle configuration
-    sprintf(NumberName, "-%04d-%s_%s_%s", TriangleFilesWritten, BTS->endpoints[0]->node->Name, BTS->endpoints[1]->node->Name, BTS->endpoints[2]->node->Name);
-    if (DoTecplotOutput) {
-      string NameofTempFile(tempbasename);
-      NameofTempFile.append(NumberName);
-      for(size_t npos = NameofTempFile.find_first_of(' '); npos != string::npos; npos = NameofTempFile.find(' ', npos))
+  cout << Verbose(1) << "Third Points are ";
+  for (CandidateList::iterator it = Opt_Candidates->begin(); it != Opt_Candidates->end(); ++it) {
+    cout << " " << *(*it)->point;
+  }
+  cout << endl;
+
+  BoundaryLineSet *BaseRay = &Line;
+  for (CandidateList::iterator it = Opt_Candidates->begin(); it != Opt_Candidates->end(); ++it) {
+    cout << Verbose(1) << " Third point candidate is " << *(*it)->point
+    << " with circumsphere's center at " << (*it)->OptCenter << "." << endl;
+    cout << Verbose(1) << " Baseline is " << *BaseRay << endl;
+
+    // check whether all edges of the new triangle still have space for one more triangle (i.e. TriangleCount <2)
+    atom *AtomCandidates[3];
+    AtomCandidates[0] = (*it)->point;
+    AtomCandidates[1] = BaseRay->endpoints[0]->node;
+    AtomCandidates[2] = BaseRay->endpoints[1]->node;
+    int existentTrianglesCount = CheckPresenceOfTriangle(out, AtomCandidates);
+
+    BTS = NULL;
+    // If there is no triangle, add it regularly.
+    if (existentTrianglesCount == 0) {
+      AddTrianglePoint((*it)->point, 0);
+      AddTrianglePoint(BaseRay->endpoints[0]->node, 1);
+      AddTrianglePoint(BaseRay->endpoints[1]->node, 2);
+
+      AddTriangleLine(TPS[0], TPS[1], 0);
+      AddTriangleLine(TPS[0], TPS[2], 1);
+      AddTriangleLine(TPS[1], TPS[2], 2);
+
+      BTS = new class BoundaryTriangleSet(BLS, TrianglesOnBoundaryCount);
+      AddTriangle();
+      (*it)->OptCenter.Scale(-1.);
+      BTS->GetNormalVector((*it)->OptCenter);
+      (*it)->OptCenter.Scale(-1.);
+
+      cout << "--> New triangle with " << *BTS << " and normal vector " << BTS->NormalVector
+        << " for this triangle ... " << endl;
+      //cout << Verbose(1) << "We have "<< TrianglesOnBoundaryCount << " for line " << *BaseRay << "." << endl;
+    } else if (existentTrianglesCount == 1) { // If there is a planar region within the structure, we need this triangle a second time.
+        AddTrianglePoint((*it)->point, 0);
+        AddTrianglePoint(BaseRay->endpoints[0]->node, 1);
+        AddTrianglePoint(BaseRay->endpoints[1]->node, 2);
+
+        // We demand that at most one new degenerate line is created and that this line also already exists (which has to be the case due to existentTrianglesCount == 1)
+        // i.e. at least one of the three lines must be present with TriangleCount <= 1
+        if (CheckLineCriteriaforDegeneratedTriangle(TPS)) {
+          AddTriangleLine(TPS[0], TPS[1], 0);
+          AddTriangleLine(TPS[0], TPS[2], 1);
+          AddTriangleLine(TPS[1], TPS[2], 2);
+
+          BTS = new class BoundaryTriangleSet(BLS, TrianglesOnBoundaryCount);
+          AddTriangle();
+
+          (*it)->OtherOptCenter.Scale(-1.);
+          BTS->GetNormalVector((*it)->OtherOptCenter);
+          (*it)->OtherOptCenter.Scale(-1.);
+
+          cout << "--> WARNING: Special new triangle with " << *BTS << " and normal vector " << BTS->NormalVector
+          << " for this triangle ... " << endl;
+          cout << Verbose(1) << "We have "<< BaseRay->TrianglesCount << " for line " << BaseRay << "." << endl;
+        } else {
+          cout << Verbose(1) << "WARNING: This triangle consisting of ";
+          cout << *(*it)->point << ", ";
+          cout << *BaseRay->endpoints[0]->node << " and ";
+          cout << *BaseRay->endpoints[1]->node << " ";
+          cout << "exists and is not added, as it does not seem helpful!" << endl;
+          result = false;
+        }
+    } else {
+      cout << Verbose(1) << "This triangle consisting of ";
+      cout << *(*it)->point << ", ";
+      cout << *BaseRay->endpoints[0]->node << " and ";
+      cout << *BaseRay->endpoints[1]->node << " ";
+      cout << "is invalid!" << endl;
+      result = false;
+    }
+
+    if ((result) && (existentTrianglesCount < 2) && (DoSingleStepOutput && (TrianglesOnBoundaryCount % 1 == 0))) { // if we have a new triangle and want to output each new triangle configuration
+      sprintf(NumberName, "-%04d-%s_%s_%s", TriangleFilesWritten, BTS->endpoints[0]->node->Name, BTS->endpoints[1]->node->Name, BTS->endpoints[2]->node->Name);
+      if (DoTecplotOutput) {
+        string NameofTempFile(tempbasename);
+        NameofTempFile.append(NumberName);
+        for(size_t npos = NameofTempFile.find_first_of(' '); npos != string::npos; npos = NameofTempFile.find(' ', npos))
         NameofTempFile.erase(npos, 1);
-      NameofTempFile.append(TecplotSuffix);
-      cout << Verbose(1) << "Writing temporary non convex hull to file " << NameofTempFile << ".\n";
-      tempstream = new ofstream(NameofTempFile.c_str(), ios::trunc);
-      write_tecplot_file(out, tempstream, this, mol, TriangleFilesWritten);
-      tempstream->close();
-      tempstream->flush();
-      delete(tempstream);
-    }
-
-    if (DoRaster3DOutput) {
-      string NameofTempFile(tempbasename);
-      NameofTempFile.append(NumberName);
-      for(size_t npos = NameofTempFile.find_first_of(' '); npos != string::npos; npos = NameofTempFile.find(' ', npos))
+        NameofTempFile.append(TecplotSuffix);
+        cout << Verbose(1) << "Writing temporary non convex hull to file " << NameofTempFile << ".\n";
+        tempstream = new ofstream(NameofTempFile.c_str(), ios::trunc);
+        write_tecplot_file(out, tempstream, this, mol, TriangleFilesWritten);
+        tempstream->close();
+        tempstream->flush();
+        delete(tempstream);
+      }
+
+      if (DoRaster3DOutput) {
+        string NameofTempFile(tempbasename);
+        NameofTempFile.append(NumberName);
+        for(size_t npos = NameofTempFile.find_first_of(' '); npos != string::npos; npos = NameofTempFile.find(' ', npos))
         NameofTempFile.erase(npos, 1);
-      NameofTempFile.append(Raster3DSuffix);
-      cout << Verbose(1) << "Writing temporary non convex hull to file " << NameofTempFile << ".\n";
-      tempstream = new ofstream(NameofTempFile.c_str(), ios::trunc);
-      write_raster3d_file(out, tempstream, this, mol);
-      // include the current position of the virtual sphere in the temporary raster3d file
-      // make the circumsphere's center absolute again
-      helper.CopyVector(&Line.endpoints[0]->node->x);
-      helper.AddVector(&Line.endpoints[1]->node->x);
-      helper.Scale(0.5);
-      OptCandidateCenter.AddVector(&helper);
-      Vector *center = mol->DetermineCenterOfAll(out);
-      OptCandidateCenter.AddVector(center);
-      delete(center);
-      // and add to file plus translucency object
-      *tempstream << "# current virtual sphere\n";
-      *tempstream << "8\n  25.0    0.6     -1.0 -1.0 -1.0     0.2        0 0 0 0\n";
-      *tempstream << "2\n  " << OptCandidateCenter.x[0] << " " << OptCandidateCenter.x[1] << " " << OptCandidateCenter.x[2] << "\t" << RADIUS << "\t1 0 0\n";
-      *tempstream << "9\n  terminating special property\n";
-      tempstream->close();
-      tempstream->flush();
-      delete(tempstream);
-    }
-    if (DoTecplotOutput || DoRaster3DOutput)
-      TriangleFilesWritten++;
-  }
-
-  cout << Verbose(1) << "End of Find_next_suitable_triangle\n";
-  return true;
+        NameofTempFile.append(Raster3DSuffix);
+        cout << Verbose(1) << "Writing temporary non convex hull to file " << NameofTempFile << ".\n";
+        tempstream = new ofstream(NameofTempFile.c_str(), ios::trunc);
+        write_raster3d_file(out, tempstream, this, mol);
+        // include the current position of the virtual sphere in the temporary raster3d file
+        // make the circumsphere's center absolute again
+        helper.CopyVector(&BaseRay->endpoints[0]->node->x);
+        helper.AddVector(&BaseRay->endpoints[1]->node->x);
+        helper.Scale(0.5);
+        (*it)->OptCenter.AddVector(&helper);
+        Vector *center = mol->DetermineCenterOfAll(out);
+        (*it)->OptCenter.AddVector(center);
+        delete(center);
+        // and add to file plus translucency object
+        *tempstream << "# current virtual sphere\n";
+        *tempstream << "8\n  25.0    0.6     -1.0 -1.0 -1.0     0.2        0 0 0 0\n";
+        *tempstream << "2\n  " << (*it)->OptCenter.x[0] << " "
+          << (*it)->OptCenter.x[1] << " " << (*it)->OptCenter.x[2]
+          << "\t" << RADIUS << "\t1 0 0\n";
+        *tempstream << "9\n  terminating special property\n";
+        tempstream->close();
+        tempstream->flush();
+        delete(tempstream);
+      }
+      if (DoTecplotOutput || DoRaster3DOutput)
+        TriangleFilesWritten++;
+    }
+
+    // set baseline to new ray from ref point (here endpoints[0]->node) to current candidate (here (*it)->point))
+    BaseRay = BLS[0];
+  }
+
+  // remove all candidates from the list and then the list itself
+  class CandidateForTesselation *remover = NULL;
+  for (CandidateList::iterator it = Opt_Candidates->begin(); it != Opt_Candidates->end(); ++it) {
+    remover = *it;
+    delete(remover);
+  }
+  delete(Opt_Candidates);
+  cout << Verbose(0) << "End of Find_next_suitable_triangle\n";
+  return result;
 };
+
+/**
+ * Sort function for the candidate list.
+ */
+bool sortCandidates(CandidateForTesselation* candidate1, CandidateForTesselation* candidate2) {
+  Vector BaseLineVector, OrthogonalVector, helper;
+  if (candidate1->BaseLine != candidate2->BaseLine) {  // sanity check
+    cout << Verbose(0) << "ERROR: sortCandidates was called for two different baselines: " << candidate1->BaseLine << " and " << candidate2->BaseLine << "." << endl;
+    //return false;
+    exit(1);
+  }
+  // create baseline vector
+  BaseLineVector.CopyVector(&(candidate1->BaseLine->endpoints[1]->node->x));
+  BaseLineVector.SubtractVector(&(candidate1->BaseLine->endpoints[0]->node->x));
+  BaseLineVector.Normalize();
+
+  // create normal in-plane vector to cope with acos() non-uniqueness on [0,2pi] (note that is pointing in the "right" direction already, hence ">0" test!)
+  helper.CopyVector(&(candidate1->BaseLine->endpoints[0]->node->x));
+  helper.SubtractVector(&(candidate1->point->x));
+  OrthogonalVector.CopyVector(&helper);
+  helper.VectorProduct(&BaseLineVector);
+  OrthogonalVector.SubtractVector(&helper);
+  OrthogonalVector.Normalize();
+
+  // calculate both angles and correct with in-plane vector
+  helper.CopyVector(&(candidate1->point->x));
+  helper.SubtractVector(&(candidate1->BaseLine->endpoints[0]->node->x));
+  double phi = BaseLineVector.Angle(&helper);
+  if (OrthogonalVector.ScalarProduct(&helper) > 0) {
+    phi = 2.*M_PI - phi;
+  }
+  helper.CopyVector(&(candidate2->point->x));
+  helper.SubtractVector(&(candidate1->BaseLine->endpoints[0]->node->x));
+  double psi = BaseLineVector.Angle(&helper);
+  if (OrthogonalVector.ScalarProduct(&helper) > 0) {
+    psi = 2.*M_PI - psi;
+  }
+
+  cout << Verbose(2) << *candidate1->point << " has angle " << phi << endl;
+  cout << Verbose(2) << *candidate2->point << " has angle " << psi << endl;
+
+  // return comparison
+  return phi < psi;
+}
 
 /** Tesselates the non convex boundary by rolling a virtual sphere along the surface of the molecule.
@@ -2734 +2792 @@
  * \param *mol molecule structure with Atom's and Bond's
  * \param *Tess Tesselation filled with points, lines and triangles on boundary on return
- * \param *LCList linked cell list of all atoms
  * \param *filename filename prefix for output of vertex data
  * \para RADIUS radius of the virtual sphere
@@ -2742 +2799 @@
   int N = 0;
   bool freeTess = false;
+  bool freeLC = false;
   *out << Verbose(1) << "Entering search for non convex hull. " << endl;
   if (Tess == NULL) {
@@ -2748 +2806 @@
     freeTess = true;
   }
-  bool freeLC = false;
   LineMap::iterator baseline;
+  LineMap::iterator testline;
   *out << Verbose(0) << "Begin of Find_non_convex_border\n";
   bool flag = false;  // marks whether we went once through all baselines without finding any without two triangles
@@ -2769 +2827 @@
         cerr << "WARNING: Find_next_suitable_triangle failed." << endl;
     } else {
-      cout << Verbose(1) << "Line " << *baseline->second << " has " << baseline->second->TrianglesCount << " triangles adjacent" << endl;
-    }
+      //cout << Verbose(1) << "Line " << *baseline->second << " has " << baseline->second->TrianglesCount << " triangles adjacent" << endl;
+      if (baseline->second->TrianglesCount != 2)
+        cout << Verbose(1) << "ERROR: TESSELATION FINISHED WITH INVALID TRIANGLE COUNT!" << endl;
+    }
+
     N++;
     baseline++;
@@ -2797 +2858 @@
     }
   } else {
-    cerr << "ERROR: Could definately not find all necessary triangles!" << endl;
-  }
+    cerr << "ERROR: Could definitively not find all necessary triangles!" << endl;
+  }
+
+  cout << Verbose(2) << "Check: List of Baselines with not two connected triangles:" << endl;
+  int counter = 0;
+  for (testline = Tess->LinesOnBoundary.begin(); testline != Tess->LinesOnBoundary.end(); testline++) {
+    if (testline->second->TrianglesCount != 2) {
+      cout << Verbose(2) << *testline->second << "\t" << testline->second->TrianglesCount << endl;
+      counter++;
+    }
+  }
+  if (counter == 0)
+    cout << Verbose(2) << "None." << endl;
+
   if (freeTess)
     delete(Tess);

src/boundary.hpp

@@ -5 +5 @@
 class BoundaryLineSet;
 class BoundaryTriangleSet;
+class CandidateForTesselation;
 
 // include config.h
@@ -17 +18 @@
 
 #include <gsl/gsl_poly.h>
-#include <gsl/gsl_matrix.h>
-#include <gsl/gsl_linalg.h>
-#include <gsl/gsl_multimin.h>
-#include <gsl/gsl_permutation.h>
 
 #include "linkedcell.hpp"
@@ -78 +75 @@
 };
 
+
+class CandidateForTesselation {
+  public :
+  CandidateForTesselation(atom* candidate, BoundaryLineSet* currentBaseLine, Vector OptCandidateCenter, Vector OtherOptCandidateCenter);
+  ~CandidateForTesselation();
+  atom *point;
+  BoundaryLineSet *BaseLine;
+  Vector OptCenter;
+  Vector OtherOptCenter;
+};
+
+
 class Tesselation {
   public:
@@ -89 +98 @@
     void AddTrianglePoint(atom* Candidate, int n);
     void AddTriangleLine(class BoundaryPointSet *a, class BoundaryPointSet *b, int n);
-    void AddTriangleToLines();
+    void AlwaysAddTriangleLine(class BoundaryPointSet *a, class BoundaryPointSet *b, int n);
+    void AddTriangle();
     void Find_starting_triangle(ofstream *out, molecule* mol, const double RADIUS, LinkedCell *LC);
     bool Find_next_suitable_triangle(ofstream *out, molecule* mol, BoundaryLineSet &Line, BoundaryTriangleSet &T, const double& RADIUS, int N, const char *filename, LinkedCell *LC);
-    bool CheckPresenceOfTriangle(ofstream *out, atom *a, atom *b, atom *c);
+    int CheckPresenceOfTriangle(ofstream *out, atom *Candidates[3]);
     void Find_next_suitable_point_via_Angle_of_Sphere(atom* a, atom* b, atom* c, atom* Candidate, atom* Parent, int RecursionLevel, Vector *Chord, Vector *direction1, Vector *OldNormal, Vector ReferencePoint, atom*& Opt_Candidate, double *Storage, const double RADIUS, molecule* mol);
 
@@ -117 +127 @@
 double * GetDiametersOfCluster(ofstream *out, Boundaries *BoundaryPtr, molecule *mol, bool IsAngstroem);
 void PrepareClustersinWater(ofstream *out, config *configuration, molecule *mol, double ClusterVolume, double celldensity);
-void Find_non_convex_border(ofstream *out, molecule* mol, class Tesselation *T, class LinkedCell *LCList, const char *tempbasename, const double RADIUS);
+void Find_non_convex_border(ofstream *out, molecule* mol, class Tesselation *T, class LinkedCell *LC, const char *tempbasename, const double RADIUS);
 void Find_next_suitable_point(class BoundaryTriangleSet *BaseTriangle, class BoundaryLineSet *BaseLine, atom*& OptCandidate, Vector *OptCandidateCenter, double *ShortestAngle, const double RADIUS, LinkedCell *LC);
+bool Choose_preferable_third_point(atom *Candidate, atom *OptCandidate, class BoundaryLineSet *BaseLine, atom *ThirdNode, Tesselation *Tess);
+bool existsIntersection(Vector point1, Vector point2, Vector point3, Vector point4);
+bool sortCandidates(CandidateForTesselation* candidate1, CandidateForTesselation* candidate2);
 
 #endif /*BOUNDARY_HPP_*/

src/builder.cpp

@@ -307 +307 @@
         cin >> x.x[i];
       }
-      // center
-      mol->CenterInBox((ofstream *)&cout, &x);
       // update Box of atoms by boundary
       mol->SetBoxDimension(&x);
+      // center
+      mol->CenterInBox((ofstream *)&cout);
       break;
   }
@@ -753 +753 @@
 static void ManipulateMolecules(periodentafel *periode, MoleculeListClass *molecules, config *configuration)
 {
-  atom *first;
+  atom *first = NULL;
   Vector x,y,z,n; // coordinates for absolute point in cell volume
   int j, axis, count, faktor;
@@ -1305 +1305 @@
  * \return exit code (0 - successful, all else - something's wrong)
  */
-static int ParseCommandLineOptions(int argc, char **argv, MoleculeListClass *&molecules, periodentafel *&periode, config& configuration, char *ConfigFileName, char *&PathToDatabases)
+static int ParseCommandLineOptions(int argc, char **argv, MoleculeListClass *&molecules, periodentafel *&periode, config& configuration, char *&ConfigFileName)
 {
   Vector x,y,z,n;  // coordinates for absolute point in cell volume
@@ -1320 +1320 @@
   clock_t start,end;
   int argptr;
-  PathToDatabases = LocalPath;
+  strncpy(configuration.databasepath, LocalPath, MAXSTRINGSIZE-1);
 
   // simply create a new molecule, wherein the config file is loaded and the manipulation takes place
@@ -1343 +1343 @@
             cout << "\t-a Z x1 x2 x3\tAdd new atom of element Z at coordinates (x1,x2,x3)." << endl;
             cout << "\t-A <source>\tCreate adjacency list from bonds parsed from 'dbond'-style file." <<endl;
-            cout << "\t-b x1 x2 x3\tCenter atoms in domain with given edge lengths of (x1,x2,x3)." << endl;
+            cout << "\t-b xx xy xz yy yz zz\tCenter atoms in domain with given symmetric matrix of (xx,xy,xz,yy,yz,zz)." << endl;
             cout << "\t-B <basis>\tSetting basis to store to MPQC config files." << endl;
             cout << "\t-c x1 x2 x3\tCenter atoms in domain with a minimum distance to boundary of (x1,x2,x3)." << endl;
@@ -1363 +1363 @@
             cout << "\t-R\t\tRemove all atoms out of sphere around a given one." << endl;
             cout << "\t-t x1 x2 x3\tTranslate all atoms by this vector (x1,x2,x3)." << endl;
-            cout << "\t-T <file> Store temperatures from the config file in <file>." << endl;
+            cout << "\t-T x1 x2 x3\tTranslate periodically all atoms by this vector (x1,x2,x3)." << endl;
+            cout << "\t-S <file> Store temperatures from the config file in <file>." << endl;
             cout << "\t-s x1 x2 x3\tScale all atom coordinates by this vector (x1,x2,x3)." << endl;
             cout << "\t-u rho\tsuspend in water solution and output necessary cell lengths, average density rho and repetition." << endl;
@@ -1385 +1386 @@
             } else {
               cout << "Using " << argv[argptr] << " as elements database." << endl;
-              PathToDatabases = argv[argptr];
+              strncpy (configuration.databasepath, argv[argptr], MAXSTRINGSIZE-1);
               argptr+=1;
             }
@@ -1402 +1403 @@
 
     // 2. Parse the element database
-    if (periode->LoadPeriodentafel(PathToDatabases)) {
+    if (periode->LoadPeriodentafel(configuration.databasepath)) {
       cout << Verbose(0) << "Element list loaded successfully." << endl;
       //periode->Output((ofstream *)&cout);
@@ -1421 +1422 @@
         } else {
           cout << "Empty configuration file." << endl;
-          strcpy(ConfigFileName, argv[1]);
+          ConfigFileName = argv[1];
           config_present = empty;
           output.close();
@@ -1427 +1428 @@
       } else {
         test.close();
-        strcpy(ConfigFileName, argv[1]);
+        ConfigFileName = argv[1];
         cout << Verbose(1) << "Specified config file found, parsing ... ";
         switch (configuration.TestSyntax(ConfigFileName, periode, mol)) {
@@ -1576 +1577 @@
               } else {
                 class Tesselation T;
-                int N = 15;
-                int number = 100;
                 string filename(argv[argptr+1]);
                 filename.append(".csv");
                 cout << Verbose(0) << "Evaluating non-convex envelope.";
                 cout << Verbose(1) << "Using rolling ball of radius " << atof(argv[argptr]) << " and storing tecplot data in " << argv[argptr+1] << "." << endl;
-                LinkedCell LCList(mol, atof(argv[argptr]));    // \NOTE not twice the radius??
+                LinkedCell LCList(mol, atof(argv[argptr])*2.);
                 Find_non_convex_border((ofstream *)&cout, mol, &T, &LCList, argv[argptr+1], atof(argv[argptr]));
-                FindDistributionOfEllipsoids((ofstream *)&cout, &T, &LCList, N, number, filename.c_str());
+                //FindDistributionOfEllipsoids((ofstream *)&cout, &T, &LCList, N, number, filename.c_str());
                 argptr+=2;
               }
               break;
-            case 'T':
+            case 'S':
               ExitFlag = 1;
               if ((argptr >= argc) || (argv[argptr][0] == '-')) {
                 ExitFlag = 255;
-                cerr << "Not enough or invalid arguments given for storing tempature: -T <temperature file>" << endl;
+                cerr << "Not enough or invalid arguments given for storing tempature: -S <temperature file>" << endl;
               } else {
                 cout << Verbose(1) << "Storing temperatures in " << argv[argptr] << "." << endl;
@@ -1667 +1666 @@
                   x.x[i] = atof(argv[argptr+i]);
                 mol->Translate((const Vector *)&x);
+                argptr+=3;
+              }
+            case 'T':
+              ExitFlag = 1;
+              if ((argptr+2 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
+                ExitFlag = 255;
+                cerr << "Not enough or invalid arguments given for periodic translation: -T <x> <y> <z>" << endl;
+              } else {
+                ExitFlag = 1;
+                SaveFlag = true;
+                cout << Verbose(1) << "Translating all ions periodically to new origin." << endl;
+                for (int i=NDIM;i--;)
+                  x.x[i] = atof(argv[argptr+i]);
+                mol->TranslatePeriodically((const Vector *)&x);
                 argptr+=3;
               }
@@ -1699 +1712 @@
             case 'b':
               ExitFlag = 1;
-              if ((argptr+2 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
+              if ((argptr+5 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) || (!IsValidNumber(argv[argptr+3])) || (!IsValidNumber(argv[argptr+4])) || (!IsValidNumber(argv[argptr+5])) ) {
                 ExitFlag = 255;
-                cerr << "Not enough or invalid arguments given for centering in box: -b <length_x> <length_y> <length_z>" << endl;
+                cerr << "Not enough or invalid arguments given for centering in box: -b <xx> <xy> <xz> <yy> <yz> <zz>" << endl;
               } else {
                 SaveFlag = true;
                 j = -1;
                 cout << Verbose(1) << "Centering atoms in config file within given simulation box." << endl;
-                j=-1;
-                for (int i=0;i<NDIM;i++) {
-                  j += i+1;
-                  x.x[i] = atof(argv[argptr++]);
-                  mol->cell_size[j] += x.x[i]*2.;
+                for (int i=0;i<6;i++) {
+                  mol->cell_size[i] = atof(argv[argptr+i]);
                 }
                 // center
-                mol->CenterInBox((ofstream *)&cout, &x);
-                // update Box of atoms by boundary
-                mol->SetBoxDimension(&x);
+                mol->CenterInBox((ofstream *)&cout);
+                argptr+=6;
               }
               break;
@@ -1735 +1744 @@
                 for (int i=0;i<NDIM;i++) {
                   j += i+1;
-                  x.x[i] = atof(argv[argptr++]);
+                  x.x[i] = atof(argv[argptr+i]);
                   mol->cell_size[j] += x.x[i]*2.;
                 }
                 mol->Translate((const Vector *)&x);
+                argptr+=3;
               }
               break;
@@ -1745 +1755 @@
               SaveFlag = true;
               cout << Verbose(1) << "Centering atoms on edge and setting box dimensions." << endl;
+              x.Zero();
               mol->CenterEdge((ofstream *)&cout, &x);
               mol->SetBoxDimension(&x);
+              argptr+=0;
               break;
             case 'r':
@@ -1902 +1914 @@
     if (SaveFlag)
       SaveConfig(ConfigFileName, &configuration, periode, molecules);
-    if ((ExitFlag >= 1)) {
-      delete(mol);
-      delete(periode);
-      return (ExitFlag);
-    }
   } else {  // no arguments, hence scan the elements db
-    if (periode->LoadPeriodentafel(PathToDatabases))
+    if (periode->LoadPeriodentafel(configuration.databasepath))
       cout << Verbose(0) << "Element list loaded successfully." << endl;
     else
@@ -1914 +1921 @@
     configuration.RetrieveConfigPathAndName("main_pcp_linux");
   }
-  return(0);
+  return(ExitFlag);
 };
 
@@ -1930 +1937 @@
   ofstream output;
   string line;
-  char ConfigFileName[MAXSTRINGSIZE];
-  char *ElementsFileName = NULL;
+  char *ConfigFileName = NULL;
   int j;
 
   // =========================== PARSE COMMAND LINE OPTIONS ====================================
-  ConfigFileName[0] = '\0';
-  j = ParseCommandLineOptions(argc, argv, molecules, periode, configuration, ConfigFileName, ElementsFileName);
-  if (j == 1) return 0; // just for -v and -h options
-  if (j) return j;  // something went wrong
+  j = ParseCommandLineOptions(argc, argv, molecules, periode, configuration, ConfigFileName);
+  switch(j) {
+    case 0:  // something went wrong
+      delete(molecules); // also free's all molecules contained
+      delete(periode);
+      return j;
+      break;
+    case 1:  // just for -v and -h options
+      delete(molecules); // also free's all molecules contained
+      delete(periode);
+      return 0;
+      break;
+    default:
+      break;
+  }
 
   // General stuff
@@ -1952 +1969 @@
     molecules->insert(mol);
   }
-  if (strlen(ConfigFileName) == 0)
-    strcpy(ConfigFileName, DEFAULTCONFIG);
-    
 
   // =========================== START INTERACTIVE SESSION ====================================
@@ -2028 +2042 @@
 
   // save element data base
-  if (periode->StorePeriodentafel(ElementsFileName)) //ElementsFileName
+  if (periode->StorePeriodentafel(configuration.databasepath)) //ElementsFileName
     cout << Verbose(0) << "Saving of elements.db successful." << endl;
   else
     cout << Verbose(0) << "Saving of elements.db failed." << endl;
 
-  delete(molecules);
+  delete(molecules); // also free's all molecules contained
   delete(periode);
   return (0);

src/config.cpp

@@ -7 +7 @@
 #include "molecules.hpp"
 
+/******************************** Functions for class ConfigFileBuffer **********************/
+
+/** Structure containing compare function for Ion_Type sorting.
+ */
+struct IonTypeCompare {
+  bool operator()(const char* s1, const char *s2) const {
+    char number1[8];
+    char number2[8];
+    char *dummy1, *dummy2;
+    //cout << s1 << "  " << s2 << endl;
+    dummy1 = strchr(s1, '_')+sizeof(char)*5;  // go just after "Ion_Type"
+    dummy2 = strchr(dummy1, '_');
+    strncpy(number1, dummy1, dummy2-dummy1); // copy the number
+    number1[dummy2-dummy1]='\0';
+    dummy1 = strchr(s2, '_')+sizeof(char)*5;  // go just after "Ion_Type"
+    dummy2 = strchr(dummy1, '_');
+    strncpy(number2, dummy1, dummy2-dummy1); // copy the number
+    number2[dummy2-dummy1]='\0';
+    if (atoi(number1) != atoi(number2))
+      return (atoi(number1) < atoi(number2));
+    else {
+      dummy1 = strchr(s1, '_')+sizeof(char);
+      dummy1 = strchr(dummy1, '_')+sizeof(char);
+      dummy2 = strchr(dummy1, ' ') < strchr(dummy1, '\t') ? strchr(dummy1, ' ') : strchr(dummy1, '\t');
+      strncpy(number1, dummy1, dummy2-dummy1); // copy the number
+      number1[dummy2-dummy1]='\0';
+      dummy1 = strchr(s2, '_')+sizeof(char);
+      dummy1 = strchr(dummy1, '_')+sizeof(char);
+      dummy2 = strchr(dummy1, ' ') < strchr(dummy1, '\t') ? strchr(dummy1, ' ') : strchr(dummy1, '\t');
+      strncpy(number2, dummy1, dummy2-dummy1); // copy the number
+      number2[dummy2-dummy1]='\0';
+      return (atoi(number1) < atoi(number2));
+    }
+  }
+};
+
+/** Constructor for ConfigFileBuffer class.
+ */
+ConfigFileBuffer::ConfigFileBuffer()
+{
+  NoLines = 0;
+  CurrentLine = 0;
+  buffer = NULL;
+  LineMapping = NULL;
+}
+
+/** Constructor for ConfigFileBuffer class with filename to be parsed.
+ * \param *filename file name
+ */
+ConfigFileBuffer::ConfigFileBuffer(char *filename)
+{
+  NoLines = 0;
+  CurrentLine = 0;
+  buffer = NULL;
+  LineMapping = NULL;
+  ifstream *file = NULL;
+  char line[MAXSTRINGSIZE];
+
+  // prescan number of lines
+  file= new ifstream(filename);
+  if (file == NULL) {
+    cerr << "ERROR: config file " << filename << " missing!" << endl;
+    return;
+  }
+  NoLines = 0; // we're overcounting by one
+  long file_position = file->tellg(); // mark current position
+  do {
+    file->getline(line, 256);
+    NoLines++;
+  } while (!file->eof());
+  file->clear();
+  file->seekg(file_position, ios::beg);
+  cout << Verbose(1) << NoLines-1 << " lines were recognized." << endl;
+
+  // allocate buffer's 1st dimension
+  if (buffer != NULL) {
+    cerr << "ERROR: FileBuffer->buffer is not NULL!" << endl;
+    return;
+  } else
+    buffer = (char **) Malloc(sizeof(char *)*NoLines, "ConfigFileBuffer::ConfigFileBuffer: **buffer");
+
+  // scan each line and put into buffer
+  int lines=0;
+  int i;
+  do {
+    buffer[lines] = (char *) Malloc(sizeof(char)*MAXSTRINGSIZE, "ConfigFileBuffer::ConfigFileBuffer: *buffer[]");
+    file->getline(buffer[lines], MAXSTRINGSIZE-1);
+    i = strlen(buffer[lines]);
+    buffer[lines][i] = '\n';
+    buffer[lines][i+1] = '\0';
+    lines++;
+  } while((!file->eof()) && (lines < NoLines));
+  cout << Verbose(1) << lines-1 << " lines were read into the buffer." << endl;
+
+  // close and exit
+  file->close();
+  file->clear();
+  delete(file);
+}
+
+/** Destructor for ConfigFileBuffer class.
+ */
+ConfigFileBuffer::~ConfigFileBuffer()
+{
+  for(int i=0;i<NoLines;++i)
+    Free((void **)&buffer[i], "ConfigFileBuffer::~ConfigFileBuffer: *buffer[]");
+  Free((void **)&buffer, "ConfigFileBuffer::~ConfigFileBuffer: **buffer");
+  Free((void **)&LineMapping, "ConfigFileBuffer::~ConfigFileBuffer: *LineMapping");
+}
+
+
+/** Create trivial mapping.
+ */
+void ConfigFileBuffer::InitMapping()
+{
+  LineMapping = (int *) Malloc(sizeof(int)*NoLines, "ConfigFileBuffer::InitMapping: *LineMapping");
+  for (int i=0;i<NoLines;i++)
+    LineMapping[i] = i;
+}
+
+/** Creates a mapping for the \a *FileBuffer's lines containing the Ion_Type keyword such that they are sorted.
+ * \a *map on return contains a list of NoAtom entries such that going through the list, yields indices to the
+ * lines in \a *FileBuffer in a sorted manner of the Ion_Type?_? keywords. We assume that ConfigFileBuffer::CurrentLine
+ * points to first Ion_Type entry.
+ * \param *FileBuffer pointer to buffer structure
+ * \param NoAtoms of subsequent lines to look at
+ */
+void ConfigFileBuffer::MapIonTypesInBuffer(int NoAtoms)
+{
+  map<const char *, int, IonTypeCompare> LineList;
+  if (LineMapping == NULL) {
+    cerr << "map pointer is NULL: " << LineMapping << endl;
+    return;
+  }
+
+  // put all into hashed map
+  for (int i=0; i<NoAtoms; ++i) {
+    LineList.insert(pair<const char *, int> (buffer[CurrentLine+i], CurrentLine+i));
+  }
+
+  // fill map
+  int nr=0;
+  for (map<const char *, int, IonTypeCompare>::iterator runner = LineList.begin(); runner != LineList.end(); ++runner) {
+    if (CurrentLine+nr < NoLines)
+      LineMapping[CurrentLine+(nr++)] = runner->second;
+    else
+      cerr << "config::MapIonTypesInBuffer - NoAtoms is wrong: We are past the end of the file!" << endl;
+  }
+}
+
 /************************************* Functions for class config ***************************/
 
@@ -14 +164 @@
 {
   mainname = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: mainname");
-  defaultpath = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: mainname");
-  pseudopotpath = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: mainname");
-  configpath = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: mainname");
-  configname = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: mainname");
-  ThermostatImplemented = (int *) Malloc((MaxThermostats)*(sizeof(int)), "IonsInitRead: *ThermostatImplemented");
-  ThermostatNames = (char **) Malloc((MaxThermostats)*(sizeof(char *)), "IonsInitRead: *ThermostatNames");
+  defaultpath = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: defaultpath");
+  pseudopotpath = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: pseudopotpath");
+  databasepath = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: databasepath");
+  configpath = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: configpath");
+  configname = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: configname");
+  ThermostatImplemented = (int *) Malloc((MaxThermostats)*(sizeof(int)), "config constructor: *ThermostatImplemented");
+  ThermostatNames = (char **) Malloc((MaxThermostats)*(sizeof(char *)), "config constructor: *ThermostatNames");
   for (int j=0;j<MaxThermostats;j++)
-    ThermostatNames[j] = (char *) MallocString(12*(sizeof(char)), "IonsInitRead: ThermostatNames[]");
+    ThermostatNames[j] = (char *) MallocString(12*(sizeof(char)), "config constructor: ThermostatNames[]");
   Thermostat = 4;
   alpha = 0.;
@@ -31 +182 @@
   configpath[0]='\0';
   configname[0]='\0';
-  basis="3-21G";
-  
+  basis = "3-21G";
 
   strcpy(ThermostatNames[0],"None");
@@ -116 +266 @@
   Free((void **)&defaultpath, "config::~config: *defaultpath");
   Free((void **)&pseudopotpath, "config::~config: *pseudopotpath");
+  Free((void **)&databasepath, "config::~config: *databasepath");
   Free((void **)&configpath, "config::~config: *configpath");
   Free((void **)&configname, "config::~config: *configname");
+  Free((void **)&ThermostatImplemented, "config::~config: *ThermostatImplemented");
+  for (int j=0;j<MaxThermostats;j++)
+    Free((void **)&ThermostatNames[j], "config::~config: *ThermostatNames[]");
+  Free((void **)&ThermostatNames, "config::~config: **ThermostatNames");
 };
 
@@ -550 +705 @@
   }
   RetrieveConfigPathAndName(filename);
-  // ParseParameters
+
+  // ParseParameterFile
+  struct ConfigFileBuffer *FileBuffer = new ConfigFileBuffer(filename);
+  FileBuffer->InitMapping();
 
   /* Oeffne Hauptparameterdatei */
@@ -568 +726 @@
   /* Namen einlesen */
 
-  ParseForParameter(verbose,file, "mainname", 0, 1, 1, string_type, (config::mainname), 1, critical);
-  ParseForParameter(verbose,file, "defaultpath", 0, 1, 1, string_type, (config::defaultpath), 1, critical);
-  ParseForParameter(verbose,file, "pseudopotpath", 0, 1, 1, string_type, (config::pseudopotpath), 1, critical);
-  ParseForParameter(verbose,file,"ProcPEGamma", 0, 1, 1, int_type, &(config::ProcPEGamma), 1, critical);
-  ParseForParameter(verbose,file,"ProcPEPsi", 0, 1, 1, int_type, &(config::ProcPEPsi), 1, critical);
-
-  if (!ParseForParameter(verbose,file,"Seed", 0, 1, 1, int_type, &(config::Seed), 1, optional))
+  ParseForParameter(verbose,FileBuffer, "mainname", 0, 1, 1, string_type, (config::mainname), 1, critical);
+  ParseForParameter(verbose,FileBuffer, "defaultpath", 0, 1, 1, string_type, (config::defaultpath), 1, critical);
+  ParseForParameter(verbose,FileBuffer, "pseudopotpath", 0, 1, 1, string_type, (config::pseudopotpath), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"ProcPEGamma", 0, 1, 1, int_type, &(config::ProcPEGamma), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"ProcPEPsi", 0, 1, 1, int_type, &(config::ProcPEPsi), 1, critical);
+
+  if (!ParseForParameter(verbose,FileBuffer,"Seed", 0, 1, 1, int_type, &(config::Seed), 1, optional))
     config::Seed = 1;
 
-  if(!ParseForParameter(verbose,file,"DoOutOrbitals", 0, 1, 1, int_type, &(config::DoOutOrbitals), 1, optional)) {
+  if(!ParseForParameter(verbose,FileBuffer,"DoOutOrbitals", 0, 1, 1, int_type, &(config::DoOutOrbitals), 1, optional)) {
     config::DoOutOrbitals = 0;
   } else {
@@ -583 +741 @@
     if (config::DoOutOrbitals > 1) config::DoOutOrbitals = 1;
   }
-  ParseForParameter(verbose,file,"DoOutVis", 0, 1, 1, int_type, &(config::DoOutVis), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"DoOutVis", 0, 1, 1, int_type, &(config::DoOutVis), 1, critical);
   if (config::DoOutVis < 0) config::DoOutVis = 0;
   if (config::DoOutVis > 1) config::DoOutVis = 1;
-  if (!ParseForParameter(verbose,file,"VectorPlane", 0, 1, 1, int_type, &(config::VectorPlane), 1, optional))
+  if (!ParseForParameter(verbose,FileBuffer,"VectorPlane", 0, 1, 1, int_type, &(config::VectorPlane), 1, optional))
     config::VectorPlane = -1;
-  if (!ParseForParameter(verbose,file,"VectorCut", 0, 1, 1, double_type, &(config::VectorCut), 1, optional))
+  if (!ParseForParameter(verbose,FileBuffer,"VectorCut", 0, 1, 1, double_type, &(config::VectorCut), 1, optional))
     config::VectorCut = 0.;
-  ParseForParameter(verbose,file,"DoOutMes", 0, 1, 1, int_type, &(config::DoOutMes), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"DoOutMes", 0, 1, 1, int_type, &(config::DoOutMes), 1, critical);
   if (config::DoOutMes < 0) config::DoOutMes = 0;
   if (config::DoOutMes > 1) config::DoOutMes = 1;
-  if (!ParseForParameter(verbose,file,"DoOutCurr", 0, 1, 1, int_type, &(config::DoOutCurrent), 1, optional))
+  if (!ParseForParameter(verbose,FileBuffer,"DoOutCurr", 0, 1, 1, int_type, &(config::DoOutCurrent), 1, optional))
     config::DoOutCurrent = 0;
   if (config::DoOutCurrent < 0) config::DoOutCurrent = 0;
   if (config::DoOutCurrent > 1) config::DoOutCurrent = 1;
-  ParseForParameter(verbose,file,"AddGramSch", 0, 1, 1, int_type, &(config::UseAddGramSch), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"AddGramSch", 0, 1, 1, int_type, &(config::UseAddGramSch), 1, critical);
   if (config::UseAddGramSch < 0) config::UseAddGramSch = 0;
   if (config::UseAddGramSch > 2) config::UseAddGramSch = 2;
-  if(!ParseForParameter(verbose,file,"DoWannier", 0, 1, 1, int_type, &(config::DoWannier), 1, optional)) {
+  if(!ParseForParameter(verbose,FileBuffer,"DoWannier", 0, 1, 1, int_type, &(config::DoWannier), 1, optional)) {
     config::DoWannier = 0;
   } else {
@@ -606 +764 @@
     if (config::DoWannier > 1) config::DoWannier = 1;
   }
-  if(!ParseForParameter(verbose,file,"CommonWannier", 0, 1, 1, int_type, &(config::CommonWannier), 1, optional)) {
+  if(!ParseForParameter(verbose,FileBuffer,"CommonWannier", 0, 1, 1, int_type, &(config::CommonWannier), 1, optional)) {
     config::CommonWannier = 0;
   } else {
@@ -612 +770 @@
     if (config::CommonWannier > 4) config::CommonWannier = 4;
   }
-  if(!ParseForParameter(verbose,file,"SawtoothStart", 0, 1, 1, double_type, &(config::SawtoothStart), 1, optional)) {
+  if(!ParseForParameter(verbose,FileBuffer,"SawtoothStart", 0, 1, 1, double_type, &(config::SawtoothStart), 1, optional)) {
     config::SawtoothStart = 0.01;
   } else {
@@ -619 +777 @@
   }
   
-  if (ParseForParameter(verbose,file,"DoConstrainedMD", 0, 1, 1, int_type, &(config::DoConstrainedMD), 1, optional))
+  if (ParseForParameter(verbose,FileBuffer,"DoConstrainedMD", 0, 1, 1, int_type, &(config::DoConstrainedMD), 1, optional))
     if (config::DoConstrainedMD < 0) 
       config::DoConstrainedMD = 0;
-  ParseForParameter(verbose,file,"MaxOuterStep", 0, 1, 1, int_type, &(config::MaxOuterStep), 1, critical);
-  if (!ParseForParameter(verbose,file,"Deltat", 0, 1, 1, double_type, &(config::Deltat), 1, optional))
+  ParseForParameter(verbose,FileBuffer,"MaxOuterStep", 0, 1, 1, int_type, &(config::MaxOuterStep), 1, critical);
+  if (!ParseForParameter(verbose,FileBuffer,"Deltat", 0, 1, 1, double_type, &(config::Deltat), 1, optional))
     config::Deltat = 1;
-  ParseForParameter(verbose,file,"OutVisStep", 0, 1, 1, int_type, &(config::OutVisStep), 1, optional);
-  ParseForParameter(verbose,file,"OutSrcStep", 0, 1, 1, int_type, &(config::OutSrcStep), 1, optional);
-  ParseForParameter(verbose,file,"TargetTemp", 0, 1, 1, double_type, &(config::TargetTemp), 1, optional);
-  //ParseForParameter(verbose,file,"Thermostat", 0, 1, 1, int_type, &(config::ScaleTempStep), 1, optional);
-  if (!ParseForParameter(verbose,file,"EpsWannier", 0, 1, 1, double_type, &(config::EpsWannier), 1, optional))
+  ParseForParameter(verbose,FileBuffer,"OutVisStep", 0, 1, 1, int_type, &(config::OutVisStep), 1, optional);
+  ParseForParameter(verbose,FileBuffer,"OutSrcStep", 0, 1, 1, int_type, &(config::OutSrcStep), 1, optional);
+  ParseForParameter(verbose,FileBuffer,"TargetTemp", 0, 1, 1, double_type, &(config::TargetTemp), 1, optional);
+  //ParseForParameter(verbose,FileBuffer,"Thermostat", 0, 1, 1, int_type, &(config::ScaleTempStep), 1, optional);
+  if (!ParseForParameter(verbose,FileBuffer,"EpsWannier", 0, 1, 1, double_type, &(config::EpsWannier), 1, optional))
     config::EpsWannier = 1e-8;
 
   // stop conditions
   //if (config::MaxOuterStep <= 0) config::MaxOuterStep = 1;
-  ParseForParameter(verbose,file,"MaxPsiStep", 0, 1, 1, int_type, &(config::MaxPsiStep), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"MaxPsiStep", 0, 1, 1, int_type, &(config::MaxPsiStep), 1, critical);
   if (config::MaxPsiStep <= 0) config::MaxPsiStep = 3;
 
-  ParseForParameter(verbose,file,"MaxMinStep", 0, 1, 1, int_type, &(config::MaxMinStep), 1, critical);
-  ParseForParameter(verbose,file,"RelEpsTotalE", 0, 1, 1, double_type, &(config::RelEpsTotalEnergy), 1, critical);
-  ParseForParameter(verbose,file,"RelEpsKineticE", 0, 1, 1, double_type, &(config::RelEpsKineticEnergy), 1, critical);
-  ParseForParameter(verbose,file,"MaxMinStopStep", 0, 1, 1, int_type, &(config::MaxMinStopStep), 1, critical);
-  ParseForParameter(verbose,file,"MaxMinGapStopStep", 0, 1, 1, int_type, &(config::MaxMinGapStopStep), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"MaxMinStep", 0, 1, 1, int_type, &(config::MaxMinStep), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"RelEpsTotalE", 0, 1, 1, double_type, &(config::RelEpsTotalEnergy), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"RelEpsKineticE", 0, 1, 1, double_type, &(config::RelEpsKineticEnergy), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"MaxMinStopStep", 0, 1, 1, int_type, &(config::MaxMinStopStep), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"MaxMinGapStopStep", 0, 1, 1, int_type, &(config::MaxMinGapStopStep), 1, critical);
   if (config::MaxMinStep <= 0) config::MaxMinStep = config::MaxPsiStep;
   if (config::MaxMinStopStep < 1) config::MaxMinStopStep = 1;
   if (config::MaxMinGapStopStep < 1) config::MaxMinGapStopStep = 1;
 
-  ParseForParameter(verbose,file,"MaxInitMinStep", 0, 1, 1, int_type, &(config::MaxInitMinStep), 1, critical);
-  ParseForParameter(verbose,file,"InitRelEpsTotalE", 0, 1, 1, double_type, &(config::InitRelEpsTotalEnergy), 1, critical);
-  ParseForParameter(verbose,file,"InitRelEpsKineticE", 0, 1, 1, double_type, &(config::InitRelEpsKineticEnergy), 1, critical);
-  ParseForParameter(verbose,file,"InitMaxMinStopStep", 0, 1, 1, int_type, &(config::InitMaxMinStopStep), 1, critical);
-  ParseForParameter(verbose,file,"InitMaxMinGapStopStep", 0, 1, 1, int_type, &(config::InitMaxMinGapStopStep), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"MaxInitMinStep", 0, 1, 1, int_type, &(config::MaxInitMinStep), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"InitRelEpsTotalE", 0, 1, 1, double_type, &(config::InitRelEpsTotalEnergy), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"InitRelEpsKineticE", 0, 1, 1, double_type, &(config::InitRelEpsKineticEnergy), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"InitMaxMinStopStep", 0, 1, 1, int_type, &(config::InitMaxMinStopStep), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"InitMaxMinGapStopStep", 0, 1, 1, int_type, &(config::InitMaxMinGapStopStep), 1, critical);
   if (config::MaxInitMinStep <= 0) config::MaxInitMinStep = config::MaxPsiStep;
   if (config::InitMaxMinStopStep < 1) config::InitMaxMinStopStep = 1;
@@ -656 +814 @@
 
   // Unit cell and magnetic field
-  ParseForParameter(verbose,file, "BoxLength", 0, 3, 3, lower_trigrid, BoxLength, 1, critical); /* Lattice->RealBasis */
+  ParseForParameter(verbose,FileBuffer, "BoxLength", 0, 3, 3, lower_trigrid, BoxLength, 1, critical); /* Lattice->RealBasis */
   mol->cell_size[0] = BoxLength[0];
   mol->cell_size[1] = BoxLength[3];
@@ -663 +821 @@
   mol->cell_size[4] = BoxLength[7];
   mol->cell_size[5] = BoxLength[8];
-  if (1) fprintf(stderr,"\n");
-
-  ParseForParameter(verbose,file,"DoPerturbation", 0, 1, 1, int_type, &(config::DoPerturbation), 1, optional);
-  ParseForParameter(verbose,file,"DoOutNICS", 0, 1, 1, int_type, &(config::DoOutNICS), 1, optional);
-  if (!ParseForParameter(verbose,file,"DoFullCurrent", 0, 1, 1, int_type, &(config::DoFullCurrent), 1, optional))
+  //if (1) fprintf(stderr,"\n");
+
+  ParseForParameter(verbose,FileBuffer,"DoPerturbation", 0, 1, 1, int_type, &(config::DoPerturbation), 1, optional);
+  ParseForParameter(verbose,FileBuffer,"DoOutNICS", 0, 1, 1, int_type, &(config::DoOutNICS), 1, optional);
+  if (!ParseForParameter(verbose,FileBuffer,"DoFullCurrent", 0, 1, 1, int_type, &(config::DoFullCurrent), 1, optional))
     config::DoFullCurrent = 0;
   if (config::DoFullCurrent < 0) config::DoFullCurrent = 0;
@@ -678 +836 @@
   }
 
-  ParseForParameter(verbose,file,"ECut", 0, 1, 1, double_type, &(config::ECut), 1, critical);
-  ParseForParameter(verbose,file,"MaxLevel", 0, 1, 1, int_type, &(config::MaxLevel), 1, critical);
-  ParseForParameter(verbose,file,"Level0Factor", 0, 1, 1, int_type, &(config::Lev0Factor), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"ECut", 0, 1, 1, double_type, &(config::ECut), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"MaxLevel", 0, 1, 1, int_type, &(config::MaxLevel), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"Level0Factor", 0, 1, 1, int_type, &(config::Lev0Factor), 1, critical);
   if (config::Lev0Factor < 2) {
     config::Lev0Factor = 2;
   }
-  ParseForParameter(verbose,file,"RiemannTensor", 0, 1, 1, int_type, &di, 1, critical);
+  ParseForParameter(verbose,FileBuffer,"RiemannTensor", 0, 1, 1, int_type, &di, 1, critical);
   if (di >= 0 && di < 2) {
     config::RiemannTensor = di;
@@ -703 +861 @@
         config::MaxLevel = 3;
       }
-      ParseForParameter(verbose,file,"RiemannLevel", 0, 1, 1, int_type, &(config::RiemannLevel), 1, critical);
+      ParseForParameter(verbose,FileBuffer,"RiemannLevel", 0, 1, 1, int_type, &(config::RiemannLevel), 1, critical);
       if (config::RiemannLevel < 2) {
         config::RiemannLevel = 2;
@@ -710 +868 @@
         config::RiemannLevel = config::MaxLevel-1;
       }
-      ParseForParameter(verbose,file,"LevRFactor", 0, 1, 1, int_type, &(config::LevRFactor), 1, critical);
+      ParseForParameter(verbose,FileBuffer,"LevRFactor", 0, 1, 1, int_type, &(config::LevRFactor), 1, critical);
       if (config::LevRFactor < 2) {
         config::LevRFactor = 2;
@@ -718 +876 @@
       break;
   }
-  ParseForParameter(verbose,file,"PsiType", 0, 1, 1, int_type, &di, 1, critical);
+  ParseForParameter(verbose,FileBuffer,"PsiType", 0, 1, 1, int_type, &di, 1, critical);
   if (di >= 0 && di < 2) {
     config::PsiType = di;
@@ -727 +885 @@
   switch (config::PsiType) {
   case 0: // SpinDouble
-    ParseForParameter(verbose,file,"MaxPsiDouble", 0, 1, 1, int_type, &(config::MaxPsiDouble), 1, critical);
-    ParseForParameter(verbose,file,"AddPsis", 0, 1, 1, int_type, &(config::AddPsis), 1, optional);
+    ParseForParameter(verbose,FileBuffer,"MaxPsiDouble", 0, 1, 1, int_type, &(config::MaxPsiDouble), 1, critical);
+    ParseForParameter(verbose,FileBuffer,"AddPsis", 0, 1, 1, int_type, &(config::AddPsis), 1, optional);
     break;
   case 1: // SpinUpDown
     if (config::ProcPEGamma % 2) config::ProcPEGamma*=2;
-    ParseForParameter(verbose,file,"PsiMaxNoUp", 0, 1, 1, int_type, &(config::PsiMaxNoUp), 1, critical);
-    ParseForParameter(verbose,file,"PsiMaxNoDown", 0, 1, 1, int_type, &(config::PsiMaxNoDown), 1, critical);
-    ParseForParameter(verbose,file,"AddPsis", 0, 1, 1, int_type, &(config::AddPsis), 1, optional);
+    ParseForParameter(verbose,FileBuffer,"PsiMaxNoUp", 0, 1, 1, int_type, &(config::PsiMaxNoUp), 1, critical);
+    ParseForParameter(verbose,FileBuffer,"PsiMaxNoDown", 0, 1, 1, int_type, &(config::PsiMaxNoDown), 1, critical);
+    ParseForParameter(verbose,FileBuffer,"AddPsis", 0, 1, 1, int_type, &(config::AddPsis), 1, optional);
     break;
   }
@@ -740 +898 @@
   // IonsInitRead
 
-  ParseForParameter(verbose,file,"RCut", 0, 1, 1, double_type, &(config::RCut), 1, critical);
-  ParseForParameter(verbose,file,"IsAngstroem", 0, 1, 1, int_type, &(config::IsAngstroem), 1, critical);
-  ParseForParameter(verbose,file,"MaxTypes", 0, 1, 1, int_type, &(config::MaxTypes), 1, critical);
-  if (!ParseForParameter(verbose,file,"RelativeCoord", 0, 1, 1, int_type, &(config::RelativeCoord) , 1, optional))
+  ParseForParameter(verbose,FileBuffer,"RCut", 0, 1, 1, double_type, &(config::RCut), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"IsAngstroem", 0, 1, 1, int_type, &(config::IsAngstroem), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"MaxTypes", 0, 1, 1, int_type, &(config::MaxTypes), 1, critical);
+  if (!ParseForParameter(verbose,FileBuffer,"RelativeCoord", 0, 1, 1, int_type, &(config::RelativeCoord) , 1, optional))
     config::RelativeCoord = 0;
-  if (!ParseForParameter(verbose,file,"StructOpt", 0, 1, 1, int_type, &(config::StructOpt), 1, optional))
+  if (!ParseForParameter(verbose,FileBuffer,"StructOpt", 0, 1, 1, int_type, &(config::StructOpt), 1, optional))
     config::StructOpt = 0;
   if (MaxTypes == 0) {
@@ -752 +910 @@
     // prescan number of ions per type
     cout << Verbose(0) << "Prescanning ions per type: " << endl;
+    int NoAtoms = 0;
     for (int i=0; i < config::MaxTypes; i++) {
       sprintf(name,"Ion_Type%i",i+1);
-      ParseForParameter(verbose,file, (const char*)name, 0, 1, 1, int_type, &No[i], 1, critical);
-      ParseForParameter(verbose,file, name, 0, 2, 1, int_type, &Z, 1, critical);
+      ParseForParameter(verbose,FileBuffer, (const char*)name, 0, 1, 1, int_type, &No[i], 1, critical);
+      ParseForParameter(verbose,FileBuffer, name, 0, 2, 1, int_type, &Z, 1, critical);
       elementhash[i] = periode->FindElement(Z);
       cout << Verbose(1) << i << ". Z = " << elementhash[i]->Z << " with " << No[i] << " ions." << endl;
+      NoAtoms += No[i];
     }
     int repetition = 0; // which repeated keyword shall be read
 
+    // sort the lines via the LineMapping
+    sprintf(name,"Ion_Type%i",config::MaxTypes);
+    if (!ParseForParameter(verbose,FileBuffer, (const char*)name, 1, 1, 1, int_type, &value[0], 1, critical)) {
+      cerr << "There are no atoms in the config file!" << endl;
+      return;
+    }
+    FileBuffer->CurrentLine++;
+    //cout << FileBuffer->buffer[ FileBuffer->LineMapping[FileBuffer->CurrentLine]];
+    FileBuffer->MapIonTypesInBuffer(NoAtoms);
+    //for (int i=0; i<(NoAtoms < 100 ? NoAtoms : 100 < 100 ? NoAtoms : 100);++i) {
+    //  cout << FileBuffer->buffer[ FileBuffer->LineMapping[FileBuffer->CurrentLine+i]];
+    //}
+
     map<int, atom *> AtomList[config::MaxTypes];
+    map<int, atom *> LinearList;
     if (!FastParsing) {
       // parse in trajectories
@@ -775 +949 @@
               neues = new atom();
               AtomList[i][j] = neues;
+              LinearList[FileBuffer->CurrentLine] = neues;
               neues->type = elementhash[i]; // find element type
-              mol->AddAtom(neues);
             } else
               neues = AtomList[i][j];
             status = (status &&
-                    ParseForParameter(verbose,file, keyword, 0, 1, 1, double_type, &neues->x.x[0], 1, (repetition == 0) ? critical : optional) &&
-                    ParseForParameter(verbose,file, keyword, 0, 2, 1, double_type, &neues->x.x[1], 1, (repetition == 0) ? critical : optional) &&
-                    ParseForParameter(verbose,file, keyword, 0, 3, 1, double_type, &neues->x.x[2], 1, (repetition == 0) ? critical : optional) &&
-                    ParseForParameter(verbose,file, keyword, 0, 4, 1, int_type, &neues->FixedIon, 1, (repetition == 0) ? critical : optional));
+                    ParseForParameter(verbose,FileBuffer, keyword, 0, 1, 1, double_type, &neues->x.x[0], 1, (repetition == 0) ? critical : optional) &&
+                    ParseForParameter(verbose,FileBuffer, keyword, 0, 2, 1, double_type, &neues->x.x[1], 1, (repetition == 0) ? critical : optional) &&
+                    ParseForParameter(verbose,FileBuffer, keyword, 0, 3, 1, double_type, &neues->x.x[2], 1, (repetition == 0) ? critical : optional) &&
+                    ParseForParameter(verbose,FileBuffer, keyword, 0, 4, 1, int_type, &neues->FixedIon, 1, (repetition == 0) ? critical : optional));
             if (!status) break;
 
@@ -799 +973 @@
 
             // parse velocities if present
-            if(!ParseForParameter(verbose,file, keyword, 0, 5, 1, double_type, &neues->v.x[0], 1,optional))
+            if(!ParseForParameter(verbose,FileBuffer, keyword, 0, 5, 1, double_type, &neues->v.x[0], 1,optional))
               neues->v.x[0] = 0.;
-            if(!ParseForParameter(verbose,file, keyword, 0, 6, 1, double_type, &neues->v.x[1], 1,optional))
+            if(!ParseForParameter(verbose,FileBuffer, keyword, 0, 6, 1, double_type, &neues->v.x[1], 1,optional))
               neues->v.x[1] = 0.;
-            if(!ParseForParameter(verbose,file, keyword, 0, 7, 1, double_type, &neues->v.x[2], 1,optional))
+            if(!ParseForParameter(verbose,FileBuffer, keyword, 0, 7, 1, double_type, &neues->v.x[2], 1,optional))
               neues->v.x[2] = 0.;
             for (int d=0;d<NDIM;d++)
@@ -809 +983 @@
 
             // parse forces if present
-            if(!ParseForParameter(verbose,file, keyword, 0, 8, 1, double_type, &value[0], 1,optional))
+            if(!ParseForParameter(verbose,FileBuffer, keyword, 0, 8, 1, double_type, &value[0], 1,optional))
               value[0] = 0.;
-            if(!ParseForParameter(verbose,file, keyword, 0, 9, 1, double_type, &value[1], 1,optional))
+            if(!ParseForParameter(verbose,FileBuffer, keyword, 0, 9, 1, double_type, &value[1], 1,optional))
               value[1] = 0.;
-            if(!ParseForParameter(verbose,file, keyword, 1, 10, 1, double_type, &value[2], 1,optional))
+            if(!ParseForParameter(verbose,FileBuffer, keyword, 1, 10, 1, double_type, &value[2], 1,optional))
               value[2] = 0.;
             for (int d=0;d<NDIM;d++)
@@ -832 +1006 @@
         repetition++;
       }
+      // put atoms into the molecule in their original order
+      for(map<int, atom*>::iterator runner = LinearList.begin(); runner != LinearList.end(); ++runner) {
+        mol->AddAtom(runner->second);
+      }
       repetition--;
       cout << "Found " << repetition << " trajectory steps." << endl;
@@ -838 +1016 @@
       // find the maximum number of MD steps so that we may parse last one (Ion_Type1_1 must always be present, because is the first atom)
       repetition = 0;
-      while ( ParseForParameter(verbose,file, "Ion_Type1_1", 0, 1, 1, double_type, &value[0], repetition, (repetition == 0) ? critical : optional) &&
-              ParseForParameter(verbose,file, "Ion_Type1_1", 0, 2, 1, double_type, &value[1], repetition, (repetition == 0) ? critical : optional) &&
-              ParseForParameter(verbose,file, "Ion_Type1_1", 0, 3, 1, double_type, &value[2], repetition, (repetition == 0) ? critical : optional))
+      while ( ParseForParameter(verbose,FileBuffer, "Ion_Type1_1", 0, 1, 1, double_type, &value[0], repetition, (repetition == 0) ? critical : optional) &&
+              ParseForParameter(verbose,FileBuffer, "Ion_Type1_1", 0, 2, 1, double_type, &value[1], repetition, (repetition == 0) ? critical : optional) &&
+              ParseForParameter(verbose,FileBuffer, "Ion_Type1_1", 0, 3, 1, double_type, &value[2], repetition, (repetition == 0) ? critical : optional))
         repetition++;
       cout << "I found " << repetition << " times the keyword Ion_Type1_1." << endl;
@@ -850 +1028 @@
           atom *neues = new atom();
           // then parse for each atom the coordinates as often as present
-          ParseForParameter(verbose,file, keyword, 0, 1, 1, double_type, &neues->x.x[0], repetition,critical);
-          ParseForParameter(verbose,file, keyword, 0, 2, 1, double_type, &neues->x.x[1], repetition,critical);
-          ParseForParameter(verbose,file, keyword, 0, 3, 1, double_type, &neues->x.x[2], repetition,critical);
-          ParseForParameter(verbose,file, keyword, 0, 4, 1, int_type, &neues->FixedIon, repetition,critical);
-          if(!ParseForParameter(verbose,file, keyword, 0, 5, 1, double_type, &neues->v.x[0], repetition,optional))
+          ParseForParameter(verbose,FileBuffer, keyword, 0, 1, 1, double_type, &neues->x.x[0], repetition,critical);
+          ParseForParameter(verbose,FileBuffer, keyword, 0, 2, 1, double_type, &neues->x.x[1], repetition,critical);
+          ParseForParameter(verbose,FileBuffer, keyword, 0, 3, 1, double_type, &neues->x.x[2], repetition,critical);
+          ParseForParameter(verbose,FileBuffer, keyword, 0, 4, 1, int_type, &neues->FixedIon, repetition,critical);
+          if(!ParseForParameter(verbose,FileBuffer, keyword, 0, 5, 1, double_type, &neues->v.x[0], repetition,optional))
             neues->v.x[0] = 0.;
-          if(!ParseForParameter(verbose,file, keyword, 0, 6, 1, double_type, &neues->v.x[1], repetition,optional))
+          if(!ParseForParameter(verbose,FileBuffer, keyword, 0, 6, 1, double_type, &neues->v.x[1], repetition,optional))
             neues->v.x[1] = 0.;
-          if(!ParseForParameter(verbose,file, keyword, 0, 7, 1, double_type, &neues->v.x[2], repetition,optional))
+          if(!ParseForParameter(verbose,FileBuffer, keyword, 0, 7, 1, double_type, &neues->v.x[2], repetition,optional))
             neues->v.x[2] = 0.;
           // here we don't care if forces are present (last in trajectories is always equal to current position)
@@ -867 +1045 @@
     }
   }
-  file->close();
-  delete(file);
+  delete(FileBuffer);
 };
 
@@ -1328 +1505 @@
  * \warning value is modified (both in contents and position)!
  * \param verbose 1 - print found value to stderr, 0 - don't
- * \param file file to be parsed
+ * \param *file file to be parsed
  * \param name Name of value in file (at least 3 chars!)
  * \param sequential 1 - do not reset file pointer to begin of file, 0 - set to beginning
@@ -1557 +1734 @@
   return (found); // true if found, false if not
 }
+
+
+/** Reads parameter from a parsed file.
+ * The file is either parsed for a certain keyword or if null is given for
+ * the value in row yth and column xth. If the keyword was necessity#critical,
+ * then an error is thrown and the programme aborted.
+ * \warning value is modified (both in contents and position)!
+ * \param verbose 1 - print found value to stderr, 0 - don't
+ * \param *FileBuffer pointer to buffer structure
+ * \param name Name of value in file (at least 3 chars!)
+ * \param sequential 1 - do not reset file pointer to begin of file, 0 - set to beginning
+ *        (if file is sequentially parsed this can be way faster! However, beware of multiple values per line, as whole line is read -
+ *         best approach: 0 0 0 1 (not resetted only on last value of line) - and of yth, which is now
+ *         counted from this unresetted position!)
+ * \param xth Which among a number of parameters it is (in grid case it's row number as grid is read as a whole!)
+ * \param yth In grid case specifying column number, otherwise the yth \a name matching line
+ * \param type Type of the Parameter to be read
+ * \param value address of the value to be read (must have been allocated)
+ * \param repetition determines, if the keyword appears multiply in the config file, which repetition shall be parsed, i.e. 1 if not multiply
+ * \param critical necessity of this keyword being specified (optional, critical)
+ * \return 1 - found, 0 - not found
+ * \note Routine is taken from the pcp project and hack-a-slack adapted to C++
+ */
+int config::ParseForParameter(int verbose, struct ConfigFileBuffer *FileBuffer, const char *name, int sequential, int const xth, int const yth, int type, void *value, int repetition, int critical) {
+  int i,j;  // loop variables
+  int length = 0, maxlength = -1;
+  int OldCurrentLine = FileBuffer->CurrentLine;
+  char *dummy1, *dummy;    // pointers in the line that is read in per step
+
+  //fprintf(stderr,"Parsing for %s\n",name);
+  if (repetition == 0)
+    //Error(SomeError, "ParseForParameter(): argument repetition must not be 0!");
+    return 0;
+
+  int line = 0; // marks line where parameter was found
+  int found = (type >= grid) ? 0 : (-yth + 1);  // marks if yth parameter name was found
+  while((found != repetition)) {
+    dummy1 = dummy = NULL;
+    do {
+      dummy1 = FileBuffer->buffer[ FileBuffer->LineMapping[FileBuffer->CurrentLine++] ];
+      if (FileBuffer->CurrentLine >= FileBuffer->NoLines) {
+        if ((critical) && (found == 0)) {
+          //Error(InitReading, name);
+          fprintf(stderr,"Error:InitReading, critical %s not found\n", name);
+          exit(255);
+        } else {
+          FileBuffer->CurrentLine = OldCurrentLine; // rewind to start position
+          return 0;
+        }
+      }
+      if (dummy1 == NULL) {
+        if (verbose) fprintf(stderr,"Error reading line %i\n",line);
+      } else {
+        //fprintf(stderr,"Now parsing the line %i: %s\n", line, dummy1);
+      }
+      line++;
+    } while (dummy1 != NULL && ((dummy1[0] == '#') || (dummy1[0] == '\0'))); // skip commentary and empty lines
+
+    // Seek for possible end of keyword on line if given ...
+    if (name != NULL) {
+      dummy = strchr(dummy1,'\t');  // set dummy on first tab or space which ever's nearer
+      if (dummy == NULL) {
+        dummy = strchr(dummy1, ' ');  // if not found seek for space
+        while ((dummy != NULL) && ((*dummy == '\t') || (*dummy == ' ')))    // skip some more tabs and spaces if necessary
+          dummy++;
+      }
+      if (dummy == NULL) {
+        dummy = strchr(dummy1, '\n'); // set on line end then (whole line = keyword)
+        //fprintf(stderr,"Error: Cannot find tabs or spaces on line %i in search for %s\n", line, name);
+        //Free((void **)&free_dummy);
+        //Error(FileOpenParams, NULL);
+      } else {
+        //fprintf(stderr,"found tab at %i\n",(char *)dummy-(char *)dummy1);
+      }
+    } else dummy = dummy1;
+    // ... and check if it is the keyword!
+    //fprintf(stderr,"name %p, dummy %i/%c, dummy1 %i/%c, strlen(name) %i\n", &name, dummy, *dummy, dummy1, *dummy1, strlen(name));
+    if ((name == NULL) || (((dummy-dummy1 >= 3) && (strncmp(dummy1, name, strlen(name)) == 0)) && ((unsigned int)(dummy-dummy1) == strlen(name)))) {
+      found++; // found the parameter!
+      //fprintf(stderr,"found %s at line %i between %i and %i\n", name, line, dummy1, dummy);
+
+      if (found == repetition) {
+        for (i=0;i<xth;i++) { // i = rows
+          if (type >= grid) {
+            // grid structure means that grid starts on the next line, not right after keyword
+            dummy1 = dummy = NULL;
+            do {
+              dummy1 = FileBuffer->buffer[ FileBuffer->LineMapping[ FileBuffer->CurrentLine++] ];
+              if (FileBuffer->CurrentLine >= FileBuffer->NoLines) {
+                if ((critical) && (found == 0)) {
+                  //Error(InitReading, name);
+                  fprintf(stderr,"Error:InitReading, critical %s not found\n", name);
+                  exit(255);
+                } else {
+                  FileBuffer->CurrentLine = OldCurrentLine; // rewind to start position
+                  return 0;
+                }
+              }
+              if (dummy1 == NULL) {
+                if (verbose) fprintf(stderr,"Error reading line %i\n", line);
+              } else {
+                //fprintf(stderr,"Reading next line %i: %s\n", line, dummy1);
+              }
+              line++;
+            } while (dummy1 != NULL && (dummy1[0] == '#') || (dummy1[0] == '\n'));
+            dummy = dummy1;
+          } else { // simple int, strings or doubles start in the same line
+            while ((*dummy == '\t') || (*dummy == ' '))  // skip interjacent tabs and spaces
+              dummy++;
+          }
+
+          for (j=((type >= grid) ? 0 : yth-1);j<yth;j++) { // j = columns
+            // check for lower triangular area and upper triangular area
+            if ( ((i > j) && (type == upper_trigrid)) || ((j > i) && (type == lower_trigrid))) {
+              *((double *)value) = 0.0;
+              fprintf(stderr,"%f\t",*((double *)value));
+              value = (void *)((long)value + sizeof(double));
+              //value += sizeof(double);
+            } else {
+              // otherwise we must skip all interjacent tabs and spaces and find next value
+              dummy1 = dummy;
+              dummy = strchr(dummy1, '\t'); // seek for tab or space
+              if (dummy == NULL)
+                dummy = strchr(dummy1, ' ');  // if not found seek for space
+              if (dummy == NULL) { // if still zero returned ...
+                dummy = strchr(dummy1, '\n'); // ... at line end then
+                if ((j < yth-1) && (type < 4)) {  // check if xth value or not yet
+                  if (critical) {
+                    if (verbose) fprintf(stderr,"Error: EoL at %i and still missing %i value(s) for parameter %s\n", line, yth-j, name);
+                    //return 0;
+                    exit(255);
+                    //Error(FileOpenParams, NULL);
+                  } else {
+                    if (!sequential) { // here we need it!
+                      FileBuffer->CurrentLine = OldCurrentLine; // rewind to start position
+                    }
+                    return 0;
+                  }
+                }
+              } else {
+                //fprintf(stderr,"found tab at %i\n",(char *)dummy-(char *)free_dummy);
+              }
+              if (*dummy1 == '#') {
+                // found comment, skipping rest of line
+                //if (verbose) fprintf(stderr,"Error: '#' at %i and still missing %i value(s) for parameter %s\n", line, yth-j, name);
+                if (!sequential) { // here we need it!
+                  FileBuffer->CurrentLine = OldCurrentLine; // rewind to start position
+                }
+                return 0;
+              }
+              //fprintf(stderr,"value from %i to %i\n",(char *)dummy1-(char *)free_dummy,(char *)dummy-(char *)free_dummy);
+              switch(type) {
+                case (row_int):
+                  *((int *)value) = atoi(dummy1);
+                  if ((verbose) && (i==0) && (j==0)) fprintf(stderr,"%s = ", name);
+                  if (verbose) fprintf(stderr,"%i\t",*((int *)value));
+                    value = (void *)((long)value + sizeof(int));
+                    //value += sizeof(int);
+                  break;
+                case(row_double):
+                case(grid):
+                case(lower_trigrid):
+                case(upper_trigrid):
+                  *((double *)value) = atof(dummy1);
+                  if ((verbose) && (i==0) && (j==0)) fprintf(stderr,"%s = ", name);
+                  if (verbose) fprintf(stderr,"%lg\t",*((double *)value));
+                  value = (void *)((long)value + sizeof(double));
+                  //value += sizeof(double);
+                  break;
+                case(double_type):
+                  *((double *)value) = atof(dummy1);
+                  if ((verbose) && (i == xth-1)) fprintf(stderr,"%s = %lg\n", name, *((double *) value));
+                  //value += sizeof(double);
+                  break;
+                case(int_type):
+                  *((int *)value) = atoi(dummy1);
+                  if ((verbose) && (i == xth-1)) fprintf(stderr,"%s = %i\n", name, *((int *) value));
+                  //value += sizeof(int);
+                  break;
+                default:
+                case(string_type):
+                  if (value != NULL) {
+                    //if (maxlength == -1) maxlength = strlen((char *)value); // get maximum size of string array
+                    maxlength = MAXSTRINGSIZE;
+                    length = maxlength > (dummy-dummy1) ? (dummy-dummy1) : maxlength; // cap at maximum
+                    strncpy((char *)value, dummy1, length); // copy as much
+                    ((char *)value)[length] = '\0'; // and set end marker
+                    if ((verbose) && (i == xth-1)) fprintf(stderr,"%s is '%s' (%i chars)\n",name,((char *) value), length);
+                    //value += sizeof(char);
+                  } else {
+                  }
+                break;
+              }
+            }
+            while (*dummy == '\t')
+              dummy++;
+          }
+        }
+      }
+    }
+  }
+  if ((type >= row_int) && (verbose)) fprintf(stderr,"\n");
+  if (!sequential) {
+    FileBuffer->CurrentLine = OldCurrentLine; // rewind to start position
+  }
+  //fprintf(stderr, "End of Parsing\n\n");
+
+  return (found); // true if found, false if not
+}

src/datacreator.cpp

@@ -54 +54 @@
  * \return true if file was written successfully
  */
-bool CreateDataEnergyOrder(class EnergyMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum)
+bool CreateDataEnergyOrder(class EnergyMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum)
 {
   stringstream filename;
@@ -87 +87 @@
  * \return true if file was written successfully
  */
-bool CreateDataDeltaEnergyOrder(class EnergyMatrix &Energy, class EnergyMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum)
+bool CreateDataDeltaEnergyOrder(class EnergyMatrix &Energy, class EnergyMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum)
 {
   stringstream filename;
@@ -124 +124 @@
  * \return true if file was written successfully
  */
-bool CreateDataForcesOrder(class ForceMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum, void (*CreateForce)(class MatrixContainer &, int))
+bool CreateDataForcesOrder(class ForceMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix,const  char *msg, const char *datum, void (*CreateForce)(class MatrixContainer &, int))
 {
   stringstream filename;
@@ -156 +156 @@
  * \return true if file was written successfully
  */
-bool CreateDataDeltaForcesOrder(class ForceMatrix &Force, class ForceMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum, void (*CreateForce)(class MatrixContainer &, int))
+bool CreateDataDeltaForcesOrder(class ForceMatrix &Force, class ForceMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum, void (*CreateForce)(class MatrixContainer &, int))
 {
   stringstream filename;
@@ -188 +188 @@
  * \return true if file was written successfully
  */
-bool CreateDataDeltaForcesOrderPerAtom(class ForceMatrix &Force, class ForceMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum)
+bool CreateDataDeltaForcesOrderPerAtom(class ForceMatrix &Force, class ForceMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum)
 {
   stringstream filename;
@@ -235 +235 @@
  * \return true if file was written successfully
  */
-bool CreateDataForcesOrderPerAtom(class ForceMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum)
+bool CreateDataForcesOrderPerAtom(class ForceMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum)
 {
   stringstream filename;
@@ -272 +272 @@
  * \return true if file was written successfully
  */
-bool CreateDataDeltaHessianOrderPerAtom(class HessianMatrix &Hessian, class HessianMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum) 
+bool CreateDataDeltaHessianOrderPerAtom(class HessianMatrix &Hessian, class HessianMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum) 
 {
   stringstream filename;
@@ -310 +310 @@
  * \return true if file was written successfully
  */
-bool CreateDataDeltaFrobeniusOrderPerAtom(class HessianMatrix &Hessian, class HessianMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum) 
+bool CreateDataDeltaFrobeniusOrderPerAtom(class HessianMatrix &Hessian, class HessianMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum) 
 {
   stringstream filename;
@@ -354 +354 @@
  * \return true if file was written successfully
  */
-bool CreateDataHessianOrderPerAtom(class HessianMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum) 
+bool CreateDataHessianOrderPerAtom(class HessianMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum) 
 {
   stringstream filename;
@@ -384 +384 @@
 /** Plot matrix vs. fragment.
  */
-bool CreateDataFragment(class MatrixContainer &Fragment, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum, void (*CreateFragment)(class MatrixContainer &, int))
+bool CreateDataFragment(class MatrixContainer &Fragment, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum, void (*CreateFragment)(class MatrixContainer &, int))
 {
   stringstream filename;
@@ -449 +449 @@
 /** Plot matrix vs. fragment.
  */
-bool CreateDataFragmentOrder(class MatrixContainer &Fragment, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum, void (*CreateFragmentOrder)(class MatrixContainer &, class KeySetsContainer &, int))
+bool CreateDataFragmentOrder(class MatrixContainer &Fragment, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum, void (*CreateFragmentOrder)(class MatrixContainer &, class KeySetsContainer &, int))
 {
   stringstream filename;

src/datacreator.hpp

@@ -20 +20 @@
 bool AppendOutputFile(ofstream &output, const char *dir, const char *filename);
 
-bool CreateDataEnergyOrder(class EnergyMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum);
-bool CreateDataDeltaEnergyOrder(class EnergyMatrix &Energy, class EnergyMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum);
-bool CreateDataForcesOrder(class ForceMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum, void (*CreateForce)(class MatrixContainer &, int));
-bool CreateDataForcesOrderPerAtom(class ForceMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum);
-bool CreateDataDeltaForcesOrder(class ForceMatrix &Force, class ForceMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum, void (*CreateForce)(class MatrixContainer &, int));
-bool CreateDataDeltaForcesOrderPerAtom(class ForceMatrix &Force, class ForceMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum); 
-bool CreateDataHessianOrderPerAtom(class HessianMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum); 
-bool CreateDataDeltaHessianOrderPerAtom(class HessianMatrix &Hessian, class HessianMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum); 
-bool CreateDataDeltaFrobeniusOrderPerAtom(class HessianMatrix &Hessian, class HessianMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum); 
-bool CreateDataFragment(class MatrixContainer &ForceFragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum, void (*CreateForce)(class MatrixContainer &, int));
-bool CreateDataFragmentOrder(class MatrixContainer &Fragment, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum, void (*CreateFragmentOrder)(class MatrixContainer &, class KeySetsContainer &, int));
+bool CreateDataEnergyOrder(class EnergyMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum);
+bool CreateDataDeltaEnergyOrder(class EnergyMatrix &Energy, class EnergyMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum);
+bool CreateDataForcesOrder(class ForceMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum, void (*CreateForce)(class MatrixContainer &, int));
+bool CreateDataForcesOrderPerAtom(class ForceMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum);
+bool CreateDataDeltaForcesOrder(class ForceMatrix &Force, class ForceMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum, void (*CreateForce)(class MatrixContainer &, int));
+bool CreateDataDeltaForcesOrderPerAtom(class ForceMatrix &Force, class ForceMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum); 
+bool CreateDataHessianOrderPerAtom(class HessianMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum); 
+bool CreateDataDeltaHessianOrderPerAtom(class HessianMatrix &Hessian, class HessianMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum); 
+bool CreateDataDeltaFrobeniusOrderPerAtom(class HessianMatrix &Hessian, class HessianMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum); 
+bool CreateDataFragment(class MatrixContainer &ForceFragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum, void (*CreateForce)(class MatrixContainer &, int));
+bool CreateDataFragmentOrder(class MatrixContainer &Fragment, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum, void (*CreateFragmentOrder)(class MatrixContainer &, class KeySetsContainer &, int));
 
 void CreateEnergy(class MatrixContainer &Energy, int MatrixNumber);

src/element.cpp

@@ -12 +12 @@
  */
 element::element() {
-        Z = -1;
-        No = -1;
-        previous = NULL;
-        next = NULL;
-        sort = NULL;
+  Z = -1;
+  No = -1;
+  previous = NULL;
+  next = NULL;
+  sort = NULL;
 };
 
@@ -28 +28 @@
 bool element::Output(ofstream *out) const
 { 
-        if (out != NULL) {
-                *out << name << "\t" << symbol << "\t" << period << "\t" << group << "\t" << block << "\t" << Z << "\t" << mass << "\t" << CovalentRadius << "\t" << VanDerWaalsRadius << endl;
-                //*out << Z << "\t"     << fixed << setprecision(11) << showpoint << mass << "g/mol\t" << name << "\t" << symbol << "\t" << endl;
-                return true;
-        } else
-                return false;
+  if (out != NULL) {
+    *out << name << "\t" << symbol << "\t" << period << "\t" << group << "\t" << block << "\t" << Z << "\t" << mass << "\t" << CovalentRadius << "\t" << VanDerWaalsRadius << endl;
+    //*out << Z << "\t"  << fixed << setprecision(11) << showpoint << mass << "g/mol\t" << name << "\t" << symbol << "\t" << endl;
+    return true;
+  } else
+    return false;
 };
 
 /** Prints element data to \a *out.
  * \param *out outstream
- * \param No    cardinal number of element
+ * \param No  cardinal number of element
  * \param NoOfAtoms total number of atom of this element type
  */
 bool element::Checkout(ofstream *out, const int Number, const int NoOfAtoms) const
 { 
-        if (out != NULL) {
-                *out << "Ion_Type" << Number << "\t" << NoOfAtoms << "\t" << Z << "\t1.0\t3\t3\t" << fixed << setprecision(11) << showpoint << mass << "\t" << name << "\t" << symbol <<endl;
-                return true;
-        } else
-                return false;
+  if (out != NULL) {
+    *out << "Ion_Type" << Number << "\t" << NoOfAtoms << "\t" << Z << "\t1.0\t3\t3\t" << fixed << setprecision(11) << showpoint << mass << "\t" << name << "\t" << symbol <<endl;
+    return true;
+  } else
+    return false;
 };

src/ellipsoid.cpp

@@ -2 +2 @@
  * ellipsoid.cpp
  *
- *      Created on: Jan 20, 2009
- *                      Author: heber
+ *  Created on: Jan 20, 2009
+ *      Author: heber
  */
 
@@ -17 +17 @@
 double SquaredDistanceToEllipsoid(Vector &x, Vector &EllipsoidCenter, double *EllipsoidLength, double *EllipsoidAngle)
 {
-        Vector helper, RefPoint;
-        double distance = -1.;
-        double Matrix[NDIM*NDIM];
-        double InverseLength[3];
-        double psi,theta,phi; // euler angles in ZX'Z'' convention
-
-        //cout << Verbose(3) << "Begin of SquaredDistanceToEllipsoid" << endl;
-
-        for(int i=0;i<3;i++)
-                InverseLength[i] = 1./EllipsoidLength[i];
-
-        // 1. translate coordinate system so that ellipsoid center is in origin
-        helper.CopyVector(&x);
-        helper.SubtractVector(&EllipsoidCenter);
-        RefPoint.CopyVector(&helper);
-        //cout << Verbose(4) << "Translated given point is at " << RefPoint << "." << endl;
-
-        // 2. transform coordinate system by inverse of rotation matrix and of diagonal matrix
-        psi = EllipsoidAngle[0];
-        theta = EllipsoidAngle[1];
-        phi = EllipsoidAngle[2];
-        Matrix[0] = cos(psi)*cos(phi) - sin(psi)*cos(theta)*sin(phi);
-        Matrix[1] = -cos(psi)*sin(phi) - sin(psi)*cos(theta)*cos(phi);
-        Matrix[2] = sin(psi)*sin(theta);
-        Matrix[3] = sin(psi)*cos(phi) + cos(psi)*cos(theta)*sin(phi);
-        Matrix[4] = cos(psi)*cos(theta)*cos(phi) - sin(psi)*sin(phi);
-        Matrix[5] = -cos(psi)*sin(theta);
-        Matrix[6] = sin(theta)*sin(phi);
-        Matrix[7] = sin(theta)*cos(phi);
-        Matrix[8] = cos(theta);
-        helper.MatrixMultiplication(Matrix);
-        helper.Scale(InverseLength);
-        //cout << Verbose(4) << "Transformed RefPoint is at " << helper << "." << endl;
-
-        // 3. construct intersection point with unit sphere and ray between origin and x
-        helper.Normalize(); // is simply normalizes vector in distance direction
-        //cout << Verbose(4) << "Transformed intersection is at " << helper << "." << endl;
-
-        // 4. transform back the constructed intersection point
-        psi = -EllipsoidAngle[0];
-        theta = -EllipsoidAngle[1];
-        phi = -EllipsoidAngle[2];
-        helper.Scale(EllipsoidLength);
-        Matrix[0] = cos(psi)*cos(phi) - sin(psi)*cos(theta)*sin(phi);
-        Matrix[1] = -cos(psi)*sin(phi) - sin(psi)*cos(theta)*cos(phi);
-        Matrix[2] = sin(psi)*sin(theta);
-        Matrix[3] = sin(psi)*cos(phi) + cos(psi)*cos(theta)*sin(phi);
-        Matrix[4] = cos(psi)*cos(theta)*cos(phi) - sin(psi)*sin(phi);
-        Matrix[5] = -cos(psi)*sin(theta);
-        Matrix[6] = sin(theta)*sin(phi);
-        Matrix[7] = sin(theta)*cos(phi);
-        Matrix[8] = cos(theta);
-        helper.MatrixMultiplication(Matrix);
-        //cout << Verbose(4) << "Intersection is at " << helper << "." << endl;
-
-        // 5. determine distance between backtransformed point and x
-        distance = RefPoint.DistanceSquared(&helper);
-        //cout << Verbose(4) << "Squared distance between intersection and RefPoint is " << distance << "." << endl;
-
-        return distance;
-        //cout << Verbose(3) << "End of SquaredDistanceToEllipsoid" << endl;
+  Vector helper, RefPoint;
+  double distance = -1.;
+  double Matrix[NDIM*NDIM];
+  double InverseLength[3];
+  double psi,theta,phi; // euler angles in ZX'Z'' convention
+
+  //cout << Verbose(3) << "Begin of SquaredDistanceToEllipsoid" << endl;
+
+  for(int i=0;i<3;i++)
+    InverseLength[i] = 1./EllipsoidLength[i];
+
+  // 1. translate coordinate system so that ellipsoid center is in origin
+  helper.CopyVector(&x);
+  helper.SubtractVector(&EllipsoidCenter);
+  RefPoint.CopyVector(&helper);
+  //cout << Verbose(4) << "Translated given point is at " << RefPoint << "." << endl;
+
+  // 2. transform coordinate system by inverse of rotation matrix and of diagonal matrix
+  psi = EllipsoidAngle[0];
+  theta = EllipsoidAngle[1];
+  phi = EllipsoidAngle[2];
+  Matrix[0] = cos(psi)*cos(phi) - sin(psi)*cos(theta)*sin(phi);
+  Matrix[1] = -cos(psi)*sin(phi) - sin(psi)*cos(theta)*cos(phi);
+  Matrix[2] = sin(psi)*sin(theta);
+  Matrix[3] = sin(psi)*cos(phi) + cos(psi)*cos(theta)*sin(phi);
+  Matrix[4] = cos(psi)*cos(theta)*cos(phi) - sin(psi)*sin(phi);
+  Matrix[5] = -cos(psi)*sin(theta);
+  Matrix[6] = sin(theta)*sin(phi);
+  Matrix[7] = sin(theta)*cos(phi);
+  Matrix[8] = cos(theta);
+  helper.MatrixMultiplication(Matrix);
+  helper.Scale(InverseLength);
+  //cout << Verbose(4) << "Transformed RefPoint is at " << helper << "." << endl;
+
+  // 3. construct intersection point with unit sphere and ray between origin and x
+  helper.Normalize(); // is simply normalizes vector in distance direction
+  //cout << Verbose(4) << "Transformed intersection is at " << helper << "." << endl;
+
+  // 4. transform back the constructed intersection point
+  psi = -EllipsoidAngle[0];
+  theta = -EllipsoidAngle[1];
+  phi = -EllipsoidAngle[2];
+  helper.Scale(EllipsoidLength);
+  Matrix[0] = cos(psi)*cos(phi) - sin(psi)*cos(theta)*sin(phi);
+  Matrix[1] = -cos(psi)*sin(phi) - sin(psi)*cos(theta)*cos(phi);
+  Matrix[2] = sin(psi)*sin(theta);
+  Matrix[3] = sin(psi)*cos(phi) + cos(psi)*cos(theta)*sin(phi);
+  Matrix[4] = cos(psi)*cos(theta)*cos(phi) - sin(psi)*sin(phi);
+  Matrix[5] = -cos(psi)*sin(theta);
+  Matrix[6] = sin(theta)*sin(phi);
+  Matrix[7] = sin(theta)*cos(phi);
+  Matrix[8] = cos(theta);
+  helper.MatrixMultiplication(Matrix);
+  //cout << Verbose(4) << "Intersection is at " << helper << "." << endl;
+
+  // 5. determine distance between backtransformed point and x
+  distance = RefPoint.DistanceSquared(&helper);
+  //cout << Verbose(4) << "Squared distance between intersection and RefPoint is " << distance << "." << endl;
+
+  return distance;
+  //cout << Verbose(3) << "End of SquaredDistanceToEllipsoid" << endl;
 };
 
@@ -83 +83 @@
  */
 struct EllipsoidMinimisation {
-        int N;                  //!< dimension of vector set
-        Vector *x;      //!< array of vectors
+  int N;      //!< dimension of vector set
+  Vector *x;  //!< array of vectors
 };
 
@@ -94 +94 @@
 double SumSquaredDistance (const gsl_vector * x, void * params)
 {
-        Vector *set= ((struct EllipsoidMinimisation *)params)->x;
-        int N = ((struct EllipsoidMinimisation *)params)->N;
-        double SumDistance = 0.;
-        double distance;
-        Vector Center;
-        double EllipsoidLength[3], EllipsoidAngle[3];
-
-        // put parameters into suitable ellipsoid form
-        for (int i=0;i<3;i++) {
-                Center.x[i] = gsl_vector_get(x, i+0);
-                EllipsoidLength[i] = gsl_vector_get(x, i+3);
-                EllipsoidAngle[i] = gsl_vector_get(x, i+6);
-        }
-
-        // go through all points and sum distance
-        for (int i=0;i<N;i++) {
-                distance = SquaredDistanceToEllipsoid(set[i], Center, EllipsoidLength, EllipsoidAngle);
-                if (!isnan(distance)) {
-                        SumDistance += distance;
-                } else {
-                        SumDistance = GSL_NAN;
-                        break;
-                }
-        }
-
-        //cout << "Current summed distance is " << SumDistance << "." << endl;
-        return SumDistance;
+  Vector *set= ((struct EllipsoidMinimisation *)params)->x;
+  int N = ((struct EllipsoidMinimisation *)params)->N;
+  double SumDistance = 0.;
+  double distance;
+  Vector Center;
+  double EllipsoidLength[3], EllipsoidAngle[3];
+
+  // put parameters into suitable ellipsoid form
+  for (int i=0;i<3;i++) {
+    Center.x[i] = gsl_vector_get(x, i+0);
+    EllipsoidLength[i] = gsl_vector_get(x, i+3);
+    EllipsoidAngle[i] = gsl_vector_get(x, i+6);
+  }
+
+  // go through all points and sum distance
+  for (int i=0;i<N;i++) {
+    distance = SquaredDistanceToEllipsoid(set[i], Center, EllipsoidLength, EllipsoidAngle);
+    if (!isnan(distance)) {
+      SumDistance += distance;
+    } else {
+      SumDistance = GSL_NAN;
+      break;
+    }
+  }
+
+  //cout << "Current summed distance is " << SumDistance << "." << endl;
+  return SumDistance;
 };
 
@@ -132 +132 @@
 bool FitPointSetToEllipsoid(ofstream *out, Vector *set, int N, Vector *EllipsoidCenter, double *EllipsoidLength, double *EllipsoidAngle)
 {
-        int status = GSL_SUCCESS;
-        *out << Verbose(2) << "Begin of FitPointSetToEllipsoid " << endl;
-        if (N >= 3) { // check that enough points are given (9 d.o.f.)
-                struct EllipsoidMinimisation par;
-                const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex;
-                gsl_multimin_fminimizer *s = NULL;
-                gsl_vector *ss, *x;
-                gsl_multimin_function minex_func;
-
-                size_t iter = 0;
-                double size;
-
-                /* Starting point */
-                x = gsl_vector_alloc (9);
-                for (int i=0;i<3;i++) {
-                        gsl_vector_set (x, i+0, EllipsoidCenter->x[i]);
-                        gsl_vector_set (x, i+3, EllipsoidLength[i]);
-                        gsl_vector_set (x, i+6, EllipsoidAngle[i]);
-                }
-                par.x = set;
-                par.N = N;
-
-                /* Set initial step sizes */
-                ss = gsl_vector_alloc (9);
-                for (int i=0;i<3;i++) {
-                        gsl_vector_set (ss, i+0, 0.1);
-                        gsl_vector_set (ss, i+3, 1.0);
-                        gsl_vector_set (ss, i+6, M_PI/20.);
-                }
-
-                /* Initialize method and iterate */
-                minex_func.n = 9;
-                minex_func.f = &SumSquaredDistance;
-                minex_func.params = (void *)&par;
-
-                s = gsl_multimin_fminimizer_alloc (T, 9);
-                gsl_multimin_fminimizer_set (s, &minex_func, x, ss);
-
-                do {
-                        iter++;
-                        status = gsl_multimin_fminimizer_iterate(s);
-
-                        if (status)
-                                break;
-
-                        size = gsl_multimin_fminimizer_size (s);
-                        status = gsl_multimin_test_size (size, 1e-2);
-
-                        if (status == GSL_SUCCESS) {
-                                for (int i=0;i<3;i++) {
-                                        EllipsoidCenter->x[i] = gsl_vector_get (s->x,i+0);
-                                        EllipsoidLength[i] = gsl_vector_get (s->x, i+3);
-                                        EllipsoidAngle[i] = gsl_vector_get (s->x, i+6);
-                                }
-                                *out << setprecision(3) << Verbose(4) << "Converged fit at: " << *EllipsoidCenter << ", lengths " << EllipsoidLength[0] << ", " << EllipsoidLength[1] << ", " << EllipsoidLength[2] << ", angles " << EllipsoidAngle[0] << ", " << EllipsoidAngle[1] << ", " << EllipsoidAngle[2] << " with summed distance " << s->fval << "." << endl;
-                        }
-
-                } while (status == GSL_CONTINUE && iter < 1000);
-
-                gsl_vector_free(x);
-                gsl_vector_free(ss);
-                gsl_multimin_fminimizer_free (s);
-
-        } else {
-                *out << Verbose(3) << "Not enough points provided for fit to ellipsoid." << endl;
-                return false;
-        }
-        *out << Verbose(2) << "End of FitPointSetToEllipsoid" << endl;
-        if (status == GSL_SUCCESS)
-                return true;
-        else
-                return false;
+  int status = GSL_SUCCESS;
+  *out << Verbose(2) << "Begin of FitPointSetToEllipsoid " << endl;
+  if (N >= 3) { // check that enough points are given (9 d.o.f.)
+    struct EllipsoidMinimisation par;
+    const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex;
+    gsl_multimin_fminimizer *s = NULL;
+    gsl_vector *ss, *x;
+    gsl_multimin_function minex_func;
+
+    size_t iter = 0;
+    double size;
+
+    /* Starting point */
+    x = gsl_vector_alloc (9);
+    for (int i=0;i<3;i++) {
+      gsl_vector_set (x, i+0, EllipsoidCenter->x[i]);
+      gsl_vector_set (x, i+3, EllipsoidLength[i]);
+      gsl_vector_set (x, i+6, EllipsoidAngle[i]);
+    }
+    par.x = set;
+    par.N = N;
+
+    /* Set initial step sizes */
+    ss = gsl_vector_alloc (9);
+    for (int i=0;i<3;i++) {
+      gsl_vector_set (ss, i+0, 0.1);
+      gsl_vector_set (ss, i+3, 1.0);
+      gsl_vector_set (ss, i+6, M_PI/20.);
+    }
+
+    /* Initialize method and iterate */
+    minex_func.n = 9;
+    minex_func.f = &SumSquaredDistance;
+    minex_func.params = (void *)&par;
+
+    s = gsl_multimin_fminimizer_alloc (T, 9);
+    gsl_multimin_fminimizer_set (s, &minex_func, x, ss);
+
+    do {
+      iter++;
+      status = gsl_multimin_fminimizer_iterate(s);
+
+      if (status)
+        break;
+
+      size = gsl_multimin_fminimizer_size (s);
+      status = gsl_multimin_test_size (size, 1e-2);
+
+      if (status == GSL_SUCCESS) {
+        for (int i=0;i<3;i++) {
+          EllipsoidCenter->x[i] = gsl_vector_get (s->x,i+0);
+          EllipsoidLength[i] = gsl_vector_get (s->x, i+3);
+          EllipsoidAngle[i] = gsl_vector_get (s->x, i+6);
+        }
+        *out << setprecision(3) << Verbose(4) << "Converged fit at: " << *EllipsoidCenter << ", lengths " << EllipsoidLength[0] << ", " << EllipsoidLength[1] << ", " << EllipsoidLength[2] << ", angles " << EllipsoidAngle[0] << ", " << EllipsoidAngle[1] << ", " << EllipsoidAngle[2] << " with summed distance " << s->fval << "." << endl;
+      }
+
+    } while (status == GSL_CONTINUE && iter < 1000);
+
+    gsl_vector_free(x);
+    gsl_vector_free(ss);
+    gsl_multimin_fminimizer_free (s);
+
+  } else {
+    *out << Verbose(3) << "Not enough points provided for fit to ellipsoid." << endl;
+    return false;
+  }
+  *out << Verbose(2) << "End of FitPointSetToEllipsoid" << endl;
+  if (status == GSL_SUCCESS)
+    return true;
+  else
+    return false;
 };
 
@@ -213 +213 @@
  * \param PointsToPick number of points in set to pick
  */
-void PickRandomNeighbouredPointSet(ofstream *out, class Tesselation *T, class LinkedCell *LC, Vector *&x, int PointsToPick)
-{
-        int PointsLeft = 0;
-        int PointsPicked = 0;
-        int Nlower[NDIM], Nupper[NDIM];
-        set<int> PickedAtomNrs;  // ordered list of picked atoms
-        set<int>::iterator current;
-        int index;
-        atom *Candidate = NULL;
-        LinkedAtoms *List = NULL;
-        *out << Verbose(2) << "Begin of PickRandomPointSet" << endl;
-
-        // allocate array
-        if (x == NULL) {
-                x = new Vector[PointsToPick];
-        } else {
-                *out << "WARNING: Given pointer to vector array seems already allocated." << endl;
-        }
-
-        do {
-                for(int i=0;i<NDIM;i++) // pick three random indices
-                        LC->n[i] = (rand() % LC->N[i]);
-                *out << Verbose(2) << "INFO: Center cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " ... ";
-                // get random cell
-                List = LC->GetCurrentCell();
-                if (List == NULL) {     // set index to it
-                        continue;
-                }
-                *out << "with No. " << LC->index << "." << endl;
-
-                *out << Verbose(2) << "LC Intervals:";
-                for (int i=0;i<NDIM;i++) {
-                        Nlower[i] = ((LC->n[i]-1) >= 0) ? LC->n[i]-1 : 0;
-                        Nupper[i] = ((LC->n[i]+1) < LC->N[i]) ? LC->n[i]+1 : LC->N[i]-1;
-                        *out << " [" << Nlower[i] << "," << Nupper[i] << "] ";
-                }
-                *out << endl;
-
-                // count whether there are sufficient atoms in this cell+neighbors
-                PointsLeft=0;
-                for (LC->n[0] = Nlower[0]; LC->n[0] <= Nupper[0]; LC->n[0]++)
-                        for (LC->n[1] = Nlower[1]; LC->n[1] <= Nupper[1]; LC->n[1]++)
-                                for (LC->n[2] = Nlower[2]; LC->n[2] <= Nupper[2]; LC->n[2]++) {
-                                        List = LC->GetCurrentCell();
-                                        PointsLeft += List->size();
-                                }
-                *out << Verbose(2) << "There are " << PointsLeft << " atoms in this neighbourhood." << endl;
-                if (PointsLeft < PointsToPick) {        // ensure that we can pick enough points in its neighbourhood at all.
-                        continue;
-                }
-
-                // pre-pick a fixed number of atoms
-                PickedAtomNrs.clear();
-                do {
-                        index = (rand() % PointsLeft);
-                        current = PickedAtomNrs.find(index);    // not present?
-                        if (current == PickedAtomNrs.end()) {
-                                //*out << Verbose(2) << "Picking atom nr. " << index << "." << endl;
-                                PickedAtomNrs.insert(index);
-                        }
-                } while (PickedAtomNrs.size() < (size_t) PointsToPick);
-
-                index = 0; // now go through all and pick those whose from PickedAtomsNr
-                PointsPicked=0;
-                current = PickedAtomNrs.begin();
-                for (LC->n[0] = Nlower[0]; LC->n[0] <= Nupper[0]; LC->n[0]++)
-                        for (LC->n[1] = Nlower[1]; LC->n[1] <= Nupper[1]; LC->n[1]++)
-                                for (LC->n[2] = Nlower[2]; LC->n[2] <= Nupper[2]; LC->n[2]++) {
-                                        List = LC->GetCurrentCell();
-//                                      *out << Verbose(2) << "Current cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << " containing " << List->size() << " points." << endl;
-                                        if (List != NULL) {
-//                                              if (List->begin() != List->end())
-//                                                      *out << Verbose(2) << "Going through candidates ... " << endl;
-//                                              else
-//                                                      *out << Verbose(2) << "Cell is empty ... " << endl;
-                                                for (LinkedAtoms::iterator Runner = List->begin(); Runner != List->end(); Runner++) {
-                                                        if ((current != PickedAtomNrs.end()) && (*current == index)) {
-                                                                Candidate = (*Runner);
-                                                                *out << Verbose(2) << "Current picked node is " << **Runner << " with index " << index << "." << endl;
-                                                                x[PointsPicked++].CopyVector(&(Candidate->x));          // we have one more atom picked
-                                                                current++;              // next pre-picked atom
-                                                        }
-                                                        index++;        // next atom nr.
-                                                }
-//                                      } else {
-//                                              *out << Verbose(2) << "List for this index not allocated!" << endl;
-                                        }
-                                }
-                *out << Verbose(2) << "The following points were picked: " << endl;
-                for (int i=0;i<PointsPicked;i++)
-                        *out << Verbose(2) << x[i] << endl;
-                if (PointsPicked == PointsToPick)       // break out of loop if we have all
-                        break;
-        } while(1);
-
-        *out << Verbose(2) << "End of PickRandomPointSet" << endl;
+void PickRandomNeighbouredPointSet(ofstream *out, class Tesselation *T, class LinkedCell *LC, Vector *&x, size_t PointsToPick)
+{
+  size_t PointsLeft = 0;
+  size_t PointsPicked = 0;
+  int Nlower[NDIM], Nupper[NDIM];
+  set<int> PickedAtomNrs;   // ordered list of picked atoms
+  set<int>::iterator current;
+  int index;
+  atom *Candidate = NULL;
+  LinkedAtoms *List = NULL;
+  *out << Verbose(2) << "Begin of PickRandomPointSet" << endl;
+
+  // allocate array
+  if (x == NULL) {
+    x = new Vector[PointsToPick];
+  } else {
+    *out << "WARNING: Given pointer to vector array seems already allocated." << endl;
+  }
+
+  do {
+    for(int i=0;i<NDIM;i++) // pick three random indices
+      LC->n[i] = (rand() % LC->N[i]);
+    *out << Verbose(2) << "INFO: Center cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " ... ";
+    // get random cell
+    List = LC->GetCurrentCell();
+    if (List == NULL) {  // set index to it
+      continue;
+    }
+    *out << "with No. " << LC->index << "." << endl;
+
+    *out << Verbose(2) << "LC Intervals:";
+    for (int i=0;i<NDIM;i++) {
+      Nlower[i] = ((LC->n[i]-1) >= 0) ? LC->n[i]-1 : 0;
+      Nupper[i] = ((LC->n[i]+1) < LC->N[i]) ? LC->n[i]+1 : LC->N[i]-1;
+      *out << " [" << Nlower[i] << "," << Nupper[i] << "] ";
+    }
+    *out << endl;
+
+    // count whether there are sufficient atoms in this cell+neighbors
+    PointsLeft=0;
+    for (LC->n[0] = Nlower[0]; LC->n[0] <= Nupper[0]; LC->n[0]++)
+      for (LC->n[1] = Nlower[1]; LC->n[1] <= Nupper[1]; LC->n[1]++)
+        for (LC->n[2] = Nlower[2]; LC->n[2] <= Nupper[2]; LC->n[2]++) {
+          List = LC->GetCurrentCell();
+          PointsLeft += List->size();
+        }
+    *out << Verbose(2) << "There are " << PointsLeft << " atoms in this neighbourhood." << endl;
+    if (PointsLeft < PointsToPick) {  // ensure that we can pick enough points in its neighbourhood at all.
+      continue;
+    }
+
+    // pre-pick a fixed number of atoms
+    PickedAtomNrs.clear();
+    do {
+      index = (rand() % PointsLeft);
+      current = PickedAtomNrs.find(index);  // not present?
+      if (current == PickedAtomNrs.end()) {
+        //*out << Verbose(2) << "Picking atom nr. " << index << "." << endl;
+        PickedAtomNrs.insert(index);
+      }
+    } while (PickedAtomNrs.size() < PointsToPick);
+
+    index = 0; // now go through all and pick those whose from PickedAtomsNr
+    PointsPicked=0;
+    current = PickedAtomNrs.begin();
+    for (LC->n[0] = Nlower[0]; LC->n[0] <= Nupper[0]; LC->n[0]++)
+      for (LC->n[1] = Nlower[1]; LC->n[1] <= Nupper[1]; LC->n[1]++)
+        for (LC->n[2] = Nlower[2]; LC->n[2] <= Nupper[2]; LC->n[2]++) {
+          List = LC->GetCurrentCell();
+//          *out << Verbose(2) << "Current cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << " containing " << List->size() << " points." << endl;
+          if (List != NULL) {
+//            if (List->begin() != List->end())
+//              *out << Verbose(2) << "Going through candidates ... " << endl;
+//            else
+//              *out << Verbose(2) << "Cell is empty ... " << endl;
+            for (LinkedAtoms::iterator Runner = List->begin(); Runner != List->end(); Runner++) {
+              if ((current != PickedAtomNrs.end()) && (*current == index)) {
+                Candidate = (*Runner);
+                *out << Verbose(2) << "Current picked node is " << **Runner << " with index " << index << "." << endl;
+                x[PointsPicked++].CopyVector(&(Candidate->x));    // we have one more atom picked
+                current++;    // next pre-picked atom
+              }
+              index++;  // next atom nr.
+            }
+//          } else {
+//            *out << Verbose(2) << "List for this index not allocated!" << endl;
+          }
+        }
+    *out << Verbose(2) << "The following points were picked: " << endl;
+    for (size_t i=0;i<PointsPicked;i++)
+      *out << Verbose(2) << x[i] << endl;
+    if (PointsPicked == PointsToPick)  // break out of loop if we have all
+      break;
+  } while(1);
+
+  *out << Verbose(2) << "End of PickRandomPointSet" << endl;
 };
 
@@ -317 +317 @@
  * \param PointsToPick number of points in set to pick
  */
-void PickRandomPointSet(ofstream *out, class Tesselation *T, Vector *&x, int PointsToPick)
-{
-        int PointsLeft = T->PointsOnBoundaryCount;
-        int PointsPicked = 0;
-        double value, threshold;
-        PointMap *List = &T->PointsOnBoundary;
-        *out << Verbose(2) << "Begin of PickRandomPointSet" << endl;
-
-        // allocate array
-        if (x == NULL) {
-                x = new Vector[PointsToPick];
-        } else {
-                *out << "WARNING: Given pointer to vector array seems already allocated." << endl;
-        }
-
-        if (List != NULL)
-                for (PointMap::iterator Runner = List->begin(); Runner != List->end(); Runner++) {
-                        threshold = 1. - (double)(PointsToPick - PointsPicked)/(double)PointsLeft;
-                        value = (double)rand()/(double)RAND_MAX;
-                        //*out << Verbose(3) << "Current node is " << *Runner->second->node << " with " << value << " ... " << threshold << ": ";
-                        if (value > threshold) {
-                                x[PointsPicked].CopyVector(&(Runner->second->node->x));
-                                PointsPicked++;
-                                //*out << "IN." << endl;
-                        } else {
-                                //*out << "OUT." << endl;
-                        }
-                        PointsLeft--;
-                }
-        *out << Verbose(2) << "The following points were picked: " << endl;
-        for (int i=0;i<PointsPicked;i++)
-                *out << Verbose(3) << x[i] << endl;
-
-        *out << Verbose(2) << "End of PickRandomPointSet" << endl;
+void PickRandomPointSet(ofstream *out, class Tesselation *T, Vector *&x, size_t PointsToPick)
+{
+  size_t PointsLeft = (size_t) T->PointsOnBoundaryCount;
+  size_t PointsPicked = 0;
+  double value, threshold;
+  PointMap *List = &T->PointsOnBoundary;
+  *out << Verbose(2) << "Begin of PickRandomPointSet" << endl;
+
+  // allocate array
+  if (x == NULL) {
+    x = new Vector[PointsToPick];
+  } else {
+    *out << "WARNING: Given pointer to vector array seems already allocated." << endl;
+  }
+
+  if (List != NULL)
+    for (PointMap::iterator Runner = List->begin(); Runner != List->end(); Runner++) {
+      threshold = 1. - (double)(PointsToPick - PointsPicked)/(double)PointsLeft;
+      value = (double)rand()/(double)RAND_MAX;
+      //*out << Verbose(3) << "Current node is " << *Runner->second->node << " with " << value << " ... " << threshold << ": ";
+      if (value > threshold) {
+        x[PointsPicked].CopyVector(&(Runner->second->node->x));
+        PointsPicked++;
+        //*out << "IN." << endl;
+      } else {
+        //*out << "OUT." << endl;
+      }
+      PointsLeft--;
+    }
+  *out << Verbose(2) << "The following points were picked: " << endl;
+  for (size_t i=0;i<PointsPicked;i++)
+    *out << Verbose(3) << x[i] << endl;
+
+  *out << Verbose(2) << "End of PickRandomPointSet" << endl;
 };
 
@@ -363 +363 @@
 void FindDistributionOfEllipsoids(ofstream *out, class Tesselation *T, class LinkedCell *LCList, int N, int number, const char *filename)
 {
-        ofstream output;
-        Vector *x = NULL;
-        Vector Center;
-        Vector EllipsoidCenter;
-        double EllipsoidLength[3];
-        double EllipsoidAngle[3];
-        double distance, MaxDistance, MinDistance;
-        *out << Verbose(0) << "Begin of FindDistributionOfEllipsoids" << endl;
-
-        // construct center of gravity of boundary point set for initial ellipsoid center
-        Center.Zero();
-        for (PointMap::iterator Runner = T->PointsOnBoundary.begin(); Runner != T->PointsOnBoundary.end(); Runner++)
-                Center.AddVector(&Runner->second->node->x);
-        Center.Scale(1./T->PointsOnBoundaryCount);
-        *out << Verbose(1) << "Center is at " << Center << "." << endl;
-
-        // Output header
-        output.open(filename, ios::trunc);
-        output << "# Nr.\tCenterX\tCenterY\tCenterZ\ta\tb\tc\tpsi\ttheta\tphi" << endl;
-
-        // loop over desired number of parameter sets
-        for (;number >0;number--) {
-                *out << Verbose(1) << "Determining data set " << number << " ... " << endl;
-                // pick the point set
-                x = NULL;
-                //PickRandomPointSet(out, T, LCList, x, N);
-                PickRandomNeighbouredPointSet(out, T, LCList, x, N);
-
-                // calculate some sensible starting values for parameter fit
-                MaxDistance = 0.;
-                MinDistance = x[0].ScalarProduct(&x[0]);
-                for (int i=0;i<N;i++) {
-                        distance = x[i].ScalarProduct(&x[i]);
-                        if (distance > MaxDistance)
-                                MaxDistance = distance;
-                        if (distance < MinDistance)
-                                MinDistance = distance;
-                }
-                //*out << Verbose(2) << "MinDistance " << MinDistance << ", MaxDistance " << MaxDistance << "." << endl;
-                EllipsoidCenter.CopyVector(&Center);    // use Center of Gravity as initial center of ellipsoid
-                for (int i=0;i<3;i++)
-                        EllipsoidAngle[i] = 0.;
-                EllipsoidLength[0] = sqrt(MaxDistance);
-                EllipsoidLength[1] = sqrt((MaxDistance+MinDistance)/2.);
-                EllipsoidLength[2] = sqrt(MinDistance);
-
-                // fit the parameters
-                if (FitPointSetToEllipsoid(out, x, N, &EllipsoidCenter, &EllipsoidLength[0], &EllipsoidAngle[0])) {
-                        *out << Verbose(1) << "Picking succeeded!" << endl;
-                        // output obtained parameter set
-                        output << number << "\t";
-                        for (int i=0;i<3;i++)
-                                output << setprecision(9) << EllipsoidCenter.x[i] << "\t";
-                        for (int i=0;i<3;i++)
-                                output << setprecision(9) << EllipsoidLength[i] << "\t";
-                        for (int i=0;i<3;i++)
-                                output << setprecision(9) << EllipsoidAngle[i] << "\t";
-                        output << endl;
-                } else { // increase N to pick one more
-                        *out << Verbose(1) << "Picking failed!" << endl;
-                        number++;
-                }
-                delete[](x);    // free allocated memory for point set
-        }
-        // close output and finish
-        output.close();
-
-        *out << Verbose(0) << "End of FindDistributionOfEllipsoids" << endl;
-};
+  ofstream output;
+  Vector *x = NULL;
+  Vector Center;
+  Vector EllipsoidCenter;
+  double EllipsoidLength[3];
+  double EllipsoidAngle[3];
+  double distance, MaxDistance, MinDistance;
+  *out << Verbose(0) << "Begin of FindDistributionOfEllipsoids" << endl;
+
+  // construct center of gravity of boundary point set for initial ellipsoid center
+  Center.Zero();
+  for (PointMap::iterator Runner = T->PointsOnBoundary.begin(); Runner != T->PointsOnBoundary.end(); Runner++)
+    Center.AddVector(&Runner->second->node->x);
+  Center.Scale(1./T->PointsOnBoundaryCount);
+  *out << Verbose(1) << "Center is at " << Center << "." << endl;
+
+  // Output header
+  output.open(filename, ios::trunc);
+  output << "# Nr.\tCenterX\tCenterY\tCenterZ\ta\tb\tc\tpsi\ttheta\tphi" << endl;
+
+  // loop over desired number of parameter sets
+  for (;number >0;number--) {
+    *out << Verbose(1) << "Determining data set " << number << " ... " << endl;
+    // pick the point set
+    x = NULL;
+    //PickRandomPointSet(out, T, LCList, x, N);
+    PickRandomNeighbouredPointSet(out, T, LCList, x, N);
+
+    // calculate some sensible starting values for parameter fit
+    MaxDistance = 0.;
+    MinDistance = x[0].ScalarProduct(&x[0]);
+    for (int i=0;i<N;i++) {
+      distance = x[i].ScalarProduct(&x[i]);
+      if (distance > MaxDistance)
+        MaxDistance = distance;
+      if (distance < MinDistance)
+        MinDistance = distance;
+    }
+    //*out << Verbose(2) << "MinDistance " << MinDistance << ", MaxDistance " << MaxDistance << "." << endl;
+    EllipsoidCenter.CopyVector(&Center);  // use Center of Gravity as initial center of ellipsoid
+    for (int i=0;i<3;i++)
+      EllipsoidAngle[i] = 0.;
+    EllipsoidLength[0] = sqrt(MaxDistance);
+    EllipsoidLength[1] = sqrt((MaxDistance+MinDistance)/2.);
+    EllipsoidLength[2] = sqrt(MinDistance);
+
+    // fit the parameters
+    if (FitPointSetToEllipsoid(out, x, N, &EllipsoidCenter, &EllipsoidLength[0], &EllipsoidAngle[0])) {
+      *out << Verbose(1) << "Picking succeeded!" << endl;
+      // output obtained parameter set
+      output << number << "\t";
+      for (int i=0;i<3;i++)
+        output << setprecision(9) << EllipsoidCenter.x[i] << "\t";
+      for (int i=0;i<3;i++)
+        output << setprecision(9) << EllipsoidLength[i] << "\t";
+      for (int i=0;i<3;i++)
+        output << setprecision(9) << EllipsoidAngle[i] << "\t";
+      output << endl;
+    } else { // increase N to pick one more
+      *out << Verbose(1) << "Picking failed!" << endl;
+      number++;
+    }
+    delete[](x);  // free allocated memory for point set
+  }
+  // close output and finish
+  output.close();
+
+  *out << Verbose(0) << "End of FindDistributionOfEllipsoids" << endl;
+};

src/ellipsoid.hpp

@@ -2 +2 @@
  * ellipsoid.hpp
  *
- *      Created on: Jan 20, 2009
- *                      Author: heber
+ *  Created on: Jan 20, 2009
+ *      Author: heber
  */
 
@@ -22 +22 @@
 double SumSquaredDistance (const gsl_vector * x, void * params);
 bool FitPointSetToEllipsoid(ofstream *out, Vector *set, int N, Vector *EllipsoidCenter, double *EllipsoidLength, double *EllipsoidAngle);
-void PickRandomPointSet(ofstream *out, class Tesselation *T, Vector *&x, int N);
-void PickRandomNeighbouredPointSet(ofstream *out, class Tesselation *T, class LinkedCell *LC, Vector *&x, int PointsToPick);
+void PickRandomPointSet(ofstream *out, class Tesselation *T, Vector *&x, size_t PointsToPick);
+void PickRandomNeighbouredPointSet(ofstream *out, class Tesselation *T, class LinkedCell *LC, Vector *&x, size_t PointsToPick);
 void FindDistributionOfEllipsoids(ofstream *out, class Tesselation *T, class LinkedCell *LCList, int N, int number, const char *filename);
 

src/helpers.cpp

@@ -15 +15 @@
 double ask_value(const char *text)
 {
-        double test = 0.1439851348959832147598734598273456723948652983045928346598365;
-        do {
-                cout << Verbose(0) << text;
-                cin >> test;
-        } while (test == 0.1439851348959832147598734598273456723948652983045928346598365);
-        return test;
+  double test = 0.1439851348959832147598734598273456723948652983045928346598365;
+  do {
+    cout << Verbose(0) << text;
+    cin >> test;
+  } while (test == 0.1439851348959832147598734598273456723948652983045928346598365);
+  return test;
 };
 
@@ -29 +29 @@
 #ifdef HAVE_DEBUG
 void debug_in(const char *output, const char *file, const int line) {
-        if (output) fprintf(stderr,"DEBUG: in %s at line %i: %s\n", file, line, output);
+  if (output) fprintf(stderr,"DEBUG: in %s at line %i: %s\n", file, line, output);
 }
 #else
-void debug_in(const char *output, const char *file, const int line) {}  // print nothing
+void debug_in(const char *output, const char *file, const int line) {}  // print nothing
 #endif
 
@@ -42 +42 @@
 void * Malloc(size_t size, const char* output)
 {
-        void *buffer = NULL;
-        buffer = (void *)malloc(size); // alloc
-        if (buffer == NULL)
-                cout << Verbose(0) << "Malloc failed - pointer is NULL: " << output << endl;
-        return(buffer);
+  void *buffer = NULL;
+  buffer = (void *)malloc(size); // alloc
+  if (buffer == NULL)
+    cout << Verbose(0) << "Malloc failed - pointer is NULL: " << output << endl;
+  return(buffer);
 };
 
@@ -56 +56 @@
 void * Calloc(size_t size, const char* output)
 {
-        void *buffer = NULL;
-        buffer = (void *)calloc(size, (size_t)0); // alloc
-        if (buffer == NULL)
-                cout << Verbose(0) << "Calloc failed - pointer is NULL: " << output << endl;
-        return(buffer);
+  void *buffer = NULL;
+  buffer = (void *)calloc(size, (size_t)0); // alloc
+  if (buffer == NULL)
+    cout << Verbose(0) << "Calloc failed - pointer is NULL: " << output << endl;
+  return(buffer);
 };
 
@@ -88 +88 @@
 void Free(void ** buffer, const char* output)
 {
-        if (*buffer == NULL) {
-                //cout << Verbose(5) << "Free not necesary: " << output << endl;
-        } else {
-                free(*buffer);
-                *buffer = NULL;
-        }
+  if (*buffer == NULL) {
+    //cout << Verbose(5) << "Free not necesary: " << output << endl;
+  } else {
+    free(*buffer);
+    *buffer = NULL;
+  }
 };
 
@@ -103 +103 @@
 char* MallocString(size_t size, const char* output)
 {
-        size_t i;
-        char *buffer;
-        buffer = (char *)malloc(sizeof(char) * (size+1)); // alloc
-        if (buffer == NULL)
-                cout << Verbose(0) << output << endl;
-        for (i=size;i--;)       // reset
-                buffer[i] = i % 2 == 0 ? 'p': 'c';
-        buffer[size] = '\0'; // and set length marker on its end
-        return(buffer);
+  size_t i;
+  char *buffer;
+  buffer = (char *)malloc(sizeof(char) * (size+1)); // alloc
+  if (buffer == NULL)
+    cout << Verbose(0) << output << endl;
+  for (i=size;i--;)  // reset
+    buffer[i] = i % 2 == 0 ? 'p': 'c';
+  buffer[size] = '\0'; // and set length marker on its end
+  return(buffer);
 }
 
@@ -121 +121 @@
 void bound(double *b, double lower_bound, double upper_bound)
 {
-        double step = (upper_bound - lower_bound);
-        while (*b >= upper_bound)
-                *b -= step;
-        while (*b < lower_bound)
-                *b += step;
+  double step = (upper_bound - lower_bound);
+  while (*b >= upper_bound)
+    *b -= step;
+  while (*b < lower_bound)
+    *b += step;
 };
 
@@ -134 +134 @@
 void flip(double *x, double *y)
 {
-        double tmp;
-        tmp = *x;
-        *x = *y;
-        *y = tmp;
+  double tmp;
+  tmp = *x;
+  *x = *y;
+  *y = tmp;
 };
 
@@ -147 +147 @@
 int pot(int base, int n)
 {
-        int res = 1;
-        int j;
-        for (j=n;j--;)
-                res *= base;
-        return res;
+  int res = 1;
+  int j;
+  for (j=n;j--;)
+    res *= base;
+  return res;
 };
 
@@ -161 +161 @@
 char *FixedDigitNumber(const int FragmentNumber, const int digits)
 {
-        char *returnstring;
-        int number = FragmentNumber;
-        int order = 0;
-        while (number != 0) { // determine number of digits needed
-                number = (int)floor(((double)number / 10.));
-                order++;
-                //cout << "Number is " << number << ", order is " << order << "." << endl;
-        }
-        // allocate string
-        returnstring = (char *) Malloc(sizeof(char)*(order+2), "FixedDigitNumber: *returnstring");
-        // terminate    and fill string array from end backward
-        returnstring[order] = '\0';
-        number = digits;
-        for (int i=order;i--;) {
-                returnstring[i] = '0' + (char)(number % 10);
-                number = (int)floor(((double)number / 10.));
-        }
-        //cout << returnstring << endl;
-        return returnstring;
+  char *returnstring;
+  int number = FragmentNumber;
+  int order = 0;
+  while (number != 0) { // determine number of digits needed
+    number = (int)floor(((double)number / 10.));
+    order++;
+    //cout << "Number is " << number << ", order is " << order << "." << endl;
+  }
+  // allocate string
+  returnstring = (char *) Malloc(sizeof(char)*(order+2), "FixedDigitNumber: *returnstring");
+  // terminate  and fill string array from end backward
+  returnstring[order] = '\0';
+  number = digits;
+  for (int i=order;i--;) {
+    returnstring[i] = '0' + (char)(number % 10);
+    number = (int)floor(((double)number / 10.));
+  }
+  //cout << returnstring << endl;
+  return returnstring;
 };
 
@@ -188 +188 @@
 bool IsValidNumber( const char *string)
 {
-        int ptr = 0;
-        if ((string[ptr] == '.') || (string[ptr] == '-')) // number may be negative or start with dot
-                ptr++;
-        if ((string[ptr] >= '0') && (string[ptr] <= '9'))
-                return true;
-        return false;
+  int ptr = 0;
+  if ((string[ptr] == '.') || (string[ptr] == '-')) // number may be negative or start with dot
+    ptr++;
+  if ((string[ptr] >= '0') && (string[ptr] <= '9'))
+    return true;
+  return false;
 };
 

src/helpers.hpp

@@ -38 +38 @@
 
 /* Behandelt aufgetretene Fehler. error ist der Fehlertyp(enum Errors)
-         void *SpecialData ist ein untypisierter Zeiger auf Spezielle Daten zur Fehlerbehandlung.
-         Man koennte auch noch einen Zeiger auf eine Funktion uebergeben */
+   void *SpecialData ist ein untypisierter Zeiger auf Spezielle Daten zur Fehlerbehandlung.
+   Man koennte auch noch einen Zeiger auf eine Funktion uebergeben */
 extern void /*@exits@*/ debug(const char *output);
-        //__attribute__ ((__return__));
+  //__attribute__ ((__return__));
 #define debug(data) debug_in((data), __FILE__, __LINE__)
 
 extern void /*@exits@*/ debug_in(const char *output,
-                const char *file, const int line);
-        //__attribute__ ((__return__));
+    const char *file, const int line);
+  //__attribute__ ((__return__));
 
 double ask_value(const char *text);
@@ -73 +73 @@
 template <typename T> bool CreateFatherLookupTable(ofstream *out, T *start, T *end, T **&LookupTable, int count = 0)
 {
-        bool status = true;
-        T *Walker = NULL;
-        int AtomNo;
-
-        if (LookupTable != NULL) {
-                *out << "Pointer for Lookup table is not NULL! Aborting ..." <<endl;
-                return false;
-        }
-
-        // count them
-        if (count == 0) {
-                Walker = start;
-                while (Walker->next != end) { // create a lookup table (Atom::nr -> atom) used as a marker table lateron
-                        Walker = Walker->next;
-                        count = (count < Walker->GetTrueFather()->nr) ? Walker->GetTrueFather()->nr : count;
-                }
-        }
-        if (count <= 0) {
-                *out << "Count of lookup list is 0 or less." << endl;
-                return false;
-        }
-
-        // allocat and fill
-        LookupTable = (T **) Malloc(sizeof(T *)*count, "CreateFatherLookupTable - **LookupTable");
-        if (LookupTable == NULL) {
-                cerr << "LookupTable memory allocation failed!" << endl;
-                status = false;
-        } else {
-                for (int i=0;i<count;i++)
-                        LookupTable[i] = NULL;
-                Walker = start;
-                while (Walker->next != end) { // create a lookup table (Atom::nr -> atom) used as a marker table lateron
-                        Walker = Walker->next;
-                        AtomNo = Walker->GetTrueFather()->nr;
-                        if ((AtomNo >= 0) && (AtomNo < count)) {
-                                //*out << "Setting LookupTable[" << AtomNo << "] to " << *Walker << endl;
-                                LookupTable[AtomNo] = Walker;
-                        } else {
-                                *out << "Walker " << *Walker << " exceeded range of nuclear ids [0, " << count << ")." << endl;
-                                status = false;
-                                break;
-                        }
-                }
-        }
-
-        return status;
+  bool status = true;
+  T *Walker = NULL;
+  int AtomNo;
+
+  if (LookupTable != NULL) {
+    *out << "Pointer for Lookup table is not NULL! Aborting ..." <<endl;
+    return false;
+  }
+
+  // count them
+  if (count == 0) {
+    Walker = start;
+    while (Walker->next != end) { // create a lookup table (Atom::nr -> atom) used as a marker table lateron
+      Walker = Walker->next;
+      count = (count < Walker->GetTrueFather()->nr) ? Walker->GetTrueFather()->nr : count;
+    }
+  }
+  if (count <= 0) {
+    *out << "Count of lookup list is 0 or less." << endl;
+    return false;
+  }
+
+  // allocat and fill
+  LookupTable = (T **) Malloc(sizeof(T *)*count, "CreateFatherLookupTable - **LookupTable");
+  if (LookupTable == NULL) {
+    cerr << "LookupTable memory allocation failed!" << endl;
+    status = false;
+  } else {
+    for (int i=0;i<count;i++)
+      LookupTable[i] = NULL;
+    Walker = start;
+    while (Walker->next != end) { // create a lookup table (Atom::nr -> atom) used as a marker table lateron
+      Walker = Walker->next;
+      AtomNo = Walker->GetTrueFather()->nr;
+      if ((AtomNo >= 0) && (AtomNo < count)) {
+        //*out << "Setting LookupTable[" << AtomNo << "] to " << *Walker << endl;
+        LookupTable[AtomNo] = Walker;
+      } else {
+        *out << "Walker " << *Walker << " exceeded range of nuclear ids [0, " << count << ")." << endl;
+        status = false;
+        break;
+      }
+    }
+  }
+
+  return status;
 };
 
@@ -129 +129 @@
 template <typename X> void link(X *walker, X *end)
 {
-        X *vorher = end->previous;
-        if (vorher != NULL)
-                vorher->next = walker;
-        end->previous = walker;
-        walker->previous = vorher;
-        walker->next = end;
+  X *vorher = end->previous;
+  if (vorher != NULL)
+    vorher->next = walker;
+  end->previous = walker;
+  walker->previous = vorher;
+  walker->next = end;
 };
 
@@ -143 +143 @@
 template <typename X> void unlink(X *walker)
 {
-        if (walker->next != NULL)
-                walker->next->previous = walker->previous;
-        if (walker->previous != NULL)
-                walker->previous->next = walker->next;
+  if (walker->next != NULL)
+    walker->next->previous = walker->previous;
+  if (walker->previous != NULL)
+    walker->previous->next = walker->next;
 };
 
 /** Adds new item before an item \a *end in a list.
- * \param *pointer       item to be added
- * \param *end  end of list
+ * \param *pointer   item to be added
+ * \param *end  end of list
  * \return true - addition succeeded, false - unable to add item to list
  */
-template <typename X>   bool add(X *pointer, X *end)
-{
-        if (end != NULL) {
-                link(pointer, end);
-        } else {
-                pointer->previous = NULL;
-                pointer->next = NULL;
-        }
-        return true;
+template <typename X>  bool add(X *pointer, X *end)
+{
+  if (end != NULL) {
+    link(pointer, end);
+  } else {
+    pointer->previous = NULL;
+    pointer->next = NULL;
+  }
+  return true;
 };
 
 /** Finds item in list
- * \param *suche        search criteria
- * \param *start        begin of list
- * \param *end  end of list
+ * \param *suche  search criteria
+ * \param *start  begin of list
+ * \param *end  end of list
  * \return X - if found, NULL - if not found
  */
 template <typename X, typename Y> X * find(Y *suche, X *start, X *end)
 {
-        X *walker = start;
-        while (walker->next != end) { // go through list
-                walker = walker->next; // step onward beforehand
-                if (*walker->sort == *suche) return (walker);
-        }
-        return NULL;
+  X *walker = start;
+  while (walker->next != end) { // go through list
+    walker = walker->next; // step onward beforehand
+    if (*walker->sort == *suche) return (walker);
+  }
+  return NULL;
 };
 
@@ -187 +187 @@
 template <typename X> void removewithoutcheck(X *walker)
 {
-        if (walker != NULL) {
-                unlink(walker);
-                delete(walker);
-                walker = NULL;
-        }
+  if (walker != NULL) {
+    unlink(walker);
+    delete(walker);
+    walker = NULL;
+  }
 };
 
 /** Removes an item from the list, checks if exists.
  * Checks beforehand if atom is really within molecule list.
- * \param *pointer       item to be removed
- * \param *start        begin of list
- * \param *end  end of list
+ * \param *pointer   item to be removed
+ * \param *start  begin of list
+ * \param *end  end of list
  * \return true - removing succeeded, false - given item not found in list
  */
 template <typename X> bool remove(X *pointer, X *start, X *end)
 {
-        X *walker = find (pointer->sort, start, end);
-/*      while (walker->next != pointer) { // search through list
-                walker = walker->next;
-                if (walker == end) return false;        // item not found in list
-        }*/
-        // atom found, now unlink
-        if (walker != NULL)
-                removewithoutcheck(walker);
-        else
-                return false;
-        return true;
+  X *walker = find (pointer->sort, start, end);
+/*  while (walker->next != pointer) { // search through list
+    walker = walker->next;
+    if (walker == end) return false;  // item not found in list
+  }*/
+  // atom found, now unlink
+  if (walker != NULL)
+    removewithoutcheck(walker);
+  else
+    return false;
+  return true;
 };
 
@@ -223 +223 @@
 template <typename X> bool cleanup(X *start, X *end)
 {
-        X *pointer = start->next;
-        X *walker;
-        while (pointer != end) { // go through list
-                walker = pointer; // mark current
-                pointer = pointer->next; // step onward beforehand
-                // remove walker
-                unlink(walker);
-                delete(walker);
-                walker = NULL;
-        }
-        return true;
+  X *pointer = start->next;
+  X *walker;
+  while (pointer != end) { // go through list
+    walker = pointer; // mark current
+    pointer = pointer->next; // step onward beforehand
+    // remove walker
+    unlink(walker);
+    delete(walker);
+    walker = NULL;
+  }
+  return true;
 };
 
@@ -242 +242 @@
 template <typename X> X *GetFirst(X *me)
 {
-        X *Binder = me;
-        while(Binder->previous != NULL)
-                Binder = Binder->previous;
-        return Binder;
+  X *Binder = me;
+  while(Binder->previous != NULL)
+    Binder = Binder->previous;
+  return Binder;
 };
 
@@ -254 +254 @@
 template <typename X> X *GetLast(X *me)
 {
-        X *Binder = me;
-        while(Binder->next != NULL)
-                Binder = Binder->next;
-        return Binder;
+  X *Binder = me;
+  while(Binder->next != NULL)
+    Binder = Binder->next;
+  return Binder;
 };
 
@@ -266 +266 @@
 template <typename X> void Free2DArray(X **ptr, int dim)
 {
-        int i;
-        if (ptr != NULL) {
-                for(i=dim;i--;)
-                        if (ptr[i] != NULL)
-                                free(ptr[i]);
-                free(ptr);
-        }
+  int i;
+  if (ptr != NULL) {
+    for(i=dim;i--;)
+      if (ptr[i] != NULL)
+        free(ptr[i]);
+    free(ptr);
+  }
 };
 
@@ -281 +281 @@
 class Verbose
 {
-        public:
-                Verbose(int value) : Verbosity(value) { }
-
-                ostream& print (ostream &ost) const;
-        private:
-                int Verbosity;
+  public:
+    Verbose(int value) : Verbosity(value) { }
+
+    ostream& print (ostream &ost) const;
+  private:
+    int Verbosity;
 };
 
@@ -295 +295 @@
 class Binary
 {
-        public:
-                Binary(int value) : BinaryNumber(value) { }
-
-                ostream& print (ostream &ost) const;
-        private:
-                int BinaryNumber;
+  public:
+    Binary(int value) : BinaryNumber(value) { }
+
+    ostream& print (ostream &ost) const;
+  private:
+    int BinaryNumber;
 };
 

src/joiner.cpp

@@ -110 +110 @@
   // ---------- Parse the KeySets into an array ---------------
   if (!KeySet.ParseKeySets(argv[1], Force.RowCounter, Force.MatrixCounter)) return 1;
+
   if (!KeySet.ParseManyBodyTerms()) return 1;
 

src/linkedcell.cpp

@@ -6 +6 @@
 LinkedCell::LinkedCell()
 {
-        LC = NULL;
-        for(int i=0;i<NDIM;i++)
-                N[i] = 0;
-        index = -1;
-        RADIUS = 0.;
-        max.Zero();
-        min.Zero();
+  LC = NULL;
+  for(int i=0;i<NDIM;i++)
+    N[i] = 0;
+  index = -1;
+  RADIUS = 0.;
+  max.Zero();
+  min.Zero();
 };
 
@@ -21 +21 @@
 LinkedCell::LinkedCell(molecule *mol, double radius)
 {
-        atom *Walker = NULL;
+  atom *Walker = NULL;
 
-        RADIUS = radius;
-        LC = NULL;
-        for(int i=0;i<NDIM;i++)
-                N[i] = 0;
-        index = -1;
-        max.Zero();
-        min.Zero();
-        cout << Verbose(1) << "Begin of LinkedCell" << endl;
-        if (mol->start->next == mol->end) {
-                cerr << "ERROR: molecule contains no atoms!" << endl;
-                return;
-        }
-        // 1. find max and min per axis of atoms
-        Walker = mol->start->next;
-        for (int i=0;i<NDIM;i++) {
-                max.x[i] = Walker->x.x[i];
-                min.x[i] = Walker->x.x[i];
-        }
-        while (Walker != mol->end) {
-                for (int i=0;i<NDIM;i++) {
-                        if (max.x[i] < Walker->x.x[i])
-                                max.x[i] = Walker->x.x[i];
-                        if (min.x[i] > Walker->x.x[i])
-                                min.x[i] = Walker->x.x[i];
-                }
-                Walker = Walker->next;
-        }
-        cout << Verbose(2) << "Bounding box is " << min << " and " << max << "." << endl;
+  RADIUS = radius;
+  LC = NULL;
+  for(int i=0;i<NDIM;i++)
+    N[i] = 0;
+  index = -1;
+  max.Zero();
+  min.Zero();
+  cout << Verbose(1) << "Begin of LinkedCell" << endl;
+  if (mol->start->next == mol->end) {
+    cerr << "ERROR: molecule contains no atoms!" << endl;
+    return;
+  }
+  // 1. find max and min per axis of atoms
+  Walker = mol->start->next;
+  for (int i=0;i<NDIM;i++) {
+    max.x[i] = Walker->x.x[i];
+    min.x[i] = Walker->x.x[i];
+  }
+  while (Walker != mol->end) {
+    for (int i=0;i<NDIM;i++) {
+      if (max.x[i] < Walker->x.x[i])
+        max.x[i] = Walker->x.x[i];
+      if (min.x[i] > Walker->x.x[i])
+        min.x[i] = Walker->x.x[i];
+    }
+    Walker = Walker->next;
+  }
+  cout << Verbose(2) << "Bounding box is " << min << " and " << max << "." << endl;
 
-        // 2. find then umber of cells per axis
-        for (int i=0;i<NDIM;i++) {
-                N[i] = (int)floor((max.x[i] - min.x[i])/RADIUS)+1;
-        }
-        cout << Verbose(2) << "Number of cells per axis are " << N[0] << ", " << N[1] << " and " << N[2] << "." << endl;
+  // 2. find then umber of cells per axis
+  for (int i=0;i<NDIM;i++) {
+    N[i] = (int)floor((max.x[i] - min.x[i])/RADIUS)+1;
+  }
+  cout << Verbose(2) << "Number of cells per axis are " << N[0] << ", " << N[1] << " and " << N[2] << "." << endl;
 
-        // 3. allocate the lists
-        cout << Verbose(2) << "Allocating cells ... " << endl;
-        if (LC != NULL) {
-                cout << Verbose(1) << "ERROR: Linked Cell list is already allocated, I do nothing." << endl;
-                return;
-        }
-        LC = new LinkedAtoms[N[0]*N[1]*N[2]];
-        for (index=0;index<N[0]*N[1]*N[2];index++) {
-                LC [index].clear();
-        }
+  // 3. allocate the lists
+  cout << Verbose(2) << "Allocating cells ... ";
+  if (LC != NULL) {
+    cout << Verbose(1) << "ERROR: Linked Cell list is already allocated, I do nothing." << endl;
+    return;
+  }
+  LC = new LinkedAtoms[N[0]*N[1]*N[2]];
+  for (index=0;index<N[0]*N[1]*N[2];index++) {
+    LC [index].clear();
+  }
+  cout << "done."  << endl;
 
-        // 4. put each atom into its respective cell
-        Walker = mol->start;
-        while (Walker->next != mol->end) {
-                Walker = Walker->next;
-                for (int i=0;i<NDIM;i++) {
-                        n[i] = (int)floor((Walker->x.x[i] - min.x[i])/RADIUS);
-                }
-                index = n[0] * N[1] * N[2] + n[1] * N[2] + n[2];
-                LC[index].push_back(Walker);
-                cout << Verbose(2) << *Walker << " goes into cell " << n[0] << ", " << n[1] << ", " << n[2] << " with No. " << index << "." << endl;
-        }
-        cout << Verbose(1) << "End of LinkedCell" << endl;
+  // 4. put each atom into its respective cell
+  cout << Verbose(2) << "Filling cells ... ";
+  Walker = mol->start;
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    for (int i=0;i<NDIM;i++) {
+      n[i] = (int)floor((Walker->x.x[i] - min.x[i])/RADIUS);
+    }
+    index = n[0] * N[1] * N[2] + n[1] * N[2] + n[2];
+    LC[index].push_back(Walker);
+    //cout << Verbose(2) << *Walker << " goes into cell " << n[0] << ", " << n[1] << ", " << n[2] << " with No. " << index << "." << endl;
+  }
+  cout << "done."  << endl;
+  cout << Verbose(1) << "End of LinkedCell" << endl;
 };
 
@@ -87 +90 @@
 LinkedCell::~LinkedCell()
 {
-        if (LC != NULL)
-        for (index=0;index<N[0]*N[1]*N[2];index++)
-                LC[index].clear();
-        delete[](LC);
-        for(int i=0;i<NDIM;i++)
-                N[i] = 0;
-        index = -1;
-        max.Zero();
-        min.Zero();
+  if (LC != NULL)
+  for (index=0;index<N[0]*N[1]*N[2];index++)
+    LC[index].clear();
+  delete[](LC);
+  for(int i=0;i<NDIM;i++)
+    N[i] = 0;
+  index = -1;
+  max.Zero();
+  min.Zero();
 };
 
@@ -103 +106 @@
 bool LinkedCell::CheckBounds()
 {
-        bool status = true;
-        for(int i=0;i<NDIM;i++)
-                status = status && ((n[i] >=0) && (n[i] < N[i]));
-        if (!status)
-        cerr << "ERROR: indices are out of bounds!" << endl;
-        return status;
+  bool status = true;
+  for(int i=0;i<NDIM;i++)
+    status = status && ((n[i] >=0) && (n[i] < N[i]));
+  if (!status)
+  cerr << "ERROR: indices are out of bounds!" << endl;
+  return status;
 };
 
@@ -117 +120 @@
 LinkedAtoms* LinkedCell::GetCurrentCell()
 {
-        if (CheckBounds()) {
-                index = n[0] * N[1] * N[2] + n[1] * N[2] + n[2];
-                return (&(LC[index]));
-        } else {
-                return NULL;
-        }
+  if (CheckBounds()) {
+    index = n[0] * N[1] * N[2] + n[1] * N[2] + n[2];
+    return (&(LC[index]));
+  } else {
+    return NULL;
+  }
 };
 
@@ -131 +134 @@
 bool LinkedCell::SetIndexToAtom(atom *Walker)
 {
-        bool status = false;
-        for (int i=0;i<NDIM;i++) {
-                n[i] = (int)floor((Walker->x.x[i] - min.x[i])/RADIUS);
-        }
-        index = n[0] * N[1] * N[2] + n[1] * N[2] + n[2];
-        if (CheckBounds()) {
-                for (LinkedAtoms::iterator Runner = LC[index].begin(); Runner != LC[index].end(); Runner++)
-                        status = status || ((*Runner) == Walker);
-                return status;
-        } else {
-                cerr << Verbose(1) << "ERROR: Atom "<< *Walker << " at " << Walker->x << " is out of bounds." << endl;
-                return false;
-        }
+  bool status = false;
+  for (int i=0;i<NDIM;i++) {
+    n[i] = (int)floor((Walker->x.x[i] - min.x[i])/RADIUS);
+  }
+  index = n[0] * N[1] * N[2] + n[1] * N[2] + n[2];
+  if (CheckBounds()) {
+    for (LinkedAtoms::iterator Runner = LC[index].begin(); Runner != LC[index].end(); Runner++)
+      status = status || ((*Runner) == Walker);
+    return status;
+  } else {
+    cerr << Verbose(1) << "ERROR: Atom "<< *Walker << " at " << Walker->x << " is out of bounds." << endl;
+    return false;
+  }
 };
 
@@ -152 +155 @@
 bool LinkedCell::SetIndexToVector(Vector *x)
 {
-        bool status = true;
-        for (int i=0;i<NDIM;i++) {
-                n[i] = (int)floor((x->x[i] - min.x[i])/RADIUS);
-                if (max.x[i] < x->x[i])
-                        status = false;
-                if (min.x[i] > x->x[i])
-                        status = false;
-        }
-        return status;
+  bool status = true;
+  for (int i=0;i<NDIM;i++) {
+    n[i] = (int)floor((x->x[i] - min.x[i])/RADIUS);
+    if (max.x[i] < x->x[i])
+      status = false;
+    if (min.x[i] > x->x[i])
+      status = false;
+  }
+  return status;
 };
 

src/linkedcell.hpp

@@ -12 +12 @@
 
 class LinkedCell{
-        public:
-                Vector max;                      // upper boundary
-                Vector min;                      // lower boundary
-                LinkedAtoms *LC;        // linked cell list
-                double RADIUS;          // cell edge length
-                int N[NDIM];                    // number of cells per axis
-                int n[NDIM];                    // temporary variable for current cell per axis
-                int index;                              // temporary index variable , access by index = n[0] * N[1] * N[2] + n[1] * N[2] + n[2];
+  public:
+    Vector max;       // upper boundary
+    Vector min;       // lower boundary
+    LinkedAtoms *LC;  // linked cell list
+    double RADIUS;    // cell edge length
+    int N[NDIM];      // number of cells per axis
+    int n[NDIM];      // temporary variable for current cell per axis
+    int index;        // temporary index variable , access by index = n[0] * N[1] * N[2] + n[1] * N[2] + n[2];
 
-                LinkedCell();
-                LinkedCell(molecule *mol, double RADIUS);
-                ~LinkedCell();
-                LinkedAtoms* GetCurrentCell();
-                bool SetIndexToAtom(atom *Walker);
-                bool SetIndexToVector(Vector *x);
-                bool CheckBounds();
+    LinkedCell();
+    LinkedCell(molecule *mol, double RADIUS);
+    ~LinkedCell();
+    LinkedAtoms* GetCurrentCell();
+    bool SetIndexToAtom(atom *Walker);
+    bool SetIndexToVector(Vector *x);
+    bool CheckBounds();
 
-                // not implemented yet
-                bool AddAtom(atom *Walker);
-                bool DeleteAtom(atom *Walker);
-                bool MoveAtom(atom *Walker);
+    // not implemented yet
+    bool AddAtom(atom *Walker);
+    bool DeleteAtom(atom *Walker);
+    bool MoveAtom(atom *Walker);
 };
 

src/molecules.cpp

@@ -632 +632 @@
 /** Centers the molecule in the box whose lengths are defined by vector \a *BoxLengths.
  * \param *out output stream for debugging
- * \param *BoxLengths box lengths
- */
-bool molecule::CenterInBox(ofstream *out, Vector *BoxLengths)
+ */
+bool molecule::CenterInBox(ofstream *out)
 {
   bool status = true;
   atom *ptr = NULL;
-  Vector *min = new Vector;
-  Vector *max = new Vector;
-
-  // gather min and max for each axis
+  Vector x;
+  double *M = ReturnFullMatrixforSymmetric(cell_size);
+  double *Minv = x.InverseMatrix(M);
+  double value;
+
+//  cout << "The box matrix is :" << endl;
+//  for (int i=0;i<NDIM;++i) {
+//    for (int j=0;j<NDIM;++j)
+//      cout << M[i*NDIM+j] << "\t";
+//    cout << endl;
+//  }
+//  cout << "And its inverse is :" << endl;
+//  for (int i=0;i<NDIM;++i) {
+//    for (int j=0;j<NDIM;++j)
+//      cout << Minv[i*NDIM+j] << "\t";
+//    cout << endl;
+//  }
+  // go through all atoms
   ptr = start->next;  // start at first in list
-  if (ptr != end) {   //list not empty?
-    for (int i=NDIM;i--;) {
-      max->x[i] = ptr->x.x[i];
-      min->x[i] = ptr->x.x[i];
-    }
+  if (ptr != end) {  //list not empty?
     while (ptr->next != end) {  // continue with second if present
       ptr = ptr->next;
       //ptr->Output(1,1,out);
-      for (int i=NDIM;i--;) {
-        max->x[i] = (max->x[i] < ptr->x.x[i]) ? ptr->x.x[i] : max->x[i];
-        min->x[i] = (min->x[i] > ptr->x.x[i]) ? ptr->x.x[i] : min->x[i];
-      }
-    }
-  }
-  // sanity check
-  for(int i=NDIM;i--;) {
-    if (max->x[i] - min->x[i] > BoxLengths->x[i])
-      status = false;
-  }
-  // warn if check failed
-  if (!status)
-    *out << "WARNING: molecule is bigger than defined box!" << endl;
-  else {  // else center in box
-    max->AddVector(min);
-    max->Scale(-1.);
-    max->AddVector(BoxLengths);
-    max->Scale(0.5);
-    Translate(max);
-    Center.Zero();
-  }
-
-  // free and exit
-  delete(min);
-  delete(max);
+      // multiply its vector with matrix inverse
+      x.CopyVector(&ptr->x);
+      x.MatrixMultiplication(Minv);
+      // truncate to [0,1] for each axis
+      for (int i=0;i<NDIM;i++) {
+        value = floor(x.x[i]);  // next lower integer
+        if (x.x[i] >=0) {
+          x.x[i] -= value;
+        } else {
+          x.x[i] += value+1;
+        }
+      }
+    }
+  }
+  delete(M);
+  delete(Minv);
   return status;
 };
@@ -806 +805 @@
 };
 
+
 /** Centers the center of gravity of the atoms at (0,0,0).
  * \param *out output stream for debugging
@@ -814 +814 @@
   Center.CopyVector(newcenter);
 };
+
 
 /** Scales all atoms by \a *factor.
@@ -844 +845 @@
   }
 };
+
+/** Translate the molecule periodically in the box.
+ * \param trans[] translation vector.
+ */
+void molecule::TranslatePeriodically(const Vector *trans)
+{
+  atom *ptr = NULL;
+  Vector x;
+  double *M = ReturnFullMatrixforSymmetric(cell_size);
+  double *Minv = x.InverseMatrix(M);
+  double value;
+
+  // go through all atoms
+  ptr = start->next;  // start at first in list
+  while (ptr != end) {  // continue with second if present
+    //ptr->Output(1,1,out);
+    // multiply its vector with matrix inverse
+    x.CopyVector(&ptr->x);
+    x.Translate(trans);
+    x.MatrixMultiplication(Minv);
+    // truncate to [0,1] for each axis
+    for (int i=0;i<NDIM;i++) {
+      value = floor(fabs(x.x[i]));  // next lower integer
+      if (x.x[i] >=0) {
+        x.x[i] -= value;
+      } else {
+        x.x[i] += value+1;
+      }
+    }
+    // matrix multiply
+    x.MatrixMultiplication(M);
+    ptr->x.CopyVector(&x);
+    for (int j=0;j<MDSteps;j++) {
+      x.CopyVector(&Trajectories[ptr].R.at(j));
+      x.Translate(trans);
+      x.MatrixMultiplication(Minv);
+      // truncate to [0,1] for each axis
+      for (int i=0;i<NDIM;i++) {
+        value = floor(x.x[i]);  // next lower integer
+        if (x.x[i] >=0) {
+          x.x[i] -= value;
+        } else {
+          x.x[i] += value+1;
+        }
+      }
+      // matrix multiply
+      x.MatrixMultiplication(M);
+      Trajectories[ptr].R.at(j).CopyVector(&x);
+    }
+    ptr = ptr->next;
+  }
+  delete(M);
+  delete(Minv);
+};
+
 
 /** Mirrors all atoms against a given plane.
@@ -873 +929 @@
 
   do {
-    center.Zero();
+    Center.Zero();
     flag = true;
     while (Walker->next != end) {
@@ -900 +956 @@
         Testvector.AddVector(&Translationvector);
         Testvector.MatrixMultiplication(matrix);
-        center.AddVector(&Testvector);
+        Center.AddVector(&Testvector);
         cout << Verbose(1) << "vector is: ";
         Testvector.Output((ofstream *)&cout);
@@ -913 +969 @@
             Testvector.AddVector(&Translationvector);
             Testvector.MatrixMultiplication(matrix);
-            center.AddVector(&Testvector);
+            Center.AddVector(&Testvector);
             cout << Verbose(1) << "Hydrogen vector is: ";
             Testvector.Output((ofstream *)&cout);
@@ -924 +980 @@
   } while (!flag);
   Free((void **)&matrix, "molecule::DetermineCenter: *matrix");
-  center.Scale(1./(double)AtomCount);
+  Center.Scale(1./(double)AtomCount);
 };
 
@@ -937 +993 @@
   Vector *CenterOfGravity = DetermineCenterOfGravity(out);
 
-  CenterAtVector(out, CenterOfGravity);
+  CenterPeriodic(out);
 
   // reset inertia tensor
@@ -2061 +2117 @@
 bool molecule::Output(ofstream *out)
 {
-  element *runner;
   atom *walker = NULL;
-  int ElementNo, AtomNo;
+  int ElementNo[MAX_ELEMENTS], AtomNo[MAX_ELEMENTS];
   CountElements();
 
+  for (int i=0;i<MAX_ELEMENTS;++i) {
+    AtomNo[i] = 0;
+    ElementNo[i] = 0;
+  }
   if (out == NULL) {
     return false;
   } else {
     *out << "#Ion_TypeNr._Nr.R[0]    R[1]    R[2]    MoveType (0 MoveIon, 1 FixedIon)" << endl;
-    ElementNo = 0;
-    runner = elemente->start;
-    while (runner->next != elemente->end) { // go through every element
-      runner = runner->next;
-      if (ElementsInMolecule[runner->Z]) { // if this element got atoms
-        ElementNo++;
-        AtomNo = 0;
-        walker = start;
-        while (walker->next != end) { // go through every atom of this element
-          walker = walker->next;
-          if (walker->type == runner) { // if this atom fits to element
-            AtomNo++;
-            walker->Output(ElementNo, AtomNo, out); // removed due to trajectories
-          }
-        }
-      }
+    walker = start;
+    while (walker->next != end) { // go through every atom of this element
+      walker = walker->next;
+      ElementNo[walker->type->Z] = 1;
+    }
+    int current=1;
+    for (int i=0;i<MAX_ELEMENTS;++i) {
+      if (ElementNo[i] == 1)
+        ElementNo[i] = current++;
+    }
+    walker = start;
+    while (walker->next != end) { // go through every atom of this element
+      walker = walker->next;
+      AtomNo[walker->type->Z]++;
+      walker->Output(ElementNo[walker->type->Z], AtomNo[walker->type->Z], out); // removed due to trajectories
     }
     return true;
@@ -2096 +2154 @@
 bool molecule::OutputTrajectories(ofstream *out)
 {
-  element *runner = NULL;
   atom *walker = NULL;
-  int ElementNo, AtomNo;
+  int ElementNo[MAX_ELEMENTS], AtomNo[MAX_ELEMENTS];
   CountElements();
 
@@ -2110 +2167 @@
         *out << "# ====== MD step " << step << " =========" << endl;
       }
-      ElementNo = 0;
-      runner = elemente->start;
-      while (runner->next != elemente->end) { // go through every element
-        runner = runner->next;
-        if (ElementsInMolecule[runner->Z]) { // if this element got atoms
-          ElementNo++;
-          AtomNo = 0;
-          walker = start;
-          while (walker->next != end) { // go through every atom of this element
-            walker = walker->next;
-            if (walker->type == runner) { // if this atom fits to element
-              AtomNo++;
-              *out << "Ion_Type" << ElementNo << "_" << AtomNo << "\t"  << fixed << setprecision(9) << showpoint;
-              *out << Trajectories[walker].R.at(step).x[0] << "\t" << Trajectories[walker].R.at(step).x[1] << "\t" << Trajectories[walker].R.at(step).x[2];
-              *out << "\t" << walker->FixedIon;
-              if (Trajectories[walker].U.at(step).Norm() > MYEPSILON)
-                *out << "\t" << scientific << setprecision(6) << Trajectories[walker].U.at(step).x[0] << "\t" << Trajectories[walker].U.at(step).x[1] << "\t" << Trajectories[walker].U.at(step).x[2] << "\t";
-              if (Trajectories[walker].F.at(step).Norm() > MYEPSILON)
-                *out << "\t" << scientific << setprecision(6) << Trajectories[walker].F.at(step).x[0] << "\t" << Trajectories[walker].F.at(step).x[1] << "\t" << Trajectories[walker].F.at(step).x[2] << "\t";
-              *out << "\t# Number in molecule " << walker->nr << endl;
-            }
-          }
-        }
+      for (int i=0;i<MAX_ELEMENTS;++i) {
+        AtomNo[i] = 0;
+        ElementNo[i] = 0;
+      }
+    walker = start;
+    while (walker->next != end) { // go through every atom of this element
+      walker = walker->next;
+      ElementNo[walker->type->Z] = 1;
+    }
+    int current=1;
+    for (int i=0;i<MAX_ELEMENTS;++i) {
+      if (ElementNo[i] == 1)
+        ElementNo[i] = current++;
+    }
+    walker = start;
+      while (walker->next != end) { // go through every atom of this element
+        walker = walker->next;
+        AtomNo[walker->type->Z]++;
+        *out << "Ion_Type" << ElementNo[walker->type->Z] << "_" << AtomNo[walker->type->Z] << "\t"  << fixed << setprecision(9) << showpoint;
+        *out << Trajectories[walker].R.at(step).x[0] << "\t" << Trajectories[walker].R.at(step).x[1] << "\t" << Trajectories[walker].R.at(step).x[2];
+        *out << "\t" << walker->FixedIon;
+        if (Trajectories[walker].U.at(step).Norm() > MYEPSILON)
+          *out << "\t" << scientific << setprecision(6) << Trajectories[walker].U.at(step).x[0] << "\t" << Trajectories[walker].U.at(step).x[1] << "\t" << Trajectories[walker].U.at(step).x[2] << "\t";
+        if (Trajectories[walker].F.at(step).Norm() > MYEPSILON)
+          *out << "\t" << scientific << setprecision(6) << Trajectories[walker].F.at(step).x[0] << "\t" << Trajectories[walker].F.at(step).x[1] << "\t" << Trajectories[walker].F.at(step).x[2] << "\t";
+        *out << "\t# Number in molecule " << walker->nr << endl;
       }
     }
@@ -2205 +2265 @@
 {
   atom *walker = NULL;
-  int AtomNo = 0, ElementNo;
+  int AtomNo = 0;
   time_t now;
-  element *runner = NULL;
 
   now = time((time_t *)NULL);   // Get the system time and put it into 'now' as 'calender time'
@@ -2217 +2276 @@
   if (out != NULL) {
     *out << AtomNo << "\n\tCreated by molecuilder on " << ctime(&now);
-    ElementNo = 0;
-    runner = elemente->start;
-    while (runner->next != elemente->end) { // go through every element
-      runner = runner->next;
-      if (ElementsInMolecule[runner->Z]) { // if this element got atoms
-        ElementNo++;
-        walker = start;
-        while (walker->next != end) { // go through every atom of this element
-          walker = walker->next;
-          if (walker->type == runner) { // if this atom fits to element
-            walker->OutputXYZLine(out);
-          }
-        }
-      }
+    walker = start;
+    while (walker->next != end) { // go through every atom of this element
+      walker = walker->next;
+      walker->OutputXYZLine(out);
     }
     return true;
@@ -2451 +2500 @@
   Vector x;
   int FalseBondDegree = 0;
- 
+
   BondDistance = bonddistance; // * ((IsAngstroem) ? 1. : 1./AtomicLengthToAngstroem);
   *out << Verbose(0) << "Begin of CreateAdjacencyList." << endl;
@@ -4946 +4995 @@
   matrix[0] = symm[0];
   matrix[1] = symm[1];
-  matrix[2] = symm[3];
+  matrix[2] = symm[2];
   matrix[3] = symm[1];
-  matrix[4] = symm[2];
+  matrix[4] = symm[3];
   matrix[5] = symm[4];
-  matrix[6] = symm[3];
+  matrix[6] = symm[2];
   matrix[7] = symm[4];
   matrix[8] = symm[5];

src/molecules.hpp

@@ -59 +59 @@
 #define PointPair pair < int, class BoundaryPointSet * >
 #define PointTestPair pair < PointMap::iterator, bool >
-
-#define LineMap map < int, class BoundaryLineSet * >
+#define CandidateList list <class CandidateForTesselation *>
+
+#define LineMap multimap < int, class BoundaryLineSet * >
 #define LinePair pair < int, class BoundaryLineSet * >
 #define LineTestPair pair < LineMap::iterator, bool >
@@ -73 +74 @@
 #define MoleculeList list <molecule *>
 #define MoleculeListTest pair <MoleculeList::iterator, bool>
+
+#define LinkedAtoms list <atom *>
 
 /******************************** Some small functions and/or structures **********************************/
@@ -257 +260 @@
   void CountElements();
   void CalculateOrbitals(class config &configuration);
-  bool CenterInBox(ofstream *out, Vector *BoxLengths);
+  bool CenterInBox(ofstream *out);
   void CenterEdge(ofstream *out, Vector *max);
   void CenterOrigin(ofstream *out);
@@ -263 +266 @@
   void CenterAtVector(ofstream *out, Vector *newcenter);
   void Translate(const Vector *x);
+  void TranslatePeriodically(const Vector *trans);
   void Mirror(const Vector *x);
   void Align(Vector *n);
@@ -403 +407 @@
 };
 
+class ConfigFileBuffer {
+  public:
+    char **buffer;
+    int *LineMapping;
+    int CurrentLine;
+    int NoLines;
+
+    ConfigFileBuffer();
+    ConfigFileBuffer(char *filename);
+    ~ConfigFileBuffer();
+
+    void InitMapping();
+    void MapIonTypesInBuffer(int NoAtoms);
+};
+
+
 /** The config file.
  * The class contains all parameters that control a dft run also functions to load and save.
@@ -422 +442 @@
     string basis;
 
+    char *databasepath;
+
     int DoConstrainedMD;
     int MaxOuterStep;
@@ -433 +455 @@
     int ScaleTempStep;
     
-    private:
+  private:
     char *mainname;
     char *defaultpath;
@@ -486 +508 @@
 
   int ParseForParameter(int verbose, ifstream *file, const char *name, int sequential, int const xth, int const yth, int type, void *value, int repetition, int critical);
+  int ParseForParameter(int verbose, struct ConfigFileBuffer *FileBuffer, const char *name, int sequential, int const xth, int const yth, int type, void *value, int repetition, int critical);
 
   public:

src/parser.cpp

@@ -249 +249 @@
  * \return parsing successful
  */
-bool MatrixContainer::ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns)
+bool MatrixContainer::ParseFragmentMatrix(const char *name, const char *prefix, string suffix, int skiplines, int skipcolumns)
 {
   char filename[1023];
@@ -562 +562 @@
  * \return parsing successful
  */
-bool EnergyMatrix::ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns)
+bool EnergyMatrix::ParseFragmentMatrix(const char *name, const char *prefix, string suffix, int skiplines, int skipcolumns)
 {
   char filename[1024];
@@ -598 +598 @@
  * \return parsing successful
  */
-bool ForceMatrix::ParseIndices(char *name)
+bool ForceMatrix::ParseIndices(const char *name)
 {
   ifstream input;
@@ -676 +676 @@
  * \return parsing successful
  */
-bool ForceMatrix::ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns)
+bool ForceMatrix::ParseFragmentMatrix(const char *name, const char *prefix, string suffix, int skiplines, int skipcolumns)
 {
   char filename[1023];
@@ -902 +902 @@
  * \return parsing successful
  */ 
-bool HessianMatrix::ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns)
+bool HessianMatrix::ParseFragmentMatrix(const char *name, const char *prefix, string suffix, int skiplines, int skipcolumns)
 {
   char filename[1023];

src/parser.hpp

@@ -59 +59 @@
   bool InitialiseIndices(class MatrixContainer *Matrix = NULL);
   bool ParseMatrix(const char *name, int skiplines, int skipcolumns, int MatrixNr);
-  virtual bool ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns);
+  virtual bool ParseFragmentMatrix(const char *name, const char *prefix, string suffix, int skiplines, int skipcolumns);
   bool AllocateMatrix(char **GivenHeader, int MCounter, int *RCounter, int *CCounter);
   bool ResetMatrix();
@@ -79 +79 @@
     bool ParseIndices();
     bool SumSubEnergy(class EnergyMatrix &Fragments, class EnergyMatrix *CorrectionFragments, class KeySetsContainer &KeySet, int Order, double sign);
-    bool ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns);
+    bool ParseFragmentMatrix(const char *name, const char *prefix, string suffix, int skiplines, int skipcolumns);
 };
 
@@ -86 +86 @@
 class ForceMatrix : public MatrixContainer {
   public:
-    bool ParseIndices(char *name);
+    bool ParseIndices(const char *name);
     bool SumSubForces(class ForceMatrix &Fragments, class KeySetsContainer &KeySet, int Order, double sign);
-    bool ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns);
+    bool ParseFragmentMatrix(const char *name, const char *prefix, string suffix, int skiplines, int skipcolumns);
 };
 
@@ -100 +100 @@
     bool SumSubManyBodyTerms(class MatrixContainer &MatrixValues, class KeySetsContainer &KeySet, int Order);
     bool SumSubHessians(class HessianMatrix &Fragments, class KeySetsContainer &KeySet, int Order, double sign);
-    bool ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns);
+    bool ParseFragmentMatrix(const char *name, const char *prefix, string suffix, int skiplines, int skipcolumns);
   private:
     bool IsSymmetric;

src/periodentafel.cpp

@@ -92 +92 @@
  * \return pointer to element
  */
-element * periodentafel::FindElement(char *shorthand) const
+element * periodentafel::FindElement(const char *shorthand) const
 {
   element *walker =  periodentafel::start;
@@ -162 +162 @@
  * \param *path to to standard file names
  */
-bool periodentafel::LoadPeriodentafel(char *path)
+bool periodentafel::LoadPeriodentafel(const char *path)
 {
   ifstream infile;
@@ -301 +301 @@
 /** Stores element list to file.
  */
-bool periodentafel::StorePeriodentafel(char *path) const
+bool periodentafel::StorePeriodentafel(const char *path) const
 {
   bool result = true;

src/periodentafel.hpp

@@ -21 +21 @@
  */
 class element {
-        public:
-                double mass;            //!< mass in g/mol
-                double CovalentRadius;  //!< covalent radius
-                double VanDerWaalsRadius;       //!< can-der-Waals radius
-                int Z;                                  //!< atomic number
-                char name[64];  //!< atom name, i.e. "Hydrogren"
-                char symbol[3]; //!< short form of the atom, i.e. "H"
-                char period[8];         //!< period: n quantum number
-                char group[8];          //!< group: l quantum number
-                char block[8];          //!< block: l quantum number
-                element *previous;      //!< previous item in list
-                element *next;  //!< next element in list
-                int *sort;                      //!< sorc criteria
-                int No;                          //!< number of element set on periodentafel::Output()
-                double Valence;  //!< number of valence electrons for this element
-                int NoValenceOrbitals;  //!< number of valence orbitals, used for determining bond degree in molecule::CreateConnectmatrix()
-                double HBondDistance[NDIM]; //!< distance in Angstrom of this element to hydrogen       (for single, double and triple bonds)
-                double HBondAngle[NDIM];                 //!< typical angle for one, two, three bonded hydrogen (in degrees)
+  public:
+    double mass;    //!< mass in g/mol
+    double CovalentRadius;  //!< covalent radius
+    double VanDerWaalsRadius;  //!< can-der-Waals radius
+    int Z;          //!< atomic number
+    char name[64];  //!< atom name, i.e. "Hydrogren"
+    char symbol[3]; //!< short form of the atom, i.e. "H"
+    char period[8];    //!< period: n quantum number
+    char group[8];    //!< group: l quantum number
+    char block[8];    //!< block: l quantum number
+    element *previous;  //!< previous item in list
+    element *next;  //!< next element in list
+    int *sort;      //!< sorc criteria
+    int No;         //!< number of element set on periodentafel::Output()
+    double Valence;   //!< number of valence electrons for this element
+    int NoValenceOrbitals;  //!< number of valence orbitals, used for determining bond degree in molecule::CreateConnectmatrix()
+    double HBondDistance[NDIM]; //!< distance in Angstrom of this element to hydrogen  (for single, double and triple bonds)
+    double HBondAngle[NDIM];     //!< typical angle for one, two, three bonded hydrogen (in degrees)
 
-        element();
-        ~element();
+  element();
+  ~element();
 
-        //> print element entries to screen
-        bool Output(ofstream *out) const;
-        bool Checkout(ofstream *out, const int No, const int NoOfAtoms) const;
+  //> print element entries to screen
+  bool Output(ofstream *out) const;
+  bool Checkout(ofstream *out, const int No, const int NoOfAtoms) const;
 
-        private:
+  private:
 };
 
@@ -53 +53 @@
  */
 class periodentafel {
-        public:
-                element *start; //!< start of element list
-                element *end;    //!< end of element list
-                char header1[MAXSTRINGSIZE]; //!< store first header line
-                char header2[MAXSTRINGSIZE]; //!< store second header line
+  public:
+    element *start; //!< start of element list
+    element *end;   //!< end of element list
+    char header1[MAXSTRINGSIZE]; //!< store first header line
+    char header2[MAXSTRINGSIZE]; //!< store second header line
 
-        periodentafel();
-        ~periodentafel();
+  periodentafel();
+  ~periodentafel();
 
-        bool AddElement(element *pointer);
-        bool RemoveElement(element *pointer);
-        bool CleanupPeriodtable();
-        element * FindElement(int Z);
-        element * FindElement(char *shorthand) const;
-        element * AskElement();
-        bool Output(ofstream *output) const;
-        bool Checkout(ofstream *output, const int *checkliste) const;
-        bool LoadPeriodentafel(char *path = NULL);
-        bool StorePeriodentafel(char *path = NULL) const;
+  bool AddElement(element *pointer);
+  bool RemoveElement(element *pointer);
+  bool CleanupPeriodtable();
+  element * FindElement(int Z);
+  element * FindElement(const char *shorthand) const;
+  element * AskElement();
+  bool Output(ofstream *output) const;
+  bool Checkout(ofstream *output, const int *checkliste) const;
+  bool LoadPeriodentafel(const char *path);
+  bool StorePeriodentafel(const char *path) const;
 
-        private:
+  private:
 };
 

src/stackclass.hpp

@@ -10 +10 @@
  */
 template <typename T> class StackClass {
-        public:
-        StackClass<T>(int dimension);
-        ~StackClass<T>();
-
-        bool Push(T object);
-        T PopFirst();
-        T PopLast();
-        bool RemoveItem(T ptr);
-        void ClearStack();
-        bool IsEmpty();
-        bool IsFull();
-        int ItemCount();
-        void Output(ofstream *out) const;
-        void TestImplementation(ofstream *out, T test);
-
-        private:
-                T *StackList;    //!< the list containing the atom pointers
-                int EntryCount;          //!< number of entries in the stack
-                int CurrentLastEntry;    //!< Current last entry (newest item on stack)
-                int CurrentFirstEntry;   //!< Current first entry (oldest item on stack)
-                int NextFreeField;                       //!< Current index of next free field
+  public:
+  StackClass<T>(int dimension);
+  ~StackClass<T>();
+
+  bool Push(T object);
+  T PopFirst();
+  T PopLast();
+  bool RemoveItem(T ptr);
+  void ClearStack();
+  bool IsEmpty();
+  bool IsFull();
+  int ItemCount();
+  void Output(ofstream *out) const;
+  void TestImplementation(ofstream *out, T test);
+
+  private:
+    T *StackList;   //!< the list containing the atom pointers
+    int EntryCount;     //!< number of entries in the stack
+    int CurrentLastEntry;   //!< Current last entry (newest item on stack)
+    int CurrentFirstEntry;   //!< Current first entry (oldest item on stack)
+    int NextFreeField;       //!< Current index of next free field
 };
 
@@ -37 +37 @@
 template <typename T> StackClass<T>::StackClass(int dimension)
 {
-        CurrentLastEntry = 0;
-        CurrentFirstEntry = 0;
-        NextFreeField = 0;
-        EntryCount = dimension;
-        StackList = (T *) Malloc(sizeof(T)*EntryCount, "StackClass::StackClass: **StackList");
+  CurrentLastEntry = 0;
+  CurrentFirstEntry = 0;
+  NextFreeField = 0;
+  EntryCount = dimension;
+  StackList = (T *) Malloc(sizeof(T)*EntryCount, "StackClass::StackClass: **StackList");
 };
 
@@ -48 +48 @@
 template <typename T> StackClass<T>::~StackClass()
 {
-        Free((void **)&StackList, "StackClass::StackClass: **StackList");
+  Free((void **)&StackList, "StackClass::StackClass: **StackList");
 };
 
@@ -57 +57 @@
 template <typename T> bool StackClass<T>::Push(T object)
 {
-        if (!IsFull()) {                // check whether free field is really not occupied
-                StackList[NextFreeField] = object;
-                CurrentLastEntry = NextFreeField;
-                NextFreeField = (NextFreeField + 1) % EntryCount; // step on to next free field
-                return true;
-        } else {
-                cerr << "ERROR: Stack is full, " << "Stack: CurrentLastEntry " << CurrentLastEntry<< "\tCurrentFirstEntry " << CurrentFirstEntry << "\tNextFreeField " << NextFreeField << "\tEntryCount " << EntryCount << "!" << endl;
-                return false;
-        }
+  if (!IsFull()) {    // check whether free field is really not occupied
+    StackList[NextFreeField] = object;
+    CurrentLastEntry = NextFreeField;
+    NextFreeField = (NextFreeField + 1) % EntryCount; // step on to next free field
+    return true;
+  } else {
+    cerr << "ERROR: Stack is full, " << "Stack: CurrentLastEntry " << CurrentLastEntry<< "\tCurrentFirstEntry " << CurrentFirstEntry << "\tNextFreeField " << NextFreeField << "\tEntryCount " << EntryCount << "!" << endl;
+    return false;
+  }
 };
 
@@ -74 +74 @@
 template <typename T> T StackClass<T>::PopFirst()
 {
-        T Walker = NULL;
-        if (!IsEmpty()) {
-                Walker = StackList[CurrentFirstEntry];
-                if (Walker == NULL)
-                        cerr << "ERROR: Stack's field is empty!" << endl;
-                StackList[CurrentFirstEntry] = NULL;
-                if (CurrentFirstEntry != CurrentLastEntry) { // hasn't last item been popped as well?
-                        CurrentFirstEntry = (CurrentFirstEntry + 1) % EntryCount; // step back from current free field to last used (somehow modulo does not work in -1)
-                } else {
-                        CurrentFirstEntry = (CurrentFirstEntry + 1) % EntryCount; // step back from current free field to last used (somehow modulo does not work in -1)
-                        CurrentLastEntry = CurrentFirstEntry;
-                }
-        } else
-                cerr << "ERROR: Stack is empty!" << endl;
-        return Walker;
+  T Walker = NULL;
+  if (!IsEmpty()) {
+    Walker = StackList[CurrentFirstEntry];
+    if (Walker == NULL)
+      cerr << "ERROR: Stack's field is empty!" << endl;
+    StackList[CurrentFirstEntry] = NULL;
+    if (CurrentFirstEntry != CurrentLastEntry) { // hasn't last item been popped as well?
+      CurrentFirstEntry = (CurrentFirstEntry + 1) % EntryCount; // step back from current free field to last used (somehow modulo does not work in -1)
+    } else {
+      CurrentFirstEntry = (CurrentFirstEntry + 1) % EntryCount; // step back from current free field to last used (somehow modulo does not work in -1)
+      CurrentLastEntry = CurrentFirstEntry;
+    }
+  } else
+    cerr << "ERROR: Stack is empty!" << endl;
+  return Walker;
 };
 
@@ -97 +97 @@
 template <typename T> T StackClass<T>::PopLast()
 {
-        T Walker = NULL;
-        if (!IsEmpty()) {
-                Walker = StackList[CurrentLastEntry];
-                StackList[CurrentLastEntry] = NULL;
-                if (Walker == NULL)
-                        cerr << "ERROR: Stack's field is empty!" << endl;
-                NextFreeField = CurrentLastEntry;
-                if (CurrentLastEntry != CurrentFirstEntry)      // has there been more than one item on stack
-                        CurrentLastEntry = (CurrentLastEntry + (EntryCount-1)) % EntryCount; // step back from current free field to last (modulo does not work in -1, thus go EntryCount-1 instead)
-        } else {
-                cerr << "ERROR: Stack is empty!" << endl;
-        }
-        return Walker;
+  T Walker = NULL;
+  if (!IsEmpty()) {
+    Walker = StackList[CurrentLastEntry];
+    StackList[CurrentLastEntry] = NULL;
+    if (Walker == NULL)
+      cerr << "ERROR: Stack's field is empty!" << endl;
+    NextFreeField = CurrentLastEntry;
+    if (CurrentLastEntry != CurrentFirstEntry)  // has there been more than one item on stack
+      CurrentLastEntry = (CurrentLastEntry + (EntryCount-1)) % EntryCount; // step back from current free field to last (modulo does not work in -1, thus go EntryCount-1 instead)
+  } else {
+    cerr << "ERROR: Stack is empty!" << endl;
+  }
+  return Walker;
 };
 
@@ -120 +120 @@
 template <typename T> bool StackClass<T>::RemoveItem(T ptr)
 {
-        bool found = false;
-        cout << Verbose(5) << "First " << CurrentFirstEntry<< "\tLast " << CurrentLastEntry<< "\tNext " << NextFreeField<< "\tCount " << EntryCount<< "." << endl;
-        int i=CurrentFirstEntry;
-        if (!IsEmpty())
-                do {
-                        if (StackList[i] == ptr) {      // if item found, remove
-                                cout << Verbose(5) << "Item " << *ptr << " was number " << i << " on stack, removing it." << endl;
-                                found = true;
-                                StackList[i] = NULL;
-                        }
-                        if ((found) && (StackList[i] != NULL)) {        // means we have to shift (and not the removed item)
-                                if (i == 0) { // we are down to first item in stack, have to put onto last item
-                                        cout << Verbose(5) << "Shifting item 0 to place " << EntryCount-1 << "." << endl;
-                                        StackList[EntryCount-1] = StackList[0];
-                                } else {
-                                        cout << Verbose(5) << "Shifting item " << i << " to place " << i-1 << "." << endl;
-                                        StackList[i-1] = StackList[i];
-                                }
-                        }
-                        i=((i + 1) % EntryCount); // step on
-                } while (i!=NextFreeField);
-        else
-                cerr << "ERROR: Stack is already empty!" << endl;
-        if (found) {
-                NextFreeField = CurrentLastEntry;
-                if (CurrentLastEntry != CurrentFirstEntry)      // has there been more than one item on stack
-                        CurrentLastEntry = (CurrentLastEntry + (EntryCount-1)) % EntryCount;
-        }
-        return found;
+  bool found = false;
+  cout << Verbose(5) << "First " << CurrentFirstEntry<< "\tLast " << CurrentLastEntry<< "\tNext " << NextFreeField<< "\tCount " << EntryCount<< "." << endl;
+  int i=CurrentFirstEntry;
+  if (!IsEmpty())
+    do {
+      if (StackList[i] == ptr) {  // if item found, remove
+        cout << Verbose(5) << "Item " << *ptr << " was number " << i << " on stack, removing it." << endl;
+        found = true;
+        StackList[i] = NULL;
+      }
+      if ((found) && (StackList[i] != NULL)) {  // means we have to shift (and not the removed item)
+        if (i == 0) { // we are down to first item in stack, have to put onto last item
+          cout << Verbose(5) << "Shifting item 0 to place " << EntryCount-1 << "." << endl;
+          StackList[EntryCount-1] = StackList[0];
+        } else {
+          cout << Verbose(5) << "Shifting item " << i << " to place " << i-1 << "." << endl;
+          StackList[i-1] = StackList[i];
+        }
+      }
+      i=((i + 1) % EntryCount); // step on
+    } while (i!=NextFreeField);
+  else
+    cerr << "ERROR: Stack is already empty!" << endl;
+  if (found) {
+    NextFreeField = CurrentLastEntry;
+    if (CurrentLastEntry != CurrentFirstEntry)  // has there been more than one item on stack
+      CurrentLastEntry = (CurrentLastEntry + (EntryCount-1)) % EntryCount;
+  }
+  return found;
 };
 
@@ -158 +158 @@
 template <typename T> void StackClass<T>::TestImplementation(ofstream *out, T test)
 {
-        T Walker = test;
-        *out << Verbose(1) << "Testing the snake stack..." << endl;
-        for (int i=0;i<EntryCount;i++) {
-                *out << Verbose(2) << "Filling " << i << "th element of stack." << endl;
-                Push(Walker);
-                Walker=Walker->next;
-        }
-        *out << endl;
-        Output(out);
-        if (IsFull())
-                *out << "Stack is full as supposed to be!" << endl;
-        else
-                *out << "ERROR: Stack is not as full as supposed to be!" << endl;
-        //if (StackList[(EntryCount+1)/2] != NULL) {
-                *out << "Removing element in the middle ..." << endl;
-                RemoveItem(StackList[(EntryCount+1)/2]);
-                Output(out);
-        //}
-        //if (StackList[CurrentFirstEntry] != NULL) {
-                *out << "Removing first element ..." << endl;
-                RemoveItem(StackList[CurrentFirstEntry]);
-                Output(out);
-        //}
-        //if (StackList[CurrentLastEntry] != NULL) {
-                *out << "Removing last element ..." << endl;
-                RemoveItem(StackList[CurrentLastEntry]);
-                Output(out);
-        //}
-        *out << "Clearing stack ... " << endl;
-        ClearStack();
-        Output(out);
-        if (IsEmpty())
-                *out << "Stack is empty as supposed to be!" << endl;
-        else
-                *out << "ERROR: Stack is not as empty as supposed to be!" << endl;
-        *out << "done." << endl;
+  T Walker = test;
+  *out << Verbose(1) << "Testing the snake stack..." << endl;
+  for (int i=0;i<EntryCount;i++) {
+    *out << Verbose(2) << "Filling " << i << "th element of stack." << endl;
+    Push(Walker);
+    Walker=Walker->next;
+  }
+  *out << endl;
+  Output(out);
+  if (IsFull())
+    *out << "Stack is full as supposed to be!" << endl;
+  else
+    *out << "ERROR: Stack is not as full as supposed to be!" << endl;
+  //if (StackList[(EntryCount+1)/2] != NULL) {
+    *out << "Removing element in the middle ..." << endl;
+    RemoveItem(StackList[(EntryCount+1)/2]);
+    Output(out);
+  //}
+  //if (StackList[CurrentFirstEntry] != NULL) {
+    *out << "Removing first element  ..." << endl;
+    RemoveItem(StackList[CurrentFirstEntry]);
+    Output(out);
+  //}
+  //if (StackList[CurrentLastEntry] != NULL) {
+    *out << "Removing last element ..." << endl;
+    RemoveItem(StackList[CurrentLastEntry]);
+    Output(out);
+  //}
+  *out << "Clearing stack ... " << endl;
+  ClearStack();
+  Output(out);
+  if (IsEmpty())
+    *out << "Stack is empty as supposed to be!" << endl;
+  else
+    *out << "ERROR: Stack is not as empty as supposed to be!" << endl;
+  *out << "done." << endl;
 };
 
@@ -201 +201 @@
 template <typename T> void StackClass<T>::Output(ofstream *out) const
 {
-        *out << "Contents of Stack: ";
-        for(int i=0;i<EntryCount;i++) {
-                *out << "\t";
-                if (i == CurrentFirstEntry)
-                        *out << " 1";
-                if      (i == CurrentLastEntry)
-                        *out << " "<< EntryCount;
-                if (i ==        NextFreeField)
-                        *out << " F";
-                *out << ": " << StackList[i];
-        }
-        *out << endl;
+  *out << "Contents of Stack: ";
+  for(int i=0;i<EntryCount;i++) {
+    *out << "\t";
+    if (i == CurrentFirstEntry)
+      *out << " 1";
+    if  (i == CurrentLastEntry)
+      *out << " "<< EntryCount;
+    if (i ==  NextFreeField)
+      *out << " F";
+    *out << ": " << StackList[i];
+  }
+  *out << endl;
 };
 
@@ -222 +222 @@
 template <typename T> bool StackClass<T>::IsEmpty()
 {
-        return((NextFreeField == CurrentFirstEntry) && (CurrentLastEntry == CurrentFirstEntry));
+  return((NextFreeField == CurrentFirstEntry) && (CurrentLastEntry == CurrentFirstEntry));
 };
 
@@ -232 +232 @@
 template <typename T> bool StackClass<T>::IsFull()
 {
-        return((NextFreeField == CurrentFirstEntry) && (CurrentLastEntry != CurrentFirstEntry));
+  return((NextFreeField == CurrentFirstEntry) && (CurrentLastEntry != CurrentFirstEntry));
 };
 
@@ -242 +242 @@
 template <typename T> int StackClass<T>::ItemCount()
 {
-        //cout << "Stack: CurrentLastEntry " << CurrentLastEntry<< "\tCurrentFirstEntry " << CurrentFirstEntry << "\tEntryCount " << EntryCount << "." << endl;
-        return((NextFreeField + (EntryCount - CurrentFirstEntry)) % EntryCount);
+  //cout << "Stack: CurrentLastEntry " << CurrentLastEntry<< "\tCurrentFirstEntry " << CurrentFirstEntry << "\tEntryCount " << EntryCount << "." << endl;
+  return((NextFreeField + (EntryCount - CurrentFirstEntry)) % EntryCount);
 };
 
@@ -251 +251 @@
 template <typename T> void StackClass<T>::ClearStack()
 {
-        for(int i=EntryCount; i--;)
-                StackList[i] = NULL;
-        CurrentFirstEntry = 0;
-        CurrentLastEntry = 0;
-        NextFreeField = 0;
+  for(int i=EntryCount; i--;)
+    StackList[i] = NULL;
+  CurrentFirstEntry = 0;
+  CurrentLastEntry = 0;
+  NextFreeField = 0;
 };
 

src/vector.cpp

@@ -28 +28 @@
 double Vector::DistanceSquared(const Vector *y) const
 {
-        double res = 0.;
-        for (int i=NDIM;i--;)
-                res += (x[i]-y->x[i])*(x[i]-y->x[i]);
-        return (res);
+  double res = 0.;
+  for (int i=NDIM;i--;)
+    res += (x[i]-y->x[i])*(x[i]-y->x[i]);
+  return (res);
 };
 
@@ -40 +40 @@
 double Vector::Distance(const Vector *y) const
 {
-        double res = 0.;
-        for (int i=NDIM;i--;)
-                res += (x[i]-y->x[i])*(x[i]-y->x[i]);
-        return (sqrt(res));
+  double res = 0.;
+  for (int i=NDIM;i--;)
+    res += (x[i]-y->x[i])*(x[i]-y->x[i]);
+  return (sqrt(res));
 };
 
@@ -53 +53 @@
 double Vector::PeriodicDistance(const Vector *y, const double *cell_size) const
 {
-        double res = Distance(y), tmp, matrix[NDIM*NDIM];
-        Vector Shiftedy, TranslationVector;
-        int N[NDIM];
-        matrix[0] = cell_size[0];
-        matrix[1] = cell_size[1];
-        matrix[2] = cell_size[3];
-        matrix[3] = cell_size[1];
-        matrix[4] = cell_size[2];
-        matrix[5] = cell_size[4];
-        matrix[6] = cell_size[3];
-        matrix[7] = cell_size[4];
-        matrix[8] = cell_size[5];
-        // in order to check the periodic distance, translate one of the vectors into each of the 27 neighbouring cells
-        for (N[0]=-1;N[0]<=1;N[0]++)
-                for (N[1]=-1;N[1]<=1;N[1]++)
-                        for (N[2]=-1;N[2]<=1;N[2]++) {
-                                // create the translation vector
-                                TranslationVector.Zero();
-                                for (int i=NDIM;i--;)
-                                        TranslationVector.x[i] = (double)N[i];
-                                TranslationVector.MatrixMultiplication(matrix);
-                                // add onto the original vector to compare with
-                                Shiftedy.CopyVector(y);
-                                Shiftedy.AddVector(&TranslationVector);
-                                // get distance and compare with minimum so far
-                                tmp = Distance(&Shiftedy);
-                                if (tmp < res) res = tmp;
-                        }
-        return (res);
+  double res = Distance(y), tmp, matrix[NDIM*NDIM];
+  Vector Shiftedy, TranslationVector;
+  int N[NDIM];
+  matrix[0] = cell_size[0];
+  matrix[1] = cell_size[1];
+  matrix[2] = cell_size[3];
+  matrix[3] = cell_size[1];
+  matrix[4] = cell_size[2];
+  matrix[5] = cell_size[4];
+  matrix[6] = cell_size[3];
+  matrix[7] = cell_size[4];
+  matrix[8] = cell_size[5];
+  // in order to check the periodic distance, translate one of the vectors into each of the 27 neighbouring cells
+  for (N[0]=-1;N[0]<=1;N[0]++)
+    for (N[1]=-1;N[1]<=1;N[1]++)
+      for (N[2]=-1;N[2]<=1;N[2]++) {
+        // create the translation vector
+        TranslationVector.Zero();
+        for (int i=NDIM;i--;)
+          TranslationVector.x[i] = (double)N[i];
+        TranslationVector.MatrixMultiplication(matrix);
+        // add onto the original vector to compare with
+        Shiftedy.CopyVector(y);
+        Shiftedy.AddVector(&TranslationVector);
+        // get distance and compare with minimum so far
+        tmp = Distance(&Shiftedy);
+        if (tmp < res) res = tmp;
+      }
+  return (res);
 };
 
@@ -91 +91 @@
 double Vector::PeriodicDistanceSquared(const Vector *y, const double *cell_size) const
 {
-        double res = DistanceSquared(y), tmp, matrix[NDIM*NDIM];
-        Vector Shiftedy, TranslationVector;
-        int N[NDIM];
-        matrix[0] = cell_size[0];
-        matrix[1] = cell_size[1];
-        matrix[2] = cell_size[3];
-        matrix[3] = cell_size[1];
-        matrix[4] = cell_size[2];
-        matrix[5] = cell_size[4];
-        matrix[6] = cell_size[3];
-        matrix[7] = cell_size[4];
-        matrix[8] = cell_size[5];
-        // in order to check the periodic distance, translate one of the vectors into each of the 27 neighbouring cells
-        for (N[0]=-1;N[0]<=1;N[0]++)
-                for (N[1]=-1;N[1]<=1;N[1]++)
-                        for (N[2]=-1;N[2]<=1;N[2]++) {
-                                // create the translation vector
-                                TranslationVector.Zero();
-                                for (int i=NDIM;i--;)
-                                        TranslationVector.x[i] = (double)N[i];
-                                TranslationVector.MatrixMultiplication(matrix);
-                                // add onto the original vector to compare with
-                                Shiftedy.CopyVector(y);
-                                Shiftedy.AddVector(&TranslationVector);
-                                // get distance and compare with minimum so far
-                                tmp = DistanceSquared(&Shiftedy);
-                                if (tmp < res) res = tmp;
-                        }
-        return (res);
+  double res = DistanceSquared(y), tmp, matrix[NDIM*NDIM];
+  Vector Shiftedy, TranslationVector;
+  int N[NDIM];
+  matrix[0] = cell_size[0];
+  matrix[1] = cell_size[1];
+  matrix[2] = cell_size[3];
+  matrix[3] = cell_size[1];
+  matrix[4] = cell_size[2];
+  matrix[5] = cell_size[4];
+  matrix[6] = cell_size[3];
+  matrix[7] = cell_size[4];
+  matrix[8] = cell_size[5];
+  // in order to check the periodic distance, translate one of the vectors into each of the 27 neighbouring cells
+  for (N[0]=-1;N[0]<=1;N[0]++)
+    for (N[1]=-1;N[1]<=1;N[1]++)
+      for (N[2]=-1;N[2]<=1;N[2]++) {
+        // create the translation vector
+        TranslationVector.Zero();
+        for (int i=NDIM;i--;)
+          TranslationVector.x[i] = (double)N[i];
+        TranslationVector.MatrixMultiplication(matrix);
+        // add onto the original vector to compare with
+        Shiftedy.CopyVector(y);
+        Shiftedy.AddVector(&TranslationVector);
+        // get distance and compare with minimum so far
+        tmp = DistanceSquared(&Shiftedy);
+        if (tmp < res) res = tmp;
+      }
+  return (res);
 };
 
@@ -128 +128 @@
 void Vector::KeepPeriodic(ofstream *out, double *matrix)
 {
-//      int N[NDIM];
-//      bool flag = false;
-        //vector Shifted, TranslationVector;
-        Vector TestVector;
-//      *out << Verbose(1) << "Begin of KeepPeriodic." << endl;
-//      *out << Verbose(2) << "Vector is: ";
-//      Output(out);
-//      *out << endl;
-        TestVector.CopyVector(this);
-        TestVector.InverseMatrixMultiplication(matrix);
-        for(int i=NDIM;i--;) { // correct periodically
-                if (TestVector.x[i] < 0) {      // get every coefficient into the interval [0,1)
-                        TestVector.x[i] += ceil(TestVector.x[i]);
-                } else {
-                        TestVector.x[i] -= floor(TestVector.x[i]);
-                }
-        }
-        TestVector.MatrixMultiplication(matrix);
-        CopyVector(&TestVector);
-//      *out << Verbose(2) << "New corrected vector is: ";
-//      Output(out);
-//      *out << endl;
-//      *out << Verbose(1) << "End of KeepPeriodic." << endl;
+//  int N[NDIM];
+//  bool flag = false;
+  //vector Shifted, TranslationVector;
+  Vector TestVector;
+//  *out << Verbose(1) << "Begin of KeepPeriodic." << endl;
+//  *out << Verbose(2) << "Vector is: ";
+//  Output(out);
+//  *out << endl;
+  TestVector.CopyVector(this);
+  TestVector.InverseMatrixMultiplication(matrix);
+  for(int i=NDIM;i--;) { // correct periodically
+    if (TestVector.x[i] < 0) {  // get every coefficient into the interval [0,1)
+      TestVector.x[i] += ceil(TestVector.x[i]);
+    } else {
+      TestVector.x[i] -= floor(TestVector.x[i]);
+    }
+  }
+  TestVector.MatrixMultiplication(matrix);
+  CopyVector(&TestVector);
+//  *out << Verbose(2) << "New corrected vector is: ";
+//  Output(out);
+//  *out << endl;
+//  *out << Verbose(1) << "End of KeepPeriodic." << endl;
 };
 
@@ -159 +159 @@
 double Vector::ScalarProduct(const Vector *y) const
 {
-        double res = 0.;
-        for (int i=NDIM;i--;)
-                res += x[i]*y->x[i];
-        return (res);
+  double res = 0.;
+  for (int i=NDIM;i--;)
+    res += x[i]*y->x[i];
+  return (res);
 };
 
 
 /** Calculates VectorProduct between this and another vector.
- *      -# returns the Product in place of vector from which it was initiated
- *      -# ATTENTION: Only three dim.
- *      \param *y array to vector with which to calculate crossproduct
- *      \return \f$ x \times y \f&
+ *  -# returns the Product in place of vector from which it was initiated
+ *  -# ATTENTION: Only three dim.
+ *  \param *y array to vector with which to calculate crossproduct
+ *  \return \f$ x \times y \f&
  */
 void Vector::VectorProduct(const Vector *y)
 {
-        Vector tmp;
-        tmp.x[0] = x[1]* (y->x[2]) - x[2]* (y->x[1]);
-        tmp.x[1] = x[2]* (y->x[0]) - x[0]* (y->x[2]);
-        tmp.x[2] = x[0]* (y->x[1]) - x[1]* (y->x[0]);
-        this->CopyVector(&tmp);
+  Vector tmp;
+  tmp.x[0] = x[1]* (y->x[2]) - x[2]* (y->x[1]);
+  tmp.x[1] = x[2]* (y->x[0]) - x[0]* (y->x[2]);
+  tmp.x[2] = x[0]* (y->x[1]) - x[1]* (y->x[0]);
+  this->CopyVector(&tmp);
 
 };
@@ -189 +189 @@
 void Vector::ProjectOntoPlane(const Vector *y)
 {
-        Vector tmp;
-        tmp.CopyVector(y);
-        tmp.Normalize();
-        tmp.Scale(ScalarProduct(&tmp));
-        this->SubtractVector(&tmp);
+  Vector tmp;
+  tmp.CopyVector(y);
+  tmp.Normalize();
+  tmp.Scale(ScalarProduct(&tmp));
+  this->SubtractVector(&tmp);
 };
 
@@ -202 +202 @@
 double Vector::Projection(const Vector *y) const
 {
-        return (ScalarProduct(y));
+  return (ScalarProduct(y));
 };
 
@@ -210 +210 @@
 double Vector::Norm() const
 {
-        double res = 0.;
-        for (int i=NDIM;i--;)
-                res += this->x[i]*this->x[i];
-        return (sqrt(res));
+  double res = 0.;
+  for (int i=NDIM;i--;)
+    res += this->x[i]*this->x[i];
+  return (sqrt(res));
 };
 
@@ -220 +220 @@
 void Vector::Normalize()
 {
-        double res = 0.;
-        for (int i=NDIM;i--;)
-                res += this->x[i]*this->x[i];
-        if (fabs(res) > MYEPSILON)
-                res = 1./sqrt(res);
-        Scale(&res);
+  double res = 0.;
+  for (int i=NDIM;i--;)
+    res += this->x[i]*this->x[i];
+  if (fabs(res) > MYEPSILON)
+    res = 1./sqrt(res);
+  Scale(&res);
 };
 
@@ -232 +232 @@
 void Vector::Zero()
 {
-        for (int i=NDIM;i--;)
-                this->x[i] = 0.;
+  for (int i=NDIM;i--;)
+    this->x[i] = 0.;
 };
 
@@ -240 +240 @@
 void Vector::One(double one)
 {
-        for (int i=NDIM;i--;)
-                this->x[i] = one;
+  for (int i=NDIM;i--;)
+    this->x[i] = one;
 };
 
@@ -248 +248 @@
 void Vector::Init(double x1, double x2, double x3)
 {
-        x[0] = x1;
-        x[1] = x2;
-        x[2] = x3;
+  x[0] = x1;
+  x[1] = x2;
+  x[2] = x3;
 };
 
@@ -259 +259 @@
 double Vector::Angle(const Vector *y) const
 {
-        return acos(this->ScalarProduct(y)/Norm()/y->Norm());
+  double angle = this->ScalarProduct(y)/Norm()/y->Norm();
+  // -1-MYEPSILON occured due to numerical imprecision, catch ...
+  //cout << Verbose(2) << "INFO: acos(-1) = " << acos(-1) << ", acos(-1+MYEPSILON) = " << acos(-1+MYEPSILON) << ", acos(-1-MYEPSILON) = " << acos(-1-MYEPSILON) << "." << endl;
+  if (angle < -1)
+    angle = -1;
+  if (angle > 1)
+    angle = 1;
+  return acos(angle);
 };
 
@@ -268 +275 @@
 void Vector::RotateVector(const Vector *axis, const double alpha)
 {
-        Vector a,y;
-        // normalise this vector with respect to axis
-        a.CopyVector(this);
-        a.Scale(Projection(axis));
-        SubtractVector(&a);
-        // construct normal vector
-        y.MakeNormalVector(axis,this);
-        y.Scale(Norm());
-        // scale normal vector by sine and this vector by cosine
-        y.Scale(sin(alpha));
-        Scale(cos(alpha));
-        // add scaled normal vector onto this vector
-        AddVector(&y);
-        // add part in axis direction
-        AddVector(&a);
+  Vector a,y;
+  // normalise this vector with respect to axis
+  a.CopyVector(this);
+  a.Scale(Projection(axis));
+  SubtractVector(&a);
+  // construct normal vector
+  y.MakeNormalVector(axis,this);
+  y.Scale(Norm());
+  // scale normal vector by sine and this vector by cosine
+  y.Scale(sin(alpha));
+  Scale(cos(alpha));
+  // add scaled normal vector onto this vector
+  AddVector(&y);
+  // add part in axis direction
+  AddVector(&a);
 };
 
@@ -292 +299 @@
 Vector& operator+=(Vector& a, const Vector& b)
 {
-        a.AddVector(&b);
-        return a;
+  a.AddVector(&b);
+  return a;
 };
 /** factor each component of \a a times a double \a m.
@@ -302 +309 @@
 Vector& operator*=(Vector& a, const double m)
 {
-        a.Scale(m);
-        return a;
-};
-
-/** Sums two vectors \a and \b component-wise.
+  a.Scale(m);
+  return a;
+};
+
+/** Sums two vectors \a  and \b component-wise.
  * \param a first vector
  * \param b second vector
@@ -313 +320 @@
 Vector& operator+(const Vector& a, const Vector& b)
 {
-        Vector *x = new Vector;
-        x->CopyVector(&a);
-        x->AddVector(&b);
-        return *x;
+  Vector *x = new Vector;
+  x->CopyVector(&a);
+  x->AddVector(&b);
+  return *x;
 };
 
@@ -326 +333 @@
 Vector& operator*(const Vector& a, const double m)
 {
-        Vector *x = new Vector;
-        x->CopyVector(&a);
-        x->Scale(m);
-        return *x;
+  Vector *x = new Vector;
+  x->CopyVector(&a);
+  x->Scale(m);
+  return *x;
 };
 
@@ -338 +345 @@
 bool Vector::Output(ofstream *out) const
 {
-        if (out != NULL) {
-                *out << "(";
-                for (int i=0;i<NDIM;i++) {
-                        *out << x[i];
-                        if (i != 2)
-                                *out << ",";
-                }
-                *out << ")";
-                return true;
-        } else
-                return false;
+  if (out != NULL) {
+    *out << "(";
+    for (int i=0;i<NDIM;i++) {
+      *out << x[i];
+      if (i != 2)
+        *out << ",";
+    }
+    *out << ")";
+    return true;
+  } else
+    return false;
 };
 
 ostream& operator<<(ostream& ost,Vector& m)
 {
-        ost << "(";
-        for (int i=0;i<NDIM;i++) {
-                ost << m.x[i];
-                if (i != 2)
-                        ost << ",";
-        }
-        ost << ")";
-        return ost;
+  ost << "(";
+  for (int i=0;i<NDIM;i++) {
+    ost << m.x[i];
+    if (i != 2)
+      ost << ",";
+  }
+  ost << ")";
+  return ost;
 };
 
@@ -368 +375 @@
 void Vector::Scale(double **factor)
 {
-        for (int i=NDIM;i--;)
-                x[i] *= (*factor)[i];
+  for (int i=NDIM;i--;)
+    x[i] *= (*factor)[i];
 };
 
 void Vector::Scale(double *factor)
 {
-        for (int i=NDIM;i--;)
-                x[i] *= *factor;
+  for (int i=NDIM;i--;)
+    x[i] *= *factor;
 };
 
 void Vector::Scale(double factor)
 {
-        for (int i=NDIM;i--;)
-                x[i] *= factor;
+  for (int i=NDIM;i--;)
+    x[i] *= factor;
 };
 
@@ -389 +396 @@
 void Vector::Translate(const Vector *trans)
 {
-        for (int i=NDIM;i--;)
-                x[i] += trans->x[i];
+  for (int i=NDIM;i--;)
+    x[i] += trans->x[i];
 };
 
@@ -398 +405 @@
 void Vector::MatrixMultiplication(double *M)
 {
-        Vector C;
-        // do the matrix multiplication
-        C.x[0] = M[0]*x[0]+M[3]*x[1]+M[6]*x[2];
-        C.x[1] = M[1]*x[0]+M[4]*x[1]+M[7]*x[2];
-        C.x[2] = M[2]*x[0]+M[5]*x[1]+M[8]*x[2];
-        // transfer the result into this
-        for (int i=NDIM;i--;)
-                x[i] = C.x[i];
+  Vector C;
+  // do the matrix multiplication
+  C.x[0] = M[0]*x[0]+M[3]*x[1]+M[6]*x[2];
+  C.x[1] = M[1]*x[0]+M[4]*x[1]+M[7]*x[2];
+  C.x[2] = M[2]*x[0]+M[5]*x[1]+M[8]*x[2];
+  // transfer the result into this
+  for (int i=NDIM;i--;)
+    x[i] = C.x[i];
+};
+
+/** Calculate the inverse of a 3x3 matrix.
+ * \param *matrix NDIM_NDIM array
+ */
+double * Vector::InverseMatrix(double *A)
+{
+  double *B = (double *) Malloc(sizeof(double)*NDIM*NDIM, "Vector::InverseMatrix: *B");
+  double detA = RDET3(A);
+  double detAReci;
+
+  for (int i=0;i<NDIM*NDIM;++i)
+    B[i] = 0.;
+  // calculate the inverse B
+  if (fabs(detA) > MYEPSILON) {;  // RDET3(A) yields precisely zero if A irregular
+    detAReci = 1./detA;
+    B[0] =  detAReci*RDET2(A[4],A[5],A[7],A[8]);    // A_11
+    B[1] = -detAReci*RDET2(A[1],A[2],A[7],A[8]);    // A_12
+    B[2] =  detAReci*RDET2(A[1],A[2],A[4],A[5]);    // A_13
+    B[3] = -detAReci*RDET2(A[3],A[5],A[6],A[8]);    // A_21
+    B[4] =  detAReci*RDET2(A[0],A[2],A[6],A[8]);    // A_22
+    B[5] = -detAReci*RDET2(A[0],A[2],A[3],A[5]);    // A_23
+    B[6] =  detAReci*RDET2(A[3],A[4],A[6],A[7]);    // A_31
+    B[7] = -detAReci*RDET2(A[0],A[1],A[6],A[7]);    // A_32
+    B[8] =  detAReci*RDET2(A[0],A[1],A[3],A[4]);    // A_33
+  }
+  return B;
 };
 
@@ -413 +447 @@
 void Vector::InverseMatrixMultiplication(double *A)
 {
-        Vector C;
-        double B[NDIM*NDIM];
-        double detA = RDET3(A);
-        double detAReci;
-
-        // calculate the inverse B
-        if (fabs(detA) > MYEPSILON) {;  // RDET3(A) yields precisely zero if A irregular
-                detAReci = 1./detA;
-                B[0] =  detAReci*RDET2(A[4],A[5],A[7],A[8]);            // A_11
-                B[1] = -detAReci*RDET2(A[1],A[2],A[7],A[8]);            // A_12
-                B[2] =  detAReci*RDET2(A[1],A[2],A[4],A[5]);            // A_13
-                B[3] = -detAReci*RDET2(A[3],A[5],A[6],A[8]);            // A_21
-                B[4] =  detAReci*RDET2(A[0],A[2],A[6],A[8]);            // A_22
-                B[5] = -detAReci*RDET2(A[0],A[2],A[3],A[5]);            // A_23
-                B[6] =  detAReci*RDET2(A[3],A[4],A[6],A[7]);            // A_31
-                B[7] = -detAReci*RDET2(A[0],A[1],A[6],A[7]);            // A_32
-                B[8] =  detAReci*RDET2(A[0],A[1],A[3],A[4]);            // A_33
-
-                // do the matrix multiplication
-                C.x[0] = B[0]*x[0]+B[3]*x[1]+B[6]*x[2];
-                C.x[1] = B[1]*x[0]+B[4]*x[1]+B[7]*x[2];
-                C.x[2] = B[2]*x[0]+B[5]*x[1]+B[8]*x[2];
-                // transfer the result into this
-                for (int i=NDIM;i--;)
-                        x[i] = C.x[i];
-        } else {
-                cerr << "ERROR: inverse of matrix does not exists!" << endl;
-        }
+  Vector C;
+  double B[NDIM*NDIM];
+  double detA = RDET3(A);
+  double detAReci;
+
+  // calculate the inverse B
+  if (fabs(detA) > MYEPSILON) {;  // RDET3(A) yields precisely zero if A irregular
+    detAReci = 1./detA;
+    B[0] =  detAReci*RDET2(A[4],A[5],A[7],A[8]);    // A_11
+    B[1] = -detAReci*RDET2(A[1],A[2],A[7],A[8]);    // A_12
+    B[2] =  detAReci*RDET2(A[1],A[2],A[4],A[5]);    // A_13
+    B[3] = -detAReci*RDET2(A[3],A[5],A[6],A[8]);    // A_21
+    B[4] =  detAReci*RDET2(A[0],A[2],A[6],A[8]);    // A_22
+    B[5] = -detAReci*RDET2(A[0],A[2],A[3],A[5]);    // A_23
+    B[6] =  detAReci*RDET2(A[3],A[4],A[6],A[7]);    // A_31
+    B[7] = -detAReci*RDET2(A[0],A[1],A[6],A[7]);    // A_32
+    B[8] =  detAReci*RDET2(A[0],A[1],A[3],A[4]);    // A_33
+
+    // do the matrix multiplication
+    C.x[0] = B[0]*x[0]+B[3]*x[1]+B[6]*x[2];
+    C.x[1] = B[1]*x[0]+B[4]*x[1]+B[7]*x[2];
+    C.x[2] = B[2]*x[0]+B[5]*x[1]+B[8]*x[2];
+    // transfer the result into this
+    for (int i=NDIM;i--;)
+      x[i] = C.x[i];
+  } else {
+    cerr << "ERROR: inverse of matrix does not exists!" << endl;
+  }
 };
 
@@ -453 +487 @@
 void Vector::LinearCombinationOfVectors(const Vector *x1, const Vector *x2, const Vector *x3, double *factors)
 {
-        for(int i=NDIM;i--;)
-                x[i] = factors[0]*x1->x[i] + factors[1]*x2->x[i] + factors[2]*x3->x[i];
+  for(int i=NDIM;i--;)
+    x[i] = factors[0]*x1->x[i] + factors[1]*x2->x[i] + factors[2]*x3->x[i];
 };
 
@@ -462 +496 @@
 void Vector::Mirror(const Vector *n)
 {
-        double projection;
-        projection = ScalarProduct(n)/n->ScalarProduct(n);              // remove constancy from n (keep as logical one)
-        // withdraw projected vector twice from original one
-        cout << Verbose(1) << "Vector: ";
-        Output((ofstream *)&cout);
-        cout << "\t";
-        for (int i=NDIM;i--;)
-                x[i] -= 2.*projection*n->x[i];
-        cout << "Projected vector: ";
-        Output((ofstream *)&cout);
-        cout << endl;
+  double projection;
+  projection = ScalarProduct(n)/n->ScalarProduct(n);    // remove constancy from n (keep as logical one)
+  // withdraw projected vector twice from original one
+  cout << Verbose(1) << "Vector: ";
+  Output((ofstream *)&cout);
+  cout << "\t";
+  for (int i=NDIM;i--;)
+    x[i] -= 2.*projection*n->x[i];
+  cout << "Projected vector: ";
+  Output((ofstream *)&cout);
+  cout << endl;
 };
 
@@ -484 +518 @@
 bool Vector::MakeNormalVector(const Vector *y1, const Vector *y2, const Vector *y3)
 {
-        Vector x1, x2;
-
-        x1.CopyVector(y1);
-        x1.SubtractVector(y2);
-        x2.CopyVector(y3);
-        x2.SubtractVector(y2);
-        if ((fabs(x1.Norm()) < MYEPSILON) || (fabs(x2.Norm()) < MYEPSILON) || (fabs(x1.Angle(&x2)) < MYEPSILON)) {
-                cout << Verbose(4) << "Given vectors are linear dependent." << endl;
-                return false;
-        }
-//      cout << Verbose(4) << "relative, first plane coordinates:";
-//      x1.Output((ofstream *)&cout);
-//      cout << endl;
-//      cout << Verbose(4) << "second plane coordinates:";
-//      x2.Output((ofstream *)&cout);
-//      cout << endl;
-
-        this->x[0] = (x1.x[1]*x2.x[2] - x1.x[2]*x2.x[1]);
-        this->x[1] = (x1.x[2]*x2.x[0] - x1.x[0]*x2.x[2]);
-        this->x[2] = (x1.x[0]*x2.x[1] - x1.x[1]*x2.x[0]);
-        Normalize();
-
-        return true;
+  Vector x1, x2;
+
+  x1.CopyVector(y1);
+  x1.SubtractVector(y2);
+  x2.CopyVector(y3);
+  x2.SubtractVector(y2);
+  if ((fabs(x1.Norm()) < MYEPSILON) || (fabs(x2.Norm()) < MYEPSILON) || (fabs(x1.Angle(&x2)) < MYEPSILON)) {
+    cout << Verbose(4) << "Given vectors are linear dependent." << endl;
+    return false;
+  }
+//  cout << Verbose(4) << "relative, first plane coordinates:";
+//  x1.Output((ofstream *)&cout);
+//  cout << endl;
+//  cout << Verbose(4) << "second plane coordinates:";
+//  x2.Output((ofstream *)&cout);
+//  cout << endl;
+
+  this->x[0] = (x1.x[1]*x2.x[2] - x1.x[2]*x2.x[1]);
+  this->x[1] = (x1.x[2]*x2.x[0] - x1.x[0]*x2.x[2]);
+  this->x[2] = (x1.x[0]*x2.x[1] - x1.x[1]*x2.x[0]);
+  Normalize();
+
+  return true;
 };
 
@@ -520 +554 @@
 bool Vector::MakeNormalVector(const Vector *y1, const Vector *y2)
 {
-        Vector x1,x2;
-        x1.CopyVector(y1);
-        x2.CopyVector(y2);
-        Zero();
-        if ((fabs(x1.Norm()) < MYEPSILON) || (fabs(x2.Norm()) < MYEPSILON) || (fabs(x1.Angle(&x2)) < MYEPSILON)) {
-                cout << Verbose(4) << "Given vectors are linear dependent." << endl;
-                return false;
-        }
-//      cout << Verbose(4) << "relative, first plane coordinates:";
-//      x1.Output((ofstream *)&cout);
-//      cout << endl;
-//      cout << Verbose(4) << "second plane coordinates:";
-//      x2.Output((ofstream *)&cout);
-//      cout << endl;
-
-        this->x[0] = (x1.x[1]*x2.x[2] - x1.x[2]*x2.x[1]);
-        this->x[1] = (x1.x[2]*x2.x[0] - x1.x[0]*x2.x[2]);
-        this->x[2] = (x1.x[0]*x2.x[1] - x1.x[1]*x2.x[0]);
-        Normalize();
-
-        return true;
+  Vector x1,x2;
+  x1.CopyVector(y1);
+  x2.CopyVector(y2);
+  Zero();
+  if ((fabs(x1.Norm()) < MYEPSILON) || (fabs(x2.Norm()) < MYEPSILON) || (fabs(x1.Angle(&x2)) < MYEPSILON)) {
+    cout << Verbose(4) << "Given vectors are linear dependent." << endl;
+    return false;
+  }
+//  cout << Verbose(4) << "relative, first plane coordinates:";
+//  x1.Output((ofstream *)&cout);
+//  cout << endl;
+//  cout << Verbose(4) << "second plane coordinates:";
+//  x2.Output((ofstream *)&cout);
+//  cout << endl;
+
+  this->x[0] = (x1.x[1]*x2.x[2] - x1.x[2]*x2.x[1]);
+  this->x[1] = (x1.x[2]*x2.x[0] - x1.x[0]*x2.x[2]);
+  this->x[2] = (x1.x[0]*x2.x[1] - x1.x[1]*x2.x[0]);
+  Normalize();
+
+  return true;
 };
 
@@ -550 +584 @@
 bool Vector::MakeNormalVector(const Vector *y1)
 {
-        bool result = false;
-        Vector x1;
-        x1.CopyVector(y1);
-        x1.Scale(x1.Projection(this));
-        SubtractVector(&x1);
-        for (int i=NDIM;i--;)
-                result = result || (fabs(x[i]) > MYEPSILON);
-
-        return result;
+  bool result = false;
+  Vector x1;
+  x1.CopyVector(y1);
+  x1.Scale(x1.Projection(this));
+  SubtractVector(&x1);
+  for (int i=NDIM;i--;)
+    result = result || (fabs(x[i]) > MYEPSILON);
+
+  return result;
 };
 
@@ -569 +603 @@
 bool Vector::GetOneNormalVector(const Vector *GivenVector)
 {
-        int Components[NDIM]; // contains indices of non-zero components
-        int Last = 0;    // count the number of non-zero entries in vector
-        int j;  // loop variables
-        double norm;
-
-        cout << Verbose(4);
-        GivenVector->Output((ofstream *)&cout);
-        cout << endl;
-        for (j=NDIM;j--;)
-                Components[j] = -1;
-        // find two components != 0
-        for (j=0;j<NDIM;j++)
-                if (fabs(GivenVector->x[j]) > MYEPSILON)
-                        Components[Last++] = j;
-        cout << Verbose(4) << Last << " Components != 0: (" << Components[0] << "," << Components[1] << "," << Components[2] << ")" << endl;
-
-        switch(Last) {
-                case 3: // threecomponent system
-                case 2: // two component system
-                        norm = sqrt(1./(GivenVector->x[Components[1]]*GivenVector->x[Components[1]]) + 1./(GivenVector->x[Components[0]]*GivenVector->x[Components[0]]));
-                        x[Components[2]] = 0.;
-                        // in skp both remaining parts shall become zero but with opposite sign and third is zero
-                        x[Components[1]] = -1./GivenVector->x[Components[1]] / norm;
-                        x[Components[0]] = 1./GivenVector->x[Components[0]] / norm;
-                        return true;
-                        break;
-                case 1: // one component system
-                        // set sole non-zero component to 0, and one of the other zero component pendants to 1
-                        x[(Components[0]+2)%NDIM] = 0.;
-                        x[(Components[0]+1)%NDIM] = 1.;
-                        x[Components[0]] = 0.;
-                        return true;
-                        break;
-                default:
-                        return false;
-        }
+  int Components[NDIM]; // contains indices of non-zero components
+  int Last = 0;   // count the number of non-zero entries in vector
+  int j;  // loop variables
+  double norm;
+
+  cout << Verbose(4);
+  GivenVector->Output((ofstream *)&cout);
+  cout << endl;
+  for (j=NDIM;j--;)
+    Components[j] = -1;
+  // find two components != 0
+  for (j=0;j<NDIM;j++)
+    if (fabs(GivenVector->x[j]) > MYEPSILON)
+      Components[Last++] = j;
+  cout << Verbose(4) << Last << " Components != 0: (" << Components[0] << "," << Components[1] << "," << Components[2] << ")" << endl;
+
+  switch(Last) {
+    case 3:  // threecomponent system
+    case 2:  // two component system
+      norm = sqrt(1./(GivenVector->x[Components[1]]*GivenVector->x[Components[1]]) + 1./(GivenVector->x[Components[0]]*GivenVector->x[Components[0]]));
+      x[Components[2]] = 0.;
+      // in skp both remaining parts shall become zero but with opposite sign and third is zero
+      x[Components[1]] = -1./GivenVector->x[Components[1]] / norm;
+      x[Components[0]] = 1./GivenVector->x[Components[0]] / norm;
+      return true;
+      break;
+    case 1: // one component system
+      // set sole non-zero component to 0, and one of the other zero component pendants to 1
+      x[(Components[0]+2)%NDIM] = 0.;
+      x[(Components[0]+1)%NDIM] = 1.;
+      x[Components[0]] = 0.;
+      return true;
+      break;
+    default:
+      return false;
+  }
 };
 
@@ -615 +649 @@
 double Vector::CutsPlaneAt(Vector *A, Vector *B, Vector *C)
 {
-//      cout << Verbose(3) << "For comparison: ";
-//      cout << "A " << A->Projection(this) << "\t";
-//      cout << "B " << B->Projection(this) << "\t";
-//      cout << "C " << C->Projection(this) << "\t";
-//      cout << endl;
-        return A->Projection(this);
+//  cout << Verbose(3) << "For comparison: ";
+//  cout << "A " << A->Projection(this) << "\t";
+//  cout << "B " << B->Projection(this) << "\t";
+//  cout << "C " << C->Projection(this) << "\t";
+//  cout << endl;
+  return A->Projection(this);
 };
 
@@ -630 +664 @@
 bool Vector::LSQdistance(Vector **vectors, int num)
 {
-        int j;
-
-        for (j=0;j<num;j++) {
-                cout << Verbose(1) << j << "th atom's vector: ";
-                (vectors[j])->Output((ofstream *)&cout);
-                cout << endl;
-        }
-
-        int np = 3;
-        struct LSQ_params par;
-
-         const gsl_multimin_fminimizer_type *T =
-                 gsl_multimin_fminimizer_nmsimplex;
-         gsl_multimin_fminimizer *s = NULL;
-         gsl_vector *ss, *y;
-         gsl_multimin_function minex_func;
-
-         size_t iter = 0, i;
-         int status;
-         double size;
-
-         /* Initial vertex size vector */
-         ss = gsl_vector_alloc (np);
-         y = gsl_vector_alloc (np);
-
-         /* Set all step sizes to 1 */
-         gsl_vector_set_all (ss, 1.0);
-
-         /* Starting point */
-         par.vectors = vectors;
-         par.num = num;
-
-         for (i=NDIM;i--;)
-                gsl_vector_set(y, i, (vectors[0]->x[i] - vectors[1]->x[i])/2.);
-
-         /* Initialize method and iterate */
-         minex_func.f = &LSQ;
-         minex_func.n = np;
-         minex_func.params = (void *)&par;
-
-         s = gsl_multimin_fminimizer_alloc (T, np);
-         gsl_multimin_fminimizer_set (s, &minex_func, y, ss);
-
-         do
-                 {
-                         iter++;
-                         status = gsl_multimin_fminimizer_iterate(s);
-
-                         if (status)
-                                 break;
-
-                         size = gsl_multimin_fminimizer_size (s);
-                         status = gsl_multimin_test_size (size, 1e-2);
-
-                         if (status == GSL_SUCCESS)
-                                 {
-                                         printf ("converged to minimum at\n");
-                                 }
-
-                         printf ("%5d ", (int)iter);
-                         for (i = 0; i < (size_t)np; i++)
-                                 {
-                                         printf ("%10.3e ", gsl_vector_get (s->x, i));
-                                 }
-                         printf ("f() = %7.3f size = %.3f\n", s->fval, size);
-                 }
-         while (status == GSL_CONTINUE && iter < 100);
-
-        for (i=(size_t)np;i--;)
-                this->x[i] = gsl_vector_get(s->x, i);
-         gsl_vector_free(y);
-         gsl_vector_free(ss);
-         gsl_multimin_fminimizer_free (s);
-
-        return true;
+  int j;
+
+  for (j=0;j<num;j++) {
+    cout << Verbose(1) << j << "th atom's vector: ";
+    (vectors[j])->Output((ofstream *)&cout);
+    cout << endl;
+  }
+
+  int np = 3;
+  struct LSQ_params par;
+
+   const gsl_multimin_fminimizer_type *T =
+     gsl_multimin_fminimizer_nmsimplex;
+   gsl_multimin_fminimizer *s = NULL;
+   gsl_vector *ss, *y;
+   gsl_multimin_function minex_func;
+
+   size_t iter = 0, i;
+   int status;
+   double size;
+
+   /* Initial vertex size vector */
+   ss = gsl_vector_alloc (np);
+   y = gsl_vector_alloc (np);
+
+   /* Set all step sizes to 1 */
+   gsl_vector_set_all (ss, 1.0);
+
+   /* Starting point */
+   par.vectors = vectors;
+   par.num = num;
+
+   for (i=NDIM;i--;)
+    gsl_vector_set(y, i, (vectors[0]->x[i] - vectors[1]->x[i])/2.);
+
+   /* Initialize method and iterate */
+   minex_func.f = &LSQ;
+   minex_func.n = np;
+   minex_func.params = (void *)&par;
+
+   s = gsl_multimin_fminimizer_alloc (T, np);
+   gsl_multimin_fminimizer_set (s, &minex_func, y, ss);
+
+   do
+     {
+       iter++;
+       status = gsl_multimin_fminimizer_iterate(s);
+
+       if (status)
+         break;
+
+       size = gsl_multimin_fminimizer_size (s);
+       status = gsl_multimin_test_size (size, 1e-2);
+
+       if (status == GSL_SUCCESS)
+         {
+           printf ("converged to minimum at\n");
+         }
+
+       printf ("%5d ", (int)iter);
+       for (i = 0; i < (size_t)np; i++)
+         {
+           printf ("%10.3e ", gsl_vector_get (s->x, i));
+         }
+       printf ("f() = %7.3f size = %.3f\n", s->fval, size);
+     }
+   while (status == GSL_CONTINUE && iter < 100);
+
+  for (i=(size_t)np;i--;)
+    this->x[i] = gsl_vector_get(s->x, i);
+   gsl_vector_free(y);
+   gsl_vector_free(ss);
+   gsl_multimin_fminimizer_free (s);
+
+  return true;
 };
 
@@ -712 +746 @@
 void Vector::AddVector(const Vector *y)
 {
-        for (int i=NDIM;i--;)
-                this->x[i] += y->x[i];
+  for (int i=NDIM;i--;)
+    this->x[i] += y->x[i];
 }
 
@@ -721 +755 @@
 void Vector::SubtractVector(const Vector *y)
 {
-        for (int i=NDIM;i--;)
-                this->x[i] -= y->x[i];
+  for (int i=NDIM;i--;)
+    this->x[i] -= y->x[i];
 }
 
@@ -730 +764 @@
 void Vector::CopyVector(const Vector *y)
 {
-        for (int i=NDIM;i--;)
-                this->x[i] = y->x[i];
+  for (int i=NDIM;i--;)
+    this->x[i] = y->x[i];
 }
 
@@ -741 +775 @@
 void Vector::AskPosition(double *cell_size, bool check)
 {
-        char coords[3] = {'x','y','z'};
-        int j = -1;
-        for (int i=0;i<3;i++) {
-                j += i+1;
-                do {
-                        cout << Verbose(0) << coords[i] << "[0.." << cell_size[j] << "]: ";
-                        cin >> x[i];
-                } while (((x[i] < 0) || (x[i] >= cell_size[j])) && (check));
-        }
+  char coords[3] = {'x','y','z'};
+  int j = -1;
+  for (int i=0;i<3;i++) {
+    j += i+1;
+    do {
+      cout << Verbose(0) << coords[i] << "[0.." << cell_size[j] << "]: ";
+      cin >> x[i];
+    } while (((x[i] < 0) || (x[i] >= cell_size[j])) && (check));
+  }
 };
 
@@ -769 +803 @@
 bool Vector::SolveSystem(Vector *x1, Vector *x2, Vector *y, double alpha, double beta, double c)
 {
-        double D1,D2,D3,E1,E2,F1,F2,F3,p,q=0., A, B1, B2, C;
-        double ang; // angle on testing
-        double sign[3];
-        int i,j,k;
-        A = cos(alpha) * x1->Norm() * c;
-        B1 = cos(beta + M_PI/2.) * y->Norm() * c;
-        B2 = cos(beta) * x2->Norm() * c;
-        C = c * c;
-        cout << Verbose(2) << "A " << A << "\tB " << B1 << "\tC " << C << endl;
-        int flag = 0;
-        if (fabs(x1->x[0]) < MYEPSILON) { // check for zero components for the later flipping and back-flipping
-                if (fabs(x1->x[1]) > MYEPSILON) {
-                        flag = 1;
-                } else if (fabs(x1->x[2]) > MYEPSILON) {
-                         flag = 2;
-                } else {
-                        return false;
-                }
-        }
-        switch (flag) {
-                default:
-                case 0:
-                        break;
-                case 2:
-                        flip(&x1->x[0],&x1->x[1]);
-                        flip(&x2->x[0],&x2->x[1]);
-                        flip(&y->x[0],&y->x[1]);
-                        //flip(&x[0],&x[1]);
-                        flip(&x1->x[1],&x1->x[2]);
-                        flip(&x2->x[1],&x2->x[2]);
-                        flip(&y->x[1],&y->x[2]);
-                        //flip(&x[1],&x[2]);
-                case 1:
-                        flip(&x1->x[0],&x1->x[1]);
-                        flip(&x2->x[0],&x2->x[1]);
-                        flip(&y->x[0],&y->x[1]);
-                        //flip(&x[0],&x[1]);
-                        flip(&x1->x[1],&x1->x[2]);
-                        flip(&x2->x[1],&x2->x[2]);
-                        flip(&y->x[1],&y->x[2]);
-                        //flip(&x[1],&x[2]);
-                        break;
-        }
-        // now comes the case system
-        D1 = -y->x[0]/x1->x[0]*x1->x[1]+y->x[1];
-        D2 = -y->x[0]/x1->x[0]*x1->x[2]+y->x[2];
-        D3 = y->x[0]/x1->x[0]*A-B1;
-        cout << Verbose(2) << "D1 " << D1 << "\tD2 " << D2 << "\tD3 " << D3 << "\n";
-        if (fabs(D1) < MYEPSILON) {
-                cout << Verbose(2) << "D1 == 0!\n";
-                if (fabs(D2) > MYEPSILON) {
-                        cout << Verbose(3) << "D2 != 0!\n";
-                        x[2] = -D3/D2;
-                        E1 = A/x1->x[0] + x1->x[2]/x1->x[0]*D3/D2;
-                        E2 = -x1->x[1]/x1->x[0];
-                        cout << Verbose(3) << "E1 " << E1 << "\tE2 " << E2 << "\n";
-                        F1 = E1*E1 + 1.;
-                        F2 = -E1*E2;
-                        F3 = E1*E1 + D3*D3/(D2*D2) - C;
-                        cout << Verbose(3) << "F1 " << F1 << "\tF2 " << F2 << "\tF3 " << F3 << "\n";
-                        if (fabs(F1) < MYEPSILON) {
-                                cout << Verbose(4) << "F1 == 0!\n";
-                                cout << Verbose(4) << "Gleichungssystem linear\n";
-                                x[1] = F3/(2.*F2);
-                        } else {
-                                p = F2/F1;
-                                q = p*p - F3/F1;
-                                cout << Verbose(4) << "p " << p << "\tq " << q << endl;
-                                if (q < 0) {
-                                        cout << Verbose(4) << "q < 0" << endl;
-                                        return false;
-                                }
-                                x[1] = p + sqrt(q);
-                        }
-                        x[0] =  A/x1->x[0] - x1->x[1]/x1->x[0]*x[1] + x1->x[2]/x1->x[0]*x[2];
-                } else {
-                        cout << Verbose(2) << "Gleichungssystem unterbestimmt\n";
-                        return false;
-                }
-        } else {
-                E1 = A/x1->x[0]+x1->x[1]/x1->x[0]*D3/D1;
-                E2 = x1->x[1]/x1->x[0]*D2/D1 - x1->x[2];
-                cout << Verbose(2) << "E1 " << E1 << "\tE2 " << E2 << "\n";
-                F1 = E2*E2 + D2*D2/(D1*D1) + 1.;
-                F2 = -(E1*E2 + D2*D3/(D1*D1));
-                F3 = E1*E1 + D3*D3/(D1*D1) - C;
-                cout << Verbose(2) << "F1 " << F1 << "\tF2 " << F2 << "\tF3 " << F3 << "\n";
-                if (fabs(F1) < MYEPSILON) {
-                        cout << Verbose(3) << "F1 == 0!\n";
-                        cout << Verbose(3) << "Gleichungssystem linear\n";
-                        x[2] = F3/(2.*F2);
-                } else {
-                        p = F2/F1;
-                        q = p*p - F3/F1;
-                        cout << Verbose(3) << "p " << p << "\tq " << q << endl;
-                        if (q < 0) {
-                                cout << Verbose(3) << "q < 0" << endl;
-                                return false;
-                        }
-                        x[2] = p + sqrt(q);
-                }
-                x[1] = (-D2 * x[2] - D3)/D1;
-                x[0] = A/x1->x[0] - x1->x[1]/x1->x[0]*x[1] + x1->x[2]/x1->x[0]*x[2];
-        }
-        switch (flag) { // back-flipping
-                default:
-                case 0:
-                        break;
-                case 2:
-                        flip(&x1->x[0],&x1->x[1]);
-                        flip(&x2->x[0],&x2->x[1]);
-                        flip(&y->x[0],&y->x[1]);
-                        flip(&x[0],&x[1]);
-                        flip(&x1->x[1],&x1->x[2]);
-                        flip(&x2->x[1],&x2->x[2]);
-                        flip(&y->x[1],&y->x[2]);
-                        flip(&x[1],&x[2]);
-                case 1:
-                        flip(&x1->x[0],&x1->x[1]);
-                        flip(&x2->x[0],&x2->x[1]);
-                        flip(&y->x[0],&y->x[1]);
-                        //flip(&x[0],&x[1]);
-                        flip(&x1->x[1],&x1->x[2]);
-                        flip(&x2->x[1],&x2->x[2]);
-                        flip(&y->x[1],&y->x[2]);
-                        flip(&x[1],&x[2]);
-                        break;
-        }
-        // one z component is only determined by its radius (without sign)
-        // thus check eight possible sign flips and determine by checking angle with second vector
-        for (i=0;i<8;i++) {
-                // set sign vector accordingly
-                for (j=2;j>=0;j--) {
-                        k = (i & pot(2,j)) << j;
-                        cout << Verbose(2) << "k " << k << "\tpot(2,j) " << pot(2,j) << endl;
-                        sign[j] = (k == 0) ? 1. : -1.;
-                }
-                cout << Verbose(2) << i << ": sign matrix is " << sign[0] << "\t" << sign[1] << "\t" << sign[2] << "\n";
-                // apply sign matrix
-                for (j=NDIM;j--;)
-                        x[j] *= sign[j];
-                // calculate angle and check
-                ang = x2->Angle (this);
-                cout << Verbose(1) << i << "th angle " << ang << "\tbeta " << cos(beta) << " :\t";
-                if (fabs(ang - cos(beta)) < MYEPSILON) {
-                        break;
-                }
-                // unapply sign matrix (is its own inverse)
-                for (j=NDIM;j--;)
-                        x[j] *= sign[j];
-        }
-        return true;
-};
+  double D1,D2,D3,E1,E2,F1,F2,F3,p,q=0., A, B1, B2, C;
+  double ang; // angle on testing
+  double sign[3];
+  int i,j,k;
+  A = cos(alpha) * x1->Norm() * c;
+  B1 = cos(beta + M_PI/2.) * y->Norm() * c;
+  B2 = cos(beta) * x2->Norm() * c;
+  C = c * c;
+  cout << Verbose(2) << "A " << A << "\tB " << B1 << "\tC " << C << endl;
+  int flag = 0;
+  if (fabs(x1->x[0]) < MYEPSILON) { // check for zero components for the later flipping and back-flipping
+    if (fabs(x1->x[1]) > MYEPSILON) {
+      flag = 1;
+    } else if (fabs(x1->x[2]) > MYEPSILON) {
+       flag = 2;
+    } else {
+      return false;
+    }
+  }
+  switch (flag) {
+    default:
+    case 0:
+      break;
+    case 2:
+      flip(&x1->x[0],&x1->x[1]);
+      flip(&x2->x[0],&x2->x[1]);
+      flip(&y->x[0],&y->x[1]);
+      //flip(&x[0],&x[1]);
+      flip(&x1->x[1],&x1->x[2]);
+      flip(&x2->x[1],&x2->x[2]);
+      flip(&y->x[1],&y->x[2]);
+      //flip(&x[1],&x[2]);
+    case 1:
+      flip(&x1->x[0],&x1->x[1]);
+      flip(&x2->x[0],&x2->x[1]);
+      flip(&y->x[0],&y->x[1]);
+      //flip(&x[0],&x[1]);
+      flip(&x1->x[1],&x1->x[2]);
+      flip(&x2->x[1],&x2->x[2]);
+      flip(&y->x[1],&y->x[2]);
+      //flip(&x[1],&x[2]);
+      break;
+  }
+  // now comes the case system
+  D1 = -y->x[0]/x1->x[0]*x1->x[1]+y->x[1];
+  D2 = -y->x[0]/x1->x[0]*x1->x[2]+y->x[2];
+  D3 = y->x[0]/x1->x[0]*A-B1;
+  cout << Verbose(2) << "D1 " << D1 << "\tD2 " << D2 << "\tD3 " << D3 << "\n";
+  if (fabs(D1) < MYEPSILON) {
+    cout << Verbose(2) << "D1 == 0!\n";
+    if (fabs(D2) > MYEPSILON) {
+      cout << Verbose(3) << "D2 != 0!\n";
+      x[2] = -D3/D2;
+      E1 = A/x1->x[0] + x1->x[2]/x1->x[0]*D3/D2;
+      E2 = -x1->x[1]/x1->x[0];
+      cout << Verbose(3) << "E1 " << E1 << "\tE2 " << E2 << "\n";
+      F1 = E1*E1 + 1.;
+      F2 = -E1*E2;
+      F3 = E1*E1 + D3*D3/(D2*D2) - C;
+      cout << Verbose(3) << "F1 " << F1 << "\tF2 " << F2 << "\tF3 " << F3 << "\n";
+      if (fabs(F1) < MYEPSILON) {
+        cout << Verbose(4) << "F1 == 0!\n";
+        cout << Verbose(4) << "Gleichungssystem linear\n";
+        x[1] = F3/(2.*F2);
+      } else {
+        p = F2/F1;
+        q = p*p - F3/F1;
+        cout << Verbose(4) << "p " << p << "\tq " << q << endl;
+        if (q < 0) {
+          cout << Verbose(4) << "q < 0" << endl;
+          return false;
+        }
+        x[1] = p + sqrt(q);
+      }
+      x[0] =  A/x1->x[0] - x1->x[1]/x1->x[0]*x[1] + x1->x[2]/x1->x[0]*x[2];
+    } else {
+      cout << Verbose(2) << "Gleichungssystem unterbestimmt\n";
+      return false;
+    }
+  } else {
+    E1 = A/x1->x[0]+x1->x[1]/x1->x[0]*D3/D1;
+    E2 = x1->x[1]/x1->x[0]*D2/D1 - x1->x[2];
+    cout << Verbose(2) << "E1 " << E1 << "\tE2 " << E2 << "\n";
+    F1 = E2*E2 + D2*D2/(D1*D1) + 1.;
+    F2 = -(E1*E2 + D2*D3/(D1*D1));
+    F3 = E1*E1 + D3*D3/(D1*D1) - C;
+    cout << Verbose(2) << "F1 " << F1 << "\tF2 " << F2 << "\tF3 " << F3 << "\n";
+    if (fabs(F1) < MYEPSILON) {
+      cout << Verbose(3) << "F1 == 0!\n";
+      cout << Verbose(3) << "Gleichungssystem linear\n";
+      x[2] = F3/(2.*F2);
+    } else {
+      p = F2/F1;
+      q = p*p - F3/F1;
+      cout << Verbose(3) << "p " << p << "\tq " << q << endl;
+      if (q < 0) {
+        cout << Verbose(3) << "q < 0" << endl;
+        return false;
+      }
+      x[2] = p + sqrt(q);
+    }
+    x[1] = (-D2 * x[2] - D3)/D1;
+    x[0] = A/x1->x[0] - x1->x[1]/x1->x[0]*x[1] + x1->x[2]/x1->x[0]*x[2];
+  }
+  switch (flag) { // back-flipping
+    default:
+    case 0:
+      break;
+    case 2:
+      flip(&x1->x[0],&x1->x[1]);
+      flip(&x2->x[0],&x2->x[1]);
+      flip(&y->x[0],&y->x[1]);
+      flip(&x[0],&x[1]);
+      flip(&x1->x[1],&x1->x[2]);
+      flip(&x2->x[1],&x2->x[2]);
+      flip(&y->x[1],&y->x[2]);
+      flip(&x[1],&x[2]);
+    case 1:
+      flip(&x1->x[0],&x1->x[1]);
+      flip(&x2->x[0],&x2->x[1]);
+      flip(&y->x[0],&y->x[1]);
+      //flip(&x[0],&x[1]);
+      flip(&x1->x[1],&x1->x[2]);
+      flip(&x2->x[1],&x2->x[2]);
+      flip(&y->x[1],&y->x[2]);
+      flip(&x[1],&x[2]);
+      break;
+  }
+  // one z component is only determined by its radius (without sign)
+  // thus check eight possible sign flips and determine by checking angle with second vector
+  for (i=0;i<8;i++) {
+    // set sign vector accordingly
+    for (j=2;j>=0;j--) {
+      k = (i & pot(2,j)) << j;
+      cout << Verbose(2) << "k " << k << "\tpot(2,j) " << pot(2,j) << endl;
+      sign[j] = (k == 0) ? 1. : -1.;
+    }
+    cout << Verbose(2) << i << ": sign matrix is " << sign[0] << "\t" << sign[1] << "\t" << sign[2] << "\n";
+    // apply sign matrix
+    for (j=NDIM;j--;)
+      x[j] *= sign[j];
+    // calculate angle and check
+    ang = x2->Angle (this);
+    cout << Verbose(1) << i << "th angle " << ang << "\tbeta " << cos(beta) << " :\t";
+    if (fabs(ang - cos(beta)) < MYEPSILON) {
+      break;
+    }
+    // unapply sign matrix (is its own inverse)
+    for (j=NDIM;j--;)
+      x[j] *= sign[j];
+  }
+  return true;
+};

src/vector.hpp

@@ -8 +8 @@
  */
 class Vector {
-        public:
-                double x[NDIM];
+  public:
+    double x[NDIM];
 
-        Vector();
-        Vector(double x1, double x2, double x3);
-        ~Vector();
+  Vector();
+  Vector(double x1, double x2, double x3);
+  ~Vector();
 
-        double Distance(const Vector *y) const;
-        double DistanceSquared(const Vector *y) const;
-        double PeriodicDistance(const Vector *y, const double *cell_size) const;
-        double PeriodicDistanceSquared(const Vector *y, const double *cell_size) const;
-        double ScalarProduct(const Vector *y) const;
-        double Projection(const Vector *y) const;
-        double Norm() const ;
-        double Angle(const Vector *y) const;
+  double Distance(const Vector *y) const;
+  double DistanceSquared(const Vector *y) const;
+  double PeriodicDistance(const Vector *y, const double *cell_size) const;
+  double PeriodicDistanceSquared(const Vector *y, const double *cell_size) const;
+  double ScalarProduct(const Vector *y) const;
+  double Projection(const Vector *y) const;
+  double Norm() const ;
+  double Angle(const Vector *y) const;
 
-        void AddVector(const Vector *y);
-        void SubtractVector(const Vector *y);
-        void CopyVector(const Vector *y);
-        void RotateVector(const Vector *y, const double alpha);
-        void VectorProduct(const Vector *y);
-        void ProjectOntoPlane(const Vector *y);
-        void Zero();
-        void One(double one);
-        void Init(double x1, double x2, double x3);
-        void Normalize();
-        void Translate(const Vector *x);
-        void Mirror(const Vector *x);
-        void Scale(double **factor);
-        void Scale(double *factor);
-        void Scale(double factor);
-        void MatrixMultiplication(double *M);
-        void InverseMatrixMultiplication(double *M);
-        void KeepPeriodic(ofstream *out, double *matrix);
-        void LinearCombinationOfVectors(const Vector *x1, const Vector *x2, const Vector *x3, double *factors);
-        double CutsPlaneAt(Vector *A, Vector *B, Vector *C);
-        bool GetOneNormalVector(const Vector *x1);
-        bool MakeNormalVector(const Vector *y1);
-        bool MakeNormalVector(const Vector *y1, const Vector *y2);
-        bool MakeNormalVector(const Vector *x1, const Vector *x2, const Vector *x3);
-        bool SolveSystem(Vector *x1, Vector *x2, Vector *y, double alpha, double beta, double c);
-        bool LSQdistance(Vector **vectors, int dim);
-        void AskPosition(double *cell_size, bool check);
-        bool Output(ofstream *out) const;
+  void AddVector(const Vector *y);
+  void SubtractVector(const Vector *y);
+  void CopyVector(const Vector *y);
+  void RotateVector(const Vector *y, const double alpha);
+  void VectorProduct(const Vector *y);
+  void ProjectOntoPlane(const Vector *y);
+  void Zero();
+  void One(double one);
+  void Init(double x1, double x2, double x3);
+  void Normalize();
+  void Translate(const Vector *x);
+  void Mirror(const Vector *x);
+  void Scale(double **factor);
+  void Scale(double *factor);
+  void Scale(double factor);
+  void MatrixMultiplication(double *M);
+  double * InverseMatrix(double *A);
+  void InverseMatrixMultiplication(double *M);
+  void KeepPeriodic(ofstream *out, double *matrix);
+  void LinearCombinationOfVectors(const Vector *x1, const Vector *x2, const Vector *x3, double *factors);
+  double CutsPlaneAt(Vector *A, Vector *B, Vector *C);
+  bool GetOneNormalVector(const Vector *x1);
+  bool MakeNormalVector(const Vector *y1);
+  bool MakeNormalVector(const Vector *y1, const Vector *y2);
+  bool MakeNormalVector(const Vector *x1, const Vector *x2, const Vector *x3);
+  bool SolveSystem(Vector *x1, Vector *x2, Vector *y, double alpha, double beta, double c);
+  bool LSQdistance(Vector **vectors, int dim);
+  void AskPosition(double *cell_size, bool check);
+  bool Output(ofstream *out) const;
 };
 

src/verbose.cpp

@@ -7 +7 @@
 ostream& Verbose::print (ostream &ost) const
 {
-        for (int i=Verbosity;i--;)
-                ost.put('\t');
-        //cout << "Verbose(.) called." << endl;
-        return ost;
+  for (int i=Verbosity;i--;)
+    ost.put('\t');
+  //cout << "Verbose(.) called." << endl;
+  return ost;
 };