Changes in / [ce5ac3:d067d45]

Location:

src

Files:

• #border.cpp# (deleted)
• #makefile# (deleted)
• #molecules.hpp# (deleted)
• Makefile.am (modified) (1 diff)
• analyzer.cpp (modified) (18 diffs)
• atom.cpp (modified) (6 diffs)
• boundary.cpp (modified) (27 diffs)
• boundary.hpp (modified) (3 diffs)
• builder.cpp (modified) (37 diffs)
• config.cpp (modified) (59 diffs)
• datacreator.cpp (modified) (27 diffs)
• datacreator.hpp (modified) (3 diffs)
• element.cpp (modified) (2 diffs)
• ellipsoid.cpp (added)
• ellipsoid.hpp (added)
• graph.cpp (modified) (1 diff)
• helpers.cpp (modified) (13 diffs)
• helpers.hpp (modified) (12 diffs)
• joiner.cpp (modified) (5 diffs)
• linkedcell.cpp (added)
• linkedcell.hpp (added)
• moleculelist.cpp (modified) (37 diffs)
• molecules.cpp (modified) (27 diffs)
• molecules.hpp (modified) (11 diffs)
• parser.cpp (modified) (24 diffs)
• parser.hpp (modified) (5 diffs)
• periodentafel.hpp (modified) (2 diffs)
• stackclass.hpp (modified) (12 diffs)
• vector.cpp (modified) (36 diffs)
• vector.hpp (modified) (1 diff)
• verbose.cpp (modified) (1 diff)

src/Makefile.am

@@ -1 @@
-SOURCE = atom.cpp bond.cpp boundary.cpp builder.cpp config.cpp element.cpp helpers.cpp molecules.cpp moleculelist.cpp parser.cpp periodentafel.cpp vector.cpp verbose.cpp
-HEADER = boundary.hpp defs.hpp helpers.hpp molecules.hpp parser.hpp periodentafel.hpp stackclass.hpp vector.hpp
+SOURCE = atom.cpp bond.cpp boundary.cpp builder.cpp config.cpp element.cpp ellipsoid.cpp helpers.cpp molecules.cpp linkedcell.cpp moleculelist.cpp parser.cpp periodentafel.cpp vector.cpp verbose.cpp
+HEADER = boundary.hpp defs.hpp ellipsoid.hpp helpers.hpp linkedcell.hpp molecules.hpp parser.hpp periodentafel.hpp stackclass.hpp vector.hpp
 
 bin_PROGRAMS = molecuilder joiner analyzer
 molecuilderdir = ${bindir}
-molecuilder_DATA = elements.db valence.db       orbitals.db Hbonddistance.db Hbondangle.db
+molecuilder_DATA = elements.db valence.db orbitals.db Hbonddistance.db Hbondangle.db
 molecuilder_SOURCES =  ${SOURCE} ${HEADER}
 joiner_SOURCES = joiner.cpp datacreator.cpp element.cpp helpers.cpp periodentafel.cpp parser.cpp verbose.cpp datacreator.hpp helpers.hpp parser.hpp periodentafel.hpp 

src/analyzer.cpp

@@ -3 +3 @@
  * Takes evaluated fragments (energy and forces) and does evaluation of how sensible the BOSSANOVA
  * approach was, e.g. in the decay of the many-body-contributions.
- *    
+ *
  */
 
@@ -9 +9 @@
 
 #include "datacreator.hpp"
-#include "helpers.hpp" 
+#include "helpers.hpp"
 #include "parser.hpp"
-#include "periodentafel.hpp" 
+#include "periodentafel.hpp"
 
 // include config.h
@@ -55 +55 @@
   stringstream yrange;
   char *dir = NULL;
-  bool NoHCorrection = false;
   bool NoHessian = false;
   bool NoTime = false;
+  bool NoHCorrection = true;
   int counter;
-  
+
   cout << "ANOVA Analyzer" << endl;
   cout << "==============" << endl;
-  
+
   // Get the command line options
   if (argc < 4) {
@@ -76 +76 @@
     strcat(dir, argv[2]);
   }
-  
+
   if (argc > 4) {
     cout << "Loading periodentafel." << endl;
@@ -82 +82 @@
     periode->LoadPeriodentafel(argv[4]);
   }
-  
+
   // Test the given directory
   if (!TestParams(argc, argv))
@@ -88 +88 @@
 
   // +++++++++++++++++ PARSING +++++++++++++++++++++++++++++++
-  
+
   // ------------- Parse through all Fragment subdirs --------
   if (!Energy.ParseFragmentMatrix(argv[1], dir, EnergySuffix,0,0)) return 1;
@@ -113 +113 @@
 
   // ---------- Parse the TE Factors into an array -----------------
-  if (!Energy.InitialiseIndices()) return 1;
-  if (!NoHCorrection) 
-    Hcorrection.InitialiseIndices();
-  
+  if (!Energy.ParseIndices()) return 1;
+  if (!NoHCorrection) Hcorrection.ParseIndices();
+
   // ---------- Parse the Force indices into an array ---------------
   if (!Force.ParseIndices(argv[1])) return 1;
@@ -148 +147 @@
   if (!KeySet.ParseKeySets(argv[1], Force.RowCounter, Force.MatrixCounter)) return 1;
   if (!KeySet.ParseManyBodyTerms()) return 1;
-  
+
   // ---------- Parse fragment files created by 'joiner' into an array -------------
   if (!EnergyFragments.ParseFragmentMatrix(argv[1], dir, EnergyFragmentSuffix,0,0)) return 1;
@@ -164 +163 @@
 
   // +++++++++++++++ TESTING ++++++++++++++++++++++++++++++
-  
+
   // print energy and forces to file
   filename.str("");
@@ -245 +244 @@
 
   // +++++++++++++++ ANALYZING ++++++++++++++++++++++++++++++
-  
+
   cout << "Analyzing ..." << endl;
 
@@ -330 +329 @@
   }
 
-  
+
   // +++++++++++++++++++++++++++++++++++++++ Plotting deviation in energy to full QM
   if (!CreateDataDeltaEnergyOrder(Energy, EnergyFragments, KeySet, argv[3], "DeltaEnergies-Order", "Plot of error between approximated and full energies energies versus the Bond Order", datum)) return 1;
-  
+
   // +++++++++++++++++++++++++++++++++++Plotting Energies vs. Order
   if (!CreateDataEnergyOrder(EnergyFragments, KeySet, argv[3], "Energies-Order", "Plot of approximated energies versus the Bond Order", datum)) return 1;
-  
+
   // +++++++++++++++++++++++++++++++++++++++ Plotting deviation in forces to full QM
   if (!CreateDataDeltaForcesOrderPerAtom(Force, ForceFragments, KeySet, argv[3], "DeltaForces-Order", "Plot of error between approximated forces and full forces versus the Bond Order", datum)) return 1;
@@ -399 +398 @@
 
   // ======================================= Creating the plot files ==============================================================
- 
+
   Orderxrange << "[1:" << KeySet.Order << "]";
   Fragmentxrange << "[0:" << KeySet.FragmentCounter+1 << "]";
@@ -411 +410 @@
   // +++++++++++++++++++++++++++++++++++++++ Plotting deviation in energy to full QM
   if (!CreatePlotOrder(Energy, KeySet, argv[3], "DeltaEnergies-Order", 1, "outside", "y", "",  1, 1, "bond order k", "absolute error in energy [Ht]", Orderxrange.str().c_str(), yrange.str().c_str(), "1" , "with linespoints", AbsEnergyPlotLine)) return 1;
-  
+
   // +++++++++++++++++++++++++++++++++++Plotting Energies vs. Order
   if (!CreatePlotOrder(Energy, KeySet, argv[3], "Energies-Order", 1, "outside", "", "",  1, 1, "bond order k", "approximate energy [Ht]", Orderxrange.str().c_str(), "", "1" , "with linespoints", EnergyPlotLine)) return 1;
@@ -429 +428 @@
   if(!OpenOutputFile(output, argv[3], "DeltaMinMeanMaxTotalForce-Order.pyx")) return 1;
   CreatePlotHeader(output, "DeltaMinMeanMaxTotalForce-Order", 1, "bottom left", "y", NULL,  1, 1, "bond order k", "absolute error in total forces [Ht/a.u.]");
-  output << "plot " << Orderxrange.str().c_str() << " [1e-8:1e+0] \\" << endl;  
+  output << "plot " << Orderxrange.str().c_str() << " [1e-8:1e+0] \\" << endl;
   output << "'DeltaMinForces-Order.dat' title 'minimum' using 1:(sqrt($" << 8 << "*$" << 8 << "+$" << 8+1 << "*$" << 8+1 << "+$" << 8+2 << "*$" << 8+2 << ")) with linespoints, \\" << endl;
   output << "'DeltaMeanForces-Order.dat' title 'mean' using 1:(abs($" << 8 << ")) with linespoints, \\" << endl;
   output << "'DeltaMaxForces-Order.dat' title 'maximum' using 1:(sqrt($" << 8 << "*$" << 8 << "+$" << 8+1 << "*$" << 8+1 << "+$" << 8+2 << "*$" << 8+2 << ")) with linespoints" << endl;
-  output.close();  
+  output.close();
 
   // ++++++++++++++++++++++++++++++++++++++Plotting Forces vs. Order
@@ -448 +447 @@
   if(!OpenOutputFile(output, argv[3],"MinMeanMaxTotalForce-Order.pyx")) return 1;
   CreatePlotHeader(output, "MinMeanMaxTotalForce-Order", 1, "bottom left", "y", NULL, 1, 1, "bond order k", "absolute total force [Ht/a.u.]");
-  output << "plot "<< Orderxrange.str().c_str() << " [1e-8:1e+0] \\" << endl;  
+  output << "plot "<< Orderxrange.str().c_str() << " [1e-8:1e+0] \\" << endl;
   output << "'MinForces-Order.dat' title 'minimum' using 1:(sqrt($" << 8 << "*$" << 8 << "+$" << 8+1 << "*$" << 8+1 << "+$" << 8+2 << "*$" << 8+2 << ")) with linespoints, \\" << endl;
   output << "'MeanForces-Order.dat' title 'mean' using 1:(abs($" << 8 << ")) with linespoints, \\" << endl;
   output << "'MaxForces-Order.dat' title 'maximum' using 1:(sqrt($" << 8 << "*$" << 8 << "+$" << 8+1 << "*$" << 8+1 << "+$" << 8+2 << "*$" << 8+2 << ")) with linespoints" << endl;
-  output.close();  
+  output.close();
 
   // ++++++++++++++++++++++++++++++++++++++Plotting vector sum vs. Order
@@ -471 +470 @@
   // min
   if (!CreatePlotOrder(ForceFragments, KeySet, argv[3], "MinForces-Fragment", 5, "below", "y", "set boxwidth 0.2", 1, 5, "fragment number", "minimum of approximated forces [Ht/a.u.]", Fragmentxrange.str().c_str(), yrange.str().c_str(), "2" , "with boxes fillcolor", BoxesForcePlotLine)) return 1;
-    
+
   // mean
   if (!CreatePlotOrder(ForceFragments, KeySet, argv[3], "MeanForces-Fragment", 5, "below", "y", "set boxwidth 0.2", 1, 5, "fragment number", "mean of approximated forces [Ht/a.u.]", Fragmentxrange.str().c_str(), yrange.str().c_str(), "2" , "with boxes fillcolor", BoxesFirstForceValuePlotLine)) return 1;
-    
+
   // max
   if (!CreatePlotOrder(ForceFragments, KeySet, argv[3], "MaxForces-Fragment", 5, "below", "y", "set boxwidth 0.2", 1, 5, "fragment number", "maximum of approximated forces [Ht/a.u.]", Fragmentxrange.str().c_str(), yrange.str().c_str(), "2" , "with boxes fillcolor", BoxesForcePlotLine)) return 1;
@@ -481 +480 @@
   // min
   if (!CreatePlotOrder(ForceFragments, KeySet, argv[3], "MinForces-FragmentOrder", 5, "below", "y", "set boxwidth 0.2", 1, 1, "bond order", "minimum of approximated forces [Ht/a.u.]", Orderxrange.str().c_str(), yrange.str().c_str(), "1" , "with boxes fillcolor", BoxesForcePlotLine)) return 1;
-    
+
   // mean
   if (!CreatePlotOrder(ForceFragments, KeySet, argv[3], "MeanForces-FragmentOrder", 5, "below", "y", "set boxwidth 0.2", 1, 1, "bond order", "mean of approximated forces [Ht/a.u.]", Orderxrange.str().c_str(), yrange.str().c_str(), "1" , "with boxes fillcolor", BoxesFirstForceValuePlotLine)) return 1;
-    
+
   // max
   if (!CreatePlotOrder(ForceFragments, KeySet, argv[3], "MaxForces-FragmentOrder", 5, "below", "y", "set boxwidth 0.2", 1, 1, "bond order", "maximum of approximated forces [Ht/a.u.]", Orderxrange.str().c_str(), yrange.str().c_str(), "1" , "with boxes fillcolor", BoxesForcePlotLine)) return 1;
- 
+
   // +++++++++++++++++++++++++++++++=Ploting approximated and true shielding for each atom
   if (periode != NULL) { // also look for PAS values
@@ -553 +552 @@
   output << "\trm -rf $(EPS)" << endl;
   output.close();
- 
+
   // ++++++++++++++++ exit ++++++++++++++++++++++++++++++++++
   delete(periode);

src/atom.cpp

@@ -1 +1 @@
 /** \file atom.cpp
- * 
+ *
  * Function implementations for the class atom.
- * 
+ *
  */
 
 #include "molecules.hpp"
- 
+
 /************************************* Functions for class atom *************************************/
 
 /** Constructor of class atom.
  */
-atom::atom() 
+atom::atom()
 {
   Name = NULL;
@@ -33 +33 @@
 /** Destructor of class atom.
  */
-atom::~atom() 
+atom::~atom()
 {
   Free((void **)&Name, "atom::~atom: *Name");
@@ -58 +58 @@
  * \param AtomNo cardinal number among these atoms of the same element
  * \param *out stream to output to
+ * \param *comment commentary after '#' sign
  */
-bool atom::Output(int ElementNo, int AtomNo, ofstream *out) const
+bool atom::Output(int ElementNo, int AtomNo, ofstream *out, const char *comment) const
 {
   if (out != NULL) {
@@ -67 +68 @@
     if (v.Norm() > MYEPSILON)
       *out << "\t" << scientific << setprecision(6) << v.x[0] << "\t" << v.x[1] << "\t" << v.x[2] << "\t";
-    *out << " # Number in molecule " << nr << endl;
+    if (comment != NULL)
+      *out << " # " << comment << endl;
+    else
+      *out << " # molecule nr " << nr << endl;
     return true;
   } else
@@ -94 +98 @@
  * \param ptr atom to compare index against
  * \return true - this one's is smaller, false - not
- */ 
+ */
 bool atom::Compare(atom &ptr)
 {
@@ -103 +107 @@
 };
 
-bool operator < (atom &a, atom &b) 
+bool operator < (atom &a, atom &b)
 {
   return a.Compare(b);

src/boundary.cpp

@@ -1 @@
-#include "molecules.hpp"
 #include "boundary.hpp"
 
 #define DEBUG 1
-#define DoTecplotOutput 0
+#define DoSingleStepOutput 0
+#define DoTecplotOutput 1
 #define DoRaster3DOutput 1
+#define DoVRMLOutput 1
 #define TecplotSuffix ".dat"
 #define Raster3DSuffix ".r3d"
+#define VRMLSUffix ".wrl"
+#define HULLEPSILON MYEPSILON
 
 // ======================================== Points on Boundary =================================
@@ -28 +31 @@
 {
   cout << Verbose(5) << "Erasing point nr. " << Nr << "." << endl;
+  if (!lines.empty())
+    cerr << "WARNING: Memory Leak! I " << *this << " am still connected to some lines." << endl;
   node = NULL;
   lines.clear();
@@ -33 +38 @@
 ;
 
-void
-BoundaryPointSet::AddLine(class BoundaryLineSet *line)
+void BoundaryPointSet::AddLine(class BoundaryLineSet *line)
 {
   cout << Verbose(6) << "Adding " << *this << " to line " << *line << "."
@@ -101 +105 @@
       cout << Verbose(5) << *endpoints[i] << " has still lines it's attached to." << endl;
   }
+  if (!triangles.empty())
+    cerr << "WARNING: Memory Leak! I " << *this << " am still connected to some triangles." << endl;
 }
 ;
@@ -109 +115 @@
   cout << Verbose(6) << "Add " << triangle->Nr << " to line " << *this << "."
       << endl;
-  triangles.insert(TrianglePair(TrianglesCount, triangle));
+  triangles.insert(TrianglePair(triangle->Nr, triangle));
   TrianglesCount++;
 }
@@ -205 +211 @@
 
   // make it always point inward (any offset vector onto plane projected onto normal vector suffices)
-  if (endpoints[0]->node->x.Projection(&OtherVector) > 0)
+  if (NormalVector.Projection(&OtherVector) > 0)
     NormalVector.Scale(-1.);
 }
@@ -565 +571 @@
 ;
 
-/** Creates the objects in a raster3d file (renderable with a header.r3d)
+/** Creates the objects in a VRML file.
  * \param *out output stream for debugging
- * \param *tecplot output stream for tecplot data
+ * \param *vrmlfile output stream for tecplot data
+ * \param *Tess Tesselation structure with constructed triangles
+ * \param *mol molecule structure with atom positions
+ */
+void write_vrml_file(ofstream *out, ofstream *vrmlfile, class Tesselation *Tess, class molecule *mol)
+{
+  atom *Walker = mol->start;
+  bond *Binder = mol->first;
+  int i;
+  Vector *center = mol->DetermineCenterOfAll(out);
+  if (vrmlfile != NULL) {
+    //cout << Verbose(1) << "Writing Raster3D file ... ";
+    *vrmlfile << "#VRML V2.0 utf8" << endl;
+    *vrmlfile << "#Created by molecuilder" << endl;
+    *vrmlfile << "#All atoms as spheres" << endl;
+    while (Walker->next != mol->end) {
+      Walker = Walker->next;
+      *vrmlfile << "Sphere {" << endl << "  "; // 2 is sphere type
+      for (i=0;i<NDIM;i++)
+        *vrmlfile << Walker->x.x[i]+center->x[i] << " ";
+      *vrmlfile << "\t0.1\t1. 1. 1." << endl; // radius 0.05 and white as colour
+    }
+
+    *vrmlfile << "# All bonds as vertices" << endl;
+    while (Binder->next != mol->last) {
+      Binder = Binder->next;
+      *vrmlfile << "3" << endl << "  "; // 2 is round-ended cylinder type
+      for (i=0;i<NDIM;i++)
+        *vrmlfile << Binder->leftatom->x.x[i]+center->x[i] << " ";
+      *vrmlfile << "\t0.03\t";
+      for (i=0;i<NDIM;i++)
+        *vrmlfile << Binder->rightatom->x.x[i]+center->x[i] << " ";
+      *vrmlfile << "\t0.03\t0. 0. 1." << endl; // radius 0.05 and blue as colour
+    }
+
+    *vrmlfile << "# All tesselation triangles" << endl;
+    for (TriangleMap::iterator TriangleRunner = Tess->TrianglesOnBoundary.begin(); TriangleRunner != Tess->TrianglesOnBoundary.end(); TriangleRunner++) {
+      *vrmlfile << "1" << endl << "  "; // 1 is triangle type
+      for (i=0;i<3;i++) { // print each node
+        for (int j=0;j<NDIM;j++)  // and for each node all NDIM coordinates
+          *vrmlfile << TriangleRunner->second->endpoints[i]->node->x.x[j]+center->x[j] << " ";
+        *vrmlfile << "\t";
+      }
+      *vrmlfile << "1. 0. 0." << endl;  // red as colour
+      *vrmlfile << "18" << endl << "  0.5 0.5 0.5" << endl; // 18 is transparency type for previous object
+    }
+  } else {
+    cerr << "ERROR: Given vrmlfile is " << vrmlfile << "." << endl;
+  }
+  delete(center);
+};
+
+/** Creates the objects in a raster3d file (renderable with a header.r3d).
+ * \param *out output stream for debugging
+ * \param *rasterfile output stream for tecplot data
  * \param *Tess Tesselation structure with constructed triangles
  * \param *mol molecule structure with atom positions
@@ -603 +663 @@
 
     *rasterfile << "# All tesselation triangles" << endl;
+    *rasterfile << "8\n  25. -1.   1. 1. 1.   0.0    0 0 0 2\n  SOLID     1.0 0.0 0.0\n  BACKFACE  0.3 0.3 1.0   0 0\n";
     for (TriangleMap::iterator TriangleRunner = Tess->TrianglesOnBoundary.begin(); TriangleRunner != Tess->TrianglesOnBoundary.end(); TriangleRunner++) {
       *rasterfile << "1" << endl << "  ";  // 1 is triangle type
@@ -613 +674 @@
       *rasterfile << "18" << endl << "  0.5 0.5 0.5" << endl;  // 18 is transparency type for previous object
     }
+    *rasterfile << "9\n  terminating special property\n";
   } else {
     cerr << "ERROR: Given rasterfile is " << rasterfile << "." << endl;
@@ -673 +735 @@
  * Determines first the convex envelope, then tesselates it and calculates its volume.
  * \param *out output stream for debugging
- * \param *tecplot output stream for tecplot data
+ * \param *filename filename prefix for output of vertex data
  * \param *configuration needed for path to store convex envelope file
  * \param *BoundaryPoints NDIM set of boundary points on the projected plane per axis, on return if desired
@@ -680 +742 @@
  */
 double
-VolumeOfConvexEnvelope(ofstream *out, ofstream *tecplot, config *configuration,
+VolumeOfConvexEnvelope(ofstream *out, const char *filename, config *configuration,
     Boundaries *BoundaryPtr, molecule *mol)
 {
@@ -761 +823 @@
       y.CopyVector(&runner->second->endpoints[0]->node->x);
       y.SubtractVector(&runner->second->endpoints[2]->node->x);
-      a = sqrt(runner->second->endpoints[0]->node->x.Distance(
+      a = sqrt(runner->second->endpoints[0]->node->x.DistanceSquared(
           &runner->second->endpoints[1]->node->x));
-      b = sqrt(runner->second->endpoints[0]->node->x.Distance(
+      b = sqrt(runner->second->endpoints[0]->node->x.DistanceSquared(
           &runner->second->endpoints[2]->node->x));
-      c = sqrt(runner->second->endpoints[2]->node->x.Distance(
+      c = sqrt(runner->second->endpoints[2]->node->x.DistanceSquared(
           &runner->second->endpoints[1]->node->x));
-      G = sqrt(((a * a + b * b + c * c) * (a * a + b * b + c * c) - 2 * (a * a
-          * a * a + b * b * b * b + c * c * c * c)) / 16.); // area of tesselated triangle
+      G = sqrt(((a + b + c) * (a + b + c) - 2 * (a * a + b * b + c * c)) / 16.); // area of tesselated triangle
       x.MakeNormalVector(&runner->second->endpoints[0]->node->x,
           &runner->second->endpoints[1]->node->x,
@@ -797 +858 @@
 
   // 8. Store triangles in tecplot file
+  string OutputName(filename);
+  OutputName.append(TecplotSuffix);
+  ofstream *tecplot = new ofstream(OutputName.c_str());
   write_tecplot_file(out, tecplot, TesselStruct, mol, 0);
+  tecplot->close();
+  delete(tecplot);
 
   // free reference lists
@@ -998 +1064 @@
           for (; C != PointsOnBoundary.end(); C++)
             {
-              tmp = A->second->node->x.Distance(&B->second->node->x);
+              tmp = A->second->node->x.DistanceSquared(&B->second->node->x);
               distance = tmp * tmp;
-              tmp = A->second->node->x.Distance(&C->second->node->x);
+              tmp = A->second->node->x.DistanceSquared(&C->second->node->x);
               distance += tmp * tmp;
-              tmp = B->second->node->x.Distance(&C->second->node->x);
+              tmp = B->second->node->x.DistanceSquared(&C->second->node->x);
               distance += tmp * tmp;
               DistanceMMap.insert(DistanceMultiMapPair(distance, pair<
@@ -1070 +1136 @@
             }
           // 4d. Check whether the point is inside the triangle (check distance to each node
-          tmp = checker->second->node->x.Distance(&A->second->node->x);
+          tmp = checker->second->node->x.DistanceSquared(&A->second->node->x);
           int innerpoint = 0;
-          if ((tmp < A->second->node->x.Distance(
+          if ((tmp < A->second->node->x.DistanceSquared(
               &baseline->second.first->second->node->x)) && (tmp
-              < A->second->node->x.Distance(
+              < A->second->node->x.DistanceSquared(
                   &baseline->second.second->second->node->x)))
             innerpoint++;
-          tmp = checker->second->node->x.Distance(
+          tmp = checker->second->node->x.DistanceSquared(
               &baseline->second.first->second->node->x);
-          if ((tmp < baseline->second.first->second->node->x.Distance(
+          if ((tmp < baseline->second.first->second->node->x.DistanceSquared(
               &A->second->node->x)) && (tmp
-              < baseline->second.first->second->node->x.Distance(
+              < baseline->second.first->second->node->x.DistanceSquared(
                   &baseline->second.second->second->node->x)))
             innerpoint++;
-          tmp = checker->second->node->x.Distance(
+          tmp = checker->second->node->x.DistanceSquared(
               &baseline->second.second->second->node->x);
-          if ((tmp < baseline->second.second->second->node->x.Distance(
+          if ((tmp < baseline->second.second->second->node->x.DistanceSquared(
               &baseline->second.first->second->node->x)) && (tmp
-              < baseline->second.second->second->node->x.Distance(
+              < baseline->second.second->second->node->x.DistanceSquared(
                   &A->second->node->x)))
             innerpoint++;
@@ -1483 +1549 @@
 ;
 
+
+double det_get(gsl_matrix *A, int inPlace) {
+  /*
+  inPlace = 1 => A is replaced with the LU decomposed copy.
+  inPlace = 0 => A is retained, and a copy is used for LU.
+  */
+
+  double det;
+  int signum;
+  gsl_permutation *p = gsl_permutation_alloc(A->size1);
+  gsl_matrix *tmpA;
+
+  if (inPlace)
+  tmpA = A;
+  else {
+  gsl_matrix *tmpA = gsl_matrix_alloc(A->size1, A->size2);
+  gsl_matrix_memcpy(tmpA , A);
+  }
+
+
+  gsl_linalg_LU_decomp(tmpA , p , &signum);
+  det = gsl_linalg_LU_det(tmpA , signum);
+  gsl_permutation_free(p);
+  if (! inPlace)
+  gsl_matrix_free(tmpA);
+
+  return det;
+};
+
+void get_sphere(Vector *center, Vector &a, Vector &b, Vector &c, double RADIUS)
+{
+  gsl_matrix *A = gsl_matrix_calloc(3,3);
+  double m11, m12, m13, m14;
+
+  for(int i=0;i<3;i++) {
+    gsl_matrix_set(A, i, 0, a.x[i]);
+    gsl_matrix_set(A, i, 1, b.x[i]);
+    gsl_matrix_set(A, i, 2, c.x[i]);
+  }
+  m11 = det_get(A, 1);
+
+  for(int i=0;i<3;i++) {
+    gsl_matrix_set(A, i, 0, a.x[i]*a.x[i] + b.x[i]*b.x[i] + c.x[i]*c.x[i]);
+    gsl_matrix_set(A, i, 1, b.x[i]);
+    gsl_matrix_set(A, i, 2, c.x[i]);
+  }
+  m12 = det_get(A, 1);
+
+  for(int i=0;i<3;i++) {
+    gsl_matrix_set(A, i, 0, a.x[i]*a.x[i] + b.x[i]*b.x[i] + c.x[i]*c.x[i]);
+    gsl_matrix_set(A, i, 1, a.x[i]);
+    gsl_matrix_set(A, i, 2, c.x[i]);
+  }
+  m13 = det_get(A, 1);
+
+  for(int i=0;i<3;i++) {
+    gsl_matrix_set(A, i, 0, a.x[i]*a.x[i] + b.x[i]*b.x[i] + c.x[i]*c.x[i]);
+    gsl_matrix_set(A, i, 1, a.x[i]);
+    gsl_matrix_set(A, i, 2, b.x[i]);
+  }
+  m14 = det_get(A, 1);
+
+  if (fabs(m11) < MYEPSILON)
+    cerr << "ERROR: three points are colinear." << endl;
+
+  center->x[0] =  0.5 * m12/ m11;
+  center->x[1] = -0.5 * m13/ m11;
+  center->x[2] =  0.5 * m14/ m11;
+
+  if (fabs(a.Distance(center) - RADIUS) > MYEPSILON)
+    cerr << "ERROR: The given center is further way by " << fabs(a.Distance(center) - RADIUS) << " from a than RADIUS." << endl;
+
+  gsl_matrix_free(A);
+};
+
+
+
 /**
  * Function returns center of sphere with RADIUS, which rests on points a, b, c
@@ -1489 +1632 @@
  * @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
@@ -1500 +1642 @@
  * @param Umkreisradius double radius of circumscribing circle
  */
-
-  void Get_center_of_sphere(Vector* Center, Vector a, Vector b, Vector c, Vector *NewUmkreismittelpunkt, Vector* Direction, Vector* AlternativeDirection,
-      double HalfplaneIndicator, double AlternativeIndicator, double alpha, double beta, double gamma, double RADIUS, double Umkreisradius)
-  {
-    Vector TempNormal, helper;
-    double Restradius;
-    cout << Verbose(3) << "Begin of Get_center_of_sphere.\n";
-    Center->Zero();
-    helper.CopyVector(&a);
-    helper.Scale(sin(2.*alpha));
-    Center->AddVector(&helper);
-    helper.CopyVector(&b);
-    helper.Scale(sin(2.*beta));
-    Center->AddVector(&helper);
-    helper.CopyVector(&c);
-    helper.Scale(sin(2.*gamma));
-    Center->AddVector(&helper);
-    //*Center = a * sin(2.*alpha) + b * sin(2.*beta) + c * sin(2.*gamma) ;
-    Center->Scale(1./(sin(2.*alpha) + sin(2.*beta) + sin(2.*gamma)));
-    NewUmkreismittelpunkt->CopyVector(Center);
-    cout << Verbose(4) << "Center of new circumference is " << *NewUmkreismittelpunkt << ".\n";
-    // Here we calculated center of circumscribing circle, using barycentric coordinates
-    cout << Verbose(4) << "Center of circumference is " << *Center << " in direction " << *Direction << ".\n";
-
-    TempNormal.CopyVector(&a);
-    TempNormal.SubtractVector(&b);
-    helper.CopyVector(&a);
-    helper.SubtractVector(&c);
-    TempNormal.VectorProduct(&helper);
-    if (fabs(HalfplaneIndicator) < MYEPSILON)
-      {
-        if ((TempNormal.ScalarProduct(AlternativeDirection) <0 and AlternativeIndicator >0) or (TempNormal.ScalarProduct(AlternativeDirection) >0 and AlternativeIndicator <0))
-          {
-            TempNormal.Scale(-1);
-          }
-      }
-    else
-      {
-        if (TempNormal.ScalarProduct(Direction)<0 && HalfplaneIndicator >0 || TempNormal.ScalarProduct(Direction)>0 && HalfplaneIndicator<0)
-          {
-            TempNormal.Scale(-1);
-          }
-      }
-
-    TempNormal.Normalize();
-    Restradius = sqrt(RADIUS*RADIUS - Umkreisradius*Umkreisradius);
-    cout << Verbose(4) << "Height of center of circumference to center of sphere is " << Restradius << ".\n";
-    TempNormal.Scale(Restradius);
-    cout << Verbose(4) << "Shift vector to sphere of circumference is " << TempNormal << ".\n";
-
-    Center->AddVector(&TempNormal);
-    cout << Verbose(4) << "Center of sphere of circumference is " << *Center << ".\n";
-    cout << Verbose(3) << "End of Get_center_of_sphere.\n";
-  }
-  ;
-
+void Get_center_of_sphere(Vector* Center, Vector a, Vector b, Vector c, Vector *NewUmkreismittelpunkt, Vector* Direction, Vector* AlternativeDirection,
+    double HalfplaneIndicator, double AlternativeIndicator, double alpha, double beta, double gamma, double RADIUS, double Umkreisradius)
+{
+  Vector TempNormal, helper;
+  double Restradius;
+  Vector OtherCenter;
+  cout << Verbose(3) << "Begin of Get_center_of_sphere.\n";
+  Center->Zero();
+  helper.CopyVector(&a);
+  helper.Scale(sin(2.*alpha));
+  Center->AddVector(&helper);
+  helper.CopyVector(&b);
+  helper.Scale(sin(2.*beta));
+  Center->AddVector(&helper);
+  helper.CopyVector(&c);
+  helper.Scale(sin(2.*gamma));
+  Center->AddVector(&helper);
+  //*Center = a * sin(2.*alpha) + b * sin(2.*beta) + c * sin(2.*gamma) ;
+  Center->Scale(1./(sin(2.*alpha) + sin(2.*beta) + sin(2.*gamma)));
+  NewUmkreismittelpunkt->CopyVector(Center);
+  cout << Verbose(4) << "Center of new circumference is " << *NewUmkreismittelpunkt << ".\n";
+  // Here we calculated center of circumscribing circle, using barycentric coordinates
+  cout << Verbose(4) << "Center of circumference is " << *Center << " in direction " << *Direction << ".\n";
+
+  TempNormal.CopyVector(&a);
+  TempNormal.SubtractVector(&b);
+  helper.CopyVector(&a);
+  helper.SubtractVector(&c);
+  TempNormal.VectorProduct(&helper);
+  if (fabs(HalfplaneIndicator) < MYEPSILON)
+    {
+      if ((TempNormal.ScalarProduct(AlternativeDirection) <0 and AlternativeIndicator >0) or (TempNormal.ScalarProduct(AlternativeDirection) >0 and AlternativeIndicator <0))
+        {
+          TempNormal.Scale(-1);
+        }
+    }
+  else
+    {
+      if (TempNormal.ScalarProduct(Direction)<0 && HalfplaneIndicator >0 || TempNormal.ScalarProduct(Direction)>0 && HalfplaneIndicator<0)
+        {
+          TempNormal.Scale(-1);
+        }
+    }
+  TempNormal.Normalize();
+  Restradius = sqrt(RADIUS*RADIUS - Umkreisradius*Umkreisradius);
+  cout << Verbose(4) << "Height of center of circumference to center of sphere is " << Restradius << ".\n";
+  TempNormal.Scale(Restradius);
+  cout << Verbose(4) << "Shift vector to sphere of circumference is " << TempNormal << ".\n";
+
+  Center->AddVector(&TempNormal);
+  cout << Verbose(0) << "Center of sphere of circumference is " << *Center << ".\n";
+  get_sphere(&OtherCenter, a, b, c, RADIUS);
+  cout << Verbose(0) << "OtherCenter of sphere of circumference is " << OtherCenter << ".\n";
+  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.
@@ -1580 +1721 @@
  * @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,
@@ -1633 +1773 @@
     }
 
-    if ((M_PI*4. > alpha*5.) && (M_PI*4. > beta*5.) && (M_PI*4 > gamma*5.)) {
+    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;
@@ -1655 +1795 @@
           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);
-
-        AngleCheck.CopyVector(&ReferencePoint);
-        AngleCheck.Scale(-1);
-        //cout << "AngleCheck is " << AngleCheck.x[0] << " "<< AngleCheck.x[1] << " "<< AngleCheck.x[2] << " "<< endl;
-        AngleCheck.AddVector(&Mittelpunkt);
-        //cout << "AngleCheck is " << AngleCheck.x[0] << " "<< AngleCheck.x[1] << " "<< AngleCheck.x[2] << " "<< endl;
-        cout << Verbose(4) << "Reference vector to sphere's center is " << AngleCheck << "." << endl;
-
-        BallAngle = AngleCheck.Angle(OldNormal);
-        cout << Verbose(3) << "Angle between normal of base triangle and center of ball sphere is :" << BallAngle << "." << endl;
-
-        //cout << "direction1 is " << direction1->x[0] <<" "<< direction1->x[1] <<" "<< direction1->x[2] <<" " << endl;
-        //cout << "AngleCheck is " << AngleCheck.x[0] << " "<< AngleCheck.x[1] << " "<< AngleCheck.x[2] << " "<< 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;
 
-        NewUmkreismittelpunkt.SubtractVector(&ReferencePoint);
-
-        if ((AngleCheck.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 ";
+          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;
+                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;
+              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 << " refused due to Up/Down sign which is " << sign << endl;
+            cout << Verbose(3) << *Candidate << " is not in search direction." << endl;
           }
         }
@@ -1741 +1875 @@
 
 
-  /** 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 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 d1 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 Opt_Candidate candidate reference to return
-   * @param Opt_Mittelpunkt Centerpoint of ball, when resting on Opt_Candidate
-   * @param Storage array containing two angles of current Opt_Candidate
-   * @param RADIUS radius of ball
-   * @param mol molecule structure with atoms and bonds
-   */
-void Find_next_suitable_point(atom* a, atom* b, atom* Candidate, atom* Parent,
-    int RecursionLevel, Vector *Chord, Vector *d1, Vector *OldNormal,
-    atom*& Opt_Candidate, Vector *Opt_Mittelpunkt, double *Storage, const double RADIUS, molecule* mol)
-{
-  /* OldNormal is normal vector on the old triangle
-   * d1 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, AngleCheckReference, DirectionCheckPoint;
-  Vector TempNormal, Umkreismittelpunkt, Mittelpunkt, helper;
-
-  double CurrentEpsilon = 0.1;
-  double alpha, beta, gamma, SideA, SideB, SideC, sign, Umkreisradius, Restradius;
-  double BallAngle;
-  atom *Walker; // variable atom point
-
-
-  dif_a.CopyVector(&(a->x));
-  dif_a.SubtractVector(&(Candidate->x));
-  dif_b.CopyVector(&(b->x));
-  dif_b.SubtractVector(&(Candidate->x));
-  DirectionCheckPoint.CopyVector(&dif_a);
-  DirectionCheckPoint.Scale(-1);
-  DirectionCheckPoint.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);
-
-
-  if (DEBUG) {
-    cout << "Atom number" << Candidate->nr << endl;
-    Candidate->x.Output((ofstream *) &cout);
-    cout << "number of bonds " << mol->NumberOfBondsPerAtom[Candidate->nr] << endl;
-  }
-
-  if (a != Candidate and b != Candidate) {
-    //      alpha = dif_a.Angle(&dif_b) / 2.;
-    //      SideA = Chord->Norm() / 2.;// (Chord->Norm()/2.) / sin(0.5*alpha);
-    //      SideB = dif_a.Norm();
-    //      centerline = SideA * SideA + SideB * SideB - 2. * SideA * SideB * cos(
-    //          alpha); // note this is squared of center line length
-    //      centerline = (Chord->Norm()/2.) / sin(0.5*alpha);
-    // Those are remains from Freddie. Needed?
-
-    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 && DirectionCheckPoint.ScalarProduct(&(Candidate->x))>0) { //Checking whether ball will at least rest o points.
-      // intermediate calculations to aquire centre of sphere, called Mittelpunkt:
-      Umkreismittelpunkt.Zero();
-      helper.CopyVector(&a->x);
-      helper.Scale(sin(2.*alpha));
-      Umkreismittelpunkt.AddVector(&helper);
-      helper.CopyVector(&b->x);
-      helper.Scale(sin(2.*beta));
-      Umkreismittelpunkt.AddVector(&helper);
-      helper.CopyVector(&Candidate->x);
-      helper.Scale(sin(2.*gamma));
-      Umkreismittelpunkt.AddVector(&helper);
-      //Umkreismittelpunkt = (a->x) * sin(2.*alpha) + b->x * sin(2.*beta) + (Candidate->x) * sin(2.*gamma) ;
-      Umkreismittelpunkt.Scale(1/(sin(2*alpha) + sin(2*beta) + sin(2*gamma)));
-
-      TempNormal.CopyVector(&dif_a);
-      TempNormal.VectorProduct(&dif_b);
-      if (TempNormal.ScalarProduct(OldNormal)<0 && sign>0 || TempNormal.ScalarProduct(OldNormal)>0 && sign<0) {
-        TempNormal.Scale(-1);
+/** Constructs the center of the circumcircle defined by three points \a *a, \a *b and \a *c.
+ * \param *Center new center on return
+ * \param *a first point
+ * \param *b second point
+ * \param *c third point
+ */
+void GetCenterofCircumcircle(Vector *Center, Vector *a, Vector *b, Vector *c)
+{
+  Vector helper;
+  double alpha, beta, gamma;
+  Vector SideA, SideB, SideC;
+  SideA.CopyVector(b);
+  SideA.SubtractVector(c);
+  SideB.CopyVector(c);
+  SideB.SubtractVector(a);
+  SideC.CopyVector(a);
+  SideC.SubtractVector(b);
+  alpha = M_PI - SideB.Angle(&SideC);
+  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;
+  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;
+
+  Center->Zero();
+  helper.CopyVector(a);
+  helper.Scale(sin(2.*alpha));
+  Center->AddVector(&helper);
+  helper.CopyVector(b);
+  helper.Scale(sin(2.*beta));
+  Center->AddVector(&helper);
+  helper.CopyVector(c);
+  helper.Scale(sin(2.*gamma));
+  Center->AddVector(&helper);
+  Center->Scale(1./(sin(2.*alpha) + sin(2.*beta) + sin(2.*gamma)));
+};
+
+/** Returns the parameter "path length" for a given \a NewSphereCenter relative to \a OldSphereCenter on a circle on the plane \a CirclePlaneNormal with center \a CircleCenter and radius \a CircleRadius.
+ * Test whether the \a NewSphereCenter is really on the given plane and in distance \a CircleRadius from \a CircleCenter.
+ * It calculates the angle, making it unique on [0,2.*M_PI) by comparing to SearchDirection.
+ * Also the new center is invalid if it the same as the old one and does not lie right above (\a NormalVector) the base line (\a CircleCenter).
+ * \param CircleCenter Center of the parameter circle
+ * \param CirclePlaneNormal normal vector to plane of the parameter circle
+ * \param CircleRadius radius of the parameter circle
+ * \param NewSphereCenter new center of a circumcircle
+ * \param OldSphereCenter old center of a circumcircle, defining the zero "path length" on the parameter circle
+ * \param NormalVector normal vector
+ * \param SearchDirection search direction to make angle unique on return.
+ * \return Angle between \a NewSphereCenter and \a OldSphereCenter relative to \a CircleCenter, 2.*M_PI if one test fails
+ */
+double GetPathLengthonCircumCircle(Vector &CircleCenter, Vector &CirclePlaneNormal, double CircleRadius, Vector &NewSphereCenter, Vector &OldSphereCenter, Vector &NormalVector, Vector &SearchDirection)
+{
+  Vector helper;
+  double radius, alpha;
+
+  helper.CopyVector(&NewSphereCenter);
+  // test whether new center is on the parameter circle's plane
+  if (fabs(helper.ScalarProduct(&CirclePlaneNormal)) > HULLEPSILON) {
+    cerr << "ERROR: Something's very wrong here: NewSphereCenter is not on the band's plane as desired by " <<fabs(helper.ScalarProduct(&CirclePlaneNormal))  << "!" << endl;
+    helper.ProjectOntoPlane(&CirclePlaneNormal);
+  }
+  radius = helper.ScalarProduct(&helper);
+  // test whether the new center vector has length of CircleRadius
+  if (fabs(radius - CircleRadius) > HULLEPSILON)
+    cerr << Verbose(1) << "ERROR: The projected center of the new sphere has radius " << radius << " instead of " << CircleRadius << "." << endl;
+  alpha = helper.Angle(&OldSphereCenter);
+  // make the angle unique by checking the halfplanes/search direction
+  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;
+  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;
+    return alpha;
+  } else {
+    cout << Verbose(1) << "ERROR: NewSphereCenter " << helper << " is too close to OldSphereCenter" << OldSphereCenter << "." << endl;
+    return 2.*M_PI;
+  }
+};
+
+
+/** 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;
+// };
+
+
+/** This recursive function finds a third point, to form a triangle with two given ones.
+ * Note that this function is for the starting triangle.
+ * 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 NormalVector normal direction of the base triangle (here the unit axis vector, \sa Find_starting_triangle())
+ * @param SearchDirection general direction where to search for the next point, relative to center of BaseLine
+ * @param OldSphereCenter center of sphere for base triangle, relative to center of BaseLine, giving null angle for the parameter circle
+ * @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 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)
+{
+  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 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;
+  LinkedAtoms *List = NULL;
+  double CircleRadius; // radius of this circle
+  double radius;
+  double alpha, Otheralpha; // angles (i.e. parameter for the circle).
+  int N[NDIM], Nlower[NDIM], Nupper[NDIM];
+  atom *Candidate = NULL;
+
+  cout << Verbose(1) << "Begin of Find_third_point_for_Tesselation" << endl;
+
+  cout << Verbose(2) << "INFO: NormalVector of BaseTriangle is " << 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;
+
+    // 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) {
+
+      // check SearchDirection
+      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;
       }
-      TempNormal.Normalize();
-      Restradius = sqrt(RADIUS*RADIUS - Umkreisradius*Umkreisradius);
-      TempNormal.Scale(Restradius);
-
-      Mittelpunkt.CopyVector(&Umkreismittelpunkt);
-      Mittelpunkt.AddVector(&TempNormal);  //this is center of sphere supported by a, b and Candidate
-
-      AngleCheck.CopyVector(Chord);
-      AngleCheck.Scale(-0.5);
-      AngleCheck.SubtractVector(&(b->x));
-      AngleCheckReference.CopyVector(&AngleCheck);
-      AngleCheckReference.AddVector(Opt_Mittelpunkt);
-      AngleCheck.AddVector(&Mittelpunkt);
-
-      BallAngle = AngleCheck.Angle(&AngleCheckReference);
-
-      d1->ProjectOntoPlane(&AngleCheckReference);
-      sign = AngleCheck.ScalarProduct(d1);
-      if (fabs(sign) < MYEPSILON)
-        sign = 0;
-      else
-        sign /= fabs(sign); // +1 if in direction of triangle plane, -1 if in other direction...
-
-
-      if (Storage[0]< -1.5) { // first Candidate at all
-        cout << "Next better candidate is " << *Candidate << " with ";
-        Opt_Candidate = Candidate;
-        Storage[0] = sign;
-        Storage[1] = BallAngle;
-        Opt_Mittelpunkt->CopyVector(&Mittelpunkt);
-        cout << "Angle is " << Storage[1] << ", Halbraum ist " << Storage[0] << 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;
       } else {
-        /*
-         * removed due to change in criterium, now checking angle of ball to old normal.
-        //We will now check for non interference, that is if the new candidate would have the Opt_Candidate
-        //within the ball.
-
-        Distance = Opt_Candidate->x.Distance(&Mittelpunkt);
-        //cout << "Opt_Candidate " << Opt_Candidate << " has distance " << Distance << " to Center of Candidate " << endl;
-
-
-        if (Distance >RADIUS) { // We have no interference and may now check whether the new point is better.
-         */
-          //cout << "Atom " << Candidate << " has distance " << Candidate->x.Distance(Opt_Mittelpunkt) << " to Center of Candidate " << endl;
-
-        if (((Storage[0] < 0 && fabs(sign - Storage[0]) > CurrentEpsilon))) { //This will give absolute preference to those in "right-hand" quadrants
-          //(Candidate->x.Distance(Opt_Mittelpunkt) < RADIUS))    //and those where Candidate would be within old Sphere.
-          cout << "Next better candidate is " << *Candidate << " with ";
-          Opt_Candidate = Candidate;
-          Storage[0] = sign;
-          Storage[1] = BallAngle;
-          Opt_Mittelpunkt->CopyVector(&Mittelpunkt);
-          cout << "Angle is " << Storage[1] << ", Halbraum ist " << Storage[0] << endl;
-        } else {
-          if ((fabs(sign - Storage[0]) < CurrentEpsilon && sign > 0 && Storage[1] > BallAngle) || (fabs(sign - Storage[0]) < CurrentEpsilon && sign < 0 && Storage[1] < BallAngle)) {
-            //Depending on quadrant we prefer higher or lower atom with respect to Triangle normal first.
-            cout << "Next better candidate is " << *Candidate << " with ";
-            Opt_Candidate = Candidate;
-            Storage[0] = sign;
-            Storage[1] = BallAngle;
-            Opt_Mittelpunkt->CopyVector(&Mittelpunkt);
-            cout << "Angle is " << Storage[1] << ", Halbraum ist " << Storage[0] << endl;
+        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 != BaseLine->endpoints[0]->node) && (Candidate != BaseLine->endpoints[1]->node) && (Candidate != ThirdNode)) {
+                  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, 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;
+                      } 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 {
+                  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;
+                }
+              }
+            }
           }
-        }
-      }
-/*
-               * This is for checking point-angle and presence of Candidates in Ball, currently we are checking the ball Angle.
-               *
-                else
-                {
-                  if (sign>0 && BallAngle>0 && Storage[0]<0)
-                    {
-                      cout << "Next better candidate is " << *Candidate << " with ";
-                      Opt_Candidate = Candidate;
-                      Storage[0] = sign;
-                      Storage[1] = BallAngle;
-                      Opt_Mittelpunkt->CopyVector(&Mittelpunkt);
-                      cout << "Angle is " << Storage[1] << ", Halbraum ist "
-                      << Storage[0] << endl;
-
-//Debugging purposes only
-                      cout << "Umkreismittelpunkt has coordinates" << Umkreismittelpunkt.x[0] << " "<< Umkreismittelpunkt.x[1] <<" "<<Umkreismittelpunkt.x[2] << endl;
-                      cout << "Candidate has coordinates" << Candidate->x.x[0]<< " " << Candidate->x.x[1] << " " << Candidate->x.x[2] << endl;
-                      cout << "a has coordinates" << a->x.x[0]<< " " << a->x.x[1] << " " << a->x.x[2] << endl;
-                      cout << "b has coordinates" << b->x.x[0]<< " " << b->x.x[1] << " " << b->x.x[2] << endl;
-                      cout << "Mittelpunkt has coordinates" << Mittelpunkt.x[0] << " " << Mittelpunkt.x[1]<< " "  <<Mittelpunkt.x[2] << endl;
-                      cout << "Umkreisradius ist " << Umkreisradius << endl;
-                      cout << "Restradius ist " << Restradius << endl;
-                      cout << "TempNormal has coordinates " << TempNormal.x[0] << " " << TempNormal.x[1] << " " << TempNormal.x[2] << " " << endl;
-                      cout << "OldNormal has coordinates " << OldNormal->x[0] << " " << OldNormal->x[1] << " " << OldNormal->x[2] << " " << endl;
-                      cout << "Dist a to UmkreisMittelpunkt " << a->x.Distance(&Umkreismittelpunkt) << endl;
-                      cout << "Dist b to UmkreisMittelpunkt " << b->x.Distance(&Umkreismittelpunkt) << endl;
-                      cout << "Dist Candidate to UmkreisMittelpunkt " << Candidate->x.Distance(&Umkreismittelpunkt) << endl;
-                      cout << "Dist a to Mittelpunkt " << a->x.Distance(&Mittelpunkt) << endl;
-                      cout << "Dist b to Mittelpunkt " << b->x.Distance(&Mittelpunkt) << endl;
-                      cout << "Dist Candidate to Mittelpunkt " << Candidate->x.Distance(&Mittelpunkt) << endl;
-
-
-
-                    }
-                  else
-                    {
-                      if (DEBUG)
-                        cout << "Looses to better candidate" << endl;
-                    }
-                }
-                */
     } else {
-      if (DEBUG) {
-        cout << "Doesn't satisfy requirements for circumscribing circle" << endl;
-      }
+      cerr << Verbose(1) << "ERROR: The projected center of the old sphere has radius " << radius << " instead of " << CircleRadius << "." << endl;
     }
   } else {
-    if (DEBUG) {
-      cout << "identisch mit Ursprungslinie" << endl;
-    }
-  }
-
-  if (RecursionLevel < 9) { // Five 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(a, b, Walker, Candidate, RecursionLevel+1, Chord, d1, OldNormal, Opt_Candidate, Opt_Mittelpunkt, Storage, RADIUS, mol); //call function again
-      }
-    }
-  }
-};
-
-/** This function finds a triangle to a line, adjacent to an existing one.
- * @param out   output stream for debugging
- * @param tecplot output stream for writing found triangles in TecPlot format
- * @param mol molecule structure with all atoms and bonds
- * @param Line current baseline to search from
- * @param T current triangle which \a Line is edge of
- * @param RADIUS radius of the rolling ball
- * @param N number of found triangles
- * @param *filename filename base for intermediate envelopes
- */
-bool Tesselation::Find_next_suitable_triangle(ofstream *out, ofstream *tecplot,
-    molecule* mol, BoundaryLineSet &Line, BoundaryTriangleSet &T,
-    const double& RADIUS, int N, const char *tempbasename)
-{
-  cout << Verbose(1) << "Begin of Find_next_suitable_triangle\n";
-  Vector direction1;
-  Vector helper;
-  Vector Chord;
-  ofstream *tempstream = NULL;
-  char NumberName[255];
-  double tmp;
-  //atom* Walker;
-  atom* OldThirdPoint;
-
-  double Storage[3];
-  Storage[0] = -2.; // This direction is either +1 or -1 one, so any result will take precedence over initial values
-  Storage[1] = -2.; // This is also lower then any value produced by an eligible atom, which are all positive
-  Storage[2] = 9999999.;
-  atom* Opt_Candidate = NULL;
-  Vector Opt_Mittelpunkt;
-
-  cout << Verbose(1) << "Current baseline is " << Line << " of triangle " << T << "." << endl;
-
-  helper.CopyVector(&(Line.endpoints[0]->node->x));
-  for (int i = 0; i < 3; i++) {
-    if (T.endpoints[i]->node->nr != Line.endpoints[0]->node->nr && T.endpoints[i]->node->nr != Line.endpoints[1]->node->nr) {
-      OldThirdPoint = T.endpoints[i]->node;
-      helper.SubtractVector(&T.endpoints[i]->node->x);
-      break;
-    }
-  }
-
-  direction1.CopyVector(&Line.endpoints[0]->node->x);
-  direction1.SubtractVector(&Line.endpoints[1]->node->x);
-  direction1.VectorProduct(&(T.NormalVector));
-
-  if (direction1.ScalarProduct(&helper) < 0) {
-    direction1.Scale(-1);
-  }
-  cout << Verbose(2) << "Looking in direction " << direction1 << " for candidates.\n";
-
-  Chord.CopyVector(&(Line.endpoints[0]->node->x)); // bring into calling function
-  Chord.SubtractVector(&(Line.endpoints[1]->node->x));
-  cout << Verbose(2) << "Baseline vector is " << Chord << ".\n";
-
-
-  Vector Umkreismittelpunkt, a, b, c;
-  double alpha, beta, gamma;
-  a.CopyVector(&(T.endpoints[0]->node->x));
-  b.CopyVector(&(T.endpoints[1]->node->x));
-  c.CopyVector(&(T.endpoints[2]->node->x));
-  a.SubtractVector(&(T.endpoints[1]->node->x));
-  b.SubtractVector(&(T.endpoints[2]->node->x));
-  c.SubtractVector(&(T.endpoints[0]->node->x));
-
-  alpha = M_PI - a.Angle(&c);
-  beta = M_PI - b.Angle(&a);
-  gamma = M_PI - c.Angle(&b);
-  if (fabs(M_PI - alpha - beta - gamma) > MYEPSILON)
-    cerr << Verbose(0) << "WARNING: sum of angles for candidate triangle " << (alpha + beta + gamma)/M_PI*180. << " != 180.\n";
-
-  Umkreismittelpunkt.Zero();
-  helper.CopyVector(&T.endpoints[0]->node->x);
-  helper.Scale(sin(2.*alpha));
-  Umkreismittelpunkt.AddVector(&helper);
-  helper.CopyVector(&T.endpoints[1]->node->x);
-  helper.Scale(sin(2.*beta));
-  Umkreismittelpunkt.AddVector(&helper);
-  helper.CopyVector(&T.endpoints[2]->node->x);
-  helper.Scale(sin(2.*gamma));
-  Umkreismittelpunkt.AddVector(&helper);
-  //Umkreismittelpunkt = (T.endpoints[0]->node->x) * sin(2.*alpha) + T.endpoints[1]->node->x * sin(2.*beta) + (T.endpoints[2]->node->x) * sin(2.*gamma) ;
-  //cout << "UmkreisMittelpunkt is " << Umkreismittelpunkt.x[0] << " "<< Umkreismittelpunkt.x[1] << " "<< Umkreismittelpunkt.x[2] << " "<< endl;
-  Umkreismittelpunkt.Scale(1/(sin(2*alpha) + sin(2*beta) + sin(2*gamma)));
-  //cout << "UmkreisMittelpunkt is " << Umkreismittelpunkt.x[0] << " "<< Umkreismittelpunkt.x[1] << " "<< Umkreismittelpunkt.x[2] << " "<< endl;
-  cout << " We look over line " << Line << " in direction " << direction1.x[0] << " " << direction1.x[1] << " " << direction1.x[2] << " " << endl;
-  cout << " Old Normal is " <<  (T.NormalVector.x)[0] << " " << T.NormalVector.x[1] << " " << (T.NormalVector.x)[2] << " " << endl;
-
-  cout << Verbose(2) << "Base triangle has sides " << a << ", " << b << ", " << c << " with angles " << alpha/M_PI*180. << ", " << beta/M_PI*180. << ", " << gamma/M_PI*180. << "." << endl;
-  cout << Verbose(2) << "Center of circumference is " << Umkreismittelpunkt << "." << endl;
-  if (DEBUG)
-    cout << Verbose(3) << "Check of relative endpoints (same distance, equally spreaded): "<< endl;
-  tmp = 0;
-  for (int i=0;i<NDIM;i++) {
-    helper.CopyVector(&T.endpoints[i]->node->x);
-    helper.SubtractVector(&Umkreismittelpunkt);
-    if (DEBUG)
-      cout << Verbose(3) << "Endpoint[" << i << "]: " << helper << " with length " << helper.Norm() << "." << endl;
-    if (tmp == 0) // set on first time for comparison against next ones
-      tmp = helper.Norm();
-    if (fabs(helper.Norm() - tmp) > MYEPSILON)
-      cerr << Verbose(1) << "WARNING: center of circumference is wrong!" << endl;
-  }
-
-  cout << Verbose(1) << "Looking for third point candidates for triangle ... " << endl;
-
-  Find_next_suitable_point_via_Angle_of_Sphere(Line.endpoints[0]->node, Line.endpoints[1]->node, OldThirdPoint, Line.endpoints[0]->node, Line.endpoints[1]->node, 0, &Chord, &direction1, &(T.NormalVector), Umkreismittelpunkt, Opt_Candidate, Storage, RADIUS, mol);
-  Find_next_suitable_point_via_Angle_of_Sphere(Line.endpoints[0]->node, Line.endpoints[1]->node, OldThirdPoint, Line.endpoints[1]->node, Line.endpoints[0]->node, 0, &Chord, &direction1, &(T.NormalVector), Umkreismittelpunkt, Opt_Candidate, Storage, RADIUS, mol);
-  if (Opt_Candidate == NULL) {
-    cerr << "WARNING: Could not find a suitable candidate." << endl;
-    return false;
-  }
-  cout << Verbose(1) << " Optimal candidate is " << *Opt_Candidate << 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();
-
-    BTS->GetNormalVector(BTS->NormalVector);
-
-    if ((BTS->NormalVector.ScalarProduct(&(T.NormalVector)) < 0 && Storage[0] > 0)  || (BTS->NormalVector.ScalarProduct(&(T.NormalVector)) > 0 && Storage[0] < 0) || (fabs(Storage[0]) < MYEPSILON && Storage[1]*BTS->NormalVector.ScalarProduct(&direction1) < 0) ) {
-      BTS->NormalVector.Scale(-1);
-    };
-    cout << Verbose(1) << "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 ((TrianglesOnBoundaryCount % 10) == 0) {
-    sprintf(NumberName, "-%d", TriangleFilesWritten);
-    if (DoTecplotOutput) {
-      string NameofTempFile(tempbasename);
-      NameofTempFile.append(NumberName);
-      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);
-      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);
-      tempstream->close();
-      tempstream->flush();
-      delete(tempstream);
-    }
-    if (DoTecplotOutput || DoRaster3DOutput)
-      TriangleFilesWritten++;
-  }
-
-  cout << Verbose(1) << "End of Find_next_suitable_triangle\n";
-  return true;
+    if (ThirdNode != NULL)
+      cout << Verbose(1) << "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(1) << "End of Find_third_point_for_Tesselation" << endl;
 };
 
@@ -2194 +2375 @@
 
 
-void Find_second_point_for_Tesselation(atom* a, atom* Candidate, atom* Parent,
-    int RecursionLevel, Vector Oben, atom*& Opt_Candidate, double Storage[3],
-    molecule* mol, double RADIUS)
-{
-  cout << Verbose(2) << "Begin of Find_second_point_for_Tesselation, recursive level " << RecursionLevel << endl;
-  int i;
+/** Finds the second point of starting triangle.
+ * \param *a first atom
+ * \param *Candidate pointer to candidate atom on return
+ * \param Oben vector indicating the outside
+ * \param Opt_Candidate reference to recommended candidate on return
+ * \param Storage[3] array storing angles and other candidate information
+ * \param RADIUS radius of virtual sphere
+ * \param *LC LinkedCell structure with neighbouring atoms
+ */
+void Find_second_point_for_Tesselation(atom* a, atom* Candidate, Vector Oben, atom*& Opt_Candidate, double Storage[3], double RADIUS, LinkedCell *LC)
+{
+  cout << Verbose(2) << "Begin of Find_second_point_for_Tesselation" << endl;
   Vector AngleCheck;
-  atom* Walker;
   double norm = -1., angle;
-
-  // 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();
-    // second point shall have smallest angle with respect to Oben vector
-    if (norm < RADIUS) {
-      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";
-        Opt_Candidate = Candidate;
-        Storage[0] = AngleCheck.Angle(&Oben);
-        //cout << Verbose(1) << "Changing something in Storage: %lf %lf. \n", Storage[0], Storage[2]);
-      } else {
-        cout << "Looses with angle " << angle << " to a better candidate " << *Opt_Candidate << endl;
+  LinkedAtoms *List = NULL;
+  int N[NDIM], Nlower[NDIM], Nupper[NDIM];
+
+  if (LC->SetIndexToAtom(a)) {  // get cell for the starting atom
+    for(int i=0;i<NDIM;i++) // store indices of this cell
+      N[i] = LC->n[i];
+  } else {
+    cerr << "ERROR: Atom " << *a << " is not found in cell " << LC->index << "." << 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 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();
+              // second point shall have smallest angle with respect to Oben vector
+              if (norm < RADIUS) {
+                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";
+                  Opt_Candidate = Candidate;
+                  Storage[0] = AngleCheck.Angle(&Oben);
+                  //cout << Verbose(1) << "Changing something in Storage: %lf %lf. \n", Storage[0], Storage[2]);
+                } else {
+                  cout << "Looses with angle " << angle << " to a better candidate " << *Opt_Candidate << endl;
+                }
+              } else {
+                cout << "Refused due to Radius " << norm << endl;
+              }
+            }
+          }
+        }
       }
-    } else {
-      cout << "Refused due to Radius " << norm << endl;
-    }
-  }
-
-  // if not recursed to deeply, look at all its bonds
-  if (RecursionLevel < 7) {
-    for (i = 0; i < mol->NumberOfBondsPerAtom[Candidate->nr]; i++) {
-      Walker = mol->ListOfBondsPerAtom[Candidate->nr][i]->GetOtherAtom(Candidate);
-      if (Walker == Parent) // don't go back along the bond we came from
-        continue;
-      else
-        Find_second_point_for_Tesselation(a, Walker, Candidate, RecursionLevel + 1, Oben, Opt_Candidate, Storage, mol, RADIUS);
-    }
-  }
-  cout << Verbose(2) << "End of Find_second_point_for_Tesselation, recursive level " << RecursionLevel << endl;
+  cout << Verbose(2) << "End of Find_second_point_for_Tesselation" << endl;
 };
 
-void Tesselation::Find_starting_triangle(molecule* mol, const double RADIUS)
+/** Finds the starting triangle for find_non_convex_border().
+ * Looks at the outermost atom per axis, then Find_second_point_for_Tesselation()
+ * for the second and Find_next_suitable_point_via_Angle_of_Sphere() for the third
+ * point are called.
+ * \param RADIUS radius of virtual rolling sphere
+ * \param *LC LinkedCell structure with neighbouring atoms
+ */
+void Tesselation::Find_starting_triangle(ofstream *out, molecule *mol, const double RADIUS, LinkedCell *LC)
 {
   cout << Verbose(1) << "Begin of Find_starting_triangle\n";
   int i = 0;
-  atom* Walker;
+  LinkedAtoms *List = NULL;
   atom* FirstPoint;
   atom* SecondPoint;
-  atom* max_index[NDIM];
+  atom* MaxAtom[NDIM];
   double max_coordinate[NDIM];
   Vector Oben;
   Vector helper;
   Vector Chord;
-  Vector CenterOfFirstLine;
+  Vector SearchDirection;
+  Vector OptCandidateCenter;
 
   Oben.Zero();
 
   for (i = 0; i < 3; i++) {
-    max_index[i] = NULL;
+    MaxAtom[i] = NULL;
     max_coordinate[i] = -1;
   }
-  cout << Verbose(2) << "Molecule mol is there and has " << mol->AtomCount << " Atoms \n";
 
   // 1. searching topmost atom with respect to each axis
-  Walker = mol->start;
-  while (Walker->next != mol->end) {
-    Walker = Walker->next;
-    for (i = 0; i < 3; i++) {
-      if (Walker->x.x[i] > max_coordinate[i]) {
-        max_coordinate[i] = Walker->x.x[i];
-        max_index[i] = Walker;
+  for (int i=0;i<NDIM;i++) { // each axis
+    LC->n[i] = LC->N[i]-1; // current axis is topmost cell
+    for (LC->n[(i+1)%NDIM]=0;LC->n[(i+1)%NDIM]<LC->N[(i+1)%NDIM];LC->n[(i+1)%NDIM]++)
+      for (LC->n[(i+2)%NDIM]=0;LC->n[(i+2)%NDIM]<LC->N[(i+2)%NDIM];LC->n[(i+2)%NDIM]++) {
+        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++) {
+            cout << Verbose(2) << "Current atom is " << *(*Runner) << "." << endl;
+            if ((*Runner)->x.x[i] > max_coordinate[i]) {
+              max_coordinate[i] = (*Runner)->x.x[i];
+              MaxAtom[i] = (*Runner);
+            }
+          }
+        } else {
+          cerr << "ERROR: The current cell " << LC->n[0] << "," << LC->n[1] << "," << LC->n[2] << " is invalid!" << endl;
+        }
       }
-    }
   }
 
   cout << Verbose(2) << "Found maximum coordinates: ";
   for (int i=0;i<NDIM;i++)
-    cout << i << ": " << *max_index[i] << "\t";
+    cout << i << ": " << *MaxAtom[i] << "\t";
   cout << endl;
-  //Koennen dies fuer alle Richtungen, legen hier erstmal Richtung auf k=0
-  const int k = 1;
+  const int k = 1;    // arbitrary choice
   Oben.x[k] = 1.;
-  FirstPoint = max_index[k];
-
-  cout << Verbose(1) << "Coordinates of start atom " << *FirstPoint << " at " << FirstPoint->x << " with " << mol->NumberOfBondsPerAtom[FirstPoint->nr] << " bonds." << endl;
-  double Storage[3];
+  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;
-  Storage[0] = 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.
-  Storage[1] = 999999.; // This will be an angle looking for the third point.
-  Storage[2] = 999999.;
-
-  Find_second_point_for_Tesselation(FirstPoint, FirstPoint, FirstPoint, 0, Oben, Opt_Candidate, Storage, mol, RADIUS); // we give same point as next candidate as its bonds are looked into in find_second_...
+  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));
@@ -2300 +2523 @@
   Oben.Normalize();
   helper.VectorProduct(&Oben);
-  Storage[0] = -2.; // This will indicate the quadrant.
-  Storage[1] = 9999999.; // This will be an angle looking for the third point.
-  Storage[2] = 9999999.;
+  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)
 
@@ -2311 +2536 @@
   // look in one direction of baseline for initial candidate
   Opt_Candidate = NULL;
-  CenterOfFirstLine.CopyVector(&Chord);
-  CenterOfFirstLine.Scale(0.5);
-  CenterOfFirstLine.AddVector(&(SecondPoint->x));
-
-  cout << Verbose(1) << "Looking for third point candidates from " << *FirstPoint << " onward ...\n";
-  Find_next_suitable_point_via_Angle_of_Sphere(FirstPoint, SecondPoint, SecondPoint, SecondPoint, FirstPoint, 0, &Chord, &helper, &Oben, CenterOfFirstLine,  Opt_Candidate, Storage, RADIUS, mol);
-  // look in other direction of baseline for possible better candidate
-  cout << Verbose(1) << "Looking for third point candidates from " << *SecondPoint << " onward ...\n";
-  Find_next_suitable_point_via_Angle_of_Sphere(FirstPoint, SecondPoint, SecondPoint, FirstPoint, SecondPoint, 0, &Chord, &helper, &Oben, CenterOfFirstLine, Opt_Candidate, Storage, RADIUS, mol);
+  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 points
-  AddTrianglePoint(FirstPoint, 0);
-  AddTrianglePoint(SecondPoint, 1);
-  AddTrianglePoint(Opt_Candidate, 2);
-  // ... and respective lines
-  AddTriangleLine(TPS[0], TPS[1], 0);
+  // Finally, we only have to add the found further lines
   AddTriangleLine(TPS[1], TPS[2], 1);
   AddTriangleLine(TPS[0], TPS[2], 2);
@@ -2336 +2554 @@
   AddTriangleToLines();
   // ... and calculate its normal vector (with correct orientation)
-  Oben.Scale(-1.);
-  BTS->GetNormalVector(Oben);
+  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;
   cout << Verbose(1) << "End of Find_starting_triangle\n";
 };
 
-void Find_non_convex_border(ofstream *out, ofstream *tecplot, molecule* mol, const char *filename, const double RADIUS)
+/** This function finds a triangle to a line, adjacent to an existing one.
+ * @param out output stream for debugging
+ * @param *mol molecule with Atom's and Bond's
+ * @param Line current baseline to search from
+ * @param T current triangle which \a Line is edge of
+ * @param RADIUS radius of the rolling ball
+ * @param N number of found triangles
+ * @param *filename filename base for intermediate envelopes
+ * @param *LC LinkedCell structure with neighbouring atoms
+ */
+bool Tesselation::Find_next_suitable_triangle(ofstream *out,
+    molecule *mol, BoundaryLineSet &Line, BoundaryTriangleSet &T,
+    const double& RADIUS, int N, const char *tempbasename, LinkedCell *LC)
+{
+  cout << Verbose(1) << "Begin of Find_next_suitable_triangle\n";
+  ofstream *tempstream = NULL;
+  char NumberName[255];
+
+  atom* Opt_Candidate = NULL;
+  Vector OptCandidateCenter;
+
+  Vector CircleCenter;
+  Vector CirclePlaneNormal;
+  Vector OldSphereCenter;
+  Vector SearchDirection;
+  Vector helper;
+  atom *ThirdNode = NULL;
+  double ShortestAngle = 2.*M_PI; // This will indicate the quadrant.
+  double radius, CircleRadius;
+
+  cout << Verbose(1) << "Current baseline is " << Line << " of triangle " << T << "." << endl;
+  for (int i=0;i<3;i++)
+    if ((T.endpoints[i]->node != Line.endpoints[0]->node) && (T.endpoints[i]->node != Line.endpoints[1]->node))
+      ThirdNode = T.endpoints[i]->node;
+
+  // construct center of circle
+  CircleCenter.CopyVector(&Line.endpoints[0]->node->x);
+  CircleCenter.AddVector(&Line.endpoints[1]->node->x);
+  CircleCenter.Scale(0.5);
+
+  // construct normal vector of circle
+  CirclePlaneNormal.CopyVector(&Line.endpoints[0]->node->x);
+  CirclePlaneNormal.SubtractVector(&Line.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, &(T.endpoints[0]->node->x), &(T.endpoints[1]->node->x), &(T.endpoints[2]->node->x));
+    helper.CopyVector(&T.NormalVector);  // normal vector ensures that this is correct center of the two possible ones
+    radius = Line.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;
+
+    // construct SearchDirection
+    SearchDirection.MakeNormalVector(&T.NormalVector, &CirclePlaneNormal);
+    helper.CopyVector(&Line.endpoints[0]->node->x);
+    helper.SubtractVector(&ThirdNode->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;
+    }
+
+    // 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);
+
+  } else {
+    cout << Verbose(1) << "Circumcircle for base line " << Line << " and base triangle " << T << " is too big!" << endl;
+  }
+
+  if (Opt_Candidate == NULL) {
+    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))
+        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.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;
+};
+
+/** Tesselates the non convex boundary by rolling a virtual sphere along the surface of the molecule.
+ * \param *out output stream for debugging
+ * \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
+ */
+void Find_non_convex_border(ofstream *out, molecule* mol, class Tesselation *Tess, class LinkedCell *LCList, const char *filename, const double RADIUS)
 {
   int N = 0;
-  struct Tesselation *Tess = new Tesselation;
-  cout << Verbose(1) << "Entering search for non convex hull. " << endl;
-  cout << flush;
+  bool freeTess = false;
+  *out << Verbose(1) << "Entering search for non convex hull. " << endl;
+  if (Tess == NULL) {
+    *out << Verbose(1) << "Allocating Tesselation struct ..." << endl;
+    Tess = new Tesselation;
+    freeTess = true;
+  }
+  bool freeLC = false;
   LineMap::iterator baseline;
-  cout << Verbose(0) << "Begin of Find_non_convex_border\n";
+  *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
   bool failflag = false;
-  if ((mol->first->next == mol->last) || (mol->last->previous == mol->first))
-    mol->CreateAdjacencyList((ofstream *)&cout, 1.6, true);
-
-  Tess->Find_starting_triangle(mol, RADIUS);
+
+  if (LCList == NULL) {
+    LCList = new LinkedCell(mol, 2.*RADIUS);
+    freeLC = true;
+  }
+
+  Tess->Find_starting_triangle(out, mol, RADIUS, LCList);
 
   baseline = Tess->LinesOnBoundary.begin();
   while ((baseline != Tess->LinesOnBoundary.end()) || (flag)) {
     if (baseline->second->TrianglesCount == 1) {
-      failflag = Tess->Find_next_suitable_triangle(out, tecplot, mol, *(baseline->second), *(((baseline->second->triangles.begin()))->second), RADIUS, N, filename); //the line is there, so there is a triangle, but only one.
+      failflag = Tess->Find_next_suitable_triangle(out, mol, *(baseline->second), *(((baseline->second->triangles.begin()))->second), RADIUS, N, filename, LCList); //the line is there, so there is a triangle, but only one.
       flag = flag || failflag;
       if (!failflag)
@@ -2374 +2778 @@
     }
   }
-  if (failflag) {
-    cout << Verbose(1) << "Writing final tecplot file\n";
-    if (DoTecplotOutput)
+  if (1) { //failflag) {
+    *out << Verbose(1) << "Writing final tecplot file\n";
+    if (DoTecplotOutput) {
+      string OutputName(filename);
+      OutputName.append(TecplotSuffix);
+      ofstream *tecplot = new ofstream(OutputName.c_str());
       write_tecplot_file(out, tecplot, Tess, mol, -1);
-    if (DoRaster3DOutput)
-      write_raster3d_file(out, tecplot, Tess, mol);
+      tecplot->close();
+      delete(tecplot);
+    }
+    if (DoRaster3DOutput) {
+      string OutputName(filename);
+      OutputName.append(Raster3DSuffix);
+      ofstream *raster = new ofstream(OutputName.c_str());
+      write_raster3d_file(out, raster, Tess, mol);
+      raster->close();
+      delete(raster);
+    }
   } else {
     cerr << "ERROR: Could definately not find all necessary triangles!" << endl;
   }
-
-  cout << Verbose(0) << "End of Find_non_convex_border\n";
-  delete(Tess);
+  if (freeTess)
+    delete(Tess);
+  if (freeLC)
+    delete(LCList);
+  *out << Verbose(0) << "End of Find_non_convex_border\n";
 };
 
+/** Finds a hole of sufficient size in \a this molecule to embed \a *srcmol into it.
+ * \param *out output stream for debugging
+ * \param *srcmol molecule to embed into
+ * \return *Vector new center of \a *srcmol for embedding relative to \a this
+ */
+Vector* molecule::FindEmbeddingHole(ofstream *out, molecule *srcmol)
+{
+  Vector *Center = new Vector;
+  Center->Zero();
+  // calculate volume/shape of \a *srcmol
+
+  // find embedding holes
+
+  // if more than one, let user choose
+
+  // return embedding center
+  return Center;
+};
+

src/boundary.hpp

@@ -17 +17 @@
 
 #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"
 #include "molecules.hpp"
 
@@ -85 +90 @@
     void AddTriangleLine(class BoundaryPointSet *a, class BoundaryPointSet *b, int n);
     void AddTriangleToLines();
-    void Find_starting_triangle(molecule* mol, const double RADIUS);
-    bool Find_next_suitable_triangle(ofstream *out, ofstream *tecplot, molecule* mol, BoundaryLineSet &Line, BoundaryTriangleSet &T, const double& RADIUS, int N, const char *filename);
+    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);
     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);
@@ -109 +114 @@
 
 
-double VolumeOfConvexEnvelope(ofstream *out, ofstream *tecplot, config *configuration, Boundaries *BoundaryPoints, molecule *mol);
+double VolumeOfConvexEnvelope(ofstream *out, const char *filename, config *configuration, Boundaries *BoundaryPoints, molecule *mol);
 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, ofstream *tecplot, molecule* mol, const char *tempbasename, const double RADIUS);
-void Find_next_suitable_point(atom a, atom b, atom Candidate, int n, Vector *d1, Vector *d2, atom*& Opt_Candidate, double *Storage, const double RADIUS, molecule *mol, bool problem);
-
+void Find_non_convex_border(ofstream *out, molecule* mol, class Tesselation *T, class LinkedCell *LCList, 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);
 
 #endif /*BOUNDARY_HPP_*/

src/builder.cpp

@@ -50 +50 @@
 using namespace std;
 
+#include "boundary.hpp"
+#include "ellipsoid.hpp"
 #include "helpers.hpp"
 #include "molecules.hpp"
-#include "boundary.hpp"
-
-/********************************************** Submenu routine **************************************/
+
+/********************************************* Subsubmenu routine ************************************/
 
 /** Submenu for adding atoms to the molecule.
  * \param *periode periodentafel
- * \param *mol the molecule to add to
+ * \param *molecule molecules with atoms
  */
 static void AddAtoms(periodentafel *periode, molecule *mol)
@@ -82 +83 @@
 
   switch (choice) {
+    default:
+      cout << Verbose(0) << "Not a valid choice." << endl;
+      break;
       case 'a': // absolute coordinates of atom
         cout << Verbose(0) << "Enter absolute coordinates." << endl;
@@ -122 +126 @@
         break;
 
-      case 'd': // two atoms, two angles and a distance
+    case 'd': // two atoms, two angles and a distance
         first = new atom;
         valid = true;
@@ -255 +259 @@
 
 /** Submenu for centering the atoms in the molecule.
- * \param *mol the molecule with all the atoms
+ * \param *mol molecule with all the atoms
  */
 static void CenterAtoms(molecule *mol)
@@ -278 +282 @@
     case 'a':
       cout << Verbose(0) << "Centering atoms in config file on origin." << endl;
-      mol->CenterOrigin((ofstream *)&cout, &x);
+      mol->CenterOrigin((ofstream *)&cout);
       break;
     case 'b':
       cout << Verbose(0) << "Centering atoms in config file on center of gravity." << endl;
-      mol->CenterGravity((ofstream *)&cout, &x);
+      mol->CenterPeriodic((ofstream *)&cout);
       break;
     case 'c':
@@ -291 +295 @@
       }
       mol->CenterEdge((ofstream *)&cout, &x);  // make every coordinate positive
-      mol->Translate(&y); // translate by boundary
+      mol->Center.AddVector(&y); // translate by boundary
       helper.CopyVector(&y);
       helper.Scale(2.);
@@ -313 +317 @@
 /** Submenu for aligning the atoms in the molecule.
  * \param *periode periodentafel
- * \param *mol the molecule with all the atoms
+ * \param *mol molecule with all the atoms
  */
 static void AlignAtoms(periodentafel *periode, molecule *mol)
@@ -381 +385 @@
 
 /** Submenu for mirroring the atoms in the molecule.
- * \param *mol the molecule with all the atoms
+ * \param *mol molecule with all the atoms
  */
 static void MirrorAtoms(molecule *mol)
@@ -428 +432 @@
 
 /** Submenu for removing the atoms from the molecule.
- * \param *mol the molecule with all the atoms
+ * \param *mol molecule with all the atoms
  */
 static void RemoveAtoms(molecule *mol)
@@ -461 +465 @@
       while(first->next != mol->end) {
         first = first->next;
-        if (first->x.Distance((const Vector *)&second->x) > tmp1*tmp1) // distance to first above radius ...
+        if (first->x.DistanceSquared((const Vector *)&second->x) > tmp1*tmp1) // distance to first above radius ...
           mol->RemoveAtom(first);
       }
@@ -486 +490 @@
 /** Submenu for measuring out the atoms in the molecule.
  * \param *periode periodentafel
- * \param *mol the molecule with all the atoms
+ * \param *mol molecule with all the atoms
  */
 static void MeasureAtoms(periodentafel *periode, molecule *mol, config *configuration)
@@ -596 +600 @@
 
 /** Submenu for measuring out the atoms in the molecule.
- * \param *mol the molecule with all the atoms
+ * \param *mol molecule with all the atoms
  * \param *configuration configuration structure for the to be written config files of all fragments
  */
@@ -616 +620 @@
 };
 
+/********************************************** Submenu routine **************************************/
+
+/** Submenu for manipulating atoms.
+ * \param *periode periodentafel
+ * \param *molecules list of molecules whose atoms are to be manipulated
+ */
+static void ManipulateAtoms(periodentafel *periode, MoleculeListClass *molecules, config *configuration)
+{
+  atom *first, *second;
+  molecule *mol = NULL;
+  Vector x,y,z,n; // coordinates for absolute point in cell volume
+  double *factor; // unit factor if desired
+  double bond, min_bond;
+  char choice;  // menu choice char
+  bool valid;
+
+  cout << Verbose(0) << "=========MANIPULATE ATOMS======================" << endl;
+  cout << Verbose(0) << "a - add an atom" << endl;
+  cout << Verbose(0) << "r - remove an atom" << endl;
+  cout << Verbose(0) << "b - scale a bond between atoms" << endl;
+  cout << Verbose(0) << "u - change an atoms element" << endl;
+  cout << Verbose(0) << "l - measure lengths, angles, ... for an atom" << endl;
+  cout << Verbose(0) << "all else - go back" << endl;
+  cout << Verbose(0) << "===============================================" << endl;
+  if (molecules->NumberOfActiveMolecules() > 1)
+    cout << Verbose(0) << "WARNING: There is more than one molecule active! Atoms will be added to each." << endl;
+  cout << Verbose(0) << "INPUT: ";
+  cin >> choice;
+
+  switch (choice) {
+    default:
+      cout << Verbose(0) << "Not a valid choice." << endl;
+      break;
+
+    case 'a': // add atom
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
+        mol = *ListRunner;
+        cout << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
+        AddAtoms(periode, mol);
+      }
+      break;
+
+    case 'b': // scale a bond
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
+        mol = *ListRunner;
+        cout << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
+        cout << Verbose(0) << "Scaling bond length between two atoms." << endl;
+        first = mol->AskAtom("Enter first (fixed) atom: ");
+        second = mol->AskAtom("Enter second (shifting) atom: ");
+        min_bond = 0.;
+        for (int i=NDIM;i--;)
+          min_bond += (first->x.x[i]-second->x.x[i])*(first->x.x[i] - second->x.x[i]);
+        min_bond = sqrt(min_bond);
+        cout << Verbose(0) << "Current Bond length between " << first->type->name << " Atom " << first->nr << " and " << second->type->name << " Atom " << second->nr << ": " << min_bond << " a.u." << endl;
+        cout << Verbose(0) << "Enter new bond length [a.u.]: ";
+        cin >> bond;
+        for (int i=NDIM;i--;) {
+          second->x.x[i] -= (second->x.x[i]-first->x.x[i])/min_bond*(min_bond-bond);
+        }
+        //cout << Verbose(0) << "New coordinates of Atom " << second->nr << " are: ";
+        //second->Output(second->type->No, 1, (ofstream *)&cout);
+      }
+      break;
+
+    case 'c': // unit scaling of the metric
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
+        mol = *ListRunner;
+        cout << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
+       cout << Verbose(0) << "Angstroem -> Bohrradius: 1.8897261\t\tBohrradius -> Angstroem: 0.52917721" << endl;
+       cout << Verbose(0) << "Enter three factors: ";
+       factor = new double[NDIM];
+       cin >> factor[0];
+       cin >> factor[1];
+       cin >> factor[2];
+       valid = true;
+       mol->Scale(&factor);
+       delete[](factor);
+      }
+     break;
+
+    case 'l': // measure distances or angles
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
+        mol = *ListRunner;
+        cout << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
+        MeasureAtoms(periode, mol, configuration);
+      }
+      break;
+
+    case 'r': // remove atom
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
+        mol = *ListRunner;
+        cout << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
+        RemoveAtoms(mol);
+      }
+      break;
+
+    case 'u': // change an atom's element
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
+        int Z;
+        mol = *ListRunner;
+        cout << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
+        first = NULL;
+        do {
+          cout << Verbose(0) << "Change the element of which atom: ";
+          cin >> Z;
+        } while ((first = mol->FindAtom(Z)) == NULL);
+        cout << Verbose(0) << "New element by atomic number Z: ";
+        cin >> Z;
+        first->type = periode->FindElement(Z);
+        cout << Verbose(0) << "Atom " << first->nr << "'s element is " << first->type->name << "." << endl;
+      }
+      break;
+  }
+};
+
+/** Submenu for manipulating molecules.
+ * \param *periode periodentafel
+ * \param *molecules list of molecule to manipulate
+ */
+static void ManipulateMolecules(periodentafel *periode, MoleculeListClass *molecules, config *configuration)
+{
+  atom *first;
+  Vector x,y,z,n; // coordinates for absolute point in cell volume
+  int j, axis, count, faktor;
+  char choice;  // menu choice char
+  molecule *mol = NULL;
+  element **Elements;
+  Vector **vectors;
+  MoleculeLeafClass *Subgraphs = NULL;
+
+  cout << Verbose(0) << "=========MANIPULATE GLOBALLY===================" << endl;
+  cout << Verbose(0) << "c - scale by unit transformation" << endl;
+  cout << Verbose(0) << "d - duplicate molecule/periodic cell" << endl;
+  cout << Verbose(0) << "f - fragment molecule many-body bond order style" << endl;
+  cout << Verbose(0) << "g - center atoms in box" << endl;
+  cout << Verbose(0) << "i - realign molecule" << endl;
+  cout << Verbose(0) << "m - mirror all molecules" << endl;
+  cout << Verbose(0) << "o - create connection matrix" << endl;
+  cout << Verbose(0) << "t - translate molecule by vector" << endl;
+  cout << Verbose(0) << "all else - go back" << endl;
+  cout << Verbose(0) << "===============================================" << endl;
+  if (molecules->NumberOfActiveMolecules() > 1)
+    cout << Verbose(0) << "WARNING: There is more than one molecule active! Atoms will be added to each." << endl;
+  cout << Verbose(0) << "INPUT: ";
+  cin >> choice;
+
+  switch (choice) {
+    default:
+      cout << Verbose(0) << "Not a valid choice." << endl;
+      break;
+
+    case 'd': // duplicate the periodic cell along a given axis, given times
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++) 
+        if ((*ListRunner)->ActiveFlag) {
+        mol = *ListRunner;
+        cout << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
+        cout << Verbose(0) << "State the axis [(+-)123]: ";
+        cin >> axis;
+        cout << Verbose(0) << "State the factor: ";
+        cin >> faktor;
+
+        mol->CountAtoms((ofstream *)&cout); // recount atoms
+        if (mol->AtomCount != 0) {  // if there is more than none
+          count = mol->AtomCount;  // is changed becausing of adding, thus has to be stored away beforehand
+          Elements = new element *[count];
+          vectors = new Vector *[count];
+          j = 0;
+          first = mol->start;
+          while (first->next != mol->end) { // make a list of all atoms with coordinates and element
+            first = first->next;
+            Elements[j] = first->type;
+            vectors[j] = &first->x;
+            j++;
+          }
+          if (count != j)
+            cout << Verbose(0) << "ERROR: AtomCount " << count << " is not equal to number of atoms in molecule " << j << "!" << endl;
+          x.Zero();
+          y.Zero();
+          y.x[abs(axis)-1] = mol->cell_size[(abs(axis) == 2) ? 2 : ((abs(axis) == 3) ? 5 : 0)] * abs(axis)/axis; // last term is for sign, first is for magnitude
+          for (int i=1;i<faktor;i++) {  // then add this list with respective translation factor times
+            x.AddVector(&y); // per factor one cell width further
+            for (int k=count;k--;) { // go through every atom of the original cell
+              first = new atom(); // create a new body
+              first->x.CopyVector(vectors[k]);  // use coordinate of original atom
+              first->x.AddVector(&x);     // translate the coordinates
+              first->type = Elements[k];  // insert original element
+              mol->AddAtom(first);        // and add to the molecule (which increments ElementsInMolecule, AtomCount, ...)
+            }
+          }
+          if (mol->first->next != mol->last) // if connect matrix is present already, redo it
+            mol->CreateAdjacencyList((ofstream *)&cout, mol->BondDistance, configuration->GetIsAngstroem());
+          // free memory
+          delete[](Elements);
+          delete[](vectors);
+          // correct cell size
+          if (axis < 0) { // if sign was negative, we have to translate everything
+            x.Zero();
+            x.AddVector(&y);
+            x.Scale(-(faktor-1));
+            mol->Translate(&x);
+          }
+          mol->cell_size[(abs(axis) == 2) ? 2 : ((abs(axis) == 3) ? 5 : 0)] *= faktor;
+        }
+      }
+      break;
+
+    case 'f':
+      FragmentAtoms(mol, configuration);
+      break;
+
+    case 'g': // center the atoms
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
+        mol = *ListRunner;
+        cout << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
+        CenterAtoms(mol);
+      }
+      break;
+
+    case 'i': // align all atoms
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
+        mol = *ListRunner;
+        cout << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
+        AlignAtoms(periode, mol);
+      }
+      break;
+
+    case 'm': // mirror atoms along a given axis
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
+        mol = *ListRunner;
+        cout << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
+        MirrorAtoms(mol);
+      }
+      break;
+
+    case 'o': // create the connection matrix
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
+        double bonddistance;
+        clock_t start,end;
+        cout << Verbose(0) << "What's the maximum bond distance: ";
+        cin >> bonddistance;
+        start = clock();
+        mol->CreateAdjacencyList((ofstream *)&cout, bonddistance, configuration->GetIsAngstroem());
+        mol->CreateListOfBondsPerAtom((ofstream *)&cout);
+        end = clock();
+        cout << Verbose(0) << "Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s." << endl;
+      }
+      break;
+
+    case 't': // translate all atoms
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
+        mol = *ListRunner;
+        cout << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
+        cout << Verbose(0) << "Enter translation vector." << endl;
+        x.AskPosition(mol->cell_size,0);
+        mol->Center.AddVector((const Vector *)&x);
+     }
+     break;
+  }
+  // Free all
+  if (Subgraphs != NULL) {  // free disconnected subgraph list of DFS analysis was performed
+    while (Subgraphs->next != NULL) {
+      Subgraphs = Subgraphs->next;
+      delete(Subgraphs->previous);
+    }
+    delete(Subgraphs);
+  }
+};
+
+
+/** Submenu for creating new molecules.
+ * \param *periode periodentafel
+ * \param *molecules list of molecules to add to
+ */
+static void EditMolecules(periodentafel *periode, MoleculeListClass *molecules)
+{
+  char choice;  // menu choice char
+  Vector center;
+  int nr, count;
+  molecule *mol = NULL;
+
+  cout << Verbose(0) << "==========EDIT MOLECULES=====================" << endl;
+  cout << Verbose(0) << "c - create new molecule" << endl;
+  cout << Verbose(0) << "l - load molecule from xyz file" << endl;
+  cout << Verbose(0) << "n - change molecule's name" << endl;
+  cout << Verbose(0) << "N - give molecules filename" << endl;
+  cout << Verbose(0) << "p - parse atoms in xyz file into molecule" << endl;
+  cout << Verbose(0) << "r - remove a molecule" << endl;
+  cout << Verbose(0) << "all else - go back" << endl;
+  cout << Verbose(0) << "===============================================" << endl;
+  cout << Verbose(0) << "INPUT: ";
+  cin >> choice;
+
+  switch (choice) {
+    default:
+      cout << Verbose(0) << "Not a valid choice." << endl;
+      break;
+    case 'c':
+      mol = new molecule(periode);
+      molecules->insert(mol);
+      break;
+
+    case 'l': // load from XYZ file
+      {
+        char filename[MAXSTRINGSIZE];
+        cout << Verbose(0) << "Format should be XYZ with: ShorthandOfElement\tX\tY\tZ" << endl;
+        mol = new molecule(periode);
+        do {
+          cout << Verbose(0) << "Enter file name: ";
+          cin >> filename;
+        } while (!mol->AddXYZFile(filename));
+        mol->SetNameFromFilename(filename);
+        // center at set box dimensions
+        mol->CenterEdge((ofstream *)&cout, &center);
+        mol->cell_size[0] = center.x[0];
+        mol->cell_size[1] = 0;
+        mol->cell_size[2] = center.x[1];
+        mol->cell_size[3] = 0;
+        mol->cell_size[4] = 0;
+        mol->cell_size[5] = center.x[2];
+        molecules->insert(mol);
+      }
+      break;
+
+    case 'n':
+      {
+        char filename[MAXSTRINGSIZE];
+        do {
+          cout << Verbose(0) << "Enter index of molecule: ";
+          cin >> nr;
+          mol = molecules->ReturnIndex(nr);
+        } while (mol == NULL);
+        cout << Verbose(0) << "Enter name: ";
+        cin >> filename;
+        strcpy(mol->name, filename);
+      }
+      break;
+
+    case 'N':
+      {
+        char filename[MAXSTRINGSIZE];
+        do {
+          cout << Verbose(0) << "Enter index of molecule: ";
+          cin >> nr;
+          mol = molecules->ReturnIndex(nr);
+        } while (mol == NULL);
+        cout << Verbose(0) << "Enter name: ";
+        cin >> filename;
+        mol->SetNameFromFilename(filename);
+      }
+      break;
+
+    case 'p': // parse XYZ file
+      {
+        char filename[MAXSTRINGSIZE];
+        mol = NULL;
+        do {
+          cout << Verbose(0) << "Enter index of molecule: ";
+          cin >> nr;
+          mol = molecules->ReturnIndex(nr);
+        } while (mol == NULL);
+        cout << Verbose(0) << "Format should be XYZ with: ShorthandOfElement\tX\tY\tZ" << endl;
+        do {
+          cout << Verbose(0) << "Enter file name: ";
+          cin >> filename;
+        } while (!mol->AddXYZFile(filename));
+        mol->SetNameFromFilename(filename);
+      }
+      break;
+
+    case 'r':
+      cout << Verbose(0) << "Enter index of molecule: ";
+      cin >> nr;
+      count = 1;
+      for( MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if (nr == (*ListRunner)->IndexNr) {
+          mol = *ListRunner;
+          molecules->ListOfMolecules.erase(ListRunner);
+          delete(mol);
+        }
+      break;
+  }
+};
+
+
+/** Submenu for merging molecules.
+ * \param *periode periodentafel
+ * \param *molecules list of molecules to add to
+ */
+static void MergeMolecules(periodentafel *periode, MoleculeListClass *molecules)
+{
+  char choice;  // menu choice char
+
+  cout << Verbose(0) << "===========MERGE MOLECULES=====================" << endl;
+  cout << Verbose(0) << "a - simple add of one molecule to another" << endl;
+  cout << Verbose(0) << "e - embedding merge of two molecules" << endl;
+  cout << Verbose(0) << "m - multi-merge of all molecules" << endl;
+  cout << Verbose(0) << "s - scatter merge of two molecules" << endl;
+  cout << Verbose(0) << "t - simple merge of two molecules" << endl;
+  cout << Verbose(0) << "all else - go back" << endl;
+  cout << Verbose(0) << "===============================================" << endl;
+  cout << Verbose(0) << "INPUT: ";
+  cin >> choice;
+
+  switch (choice) {
+    default:
+      cout << Verbose(0) << "Not a valid choice." << endl;
+      break;
+
+    case 'a':
+      {
+        int src, dest;
+        molecule *srcmol = NULL, *destmol = NULL;
+        {
+          do {
+            cout << Verbose(0) << "Enter index of destination molecule: ";
+            cin >> dest;
+            destmol = molecules->ReturnIndex(dest);
+          } while ((destmol == NULL) && (dest != -1));
+          do {
+            cout << Verbose(0) << "Enter index of source molecule to add from: ";
+            cin >> src;
+            srcmol = molecules->ReturnIndex(src);
+          } while ((srcmol == NULL) && (src != -1));
+          if ((src != -1) && (dest != -1))
+            molecules->SimpleAdd(srcmol, destmol);
+        }
+      }
+      break;
+
+    case 'e':
+      cout << Verbose(0) << "Not implemented yet." << endl;
+      break;
+
+    case 'm':
+      {
+        int nr;
+        molecule *mol = NULL;
+        do {
+          cout << Verbose(0) << "Enter index of molecule to merge into: ";
+          cin >> nr;
+          mol = molecules->ReturnIndex(nr);
+        } while ((mol == NULL) && (nr != -1));
+        if (nr != -1) {
+          int N = molecules->ListOfMolecules.size()-1;
+          int *src = new int(N);
+          for(MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+            if ((*ListRunner)->IndexNr != nr)
+              src[N++] = (*ListRunner)->IndexNr;        
+          molecules->SimpleMultiMerge(mol, src, N);
+          delete[](src);
+        }
+      }
+      break;
+
+    case 's':
+      cout << Verbose(0) << "Not implemented yet." << endl;
+      break;
+
+    case 't':
+      {
+        int src, dest;
+        molecule *srcmol = NULL, *destmol = NULL;
+        {
+          do {
+            cout << Verbose(0) << "Enter index of destination molecule: ";
+            cin >> dest;
+            destmol = molecules->ReturnIndex(dest);
+          } while ((destmol == NULL) && (dest != -1));
+          do {
+            cout << Verbose(0) << "Enter index of source molecule to merge into: ";
+            cin >> src;
+            srcmol = molecules->ReturnIndex(src);
+          } while ((srcmol == NULL) && (src != -1));
+          if ((src != -1) && (dest != -1))
+            molecules->SimpleMerge(srcmol, destmol);
+        }
+      }
+      break;
+  }
+};
+
+
 /********************************************** Test routine **************************************/
 
 /** Is called always as option 'T' in the menu.
+ * \param *molecules list of molecules
  */
-static void testroutine(molecule *mol)
+static void testroutine(MoleculeListClass *molecules)
 {
   // the current test routine checks the functionality of the KeySet&Graph concept:
   // We want to have a multiindex (the KeySet) describing a unique subgraph
+  int i, comp, counter=0;
+
+  // create a clone
+  molecule *mol = NULL;
+  if (molecules->ListOfMolecules.size() != 0) // clone
+    mol = (molecules->ListOfMolecules.front())->CopyMolecule();
+  else {
+    cerr << "I don't have anything to test on ... ";
+    return;
+  }
   atom *Walker = mol->start;
-  int i, comp, counter=0;
 
   // generate some KeySets
@@ -685 +1192 @@
     A++;
   }
+  delete(mol);
 };
 
@@ -691 +1199 @@
  * \param *configuration pointer to configuration structure with all the values
  * \param *periode pointer to periodentafel structure with all the elements
- * \param *mol pointer to molecule structure with all the atoms and coordinates
+ * \param *molecules list of molecules structure with all the atoms and coordinates
  */
-static void SaveConfig(char *ConfigFileName, config *configuration, periodentafel *periode, molecule *mol)
+static void SaveConfig(char *ConfigFileName, config *configuration, periodentafel *periode, MoleculeListClass *molecules)
 {
   char filename[MAXSTRINGSIZE];
   ofstream output;
-  string basis("3-21G");
+  molecule *mol = new molecule(periode);
+
+  // translate each to its center and merge all molecules in MoleculeListClass into this molecule
+  int N = molecules->ListOfMolecules.size();
+  int *src = new int(N);
+  N=0;
+  for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++) {
+    src[N++] = (*ListRunner)->IndexNr;
+    (*ListRunner)->Translate(&(*ListRunner)->Center);
+  }
+  molecules->SimpleMultiAdd(mol, src, N);
+  delete[](src);
+  // ... and translate back
+  for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++) {
+    (*ListRunner)->Center.Scale(-1.);
+    (*ListRunner)->Translate(&(*ListRunner)->Center);
+    (*ListRunner)->Center.Scale(-1.);
+  }
 
   cout << Verbose(0) << "Storing configuration ... " << endl;
@@ -703 +1228 @@
   mol->CalculateOrbitals(*configuration);
   configuration->InitMaxMinStopStep = configuration->MaxMinStopStep = configuration->MaxPsiDouble;
-  strcpy(filename, ConfigFileName);
   if (ConfigFileName != NULL) { // test the file name
-    output.open(ConfigFileName, ios::trunc);
+    strcpy(filename, ConfigFileName);
+    output.open(filename, ios::trunc);
   } else if (strlen(configuration->configname) != 0) {
     strcpy(filename, configuration->configname);
@@ -761 +1286 @@
     cerr << "WARNING: config is found under different path then stated in config file::defaultpath!" << endl;
   }
+  delete(mol);
 };
 
@@ -766 +1292 @@
  * \param argc argument count
  * \param **argv arguments array
- * \param *mol molecule structure
+ * \param *molecules list of molecules structure
  * \param *periode elements structure
  * \param configuration config file structure
@@ -773 +1299 @@
  * \return exit code (0 - successful, all else - something's wrong)
  */
-static int ParseCommandLineOptions(int argc, char **argv, molecule *&mol, periodentafel *&periode, config& configuration, char *&ConfigFileName, char *&PathToDatabases)
+static int ParseCommandLineOptions(int argc, char **argv, MoleculeListClass *&molecules, periodentafel *&periode, config& configuration, char *ConfigFileName, char *&PathToDatabases)
 {
   Vector x,y,z,n;  // coordinates for absolute point in cell volume
@@ -789 +1315 @@
   int argptr;
   PathToDatabases = LocalPath;
+
+  // simply create a new molecule, wherein the config file is loaded and the manipulation takes place
+  molecule *mol = new molecule(periode);
+  mol->ActiveFlag = true;
+  molecules->insert(mol);
 
   if (argc > 1) { // config file specified as option
@@ -807 +1338 @@
             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 <basis>\tgive gaussian basis for MPQC output." << 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;
             cout << "\t-D <bond distance>\tDepth-First-Search Analysis of the molecule, giving cycles and tree/back edges." << endl;
@@ -871 +1402 @@
       return 1;
     }
-
     // 3. Find config file name and parse if possible
     if (argv[1][0] != '-') {
@@ -884 +1414 @@
         } else {
           cout << "Empty configuration file." << endl;
-          ConfigFileName = argv[1];
+          strcpy(ConfigFileName, argv[1]);
           config_present = empty;
           output.close();
@@ -890 +1420 @@
       } else {
         test.close();
-        ConfigFileName = argv[1];
+        strcpy(ConfigFileName, argv[1]);
         cout << Verbose(1) << "Specified config file found, parsing ... ";
         switch (configuration.TestSyntax(ConfigFileName, periode, mol)) {
@@ -910 +1440 @@
     } else
       config_present = absent;
-
     // 4. parse again through options, now for those depending on elements db and config presence
     argptr = 1;
@@ -965 +1494 @@
           switch(argv[argptr-1][1]) {
             case 'B':
-              if ((argptr >= argc) || (!IsValidNumber(argv[argptr])) || (argv[argptr][0] == '-')) {
+              if ((argptr >= argc) || (argv[argptr][0] == '-')) {
                 ExitFlag = 255;
-                cerr << "Not enough or invalid arguments given for giving gaussian basis: -B <basis>" << endl;
+                cerr << "Not enough or invalid arguments given for setting MPQC basis: -B <basis name>" << endl;
               } else {
-                cout << Verbose(1) << "Setting gaussian basis to " << argv[argptr] << "." << endl;
-                configuration.basis.copy(argv[argptr],strlen(argv[argptr]));
+                configuration.basis = argv[argptr];
+                cout << Verbose(1) << "Setting MPQC basis to " << configuration.basis << "." << endl;
                 argptr+=1;
               }
@@ -1022 +1551 @@
             case 'A':
               ExitFlag = 1;
-              if ((argptr >= argc) || (!IsValidNumber(argv[argptr])) || (argv[argptr][0] == '-')) {
+              if ((argptr >= argc) || (argv[argptr][0] == '-')) {
                 ExitFlag =255;
                 cerr << "Missing source file for bonds in molecule: -A <bond sourcefile>" << endl;
@@ -1030 +1559 @@
                 mol->CreateAdjacencyList2((ofstream *)&cout, input);
                 input->close();
+                argptr+=1;
               }
               break;
@@ -1038 +1568 @@
                 cerr << "Not enough or invalid arguments given for non-convex envelope: -o <radius> <tecplot output file>" << endl;
               } else {
-                cout << Verbose(0) << "Evaluating npn-convex envelope.";
-                string TempName(argv[argptr+1]);
-                TempName.append(".r3d");
-                ofstream *output = new ofstream(TempName.c_str(), ios::trunc);
+                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;
-                Find_non_convex_border((ofstream *)&cout, output, mol, argv[argptr+1], atof(argv[argptr]));
-                output->close();
-                delete(output);
+                LinkedCell LCList(mol, atof(argv[argptr]));    // \NOTE not twice the radius??
+                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());
                 argptr+=2;
               }
@@ -1180 +1712 @@
               ExitFlag = 1;
               SaveFlag = true;
-              cout << Verbose(1) << "Centering atoms in origin." << endl;
-              mol->CenterOrigin((ofstream *)&cout, &x);
+              cout << Verbose(1) << "Centering atoms on edge and setting box dimensions." << endl;
+              mol->CenterEdge((ofstream *)&cout, &x);
               mol->SetBoxDimension(&x);
               break;
@@ -1230 +1762 @@
               } else {
                 cout << Verbose(0) << "Evaluating volume of the convex envelope.";
-                ofstream *output = new ofstream(argv[argptr], ios::trunc);
-                //$$$
                 cout << Verbose(1) << "Storing tecplot data in " << argv[argptr] << "." << endl;
-                VolumeOfConvexEnvelope((ofstream *)&cout, output, &configuration, NULL, mol);
-                output->close();
-                delete(output);
+                VolumeOfConvexEnvelope((ofstream *)&cout, argv[argptr], &configuration, NULL, mol);
                 argptr+=1;
               }
@@ -1341 +1869 @@
     } while (argptr < argc);
     if (SaveFlag)
-      SaveConfig(ConfigFileName, &configuration, periode, mol);
+      SaveConfig(ConfigFileName, &configuration, periode, molecules);
     if ((ExitFlag >= 1)) {
       delete(mol);
@@ -1362 +1890 @@
 {
   periodentafel *periode = new periodentafel; // and a period table of all elements
-  molecule *mol = new molecule(periode);    // first we need an empty molecule
+  MoleculeListClass *molecules = new MoleculeListClass;  // list of all molecules
+  molecule *mol = NULL;
   config configuration;
-  double tmp1;
-  double bond, min_bond;
-  atom *first, *second;
   char choice;  // menu choice char
   Vector x,y,z,n;  // coordinates for absolute point in cell volume
-  double *factor;  // unit factor if desired
-  bool valid; // flag if input was valid or not
   ifstream test;
   ofstream output;
   string line;
-  char filename[MAXSTRINGSIZE];
-  char *ConfigFileName = NULL;
+  char ConfigFileName[MAXSTRINGSIZE];
   char *ElementsFileName = NULL;
-  int Z;
-  int j, axis, count, faktor;
-  clock_t start,end;
-//  int *MinimumRingSize = NULL;
-  MoleculeLeafClass *Subgraphs = NULL;
-//  class StackClass<bond *> *BackEdgeStack = NULL;
-  element **Elements;
-  Vector **vectors;
+  int j;
 
   // =========================== PARSE COMMAND LINE OPTIONS ====================================
-  j = ParseCommandLineOptions(argc, argv, mol, periode, configuration, ConfigFileName, ElementsFileName);
+  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
 
   // General stuff
-  if (mol->cell_size[0] == 0.) {
-    cout << Verbose(0) << "enter lower triadiagonal form of basis matrix" << endl << endl;
-    for (int i=0;i<6;i++) {
-      cout << Verbose(1) << "Cell size" << i << ": ";
-      cin >> mol->cell_size[i];
+  if (molecules->ListOfMolecules.size() == 0) {
+    mol = new molecule(periode);
+    if (mol->cell_size[0] == 0.) {
+      cout << Verbose(0) << "enter lower tridiagonal form of basis matrix" << endl << endl;
+      for (int i=0;i<6;i++) {
+        cout << Verbose(1) << "Cell size" << i << ": ";
+        cin >> mol->cell_size[i];
+      }
     }
+    molecules->insert(mol);
   }
+  if (strlen(ConfigFileName) == 0)
+    strcpy(ConfigFileName, DEFAULTCONFIG);
+    
 
   // =========================== START INTERACTIVE SESSION ====================================
@@ -1406 +1930 @@
   do {
     cout << Verbose(0) << endl << endl;
-    cout << Verbose(0) << "============Element list=======================" << endl;
-    mol->Checkout((ofstream *)&cout);
-    cout << Verbose(0) << "============Atom list==========================" << endl;
-    mol->Output((ofstream *)&cout);
+    cout << Verbose(0) << "============Molecule list=======================" << endl;
+    molecules->Enumerate((ofstream *)&cout);
     cout << Verbose(0) << "============Menu===============================" << endl;
-    cout << Verbose(0) << "a - add an atom" << endl;
-    cout << Verbose(0) << "r - remove an atom" << endl;
-    cout << Verbose(0) << "b - scale a bond between atoms" << endl;
-    cout << Verbose(0) << "u - change an atoms element" << endl;
-    cout << Verbose(0) << "l - measure lengths, angles, ... for an atom" << endl;
+    cout << Verbose(0) << "a - set molecule (in)active" << endl;
+    cout << Verbose(0) << "e - edit molecules (load, parse, save)" << endl;
+    cout << Verbose(0) << "g - globally manipulate atoms in molecule" << endl;
+    cout << Verbose(0) << "M - Merge molecules" << endl;
+    cout << Verbose(0) << "m - manipulate atoms" << endl;
     cout << Verbose(0) << "-----------------------------------------------" << endl;
-    cout << Verbose(0) << "p - Parse xyz file" << endl;
-    cout << Verbose(0) << "e - edit the current configuration" << endl;
-    cout << Verbose(0) << "o - create connection matrix" << endl;
-    cout << Verbose(0) << "f - fragment molecule many-body bond order style" << endl;
-    cout << Verbose(0) << "-----------------------------------------------" << endl;
-    cout << Verbose(0) << "d - duplicate molecule/periodic cell" << endl;
-    cout << Verbose(0) << "i - realign molecule" << endl;
-    cout << Verbose(0) << "m - mirror all molecules" << endl;
-    cout << Verbose(0) << "t - translate molecule by vector" << endl;
-    cout << Verbose(0) << "c - scale by unit transformation" << endl;
-    cout << Verbose(0) << "g - center atoms in box" << endl;
+    cout << Verbose(0) << "c - edit the current configuration" << endl;
     cout << Verbose(0) << "-----------------------------------------------" << endl;
     cout << Verbose(0) << "s - save current setup to config file" << endl;
@@ -1437 +1949 @@
 
     switch (choice) {
-      default:
-      case 'a': // add atom
-        AddAtoms(periode, mol);
-        choice = 'a';
-        break;
-
-      case 'b': // scale a bond
-        cout << Verbose(0) << "Scaling bond length between two atoms." << endl;
-        first = mol->AskAtom("Enter first (fixed) atom: ");
-        second = mol->AskAtom("Enter second (shifting) atom: ");
-        min_bond = 0.;
-        for (int i=NDIM;i--;)
-          min_bond += (first->x.x[i]-second->x.x[i])*(first->x.x[i] - second->x.x[i]);
-        min_bond = sqrt(min_bond);
-        cout << Verbose(0) << "Current Bond length between " << first->type->name << " Atom " << first->nr << " and " << second->type->name << " Atom " << second->nr << ": " << min_bond << " a.u." << endl;
-        cout << Verbose(0) << "Enter new bond length [a.u.]: ";
-        cin >> bond;
-        for (int i=NDIM;i--;) {
-          second->x.x[i] -= (second->x.x[i]-first->x.x[i])/min_bond*(min_bond-bond);
-        }
-        //cout << Verbose(0) << "New coordinates of Atom " << second->nr << " are: ";
-        //second->Output(second->type->No, 1, (ofstream *)&cout);
-        break;
-
-      case 'c': // unit scaling of the metric
-       cout << Verbose(0) << "Angstroem -> Bohrradius: 1.8897261\t\tBohrradius -> Angstroem: 0.52917721" << endl;
-       cout << Verbose(0) << "Enter three factors: ";
-       factor = new double[NDIM];
-       cin >> factor[0];
-       cin >> factor[1];
-       cin >> factor[2];
-       valid = true;
-       mol->Scale(&factor);
-       delete[](factor);
-       break;
-
-      case 'd': // duplicate the periodic cell along a given axis, given times
-        cout << Verbose(0) << "State the axis [(+-)123]: ";
-        cin >> axis;
-        cout << Verbose(0) << "State the factor: ";
-        cin >> faktor;
-
-        mol->CountAtoms((ofstream *)&cout);  // recount atoms
-        if (mol->AtomCount != 0) {  // if there is more than none
-          count = mol->AtomCount;   // is changed becausing of adding, thus has to be stored away beforehand
-          Elements = new element *[count];
-          vectors = new Vector *[count];
-          j = 0;
-          first = mol->start;
-          while (first->next != mol->end) {  // make a list of all atoms with coordinates and element
-            first = first->next;
-            Elements[j] = first->type;
-            vectors[j] = &first->x;
-            j++;
-          }
-          if (count != j)
-            cout << Verbose(0) << "ERROR: AtomCount " << count << " is not equal to number of atoms in molecule " << j << "!" << endl;
-          x.Zero();
-          y.Zero();
-          y.x[abs(axis)-1] = mol->cell_size[(abs(axis) == 2) ? 2 : ((abs(axis) == 3) ? 5 : 0)] * abs(axis)/axis; // last term is for sign, first is for magnitude
-          for (int i=1;i<faktor;i++) {  // then add this list with respective translation factor times
-            x.AddVector(&y); // per factor one cell width further
-            for (int k=count;k--;) { // go through every atom of the original cell
-              first = new atom(); // create a new body
-              first->x.CopyVector(vectors[k]);  // use coordinate of original atom
-              first->x.AddVector(&x);      // translate the coordinates
-              first->type = Elements[k];  // insert original element
-              mol->AddAtom(first);        // and add to the molecule (which increments ElementsInMolecule, AtomCount, ...)
-            }
-          }
-          if (mol->first->next != mol->last) // if connect matrix is present already, redo it
-            mol->CreateAdjacencyList((ofstream *)&cout, mol->BondDistance, configuration.GetIsAngstroem());
-          // free memory
-          delete[](Elements);
-          delete[](vectors);
-          // correct cell size
-          if (axis < 0) { // if sign was negative, we have to translate everything
-            x.Zero();
-            x.AddVector(&y);
-            x.Scale(-(faktor-1));
-            mol->Translate(&x);
-          }
-          mol->cell_size[(abs(axis) == 2) ? 2 : ((abs(axis) == 3) ? 5 : 0)] *= faktor;
+      case 'a':  // (in)activate molecule
+        {
+          cout << "Enter index of molecule: ";
+          cin >> j;
+          for(MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+            if ((*ListRunner)->IndexNr == j)
+              (*ListRunner)->ActiveFlag = !(*ListRunner)->ActiveFlag;
         }
         break;
 
-      case 'e': // edit each field of the configuration
-       configuration.Edit(mol);
+      case 'c': // edit each field of the configuration
+       configuration.Edit();
        break;
 
-      case 'f':
-        FragmentAtoms(mol, &configuration);
+      case 'e': // create molecule
+        EditMolecules(periode, molecules);
         break;
 
-      case 'g': // center the atoms
-        CenterAtoms(mol);
+      case 'g': // manipulate molecules
+        ManipulateMolecules(periode, molecules, &configuration);
         break;
 
-      case 'i': // align all atoms
-        AlignAtoms(periode, mol);
+      case 'M':  // merge molecules
+        MergeMolecules(periode, molecules);
         break;
 
-      case 'l': // measure distances or angles
-        MeasureAtoms(periode, mol, &configuration);
-        break;
-
-      case 'm': // mirror atoms along a given axis
-        MirrorAtoms(mol);
-        break;
-
-      case 'o': // create the connection matrix
-        {
-          cout << Verbose(0) << "What's the maximum bond distance: ";
-          cin >> tmp1;
-          start = clock();
-          mol->CreateAdjacencyList((ofstream *)&cout, tmp1, configuration.GetIsAngstroem());
-          mol->CreateListOfBondsPerAtom((ofstream *)&cout);
-//          Subgraphs = mol->DepthFirstSearchAnalysis((ofstream *)&cout, BackEdgeStack);
-//          while (Subgraphs->next != NULL) {
-//            Subgraphs = Subgraphs->next;
-//            Subgraphs->Leaf->CyclicStructureAnalysis((ofstream *)&cout, BackEdgeStack, MinimumRingSize);
-//            delete(Subgraphs->previous);
-//          }
-//          delete(Subgraphs);    // we don't need the list here, so free everything
-//          delete[](MinimumRingSize);
-//          Subgraphs = NULL;
-          end = clock();
-          cout << Verbose(0) << "Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s." << endl;
-        }
-        break;
-
-      case 'p': // parse and XYZ file
-        cout << Verbose(0) << "Format should be XYZ with: ShorthandOfElement\tX\tY\tZ" << endl;
-        do {
-          cout << Verbose(0) << "Enter file name: ";
-          cin >> filename;
-        } while (!mol->AddXYZFile(filename));
+      case 'm': // manipulate atoms
+        ManipulateAtoms(periode, molecules, &configuration);
         break;
 
@@ -1579 +1982 @@
         break;
 
-      case 'r': // remove atom
-        RemoveAtoms(mol);
+      case 's': // save to config file
+        SaveConfig(ConfigFileName, &configuration, periode, molecules);
         break;
 
-      case 's': // save to config file
-        SaveConfig(ConfigFileName, &configuration, periode, mol);
+      case 'T':
+        testroutine(molecules);
         break;
 
-      case 't': // translate all atoms
-       cout << Verbose(0) << "Enter translation vector." << endl;
-       x.AskPosition(mol->cell_size,0);
-       mol->Translate((const Vector *)&x);
-       break;
-
-      case 'T':
-        testroutine(mol);
-        break;
-
-      case 'u': // change an atom's element
-        first = NULL;
-        do {
-          cout << Verbose(0) << "Change the element of which atom: ";
-          cin >> Z;
-        } while ((first = mol->FindAtom(Z)) == NULL);
-        cout << Verbose(0) << "New element by atomic number Z: ";
-        cin >> Z;
-        first->type = periode->FindElement(Z);
-        cout << Verbose(0) << "Atom " << first->nr << "'s element is " << first->type->name << "." << endl;
+      default:
         break;
     };
@@ -1617 +2001 @@
     cout << Verbose(0) << "Saving of elements.db failed." << endl;
 
-  // Free all
-  if (Subgraphs != NULL) {  // free disconnected subgraph list of DFS analysis was performed
-    while (Subgraphs->next != NULL) {
-      Subgraphs = Subgraphs->next;
-      delete(Subgraphs->previous);
-    }
-    delete(Subgraphs);
-  }
-  delete(mol);
+  delete(molecules);
   delete(periode);
   return (0);

src/config.cpp

@@ -1 +1 @@
 /** \file config.cpp
- * 
+ *
  * Function implementations for the class config.
- * 
+ *
  */
 
@@ -65 +65 @@
   UseAddGramSch=1;
   Seed=1;
+
   MaxOuterStep=0;
   Deltat=0.01;
@@ -73 +74 @@
   MaxPsiStep=0;
   EpsWannier=1e-7;
-  
+
   MaxMinStep=100;
   RelEpsTotalEnergy=1e-7;
@@ -84 +85 @@
   InitMaxMinStopStep=1;
   InitMaxMinGapStopStep=0;
-  
+
   //BoxLength[NDIM*NDIM];
-  
+
   ECut=128.;
   MaxLevel=5;
@@ -99 +100 @@
   PsiMaxNoDown=0;
   AddPsis=0;
-  
+
   RCut=20.;
   StructOpt=0;
@@ -199 +200 @@
  * for each entry of the config file structure.
  */
-void config::Edit(molecule *mol)
+void config::Edit()
 {
   char choice;
-  
+
   do {
     cout << Verbose(0) << "===========EDIT CONFIGURATION============================" << endl;
@@ -235 +236 @@
     cout << Verbose(0) << " g - Relative change in kinetic energy to stop min. iteration during initial level" << endl;
     cout << Verbose(0) << " h - Check stop conditions every ..th step during min. iteration during initial level" << endl;
-    cout << Verbose(0) << " j - six lower diagonal entries of matrix, defining the unit cell" << endl;
+//    cout << Verbose(0) << " j - six lower diagonal entries of matrix, defining the unit cell" << endl;
     cout << Verbose(0) << " k - Energy cutoff of plane wave basis in Hartree" << endl;
     cout << Verbose(0) << " l - Maximum number of levels in multi-level-ansatz" << endl;
@@ -255 +256 @@
     cout << Verbose(0) << "INPUT: ";
     cin >> choice;
-    
+
     switch (choice) {
         case 'A': // mainname
@@ -380 +381 @@
           cin >> config::InitMaxMinStopStep;
           break;
-        
-        case 'j': // BoxLength
-          cout << Verbose(0) << "enter lower triadiagonalo form of basis matrix" << endl << endl;
-          for (int i=0;i<6;i++) {
-            cout << Verbose(0) << "Cell size" << i << ": ";
-            cin >> mol->cell_size[i];
-          }
-          break;
-        
+
+//        case 'j': // BoxLength
+//          cout << Verbose(0) << "enter lower triadiagonalo form of basis matrix" << endl << endl;
+//          for (int i=0;i<6;i++) {
+//            cout << Verbose(0) << "Cell size" << i << ": ";
+//            cin >> mol->cell_size[i];
+//          }
+//          break;
+
         case 'k': // ECut
           cout << Verbose(0) << "Old: " << config::ECut << "\t new: ";
@@ -462 +463 @@
  * \param *periode pointer to a periodentafel class with all elements
  * \param *mol pointer to molecule containing all atoms of the molecule
- * \return 0 - old syntax, 1 - new syntax, -1 - unknown syntax 
+ * \return 0 - old syntax, 1 - new syntax, -1 - unknown syntax
  */
 int config::TestSyntax(char *filename, periodentafel *periode, molecule *mol)
@@ -468 +469 @@
   int test;
   ifstream file(filename);
-  
+
   // search file for keyword: ProcPEGamma (new syntax)
   if (ParseForParameter(1,&file,"ProcPEGamma", 0, 1, 1, int_type, &test, 1, optional)) {
@@ -539 +540 @@
  * \param *file input file stream being the opened config file
  * \param *periode pointer to a periodentafel class with all elements
- * \param *mol pointer to molecule containing all atoms of the molecule 
+ * \param *mol pointer to molecule containing all atoms of the molecule
  */
 void config::Load(char *filename, periodentafel *periode, molecule *mol)
@@ -550 +551 @@
   RetrieveConfigPathAndName(filename);
   // ParseParameters
-  
+
   /* Oeffne Hauptparameterdatei */
   int di;
@@ -595 +596 @@
     config::DoOutCurrent = 0;
   if (config::DoOutCurrent < 0) config::DoOutCurrent = 0;
-  if (config::DoOutCurrent > 1) config::DoOutCurrent = 1; 
+  if (config::DoOutCurrent > 1) config::DoOutCurrent = 1;
   ParseForParameter(verbose,file,"AddGramSch", 0, 1, 1, int_type, &(config::UseAddGramSch), 1, critical);
   if (config::UseAddGramSch < 0) config::UseAddGramSch = 0;
@@ -630 +631 @@
   if (!ParseForParameter(verbose,file,"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);
   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);
@@ -644 +645 @@
   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);
@@ -653 +654 @@
   if (config::InitMaxMinStopStep < 1) config::InitMaxMinStopStep = 1;
   if (config::InitMaxMinGapStopStep < 1) config::InitMaxMinGapStopStep = 1;
-  
+
   // Unit cell and magnetic field
   ParseForParameter(verbose,file, "BoxLength", 0, 3, 3, lower_trigrid, BoxLength, 1, critical); /* Lattice->RealBasis */
@@ -669 +670 @@
     config::DoFullCurrent = 0;
   if (config::DoFullCurrent < 0) config::DoFullCurrent = 0;
-  if (config::DoFullCurrent > 2) config::DoFullCurrent = 2; 
+  if (config::DoFullCurrent > 2) config::DoFullCurrent = 2;
   if (config::DoOutNICS < 0) config::DoOutNICS = 0;
-  if (config::DoOutNICS > 2) config::DoOutNICS = 2; 
+  if (config::DoOutNICS > 2) config::DoOutNICS = 2;
   if (config::DoPerturbation == 0) {
     config::DoFullCurrent = 0;
@@ -688 +689 @@
   } else {
     fprintf(stderr, "0 <= RiemanTensor < 2: 0 UseNotRT, 1 UseRT");
-    exit(1); 
+    exit(1);
   }
   switch (config::RiemannTensor) {
@@ -705 +706 @@
       if (config::RiemannLevel < 2) {
         config::RiemannLevel = 2;
-      } 
+      }
       if (config::RiemannLevel > config::MaxLevel-1) {
         config::RiemannLevel = config::MaxLevel-1;
@@ -712 +713 @@
       if (config::LevRFactor < 2) {
         config::LevRFactor = 2;
-      } 
+      }
       config::Lev0Factor = 2;
       config::RTActualUse = 2;
@@ -722 +723 @@
   } else {
     fprintf(stderr, "0 <= PsiType < 2: 0 UseSpinDouble, 1 UseSpinUpDown");
-    exit(1); 
+    exit(1);
   }
   switch (config::PsiType) {
@@ -736 +737 @@
     break;
   }
-  
+
   // 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);
@@ -756 +757 @@
       ParseForParameter(verbose,file, 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; 
+      cout << Verbose(1) << i << ". Z = " << elementhash[i]->Z << " with " << No[i] << " ions." << endl;
     }
     int repetition = 0; // which repeated keyword shall be read
-  
+
     map<int, atom *> AtomList[config::MaxTypes];
     if (!FastParsing) {
@@ -778 +779 @@
             } else
               neues = AtomList[i][j];
-            status = (status && 
+            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) &&
@@ -784 +785 @@
                     ParseForParameter(verbose,file, keyword, 0, 4, 1, int_type, &neues->FixedIon, 1, (repetition == 0) ? critical : optional));
             if (!status) break;
-    
+
             // check size of vectors
             if (mol->Trajectories[neues].R.size() <= (unsigned int)(repetition)) {
@@ -792 +793 @@
               mol->Trajectories[neues].F.resize(repetition+10);
             }
-          
+
             // put into trajectories list
             for (int d=0;d<NDIM;d++)
               mol->Trajectories[neues].R.at(repetition).x[d] = neues->x.x[d];
-            
+
             // parse velocities if present
             if(!ParseForParameter(verbose,file, keyword, 0, 5, 1, double_type, &neues->v.x[0], 1,optional))
@@ -806 +807 @@
             for (int d=0;d<NDIM;d++)
               mol->Trajectories[neues].U.at(repetition).x[d] = neues->v.x[d];
-      
+
             // parse forces if present
             if(!ParseForParameter(verbose,file, keyword, 0, 8, 1, double_type, &value[0], 1,optional))
@@ -816 +817 @@
             for (int d=0;d<NDIM;d++)
               mol->Trajectories[neues].F.at(repetition).x[d] = value[d];
-  
-  //            cout << "Parsed position of step " << (repetition) << ": ("; 
+
+  //            cout << "Parsed position of step " << (repetition) << ": (";
   //            for (int d=0;d<NDIM;d++)
   //              cout << mol->Trajectories[neues].R.at(repetition).x[d] << " ";          // next step
@@ -873 +874 @@
  * \param *file input file stream being the opened config file with old pcp syntax
  * \param *periode pointer to a periodentafel class with all elements
- * \param *mol pointer to molecule containing all atoms of the molecule 
+ * \param *mol pointer to molecule containing all atoms of the molecule
  */
 void config::LoadOld(char *filename, periodentafel *periode, molecule *mol)
@@ -884 +885 @@
   RetrieveConfigPathAndName(filename);
   // ParseParameters
-  
+
   /* Oeffne Hauptparameterdatei */
   int l, i, di;
@@ -894 +895 @@
   int Z, No, AtomNo, found;
   int verbose = 0;
-  
+
   /* Namen einlesen */
 
@@ -926 +927 @@
   ParseForParameter(verbose,file,"ScaleTempStep", 0, 1, 1, int_type, &(config::ScaleTempStep), 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);
   if (config::MaxPsiStep <= 0) config::MaxPsiStep = 3;
-  
+
   ParseForParameter(verbose,file,"MaxMinStep", 0, 1, 1, int_type, &(config::MaxMinStep), 1, critical);
   ParseForParameter(verbose,file,"MaxMinStep", 0, 2, 1, double_type, &(config::RelEpsTotalEnergy), 1, critical);
@@ -939 +940 @@
   if (config::MaxMinStopStep < 1) config::MaxMinStopStep = 1;
   config::MaxMinGapStopStep = 1;
-  
+
   ParseForParameter(verbose,file,"MaxInitMinStep", 0, 1, 1, int_type, &(config::MaxInitMinStep), 1, critical);
   ParseForParameter(verbose,file,"MaxInitMinStep", 0, 2, 1, double_type, &(config::InitRelEpsTotalEnergy), 1, critical);
@@ -970 +971 @@
   } else {
     fprintf(stderr, "0 <= RiemanTensor < 2: 0 UseNotRT, 1 UseRT");
-    exit(1); 
+    exit(1);
   }
   switch (config::RiemannTensor) {
@@ -987 +988 @@
       if (config::RiemannLevel < 2) {
         config::RiemannLevel = 2;
-      } 
+      }
       if (config::RiemannLevel > config::MaxLevel-1) {
         config::RiemannLevel = config::MaxLevel-1;
@@ -994 +995 @@
       if (config::LevRFactor < 2) {
         config::LevRFactor = 2;
-      } 
+      }
       config::Lev0Factor = 2;
       config::RTActualUse = 2;
@@ -1004 +1005 @@
   } else {
     fprintf(stderr, "0 <= PsiType < 2: 0 UseSpinDouble, 1 UseSpinUpDown");
-    exit(1); 
+    exit(1);
   }
   switch (config::PsiType) {
@@ -1018 +1019 @@
     break;
   }
-  
+
   // 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);
@@ -1027 +1028 @@
 
   // Routine from builder.cpp
-  
-  
-  for (i=MAX_ELEMENTS;i--;) 
+
+
+  for (i=MAX_ELEMENTS;i--;)
     elementhash[i] = NULL;
   cout << Verbose(0) << "Parsing Ions ..." << endl;
@@ -1040 +1041 @@
     }
     if (found > 0) {
-      if (zeile.find("Ions_Data") == 0) 
+      if (zeile.find("Ions_Data") == 0)
         getline(*file,zeile,'\n'); // read next line and parse this one
       istringstream input(zeile);
@@ -1069 +1070 @@
       No++;
     }
-  }   
+  }
   file->close();
   delete(file);
@@ -1077 +1078 @@
  * \param *filename name of file
  * \param *periode pointer to a periodentafel class with all elements
- * \param *mol pointer to molecule containing all atoms of the molecule 
+ * \param *mol pointer to molecule containing all atoms of the molecule
  */
 bool config::Save(const char *filename, periodentafel *periode, molecule *mol) const
@@ -1207 +1208 @@
  * Note that this format cannot be parsed again.
  * \param *filename name of file (without ".in" suffix!)
- * \param *mol pointer to molecule containing all atoms of the molecule 
+ * \param *mol pointer to molecule containing all atoms of the molecule
  */
 bool config::SaveMPQC(const char *filename, molecule *mol) const
@@ -1218 +1219 @@
   ofstream *output = NULL;
   stringstream *fname = NULL;
-  
+
   // first without hessian
   fname = new stringstream;
@@ -1227 +1228 @@
   *output << "\tsavestate = no" << endl;
   *output << "\tdo_gradient = yes" << endl;
-  *output << "\tmole<CLHF>: (" << endl;
+  *output << "\tmole<MBPT2>: (" << endl;
   *output << "\t\tmaxiter = 200" << endl;
   *output << "\t\tbasis = $:basis" << endl;
   *output << "\t\tmolecule = $:molecule" << endl;
+  *output << "\t\treference<CLHF>: (" << endl;
+  *output << "\t\t\tbasis = $:basis" << endl;
+  *output << "\t\t\tmolecule = $:molecule" << endl;
+  *output << "\t\t)" << endl;
   *output << "\t)" << endl;
   *output << ")" << endl;
@@ -1313 +1318 @@
   delete(output);
   delete(fname);
-  
+
   return true;
 };
@@ -1325 +1330 @@
  * \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 
+ * \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
@@ -1345 +1350 @@
   dummy1 = free_dummy = (char *) Malloc(256 * sizeof(char), "config::ParseForParameter: *free_dummy");
 
-  //fprintf(stderr,"Parsing for %s\n",name);  
+  //fprintf(stderr,"Parsing for %s\n",name);
   if (repetition == 0)
     //Error(SomeError, "ParseForParameter(): argument repetition must not be 0!");
@@ -1366 +1371 @@
           file->clear();
           file->seekg(file_position, ios::beg);  // rewind to start position
-          Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");          
+          Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
           return 0;
         }
@@ -1372 +1377 @@
       line++;
     } while (dummy != NULL && dummy1 != NULL && ((dummy1[0] == '#') || (dummy1[0] == '\0'))); // skip commentary and empty lines
-    
+
     // C++ getline removes newline at end, thus re-add
     if ((dummy1 != NULL) && (strchr(dummy1,'\n') == NULL)) {
@@ -1398 +1403 @@
         //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);      
+        //Error(FileOpenParams, NULL);
       } else {
         //fprintf(stderr,"found tab at %i\n",(char *)dummy-(char *)dummy1);
@@ -1407 +1412 @@
     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);    
-      
+      //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
@@ -1447 +1452 @@
             dummy1[j+1] = '\0';
           }
-  
+
           int start = (type >= grid) ? 0 : yth-1 ;
           for (j=start;j<yth;j++) { // j = columns
@@ -1470 +1475 @@
                     //return 0;
                     exit(255);
-                    //Error(FileOpenParams, NULL);      
+                    //Error(FileOpenParams, NULL);
                   } else {
                     //if (!sequential)
@@ -1485 +1490 @@
                 // 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! 
+                if (!sequential) { // here we need it!
                   file->seekg(file_position, ios::beg);  // rewind to start position
                 }
@@ -1500 +1505 @@
                     //value += sizeof(int);
                   break;
-                case(row_double): 
+                case(row_double):
                 case(grid):
                 case(lower_trigrid):
@@ -1541 +1546 @@
       }
     }
-  } 
+  }
   if ((type >= row_int) && (verbose)) fprintf(stderr,"\n");
   Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
@@ -1549 +1554 @@
   }
   //fprintf(stderr, "End of Parsing\n\n");
-  
+
   return (found); // true if found, false if not
 }

src/datacreator.cpp

@@ -1 +1 @@
 /** \file datacreator.cpp
  *
- * Declarations of assisting functions in creating data and plot files. 
- *    
+ * Declarations of assisting functions in creating data and plot files.
+ *
  */
 
@@ -27 +27 @@
   }
   return true;
-}; 
+};
 
 /** Opens a file for appending with \a *filename in \a *dir.
@@ -45 +45 @@
   }
   return true;
-}; 
+};
 
 /** Plots an energy vs. order.
@@ -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) 
-{
-  stringstream filename;
-  ofstream output;
-
-  filename << prefix << ".dat";
-  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false; 
+bool CreateDataEnergyOrder(class EnergyMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum)
+{
+  stringstream filename;
+  ofstream output;
+
+  filename << prefix << ".dat";
+  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
   cout << msg << endl;
   output << "# " << msg << ", created on " << datum;
@@ -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) 
-{
-  stringstream filename;
-  ofstream output;
-
-  filename << prefix << ".dat";
-  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false; 
+bool CreateDataDeltaEnergyOrder(class EnergyMatrix &Energy, class EnergyMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum)
+{
+  stringstream filename;
+  ofstream output;
+
+  filename << prefix << ".dat";
+  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
   cout << msg << endl;
   output << "# " << msg << ", created on " << datum;
@@ -130 +130 @@
 
   filename << prefix << ".dat";
-  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false; 
+  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
   cout << msg << endl;
   output << "# " << msg << ", created on " << datum;
@@ -162 +162 @@
 
   filename << prefix << ".dat";
-  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false; 
+  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
   cout << msg << endl;
   output << "# " << msg << ", created on " << datum;
@@ -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, char *dir, char *prefix, char *msg, char *datum)
 {
   stringstream filename;
@@ -195 +195 @@
 
   filename << prefix << ".dat";
-  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false; 
+  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
   cout << msg << endl;
   output << "# " << msg << ", created on " << datum;
@@ -205 +205 @@
     // errors per atom
     output << endl << "#Order\t" << BondOrder+1 << endl;
-    for(int j=0;j<Fragments.RowCounter[ Fragments.MatrixCounter ];j++) { 
+    for(int j=0;j<Fragments.RowCounter[ Fragments.MatrixCounter ];j++) {
       output << Fragments.Indices[Fragments.MatrixCounter][j] << "\t";
       for (int l=0;l<Fragments.ColumnCounter[ Fragments.MatrixCounter ];l++) {
@@ -213 +213 @@
             norm += Force.Matrix[Force.MatrixCounter][ j ][l+m]*Force.Matrix[Force.MatrixCounter][ j ][l+m];
           norm = sqrt(norm);
-        }                                                                                                           
+        }                                                                                                    
 //        if (norm < MYEPSILON)
           output << scientific << Fragments.Matrix[Fragments.MatrixCounter][ j ][l] << "\t";
@@ -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) 
-{
-  stringstream filename;
-  ofstream output;
-
-  filename << prefix << ".dat";
-  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false; 
+bool CreateDataForcesOrderPerAtom(class ForceMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum)
+{
+  stringstream filename;
+  ofstream output;
+
+  filename << prefix << ".dat";
+  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
   cout << msg << endl;
   output << "# " << msg << ", created on " << datum;
@@ -250 +250 @@
     // errors per atom
     output << endl << "#Order\t" << BondOrder+1 << endl;
-    for(int j=0;j<Fragments.RowCounter[ Fragments.MatrixCounter ];j++) { 
+    for(int j=0;j<Fragments.RowCounter[ Fragments.MatrixCounter ];j++) {
       output << Fragments.Indices[Fragments.MatrixCounter][j] << "\t";
       for (int l=0;l<Fragments.ColumnCounter[ Fragments.MatrixCounter ];l++)
@@ -390 +390 @@
 
   filename << prefix << ".dat";
-  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false; 
+  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
   cout << msg << endl;
   output << "# " << msg << ", created on " << datum << endl;
@@ -411 +411 @@
  * \param &KeySet KeySetsContainer with associations of each fragment to a bond order
  * \param BondOrder current bond order
- */ 
+ */
 void CreateMaxFragmentOrder(class MatrixContainer &Fragments, class KeySetsContainer &KeySet, int BondOrder)
 {
@@ -420 +420 @@
           Fragments.Matrix[ Fragments.MatrixCounter ][j][k] = Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
       }
-    }      
+    }
   }
 };
@@ -428 +428 @@
  * \param &KeySet KeySetsContainer with associations of each fragment to a bond order
  * \param BondOrder current bond order
- */ 
+ */
 void CreateMinFragmentOrder(class MatrixContainer &Fragments, class KeySetsContainer &KeySet, int BondOrder)
 {
@@ -443 +443 @@
           Fragments.Matrix[ Fragments.MatrixCounter ][j][k] = Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
       }
-    }      
+    }
   }
 };
@@ -455 +455 @@
 
   filename << prefix << ".dat";
-  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false; 
+  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
   cout << msg << endl;
   output << "# " << msg << ", created on " << datum;
@@ -496 +496 @@
     do {
       for (int m=NDIM;m--;) {
-        stored += Force.Matrix[MatrixNumber][ k ][l+m] 
+        stored += Force.Matrix[MatrixNumber][ k ][l+m]
               * Force.Matrix[MatrixNumber][ k ][l+m];
-        Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l+m]  = Force.Matrix[MatrixNumber][ k ][l+m]; 
+        Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l+m]  = Force.Matrix[MatrixNumber][ k ][l+m];
       }
       k++;
@@ -505 +505 @@
       double tmp = 0;
       for (int m=NDIM;m--;)
-        tmp += Force.Matrix[MatrixNumber][ k ][l+m] 
+        tmp += Force.Matrix[MatrixNumber][ k ][l+m]
               * Force.Matrix[MatrixNumber][ k ][l+m];
       if ((fabs(tmp) > MYEPSILON) && (tmp < stored)) {  // current force is greater than stored
         for (int m=NDIM;m--;)
-          Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l+m]  = Force.Matrix[MatrixNumber][ k ][l+m]; 
+          Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l+m]  = Force.Matrix[MatrixNumber][ k ][l+m];
         stored = tmp;
       }
@@ -531 +531 @@
       double norm = 0.;
       for (int m=NDIM;m--;)
-        norm += Force.Matrix[MatrixNumber][ k ][l+m] 
+        norm += Force.Matrix[MatrixNumber][ k ][l+m]
               * Force.Matrix[MatrixNumber][ k ][l+m];
       tmp += sqrt(norm);
@@ -553 +553 @@
       double tmp = 0;
       for (int m=NDIM;m--;)
-        tmp += Force.Matrix[MatrixNumber][ k ][l+m] 
+        tmp += Force.Matrix[MatrixNumber][ k ][l+m]
               * Force.Matrix[MatrixNumber][ k ][l+m];
       if (tmp > stored) {  // current force is greater than stored
         for (int m=NDIM;m--;)
-          Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l+m]  = Force.Matrix[MatrixNumber][ k ][l+m]; 
+          Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l+m]  = Force.Matrix[MatrixNumber][ k ][l+m];
         stored = tmp;
       }
@@ -592 +592 @@
  * \param *key position of key
  * \param *logscale axis for logscale
- * \param *extraline extra set lines if desired 
+ * \param *extraline extra set lines if desired
  * \param mxtics small tics at ...
  * \param xtics large tics at ...
- * \param *xlabel label for x axis  
+ * \param *xlabel label for x axis
  * \param *ylabel label for y axis
- */ 
+ */
 void CreatePlotHeader(ofstream &output, const char *prefix, const int keycolumns, const char *key, const char *logscale, const char *extraline, const int mxtics, const int xtics, const char *xlabel, const char *ylabel)
 {
@@ -626 +626 @@
  * \param mxtics small tics at ...
  * \param xtics large tics at ...
- * \param xlabel label for x axis  
+ * \param xlabel label for x axis
  * \param xlabel label for x axis
  * \param *xrange xrange
@@ -634 +634 @@
  * \param (*CreatePlotLines) function reference that writes a single plot line
  * \return true if file was written successfully
- */   
+ */
 bool CreatePlotOrder(class MatrixContainer &Matrix, const class KeySetsContainer &KeySet, const char *dir, const char *prefix, const int keycolumns, const char *key, const char *logscale, const char *extraline, const int mxtics, const int xtics, const char *xlabel, const char *ylabel, const char *xrange, const char *yrange, const char *xargument, const char *uses, void (*CreatePlotLines)(ofstream &, class MatrixContainer &, const char *, const char *, const char *))
 {
@@ -641 +641 @@
 
   filename << prefix << ".pyx";
-  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false; 
+  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
   CreatePlotHeader(output, prefix, keycolumns, key, logscale, extraline, mxtics, xtics, xlabel, ylabel);
   output << "plot " << xrange << " " << yrange << " \\" << endl;
   CreatePlotLines(output, Matrix, prefix, xargument, uses);
-  output.close();  
+  output.close();
   return true;
 };

src/datacreator.hpp

@@ -1 +1 @@
 /** \file datacreator.cpp
  *
- * Definitions of assisting functions in creating data and plot files. 
- *    
+ * Definitions of assisting functions in creating data and plot files.
+ *
  */
 
@@ -12 +12 @@
 //============================ INCLUDES ===========================
 
-#include "helpers.hpp" 
+#include "helpers.hpp"
 #include "parser.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 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);

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/graph.cpp

@@ -1 +1 @@
 /** \file graph.cpp
- * 
+ *
  * Function implementations for the class graph.
- * 
+ *
  */
 

src/helpers.cpp

@@ -1 +1 @@
 /** \file helpers.cpp
  *
- * Implementation of some auxiliary functions for memory dis-/allocation and so on 
+ * Implementation of some auxiliary functions for memory dis-/allocation and so on
  */
 
@@ -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
 
@@ -40 +40 @@
  * \return pointer to memory range
  */
-void * Malloc(size_t size, const char* output) 
+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);
 };
 
@@ -54 +54 @@
  * \return pointer to memory range
  */
-void * Calloc(size_t size, const char* output) 
+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);
 };
 
@@ -69 +69 @@
  * \return pointer to memory range
  */
-void * ReAlloc(void * OldPointer, size_t size, const char* output) 
+void * ReAlloc(void * OldPointer, size_t size, const char* output)
 {
   void *buffer = NULL;
@@ -86 +86 @@
  * \param *output message if free fails
  */
-void Free(void ** buffer, const char* output) 
+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;
+        }
 };
 
@@ -101 +101 @@
  * \return pointer to string array
  */
-char* MallocString(size_t size, const char* output) 
+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;
+};
 
 /** Flips two doubles.
@@ -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), "MoleculeListClass::CreateFragmentNumberForOutput: *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;
 };
 
@@ -186 +186 @@
  * \return true - is a number, false - is not a valid number
  */
-bool IsValidNumber( const char *string) 
+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

@@ -1 +1 @@
 /** \file helpers.hpp
  *
- * Declaration of some auxiliary functions for memory dis-/allocation and so on 
+ * Declaration of some auxiliary functions for memory dis-/allocation and so on
  */
 
@@ -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;
+};
 
 /** Returns the last marker in a chain list.
@@ -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;
+};
 
 /** Frees a two-dimensional array.
@@ -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

@@ -2 +2 @@
  *
  * Takes evaluated fragments (energy and forces) and by reading the factors files determines total energy
- * and each force for the whole molecule. 
- *    
+ * and each force for the whole molecule.
+ *
  */
 
 //============================ INCLUDES ===========================
 
-#include "datacreator.hpp" 
-#include "helpers.hpp" 
-#include "parser.hpp" 
-#include "periodentafel.hpp" 
+#include "datacreator.hpp"
+#include "helpers.hpp"
+#include "parser.hpp"
+#include "periodentafel.hpp"
 
 //============================== MAIN =============================
@@ -46 +46 @@
   cout << "Joiner" << endl;
   cout << "======" << endl;
-  
+
   // Get the command line options
   if (argc < 3) {
@@ -63 +63 @@
     periode->LoadPeriodentafel(argv[3]);
   }
-  
+
   // Test the given directory
   if (!TestParams(argc, argv))
     return 1;
-  
+
   // +++++++++++++++++ PARSING +++++++++++++++++++++++++++++++
-  
+
   // ------------- Parse through all Fragment subdirs --------
   if (!Energy.ParseFragmentMatrix(argv[1], dir, EnergySuffix, 0,0)) return 1;
@@ -124 +124 @@
     if (!ChiPASFragments.AllocateMatrix(ChiPAS.Header, ChiPAS.MatrixCounter, ChiPAS.RowCounter, ChiPAS.ColumnCounter)) return 1;
   }
-  
+
   // ----------- Resetting last matrices (where full QM values are stored right now)
   if(!Energy.SetLastMatrix(0., 0)) return 1;
@@ -237 +237 @@
   }
 
-  // exit  
+  // exit
   delete(periode);
   Free((void **)&dir, "main: *dir");

src/moleculelist.cpp

@@ -1 +1 @@
 /** \file MoleculeListClass.cpp
- * 
+ *
  * Function implementations for the class MoleculeListClass.
- * 
+ *
  */
 
@@ -13 +13 @@
 MoleculeListClass::MoleculeListClass()
 {
-};
-
-/** constructor for MoleculeListClass.
- * \param NumMolecules number of molecules to allocate for
- * \param NumAtoms number of atoms to allocate for
- */
-MoleculeListClass::MoleculeListClass(int NumMolecules, int NumAtoms)
-{
-  ListOfMolecules = (molecule **) Malloc(sizeof(molecule *)*NumMolecules, "MoleculeListClass:MoleculeListClass: **ListOfMolecules");
-  for (int i=NumMolecules;i--;)
-    ListOfMolecules[i] = NULL;
-  NumberOfMolecules = NumMolecules;
-  NumberOfTopAtoms = NumAtoms;
-};
-
+  // empty lists
+  ListOfMolecules.clear();
+  MaxIndex = 1;
+};
 
 /** Destructor for MoleculeListClass.
@@ -34 +23 @@
 {
   cout << Verbose(3) << this << ": Freeing ListOfMolcules." << endl;
-  for (int i=NumberOfMolecules;i--;) {
-    if (ListOfMolecules[i] != NULL) { // if NULL don't free
-      cout << Verbose(4) << "ListOfMolecules: Freeing " << ListOfMolecules[i] << "." << endl;
-      delete(ListOfMolecules[i]);
-      ListOfMolecules[i] = NULL;
-    }
+  for (MoleculeList::iterator ListRunner = ListOfMolecules.begin(); ListRunner != ListOfMolecules.end(); ListRunner++) {
+    cout << Verbose(4) << "ListOfMolecules: Freeing " << *ListRunner << "." << endl;
+    delete (*ListRunner);
   }
   cout << Verbose(4) << "Freeing ListOfMolecules." << endl;
-  Free((void **)&ListOfMolecules, "MoleculeListClass:MoleculeListClass: **ListOfMolecules");
+  ListOfMolecules.clear(); // empty list
+};
+
+/** Insert a new molecule into the list and set its number.
+ * \param *mol molecule to add to list.
+ * \return true - add successful
+ */
+void MoleculeListClass::insert(molecule *mol)
+{
+  mol->IndexNr = MaxIndex++;
+  ListOfMolecules.push_back(mol);
 };
 
@@ -57 +53 @@
   atom *aWalker = NULL;
   atom *bWalker = NULL;
-  
+
   // sort each atom list and put the numbers into a list, then go through
   //cout << "Comparing fragment no. " << *(molecule **)a << " to " << *(molecule **)b << "." << endl;
-  if ( (**(molecule **)a).AtomCount < (**(molecule **)b).AtomCount ) {
+  if ((**(molecule **) a).AtomCount < (**(molecule **) b).AtomCount) {
     return -1;
-  } else { if ((**(molecule **)a).AtomCount > (**(molecule **)b).AtomCount)
-    return +1;
+  } else {
+    if ((**(molecule **) a).AtomCount > (**(molecule **) b).AtomCount)
+      return +1;
     else {
-      Count = (**(molecule **)a).AtomCount;
+      Count = (**(molecule **) a).AtomCount;
       aList = new int[Count];
       bList = new int[Count];
-  
+
       // fill the lists
-      aWalker = (**(molecule **)a).start;
-      bWalker = (**(molecule **)b).start;
+      aWalker = (**(molecule **) a).start;
+      bWalker = (**(molecule **) b).start;
       Counter = 0;
       aCounter = 0;
       bCounter = 0;
-      while ((aWalker->next != (**(molecule **)a).end) && (bWalker->next != (**(molecule **)b).end)) {
+      while ((aWalker->next != (**(molecule **) a).end) && (bWalker->next != (**(molecule **) b).end)) {
         aWalker = aWalker->next;
         bWalker = bWalker->next;
@@ -90 +87 @@
       // check if AtomCount was for real
       flag = 0;
-      if ((aWalker->next == (**(molecule **)a).end) && (bWalker->next != (**(molecule **)b).end)) {
+      if ((aWalker->next == (**(molecule **) a).end) && (bWalker->next != (**(molecule **) b).end)) {
         flag = -1;
       } else {
-        if ((aWalker->next != (**(molecule **)a).end) && (bWalker->next == (**(molecule **)b).end))
+        if ((aWalker->next != (**(molecule **) a).end) && (bWalker->next == (**(molecule **) b).end))
           flag = 1;
       }
       if (flag == 0) {
         // sort the lists
-        gsl_heapsort(aList,Count, sizeof(int), CompareDoubles); 
-        gsl_heapsort(bList,Count, sizeof(int), CompareDoubles);
-        // compare the lists 
-        
+        gsl_heapsort(aList, Count, sizeof(int), CompareDoubles);
+        gsl_heapsort(bList, Count, sizeof(int), CompareDoubles);
+        // compare the lists
+
         flag = 0;
-        for(int i=0;i<Count;i++) {
+        for (int i = 0; i < Count; i++) {
           if (aList[i] < bList[i]) {
             flag = -1;
@@ -114 +111 @@
         }
       }
-      delete[](aList);
-      delete[](bList);
+      delete[] (aList);
+      delete[] (bList);
       return flag;
     }
   }
-  return  -1;
+  return -1;
+};
+
+/** Output of a list of all molecules.
+ * \param *out output stream
+ */
+void MoleculeListClass::Enumerate(ofstream *out)
+{
+  element* Elemental = NULL;
+  atom *Walker = NULL;
+  int Counts[MAX_ELEMENTS];
+  double size=0;
+  Vector Origin;
+
+  // header
+  *out << "Index\tName\t\tAtoms\tFormula\tCenter\tSize" << endl;
+  cout << Verbose(0) << "-----------------------------------------------" << endl;
+  if (ListOfMolecules.size() == 0)
+    *out << "\tNone" << endl;
+  else {
+    Origin.Zero();
+    for (MoleculeList::iterator ListRunner = ListOfMolecules.begin(); ListRunner != ListOfMolecules.end(); ListRunner++) {
+      // reset element counts
+      for (int j = 0; j<MAX_ELEMENTS;j++)
+        Counts[j] = 0;
+      // count atoms per element and determine size of bounding sphere
+      size=0.;
+      Walker = (*ListRunner)->start;
+      while (Walker->next != (*ListRunner)->end) {
+        Walker = Walker->next;
+        Counts[Walker->type->Z]++;
+        if (Walker->x.DistanceSquared(&Origin) > size)
+          size = Walker->x.DistanceSquared(&Origin);
+      }
+      // output Index, Name, number of atoms, chemical formula
+      *out << ((*ListRunner)->ActiveFlag ? "*" : " ") << (*ListRunner)->IndexNr << "\t" << (*ListRunner)->name << "\t\t" << (*ListRunner)->AtomCount << "\t";
+      Elemental = (*ListRunner)->elemente->end;
+      while(Elemental->previous != (*ListRunner)->elemente->start) {
+        Elemental = Elemental->previous;
+        if (Counts[Elemental->Z] != 0)
+          *out << Elemental->symbol << Counts[Elemental->Z];
+      }
+      // Center and size
+      *out << "\t" << (*ListRunner)->Center << "\t" << sqrt(size) << endl;
+    }
+  }
+};
+
+/** Returns the molecule with the given index \a index.
+ * \param index index of the desired molecule
+ * \return pointer to molecule structure, NULL if not found
+ */
+molecule * MoleculeListClass::ReturnIndex(int index)
+{
+  for(MoleculeList::iterator ListRunner = ListOfMolecules.begin(); ListRunner != ListOfMolecules.end(); ListRunner++)
+    if ((*ListRunner)->IndexNr == index)
+      return (*ListRunner);
+  return NULL;
+};
+
+/** Simple merge of two molecules into one.
+ * \param *mol destination molecule
+ * \param *srcmol source molecule
+ * \return true - merge successful, false - merge failed (probably due to non-existant indices
+ */
+bool MoleculeListClass::SimpleMerge(molecule *mol, molecule *srcmol)
+{
+  if (srcmol == NULL)
+    return false;
+
+  // put all molecules of src into mol
+  atom *Walker = srcmol->start;
+  atom *NextAtom = Walker->next;
+  while (NextAtom != srcmol->end) {
+    Walker = NextAtom;
+    NextAtom = Walker->next;
+    srcmol->UnlinkAtom(Walker);
+    mol->AddAtom(Walker);
+  }
+
+  // remove src
+  ListOfMolecules.remove(srcmol);
+  delete(srcmol);
+  return true;
+};
+
+/** Simple add of one molecules into another.
+ * \param *mol destination molecule
+ * \param *srcmol source molecule
+ * \return true - merge successful, false - merge failed (probably due to non-existant indices
+ */
+bool MoleculeListClass::SimpleAdd(molecule *mol, molecule *srcmol)
+{
+  if (srcmol == NULL)
+    return false;
+
+  // put all molecules of src into mol
+  atom *Walker = srcmol->start;
+  atom *NextAtom = Walker->next;
+  while (NextAtom != srcmol->end) {
+    Walker = NextAtom;
+    NextAtom = Walker->next;
+    Walker = mol->AddCopyAtom(Walker);
+    Walker->father = Walker;
+  }
+
+  return true;
+};
+
+/** Simple merge of a given set of molecules into one.
+ * \param *mol destination molecule
+ * \param *src index of set of source molecule
+ * \param N number of source molecules
+ * \return true - merge successful, false - some merges failed (probably due to non-existant indices)
+ */
+bool MoleculeListClass::SimpleMultiMerge(molecule *mol, int *src, int N)
+{
+  bool status = true;
+  // check presence of all source molecules
+  for (int i=0;i<N;i++) {
+    molecule *srcmol = ReturnIndex(src[i]);
+    status = status && SimpleMerge(mol, srcmol);
+  }
+  return status;
+};
+
+/** Simple add of a given set of molecules into one.
+ * \param *mol destination molecule
+ * \param *src index of set of source molecule
+ * \param N number of source molecules
+ * \return true - merge successful, false - some merges failed (probably due to non-existant indices)
+ */
+bool MoleculeListClass::SimpleMultiAdd(molecule *mol, int *src, int N)
+{
+  bool status = true;
+  // check presence of all source molecules
+  for (int i=0;i<N;i++) {
+    molecule *srcmol = ReturnIndex(src[i]);
+    status = status && SimpleAdd(mol, srcmol);
+  }
+  return status;
+};
+
+/** Scatter merge of a given set of molecules into one.
+ * Scatter merge distributes the molecules in such a manner that they don't overlap.
+ * \param *mol destination molecule
+ * \param *src index of set of source molecule
+ * \param N number of source molecules
+ * \return true - merge successful, false - merge failed (probably due to non-existant indices
+ * \TODO find scatter center for each src molecule
+ */
+bool MoleculeListClass::ScatterMerge(molecule *mol, int *src, int N)
+{
+  // check presence of all source molecules
+  for (int i=0;i<N;i++) {
+    // get pointer to src molecule
+    molecule *srcmol = ReturnIndex(src[i]);
+    if (srcmol == NULL)
+      return false;
+  }
+  // adapt each Center
+  for (int i=0;i<N;i++) {
+    // get pointer to src molecule
+    molecule *srcmol = ReturnIndex(src[i]);
+    //srcmol->Center.Zero();
+    srcmol->Translate(&srcmol->Center);
+  }
+  // perform a simple multi merge
+  SimpleMultiMerge(mol, src, N);
+  return true;
+};
+
+/** Embedding merge of a given set of molecules into one.
+ * Embedding merge inserts one molecule into the other.
+ * \param *mol destination molecule
+ * \param *srcmol source molecule
+ * \return true - merge successful, false - merge failed (probably due to non-existant indices
+ * \TODO find embedding center
+ */
+bool MoleculeListClass::EmbedMerge(molecule *mol, molecule *srcmol)
+{
+  if (srcmol == NULL)
+    return false;
+
+  // calculate center for merge
+  srcmol->Center.CopyVector(mol->FindEmbeddingHole((ofstream *)&cout, srcmol));
+  srcmol->Center.Zero();
+
+  // perform simple merge
+  SimpleMerge(mol, srcmol);
+  return true;
 };
 
@@ -127 +314 @@
 void MoleculeListClass::Output(ofstream *out)
 {
-  *out<< Verbose(1) << "MoleculeList: ";
-  for (int i=0;i<NumberOfMolecules;i++)
-    *out << ListOfMolecules[i] << "\t";
+  *out << Verbose(1) << "MoleculeList: ";
+  for (MoleculeList::iterator ListRunner = ListOfMolecules.begin(); ListRunner != ListOfMolecules.end(); ListRunner++)
+    *out << *ListRunner << "\t";
   *out << endl;
 };
@@ -145 +332 @@
   atom *Runner = NULL;
   double ***FitConstant = NULL, **correction = NULL;
-  int a,b;
+  int a, b;
   ofstream output;
   ifstream input;
@@ -165 +352 @@
   input.open(line.c_str());
   if (input == NULL) {
-    cerr << endl << "Unable to open " << line << ", is the directory correct?" << endl;
+    cerr << endl << "Unable to open " << line << ", is the directory correct?"
+        << endl;
     return false;
   }
-  a=0;
-  b=-1; // we overcount by one 
+  a = 0;
+  b = -1; // we overcount by one
   while (!input.eof()) {
     input.getline(ParsedLine, 1023);
     zeile.str(ParsedLine);
-    int i=0;
+    int i = 0;
     while (!zeile.eof()) {
       zeile >> distance;
       i++;
     }
-    if (i > a) 
-      a = i; 
+    if (i > a)
+      a = i;
     b++;
   }
   cout << "I recognized " << a << " columns and " << b << " rows, ";
   input.close();
-  
+
   // 0b. allocate memory for constants
-  FitConstant = (double ***) Malloc(sizeof(double **)*3, "MoleculeListClass::AddHydrogenCorrection: ***FitConstant");
-  for (int k=0;k<3;k++) {
-    FitConstant[k] = (double **) Malloc(sizeof(double *)*a, "MoleculeListClass::AddHydrogenCorrection: **FitConstant[]");
-    for (int i=a;i--;) {
-      FitConstant[k][i] = (double *) Malloc(sizeof(double)*b, "MoleculeListClass::AddHydrogenCorrection: *FitConstant[][]");
+  FitConstant = (double ***) Malloc(sizeof(double **) * 3, "MoleculeListClass::AddHydrogenCorrection: ***FitConstant");
+  for (int k = 0; k < 3; k++) {
+    FitConstant[k] = (double **) Malloc(sizeof(double *) * a, "MoleculeListClass::AddHydrogenCorrection: **FitConstant[]");
+    for (int i = a; i--;) {
+      FitConstant[k][i] = (double *) Malloc(sizeof(double) * b, "MoleculeListClass::AddHydrogenCorrection: *FitConstant[][]");
     }
   }
   // 0c. parse in constants
-  for (int i=0;i<3;i++) {
+  for (int i = 0; i < 3; i++) {
     line = path;
     line.append("/");
     line += FRAGMENTPREFIX;
-    sprintf(ParsedLine, "%d", i+1);
+    sprintf(ParsedLine, "%d", i + 1);
     line += ParsedLine;
     line += FITCONSTANTSUFFIX;
@@ -206 +394 @@
       return false;
     }
-    int k = 0,l;
+    int k = 0, l;
     while ((!input.eof()) && (k < b)) {
       input.getline(ParsedLine, 1023);
@@ -223 +411 @@
     input.close();
   }
-  for(int k=0;k<3;k++) {
+  for (int k = 0; k < 3; k++) {
     cout << "Constants " << k << ":" << endl;
-    for (int j=0;j<b;j++) {
-      for (int i=0;i<a;i++) {
+    for (int j = 0; j < b; j++) {
+      for (int i = 0; i < a; i++) {
         cout << FitConstant[k][i][j] << "\t";
       }
@@ -233 +421 @@
     cout << endl;
   }
-  
+
   // 0d. allocate final correction matrix
-  correction = (double **) Malloc(sizeof(double *)*a, "MoleculeListClass::AddHydrogenCorrection: **correction");
-  for (int i=a;i--;)
-    correction[i] = (double *) Malloc(sizeof(double)*b, "MoleculeListClass::AddHydrogenCorrection: *correction[]");
-        
+  correction = (double **) Malloc(sizeof(double *) * a, "MoleculeListClass::AddHydrogenCorrection: **correction");
+  for (int i = a; i--;)
+    correction[i] = (double *) Malloc(sizeof(double) * b, "MoleculeListClass::AddHydrogenCorrection: *correction[]");
+
   // 1a. go through every molecule in the list
-  for(int i=NumberOfMolecules;i--;) {
+  for (MoleculeList::iterator ListRunner = ListOfMolecules.begin(); ListRunner != ListOfMolecules.end(); ListRunner++) {
     // 1b. zero final correction matrix
-    for (int k=a;k--;)
-      for (int j=b;j--;)
+    for (int k = a; k--;)
+      for (int j = b; j--;)
         correction[k][j] = 0.;
     // 2. take every hydrogen that is a saturated one
-    Walker = ListOfMolecules[i]->start;
-    while (Walker->next != ListOfMolecules[i]->end) {
+    Walker = (*ListRunner)->start;
+    while (Walker->next != (*ListRunner)->end) {
       Walker = Walker->next;
-      //cout << Verbose(1) << "Walker: " << *Walker << " with first bond " << *ListOfMolecules[i]->ListOfBondsPerAtom[Walker->nr][0] << "." << endl;
-      if ((Walker->type->Z == 1) && ((Walker->father == NULL) || (Walker->father->type->Z != 1))) { // if it's a hydrogen
-        Runner = ListOfMolecules[i]->start;
-        while (Runner->next != ListOfMolecules[i]->end) {
+      //cout << Verbose(1) << "Walker: " << *Walker << " with first bond " << *(*Runner)->ListOfBondsPerAtom[Walker->nr][0] << "." << endl;
+      if ((Walker->type->Z == 1) && ((Walker->father == NULL)
+          || (Walker->father->type->Z != 1))) { // if it's a hydrogen
+        Runner = (*ListRunner)->start;
+        while (Runner->next != (*ListRunner)->end) {
           Runner = Runner->next;
-          //cout << Verbose(2) << "Runner: " << *Runner << " with first bond " << *ListOfMolecules[i]->ListOfBondsPerAtom[Runner->nr][0] << "." << endl;
+          //cout << Verbose(2) << "Runner: " << *Runner << " with first bond " << *(*Runner)->ListOfBondsPerAtom[Runner->nr][0] << "." << endl;
           // 3. take every other hydrogen that is the not the first and not bound to same bonding partner
-          if ((Runner->type->Z == 1) && (Runner->nr > Walker->nr) && (ListOfMolecules[i]->ListOfBondsPerAtom[Runner->nr][0]->GetOtherAtom(Runner) != ListOfMolecules[i]->ListOfBondsPerAtom[Walker->nr][0]->GetOtherAtom(Walker))) {  // (hydrogens have only one bonding partner!)
+          if ((Runner->type->Z == 1) && (Runner->nr > Walker->nr) && ((*ListRunner)->ListOfBondsPerAtom[Runner->nr][0]->GetOtherAtom(Runner) != (*ListRunner)->ListOfBondsPerAtom[Walker->nr][0]->GetOtherAtom(Walker))) { // (hydrogens have only one bonding partner!)
             // 4. evaluate the morse potential for each matrix component and add up
-            distance = sqrt(Runner->x.Distance(&Walker->x));
-            //cout << "Fragment " << i << ": " << *Runner << "<= " << distance << "=>" << *Walker << ":" << endl;
-            for(int k=0;k<a;k++) {
-              for (int j=0;j<b;j++) {
-                switch(k) {
-                case 1:
-                case 7:
-                case 11:
-                  tmp = pow(FitConstant[0][k][j] * ( 1. - exp(-FitConstant[1][k][j] * (distance - FitConstant[2][k][j]) ) ),2);
-                  break;
-                default:
-                  tmp = FitConstant[0][k][j] * pow( distance,  FitConstant[1][k][j]) + FitConstant[2][k][j];
+            distance = Runner->x.Distance(&Walker->x);
+            //cout << "Fragment " << (*ListRunner)->name << ": " << *Runner << "<= " << distance << "=>" << *Walker << ":" << endl;
+            for (int k = 0; k < a; k++) {
+              for (int j = 0; j < b; j++) {
+                switch (k) {
+                  case 1:
+                  case 7:
+                  case 11:
+                    tmp = pow(FitConstant[0][k][j] * (1. - exp(-FitConstant[1][k][j] * (distance - FitConstant[2][k][j]))), 2);
+                    break;
+                  default:
+                    tmp = FitConstant[0][k][j] * pow(distance, FitConstant[1][k][j]) + FitConstant[2][k][j];
                 };
-                correction[k][j] -= tmp;    // ground state is actually lower (disturbed by additional interaction)
+                correction[k][j] -= tmp; // ground state is actually lower (disturbed by additional interaction)
                 //cout << tmp << "\t";
               }
@@ -285 +474 @@
     line.append("/");
     line += FRAGMENTPREFIX;
-    FragmentNumber = FixedDigitNumber(NumberOfMolecules, i);
+    FragmentNumber = FixedDigitNumber(ListOfMolecules.size(), (*ListRunner)->IndexNr);
     line += FragmentNumber;
-    delete(FragmentNumber);
+    delete (FragmentNumber);
     line += HCORRECTIONSUFFIX;
     output.open(line.c_str());
     output << "Time\t\tTotal\t\tKinetic\t\tNonLocal\tCorrelation\tExchange\tPseudo\t\tHartree\t\t-Gauss\t\tEwald\t\tIonKin\t\tETotal" << endl;
-    for (int j=0;j<b;j++) {
-      for(int i=0;i<a;i++)
+    for (int j = 0; j < b; j++) {
+      for (int i = 0; i < a; i++)
         output << correction[i][j] << "\t";
       output << endl;
@@ -303 +492 @@
   output.open(line.c_str());
   output << "Time\t\tTotal\t\tKinetic\t\tNonLocal\tCorrelation\tExchange\tPseudo\t\tHartree\t\t-Gauss\t\tEwald\t\tIonKin\t\tETotal" << endl;
-  for (int j=0;j<b;j++) {
-    for(int i=0;i<a;i++)
+  for (int j = 0; j < b; j++) {
+    for (int i = 0; i < a; i++)
       output << 0 << "\t";
     output << endl;
@@ -310 +499 @@
   output.close();
   // 6. free memory of parsed matrices
-  FitConstant = (double ***) Malloc(sizeof(double **)*a, "MoleculeListClass::AddHydrogenCorrection: ***FitConstant");
-  for (int k=0;k<3;k++) {
-    FitConstant[k] = (double **) Malloc(sizeof(double *)*a, "MoleculeListClass::AddHydrogenCorrection: **FitConstant[]");
-    for (int i=a;i--;) {
-      FitConstant[k][i] = (double *) Malloc(sizeof(double)*b, "MoleculeListClass::AddHydrogenCorrection: *FitConstant[][]");
+  FitConstant = (double ***) Malloc(sizeof(double **) * a, "MoleculeListClass::AddHydrogenCorrection: ***FitConstant");
+  for (int k = 0; k < 3; k++) {
+    FitConstant[k] = (double **) Malloc(sizeof(double *) * a, "MoleculeListClass::AddHydrogenCorrection: **FitConstant[]");
+    for (int i = a; i--;) {
+      FitConstant[k][i] = (double *) Malloc(sizeof(double) * b, "MoleculeListClass::AddHydrogenCorrection: *FitConstant[][]");
     }
   }
@@ -327 +516 @@
  * \return true - file written successfully, false - writing failed
  */
-bool MoleculeListClass::StoreForcesFile(ofstream *out, char *path, int *SortIndex)
+bool MoleculeListClass::StoreForcesFile(ofstream *out, char *path,
+    int *SortIndex)
 {
   bool status = true;
@@ -342 +532 @@
     //cout << Verbose(1) << "Final AtomicForcesList: ";
     //output << prefix << "Forces" << endl;
-    for(int j=0;j<NumberOfMolecules;j++) {
-      //if (TEList[j] != 0) {
-      runner = ListOfMolecules[j]->elemente->start;
-      while (runner->next != ListOfMolecules[j]->elemente->end) { // go through every element
+    for (MoleculeList::iterator ListRunner = ListOfMolecules.begin(); ListRunner != ListOfMolecules.end(); ListRunner++) {
+      runner = (*ListRunner)->elemente->start;
+      while (runner->next != (*ListRunner)->elemente->end) { // go through every element
         runner = runner->next;
-        if (ListOfMolecules[j]->ElementsInMolecule[runner->Z]) { // if this element got atoms
-          Walker = ListOfMolecules[j]->start;
-          while (Walker->next != ListOfMolecules[j]->end) { // go through every atom of this element
+        if ((*ListRunner)->ElementsInMolecule[runner->Z]) { // if this element got atoms
+          Walker = (*ListRunner)->start;
+          while (Walker->next != (*ListRunner)->end) { // go through every atom of this element
             Walker = Walker->next;
             if (Walker->type->Z == runner->Z) {
               if ((Walker->GetTrueFather() != NULL) && (Walker->GetTrueFather() != Walker)) {// if there is a rea
                 //cout << "Walker is " << *Walker << " with true father " << *( Walker->GetTrueFather()) << ", it
-                ForcesFile <<  SortIndex[Walker->GetTrueFather()->nr] << "\t";
-                } else  // otherwise a -1 to indicate an added saturation hydrogen
-                  ForcesFile << "-1\t";
-              }
+                ForcesFile << SortIndex[Walker->GetTrueFather()->nr] << "\t";
+              } else
+                // otherwise a -1 to indicate an added saturation hydrogen
+                ForcesFile << "-1\t";
             }
           }
+        }
       }
       ForcesFile << endl;
@@ -370 +560 @@
   }
   ForcesFile.close();
-  
+
   return status;
 };
@@ -382 +572 @@
  * \return true - success (each file was written), false - something went wrong.
  */
-bool MoleculeListClass::OutputConfigForListOfFragments(ofstream *out, const char *fragmentprefix, config *configuration, int *SortIndex, bool DoPeriodic, bool DoCentering)
+bool MoleculeListClass::OutputConfigForListOfFragments(ofstream *out, config *configuration, int *SortIndex)
 {
   ofstream outputFragment;
@@ -395 +585 @@
   int FragmentCounter = 0;
   ofstream output;
-  string basis("3-21G");
-  
+
   // store the fragments as config and as xyz
-  for(int i=0;i<NumberOfMolecules;i++) {
+  for (MoleculeList::iterator ListRunner = ListOfMolecules.begin(); ListRunner != ListOfMolecules.end(); ListRunner++) {
     // save default path as it is changed for each fragment
     path = configuration->GetDefaultPath();
@@ -407 +596 @@
 
     // correct periodic
-    if (DoPeriodic)
-      ListOfMolecules[i]->ScanForPeriodicCorrection(out);
+    (*ListRunner)->ScanForPeriodicCorrection(out);
 
     // output xyz file
-    FragmentNumber = FixedDigitNumber(NumberOfMolecules, FragmentCounter++);
-    sprintf(FragmentName, "%s/%s%s.conf.xyz", configuration->configpath, fragmentprefix, FragmentNumber);
+    FragmentNumber = FixedDigitNumber(ListOfMolecules.size(), FragmentCounter++);
+    sprintf(FragmentName, "%s/%s%s.conf.xyz", configuration->configpath, FRAGMENTPREFIX, FragmentNumber);
     outputFragment.open(FragmentName, ios::out);
-    *out << Verbose(2) << "Saving " << fragmentprefix << " No. " << FragmentNumber << "/" << FragmentCounter-1 << " as XYZ ...";
-    if ((intermediateResult = ListOfMolecules[i]->OutputXYZ(&outputFragment)))
+    *out << Verbose(2) << "Saving bond fragment No. " << FragmentNumber << "/" << FragmentCounter - 1 << " as XYZ ...";
+    if ((intermediateResult = (*ListRunner)->OutputXYZ(&outputFragment)))
       *out << " done." << endl;
     else
@@ -425 +613 @@
     // list atoms in fragment for debugging
     *out << Verbose(2) << "Contained atoms: ";
-    Walker = ListOfMolecules[i]->start;
-    while (Walker->next != ListOfMolecules[i]->end) {
+    Walker = (*ListRunner)->start;
+    while (Walker->next != (*ListRunner)->end) {
       Walker = Walker->next;
       *out << Walker->Name << " ";
     }
     *out << endl;
-    
+
     // center on edge
-    if (DoCentering) {
-      ListOfMolecules[i]->CenterEdge(out, &BoxDimension);
-      ListOfMolecules[i]->SetBoxDimension(&BoxDimension);  // update Box of atoms by boundary
-      int j = -1;
-      for (int k=0;k<NDIM;k++) {
-        j += k+1;
-        BoxDimension.x[k] = 2.5* (configuration->GetIsAngstroem() ? 1. : 1./AtomicLengthToAngstroem);
-        ListOfMolecules[i]->cell_size[j] += BoxDimension.x[k]*2.;
-      }
-      ListOfMolecules[i]->Translate(&BoxDimension);
-    }
+    (*ListRunner)->CenterEdge(out, &BoxDimension);
+    (*ListRunner)->SetBoxDimension(&BoxDimension); // update Box of atoms by boundary
+    int j = -1;
+    for (int k = 0; k < NDIM; k++) {
+      j += k + 1;
+      BoxDimension.x[k] = 2.5 * (configuration->GetIsAngstroem() ? 1. : 1. / AtomicLengthToAngstroem);
+      (*ListRunner)->cell_size[j] += BoxDimension.x[k] * 2.;
+    }
+    (*ListRunner)->Translate(&BoxDimension);
 
     // also calculate necessary orbitals
-    ListOfMolecules[i]->CountElements();  // this is a bugfix, atoms should should actually be added correctly to this fragment 
-    ListOfMolecules[i]->CalculateOrbitals(*configuration);
-    
+    (*ListRunner)->CountElements(); // this is a bugfix, atoms should shoulds actually be added correctly to this fragment
+    (*ListRunner)->CalculateOrbitals(*configuration);
+
     // change path in config
     //strcpy(PathBackup, configuration->configpath);
-    sprintf(FragmentName, "%s/%s%s/", PathBackup, fragmentprefix, FragmentNumber);
+    sprintf(FragmentName, "%s/%s%s/", PathBackup, FRAGMENTPREFIX, FragmentNumber);
     configuration->SetDefaultPath(FragmentName);
-    
+
     // and save as config
-    sprintf(FragmentName, "%s/%s%s.conf", configuration->configpath, fragmentprefix, FragmentNumber);
-    *out << Verbose(2) << "Saving " << fragmentprefix << " No. " << FragmentNumber << "/" << FragmentCounter-1 << " as config ...";
-    if ((intermediateResult = configuration->Save(FragmentName, ListOfMolecules[i]->elemente, ListOfMolecules[i])))
+    sprintf(FragmentName, "%s/%s%s.conf", configuration->configpath, FRAGMENTPREFIX, FragmentNumber);
+    *out << Verbose(2) << "Saving bond fragment No. " << FragmentNumber << "/" << FragmentCounter - 1 << " as config ...";
+    if ((intermediateResult = configuration->Save(FragmentName, (*ListRunner)->elemente, (*ListRunner))))
       *out << " done." << endl;
     else
@@ -466 +652 @@
     configuration->SetDefaultPath(PathBackup);
 
-
     // and save as mpqc input file
-    sprintf(FragmentName, "%s/%s%s.in", configuration->configpath, fragmentprefix, FragmentNumber);
-    *out << Verbose(2) << "Saving " << fragmentprefix << " No. " << FragmentNumber << "/" << FragmentCounter-1 << " as mpqc input ...";
-    if ((intermediateResult = configuration->SaveMPQC(FragmentName, ListOfMolecules[i])))
+    sprintf(FragmentName, "%s/%s%s.conf", configuration->configpath, FRAGMENTPREFIX, FragmentNumber);
+    *out << Verbose(2) << "Saving bond fragment No. " << FragmentNumber << "/" << FragmentCounter - 1 << " as mpqc input ...";
+    if ((intermediateResult = configuration->SaveMPQC(FragmentName, (*ListRunner))))
       *out << " done." << endl;
     else
       *out << " failed." << endl;
-       
+
     result = result && intermediateResult;
     //outputFragment.close();
     //outputFragment.clear();
-    delete(FragmentNumber);
+    delete (FragmentNumber);
     //Free((void **)&FragmentNumber, "MoleculeListClass::OutputConfigForListOfFragments: *FragmentNumber");
   }
   cout << " done." << endl;
-  
+
   // printing final number
   *out << "Final number of fragments: " << FragmentCounter << "." << endl;
-      
+
   return result;
 };
+
+/** Counts the number of molecules with the molecule::ActiveFlag set.
+ * \return number of molecules with ActiveFlag set to true.
+ */
+int MoleculeListClass::NumberOfActiveMolecules()
+{
+  int count = 0;
+  for (MoleculeList::iterator ListRunner = ListOfMolecules.begin(); ListRunner != ListOfMolecules.end(); ListRunner++)
+    count += ((*ListRunner)->ActiveFlag ? 1 : 0);
+  return count;
+};
+
 
 /******************************************* Class MoleculeLeafClass ************************************************/
@@ -498 +695 @@
 MoleculeLeafClass::MoleculeLeafClass(MoleculeLeafClass *PreviousLeaf = NULL)
 {
-//  if (Up != NULL)
-//    if (Up->DownLeaf == NULL) // are we the first down leaf for the upper leaf?
-//      Up->DownLeaf = this;
-//  UpLeaf = Up;
-//  DownLeaf = NULL;
+  //  if (Up != NULL)
+  //    if (Up->DownLeaf == NULL) // are we the first down leaf for the upper leaf?
+  //      Up->DownLeaf = this;
+  //  UpLeaf = Up;
+  //  DownLeaf = NULL;
   Leaf = NULL;
   previous = PreviousLeaf;
@@ -518 +715 @@
 MoleculeLeafClass::~MoleculeLeafClass()
 {
-//  if (DownLeaf != NULL) {// drop leaves further down
-//    MoleculeLeafClass *Walker = DownLeaf;
-//    MoleculeLeafClass *Next;
-//    do {
-//      Next = Walker->NextLeaf;
-//      delete(Walker);
-//      Walker = Next;
-//    } while (Walker != NULL);
-//    // Last Walker sets DownLeaf automatically to NULL
-//  }
+  //  if (DownLeaf != NULL) {// drop leaves further down
+  //    MoleculeLeafClass *Walker = DownLeaf;
+  //    MoleculeLeafClass *Next;
+  //    do {
+  //      Next = Walker->NextLeaf;
+  //      delete(Walker);
+  //      Walker = Next;
+  //    } while (Walker != NULL);
+  //    // Last Walker sets DownLeaf automatically to NULL
+  //  }
   // remove the leaf itself
   if (Leaf != NULL) {
-    delete(Leaf);
+    delete (Leaf);
     Leaf = NULL;
   }
   // remove this Leaf from level list
-  if (previous != NULL)   
+  if (previous != NULL)
     previous->next = next;
-//  } else { // we are first in list (connects to UpLeaf->DownLeaf)
-//    if ((NextLeaf != NULL) && (NextLeaf->UpLeaf == NULL))
-//      NextLeaf->UpLeaf = UpLeaf;  // either null as we are top level or the upleaf of the first node
-//    if (UpLeaf != NULL)
-//      UpLeaf->DownLeaf = NextLeaf;  // either null as we are only leaf or NextLeaf if we are just the first
-//  }
-//  UpLeaf = NULL;
+  //  } else { // we are first in list (connects to UpLeaf->DownLeaf)
+  //    if ((NextLeaf != NULL) && (NextLeaf->UpLeaf == NULL))
+  //      NextLeaf->UpLeaf = UpLeaf;  // either null as we are top level or the upleaf of the first node
+  //    if (UpLeaf != NULL)
+  //      UpLeaf->DownLeaf = NextLeaf;  // either null as we are only leaf or NextLeaf if we are just the first
+  //  }
+  //  UpLeaf = NULL;
   if (next != NULL) // are we last in list
     next->previous = previous;
@@ -581 +778 @@
     return false;
   }
-  
+
   if (status) {
-    *out << Verbose(1) << "Creating adjacency list for subgraph " << this << "." << endl;
+    *out << Verbose(1) << "Creating adjacency list for subgraph " << this
+        << "." << endl;
     Walker = Leaf->start;
     while (Walker->next != Leaf->end) {
       Walker = Walker->next;
-      AtomNo = Walker->GetTrueFather()->nr;  // global id of the current walker
-      for(int i=0;i<reference->NumberOfBondsPerAtom[AtomNo];i++) { // go through father's bonds and copy them all
+      AtomNo = Walker->GetTrueFather()->nr; // global id of the current walker
+      for (int i = 0; i < reference->NumberOfBondsPerAtom[AtomNo]; i++) { // go through father's bonds and copy them all
         Binder = reference->ListOfBondsPerAtom[AtomNo][i];
-        OtherWalker = ListOfLocalAtoms[FragmentCounter][Binder->GetOtherAtom(Walker->GetTrueFather())->nr];    // local copy of current bond partner of walker
+        OtherWalker = ListOfLocalAtoms[FragmentCounter][Binder->GetOtherAtom(Walker->GetTrueFather())->nr]; // local copy of current bond partner of walker
         if (OtherWalker != NULL) {
           if (OtherWalker->nr > Walker->nr)
-          Leaf->AddBond(Walker, OtherWalker, Binder->BondDegree);
+            Leaf->AddBond(Walker, OtherWalker, Binder->BondDegree);
         } else {
           *out << Verbose(1) << "OtherWalker = ListOfLocalAtoms[" << FragmentCounter << "][" << Binder->GetOtherAtom(Walker->GetTrueFather())->nr << "] is NULL!" << endl;
@@ -606 +804 @@
     FragmentCounter--;
   }
-  
+
   if ((FreeList) && (ListOfLocalAtoms != NULL)) {
     // free the index lookup list
-    Free((void **)&ListOfLocalAtoms[FragmentCounter], "MoleculeLeafClass::FillBondStructureFromReference - **ListOfLocalAtoms[]");
+    Free((void **) &ListOfLocalAtoms[FragmentCounter], "MoleculeLeafClass::FillBondStructureFromReference - **ListOfLocalAtoms[]");
     if (FragmentCounter == 0) // first fragments frees the initial pointer to list
-      Free((void **)&ListOfLocalAtoms, "MoleculeLeafClass::FillBondStructureFromReference - ***ListOfLocalAtoms");
+      Free((void **) &ListOfLocalAtoms, "MoleculeLeafClass::FillBondStructureFromReference - ***ListOfLocalAtoms");
   }
   FragmentCounter--;
@@ -626 +824 @@
  * \return true - stack is non-empty, fragmentation necessary, false - stack is empty, no more sites to update
  */
-bool MoleculeLeafClass::FillRootStackForSubgraphs(ofstream *out, KeyStack *&RootStack, bool *AtomMask, int &FragmentCounter)
+bool MoleculeLeafClass::FillRootStackForSubgraphs(ofstream *out,
+    KeyStack *&RootStack, bool *AtomMask, int &FragmentCounter)
 {
   atom *Walker = NULL, *Father = NULL;
 
   if (RootStack != NULL) {
-    // find first root candidates 
+    // find first root candidates
     if (&(RootStack[FragmentCounter]) != NULL) {
-      RootStack[FragmentCounter].clear();  
+      RootStack[FragmentCounter].clear();
       Walker = Leaf->start;
       while (Walker->next != Leaf->end) { // go through all (non-hydrogen) atoms
@@ -639 +838 @@
         Father = Walker->GetTrueFather();
         if (AtomMask[Father->nr]) // apply mask
-    #ifdef ADDHYDROGEN
+#ifdef ADDHYDROGEN
           if (Walker->type->Z != 1) // skip hydrogen
-    #endif
-            RootStack[FragmentCounter].push_front(Walker->nr);
+#endif
+          RootStack[FragmentCounter].push_front(Walker->nr);
       }
       if (next != NULL)
         next->FillRootStackForSubgraphs(out, RootStack, AtomMask, ++FragmentCounter);
-    }  else {
-      *out << Verbose(1) << "Rootstack[" << FragmentCounter  << "] is NULL." << endl;
+    } else {
+      *out << Verbose(1) << "Rootstack[" << FragmentCounter << "] is NULL." << endl;
       return false;
     }
@@ -669 +868 @@
 {
   bool status = true;
-  
+
   int Counter = Count();
   if (ListOfLocalAtoms == NULL) { // allocated initial pointer
     // allocate and set each field to NULL
-    ListOfLocalAtoms = (atom ***) Malloc(sizeof(atom **)*Counter, "MoleculeLeafClass::FillBondStructureFromReference - ***ListOfLocalAtoms");
+    ListOfLocalAtoms = (atom ***) Malloc(sizeof(atom **) * Counter, "MoleculeLeafClass::FillBondStructureFromReference - ***ListOfLocalAtoms");
     if (ListOfLocalAtoms != NULL) {
-      for (int i=Counter;i--;)
+      for (int i = Counter; i--;)
         ListOfLocalAtoms[i] = NULL;
       FreeList = FreeList && true;
@@ -681 +880 @@
       status = false;
   }
-  
+
   if ((ListOfLocalAtoms != NULL) && (ListOfLocalAtoms[FragmentCounter] == NULL)) { // allocate and fill list of this fragment/subgraph
     status = status && CreateFatherLookupTable(out, Leaf->start, Leaf->end, ListOfLocalAtoms[FragmentCounter], GlobalAtomCount);
     FreeList = FreeList && true;
   }
-  
+
   return status;
 };
@@ -700 +899 @@
  * \retuen true - success, false - failure
  */
-bool MoleculeLeafClass::AssignKeySetsToFragment(ofstream *out, molecule *reference, Graph *KeySetList, atom ***&ListOfLocalAtoms, Graph **&FragmentList, int &FragmentCounter, bool FreeList)
+bool MoleculeLeafClass::AssignKeySetsToFragment(ofstream *out,
+    molecule *reference, Graph *KeySetList, atom ***&ListOfLocalAtoms,
+    Graph **&FragmentList, int &FragmentCounter, bool FreeList)
 {
   bool status = true;
   int KeySetCounter = 0;
-  
+
   *out << Verbose(1) << "Begin of AssignKeySetsToFragment." << endl;
   // fill ListOfLocalAtoms if NULL was given
@@ -715 +916 @@
   if (FragmentList == NULL) {
     KeySetCounter = Count();
-    FragmentList = (Graph **) Malloc(sizeof(Graph *)*KeySetCounter, "MoleculeLeafClass::AssignKeySetsToFragment - **FragmentList");
-    for(int i=KeySetCounter;i--;)
+    FragmentList = (Graph **) Malloc(sizeof(Graph *) * KeySetCounter, "MoleculeLeafClass::AssignKeySetsToFragment - **FragmentList");
+    for (int i = KeySetCounter; i--;)
       FragmentList[i] = NULL;
     KeySetCounter = 0;
   }
-  
+
   if ((KeySetList != NULL) && (KeySetList->size() != 0)) { // if there are some scanned keysets at all
     // assign scanned keysets
@@ -726 +927 @@
       FragmentList[FragmentCounter] = new Graph;
     KeySet *TempSet = new KeySet;
-    for(Graph::iterator runner = KeySetList->begin();runner != KeySetList->end(); runner++) { // key sets contain global numbers!
-      if ( ListOfLocalAtoms[FragmentCounter][reference->FindAtom(*((*runner).first.begin()))->nr] != NULL) {// as we may assume that that bond structure is unchanged, we only test the first key in each set
+    for (Graph::iterator runner = KeySetList->begin(); runner != KeySetList->end(); runner++) { // key sets contain global numbers!
+      if (ListOfLocalAtoms[FragmentCounter][reference->FindAtom(*((*runner).first.begin()))->nr] != NULL) {// as we may assume that that bond structure is unchanged, we only test the first key in each set
         // translate keyset to local numbers
-        for(KeySet::iterator sprinter = (*runner).first.begin(); sprinter != (*runner).first.end(); sprinter++)
+        for (KeySet::iterator sprinter = (*runner).first.begin(); sprinter != (*runner).first.end(); sprinter++)
           TempSet->insert(ListOfLocalAtoms[FragmentCounter][reference->FindAtom(*sprinter)->nr]->nr);
         // insert into FragmentList
-        FragmentList[FragmentCounter]->insert(GraphPair (*TempSet, pair<int,double>(KeySetCounter++, (*runner).second.second)));
+        FragmentList[FragmentCounter]->insert(GraphPair(*TempSet, pair<int, double> (KeySetCounter++, (*runner).second.second)));
       }
       TempSet->clear();
     }
-    delete(TempSet);
+    delete (TempSet);
     if (KeySetCounter == 0) {// if there are no keysets, delete the list
       *out << Verbose(1) << "KeySetCounter is zero, deleting FragmentList." << endl;
-      delete(FragmentList[FragmentCounter]);
+      delete (FragmentList[FragmentCounter]);
     } else
       *out << Verbose(1) << KeySetCounter << " keysets were assigned to subgraph " << FragmentCounter << "." << endl;
@@ -748 +949 @@
   } else
     *out << Verbose(1) << "KeySetList is NULL or empty." << endl;
-  
+
   if ((FreeList) && (ListOfLocalAtoms != NULL)) {
     // free the index lookup list
-    Free((void **)&ListOfLocalAtoms[FragmentCounter], "MoleculeLeafClass::AssignKeySetsToFragment - **ListOfLocalAtoms[]");
+    Free((void **) &ListOfLocalAtoms[FragmentCounter], "MoleculeLeafClass::AssignKeySetsToFragment - **ListOfLocalAtoms[]");
     if (FragmentCounter == 0) // first fragments frees the initial pointer to list
-      Free((void **)&ListOfLocalAtoms, "MoleculeLeafClass::AssignKeySetsToFragment - ***ListOfLocalAtoms");
+      Free((void **) &ListOfLocalAtoms, "MoleculeLeafClass::AssignKeySetsToFragment - ***ListOfLocalAtoms");
   }
   *out << Verbose(1) << "End of AssignKeySetsToFragment." << endl;
@@ -765 +966 @@
  * \param &TotalNumberOfKeySets global key set counter
  * \param &TotalGraph Graph to be filled with global numbers
- */ 
-void MoleculeLeafClass::TranslateIndicesToGlobalIDs(ofstream *out, Graph **FragmentList, int &FragmentCounter, int &TotalNumberOfKeySets, Graph &TotalGraph)
+ */
+void MoleculeLeafClass::TranslateIndicesToGlobalIDs(ofstream *out,
+    Graph **FragmentList, int &FragmentCounter, int &TotalNumberOfKeySets,
+    Graph &TotalGraph)
 {
   *out << Verbose(1) << "Begin of TranslateIndicesToGlobalIDs." << endl;
   KeySet *TempSet = new KeySet;
   if (FragmentList[FragmentCounter] != NULL) {
-    for(Graph::iterator runner = FragmentList[FragmentCounter]->begin(); runner != FragmentList[FragmentCounter]->end(); runner++) {
-      for(KeySet::iterator sprinter = (*runner).first.begin(); sprinter != (*runner).first.end(); sprinter++)
+    for (Graph::iterator runner = FragmentList[FragmentCounter]->begin(); runner != FragmentList[FragmentCounter]->end(); runner++) {
+      for (KeySet::iterator sprinter = (*runner).first.begin(); sprinter != (*runner).first.end(); sprinter++)
         TempSet->insert((Leaf->FindAtom(*sprinter))->GetTrueFather()->nr);
-      TotalGraph.insert(GraphPair(*TempSet, pair<int,double>(TotalNumberOfKeySets++, (*runner).second.second)));
+      TotalGraph.insert(GraphPair(*TempSet, pair<int, double> (TotalNumberOfKeySets++, (*runner).second.second)));
       TempSet->clear();
     }
-    delete(TempSet);
+    delete (TempSet);
   } else {
     *out << Verbose(1) << "FragmentList is NULL." << endl;
@@ -793 +996 @@
 {
   if (next != NULL)
-    return next->Count()+1;
+    return next->Count() + 1;
   else
-    return 1; 
-};
+    return 1;
+};
+

src/molecules.cpp

@@ -62 +62 @@
   cell_size[0] = cell_size[2] = cell_size[5]= 20.;
   cell_size[1] = cell_size[3] = cell_size[4]= 0.;
+  strcpy(name,"none");
+  IndexNr  = -1;
+  ActiveFlag = false;
 };
 
@@ -598 +601 @@
 };
 
+/** Set molecule::name from the basename without suffix in the given \a *filename.
+ * \param *filename filename
+ */
+void molecule::SetNameFromFilename(const char *filename)
+{
+  int length = 0;
+  char *molname = strrchr(filename, '/')+sizeof(char);  // search for filename without dirs
+  char *endname = strchr(molname, '.');
+  if ((endname == NULL) || (endname < molname))
+    length = strlen(molname);
+  else
+    length = strlen(molname) - strlen(endname);
+  strncpy(name, molname, length);
+  name[length]='\0';
+};
+
 /** Sets the molecule::cell_size to the components of \a *dim (rectangular box)
  * \param *dim vector class
@@ -652 +671 @@
     max->Scale(0.5);
     Translate(max);
+    Center.Zero();
   }
 
@@ -691 +711 @@
     max->AddVector(min);
     Translate(min);
+    Center.Zero();
   }
   delete(min);
@@ -700 +721 @@
  * \param *center return vector for translation vector
  */
-void molecule::CenterOrigin(ofstream *out, Vector *center)
+void molecule::CenterOrigin(ofstream *out)
 {
   int Num = 0;
   atom *ptr = start->next;  // start at first in list
 
-  for(int i=NDIM;i--;) // zero center vector
-    center->x[i] = 0.;
+  Center.Zero();
 
   if (ptr != end) {   //list not empty?
@@ -712 +732 @@
       ptr = ptr->next;
       Num++;
-      center->AddVector(&ptr->x);
-    }
-    center->Scale(-1./Num); // divide through total number (and sign for direction)
-    Translate(center);
+      Center.AddVector(&ptr->x);
+    }
+    Center.Scale(-1./Num); // divide through total number (and sign for direction)
+    Translate(&Center);
+    Center.Zero();
   }
 };
@@ -780 +801 @@
  * \param *center return vector for translation vector
  */
-void molecule::CenterGravity(ofstream *out, Vector *center)
-{
-  if (center == NULL) {
-    DetermineCenter(*center);
-    Translate(center);
-    delete(center);
-  } else {
-    Translate(center);
-  }
+void molecule::CenterPeriodic(ofstream *out)
+{
+  DeterminePeriodicCenter(Center);
+};
+
+/** Centers the center of gravity of the atoms at (0,0,0).
+ * \param *out output stream for debugging
+ * \param *center return vector for translation vector
+ */
+void molecule::CenterAtVector(ofstream *out, Vector *newcenter)
+{
+  Center.CopyVector(newcenter);
 };
 
@@ -837 +861 @@
 
 /** Determines center of molecule (yet not considering atom masses).
- * \param Center reference to return vector
- */
-void molecule::DetermineCenter(Vector &Center)
+ * \param center reference to return vector
+ */
+void molecule::DeterminePeriodicCenter(Vector &center)
 {
   atom *Walker = start;
@@ -849 +873 @@
 
   do {
-    Center.Zero();
+    center.Zero();
     flag = true;
     while (Walker->next != end) {
@@ -876 +900 @@
         Testvector.AddVector(&Translationvector);
         Testvector.MatrixMultiplication(matrix);
-        Center.AddVector(&Testvector);
+        center.AddVector(&Testvector);
         cout << Verbose(1) << "vector is: ";
         Testvector.Output((ofstream *)&cout);
@@ -889 +913 @@
             Testvector.AddVector(&Translationvector);
             Testvector.MatrixMultiplication(matrix);
-            Center.AddVector(&Testvector);
+            center.AddVector(&Testvector);
             cout << Verbose(1) << "Hydrogen vector is: ";
             Testvector.Output((ofstream *)&cout);
@@ -900 +924 @@
   } while (!flag);
   Free((void **)&matrix, "molecule::DetermineCenter: *matrix");
-  Center.Scale(1./(double)AtomCount);
+  center.Scale(1./(double)AtomCount);
 };
 
@@ -913 +937 @@
   Vector *CenterOfGravity = DetermineCenterOfGravity(out);
 
-  CenterGravity(out, CenterOfGravity);
+  CenterAtVector(out, CenterOfGravity);
 
   // reset inertia tensor
@@ -1409 +1433 @@
 bool molecule::LinearInterpolationBetweenConfiguration(ofstream *out, int startstep, int endstep, const char *prefix, config &configuration) 
 {
+  molecule *mol = NULL;
   bool status = true;
   int MaxSteps = configuration.MaxOuterStep; 
-  MoleculeListClass *MoleculePerStep = new MoleculeListClass(MaxSteps+1, AtomCount);
+  MoleculeListClass *MoleculePerStep = new MoleculeListClass();
   // Get the Permutation Map by MinimiseConstrainedPotential
   atom **PermutationMap = NULL;
@@ -1443 +1468 @@
   *out << Verbose(1) << "Filling intermediate " << MaxSteps << " steps with MDSteps of " << MDSteps << "." << endl;
   for (int step = 0; step <= MaxSteps; step++) {
-    MoleculePerStep->ListOfMolecules[step] = new molecule(elemente);
+    mol = new molecule(elemente);
+    MoleculePerStep->insert(mol);
     Walker = start;
     while (Walker->next != end) {
       Walker = Walker->next;
       // add to molecule list
-      Sprinter = MoleculePerStep->ListOfMolecules[step]->AddCopyAtom(Walker);
+      Sprinter = mol->AddCopyAtom(Walker);
       for (int n=NDIM;n--;) {
         Sprinter->x.x[n] = Trajectories[Walker].R.at(startstep).x[n] + (Trajectories[PermutationMap[Walker->nr]].R.at(endstep).x[n] - Trajectories[Walker].R.at(startstep).x[n])*((double)step/(double)MaxSteps);
@@ -1467 +1493 @@
   for (int i=AtomCount; i--; )
     SortIndex[i] = i;
-  status = MoleculePerStep->OutputConfigForListOfFragments(out, "ConstrainedStep", &configuration, SortIndex, false, false);
+  status = MoleculePerStep->OutputConfigForListOfFragments(out, &configuration, SortIndex);
   
   // free and return
@@ -1828 +1854 @@
 };
 
-/** Removes atom from molecule list.
+/** Removes atom from molecule list and deletes it.
  * \param *pointer atom to be removed
  * \return true - succeeded, false - atom not found in list
@@ -1842 +1868 @@
   Trajectories.erase(pointer);
   return remove(pointer, start, end);
+};
+
+/** Removes atom from molecule list, but does not delete it.
+ * \param *pointer atom to be removed
+ * \return true - succeeded, false - atom not found in list
+ */
+bool molecule::UnlinkAtom(atom *pointer)
+{
+  if (pointer == NULL)
+    return false;
+  if (ElementsInMolecule[pointer->type->Z] != 0)  // this would indicate an error
+    ElementsInMolecule[pointer->type->Z]--; // decrease number of atom of this element
+  else
+    cerr << "ERROR: Atom " << pointer->Name << " is of element " << pointer->type->Z << " but the entry in the table of the molecule is 0!" << endl;
+  if (ElementsInMolecule[pointer->type->Z] == 0)  // was last atom of this element?
+    ElementCount--;
+  Trajectories.erase(pointer);
+  unlink(pointer);
+  return true;
 };
 
@@ -2368 +2413 @@
             };
             AddBond(Walker, OtherWalker); //Add the bond between the two atoms with respective indices.
-            
+
           }
 
@@ -2484 +2529 @@
                         //*out << Verbose(0) << "Current comparison atom is " << *OtherWalker << "." << endl;
                         /// \todo periodic check is missing here!
-                        //*out << Verbose(1) << "Checking distance " << OtherWalker->x.PeriodicDistance(&(Walker->x), cell_size) << " against typical bond length of " << bonddistance*bonddistance << "." << endl;
+                        //*out << Verbose(1) << "Checking distance " << OtherWalker->x.PeriodicDistanceSquared(&(Walker->x), cell_size) << " against typical bond length of " << bonddistance*bonddistance << "." << endl;
                         MinDistance = OtherWalker->type->CovalentRadius + Walker->type->CovalentRadius;
                         MinDistance *= (IsAngstroem) ? 1. : 1./AtomicLengthToAngstroem;
                         MaxDistance = MinDistance + BONDTHRESHOLD;
                         MinDistance -= BONDTHRESHOLD;
-                        distance =   OtherWalker->x.PeriodicDistance(&(Walker->x), cell_size);
+                        distance = OtherWalker->x.PeriodicDistanceSquared(&(Walker->x), cell_size);
                         if ((OtherWalker->father->nr > Walker->father->nr) && (distance <= MaxDistance*MaxDistance) && (distance >= MinDistance*MinDistance)) { // create bond if distance is smaller
-                          //*out << Verbose(0) << "Adding Bond between " << *Walker << " and " << *OtherWalker << "." << endl;
+                          //*out << Verbose(1) << "Adding Bond between " << *Walker << " and " << *OtherWalker << " in distance " << sqrt(distance) << "." << endl;
                           AddBond(Walker->father, OtherWalker->father, 1);  // also increases molecule::BondCount
-                          BondCount++;
                         } else {
                           //*out << Verbose(1) << "Not Adding: Wrong label order or distance too great." << endl;
@@ -2564 +2608 @@
       *out << Verbose(1) << "BondCount is " << BondCount << ", no bonds between any of the " << AtomCount << " atoms." << endl;
     *out << Verbose(1) << "I detected " << BondCount << " bonds in the molecule with distance " << bonddistance << ", " << FalseBondDegree << " bonds could not be corrected." << endl;
-    
+
     // output bonds for debugging (if bond chain list was correctly installed)
     *out << Verbose(1) << endl << "From contents of bond chain list:";
@@ -3171 +3215 @@
           cerr << "KeySet file must be corrupt as there are two equal key sets therein!" << endl;
         }
-        //FragmentList->ListOfMolecules[NumberOfFragments++] = StoreFragmentFromKeySet(out, CurrentSet, IsAngstroem);
       }
     }
@@ -3731 +3774 @@
   //if (FragmentationToDo) {    // we should always store the fragments again as coordination might have changed slightly without changing bond structure
     // allocate memory for the pointer array and transmorph graphs into full molecular fragments
-    BondFragments = new MoleculeListClass(TotalGraph.size(), AtomCount);
+    BondFragments = new MoleculeListClass();
     int k=0;
     for(Graph::iterator runner = TotalGraph.begin(); runner != TotalGraph.end(); runner++) {
       KeySet test = (*runner).first;
       *out << "Fragment No." << (*runner).second.first << " with TEFactor " << (*runner).second.second << "." << endl;
-      BondFragments->ListOfMolecules[k] = StoreFragmentFromKeySet(out, test, configuration);
+      BondFragments->insert(StoreFragmentFromKeySet(out, test, configuration));
       k++;
     }
-    *out << k << "/" << BondFragments->NumberOfMolecules << " fragments generated from the keysets." << endl;
+    *out << k << "/" << BondFragments->ListOfMolecules.size() << " fragments generated from the keysets." << endl;
 
     // ===== 9. Save fragments' configuration and keyset files et al to disk ===
-    if (BondFragments->NumberOfMolecules != 0) {
+    if (BondFragments->ListOfMolecules.size() != 0) {
       // create the SortIndex from BFS labels to order in the config file
       CreateMappingLabelsToConfigSequence(out, SortIndex);
 
-      *out << Verbose(1) << "Writing " << BondFragments->NumberOfMolecules << " possible bond fragmentation configs" << endl;
-      if (BondFragments->OutputConfigForListOfFragments(out, FRAGMENTPREFIX, configuration, SortIndex, true, true))
+      *out << Verbose(1) << "Writing " << BondFragments->ListOfMolecules.size() << " possible bond fragmentation configs" << endl;
+      if (BondFragments->OutputConfigForListOfFragments(out, configuration, SortIndex))
         *out << Verbose(1) << "All configs written." << endl;
       else
@@ -5318 +5361 @@
   if (result) {
     *out << Verbose(5) << "Calculating Centers of Gravity" << endl;
-    DetermineCenter(CenterOfGravity);
-    OtherMolecule->DetermineCenter(OtherCenterOfGravity);
+    DeterminePeriodicCenter(CenterOfGravity);
+    OtherMolecule->DeterminePeriodicCenter(OtherCenterOfGravity);
     *out << Verbose(5) << "Center of Gravity: ";
     CenterOfGravity.Output(out);
@@ -5325 +5368 @@
     OtherCenterOfGravity.Output(out);
     *out << endl;
-    if (CenterOfGravity.Distance(&OtherCenterOfGravity) > threshold) {
+    if (CenterOfGravity.DistanceSquared(&OtherCenterOfGravity) > threshold*threshold) {
       *out << Verbose(4) << "Centers of gravity don't match." << endl;
       result = false;
@@ -5339 +5382 @@
     while (Walker->next != end) {
       Walker = Walker->next;
-      Distances[Walker->nr] = CenterOfGravity.Distance(&Walker->x);
+      Distances[Walker->nr] = CenterOfGravity.DistanceSquared(&Walker->x);
     }
     Walker = OtherMolecule->start;
     while (Walker->next != OtherMolecule->end) {
       Walker = Walker->next;
-      OtherDistances[Walker->nr] = OtherCenterOfGravity.Distance(&Walker->x);
+      OtherDistances[Walker->nr] = OtherCenterOfGravity.DistanceSquared(&Walker->x);
     }
 
@@ -5362 +5405 @@
     flag = 0;
     for (int i=0;i<AtomCount;i++) {
-      *out << Verbose(5) << "Distances: |" << Distances[PermMap[i]] << " - " << OtherDistances[OtherPermMap[i]] << "| = " << fabs(Distances[PermMap[i]] - OtherDistances[OtherPermMap[i]]) << " ?<? " <<  threshold << endl;
-      if (fabs(Distances[PermMap[i]] - OtherDistances[OtherPermMap[i]]) > threshold)
+      *out << Verbose(5) << "Distances squared: |" << Distances[PermMap[i]] << " - " << OtherDistances[OtherPermMap[i]] << "| = " << fabs(Distances[PermMap[i]] - OtherDistances[OtherPermMap[i]]) << " ?<? " <<  threshold << endl;
+      if (fabs(Distances[PermMap[i]] - OtherDistances[OtherPermMap[i]]) > threshold*threshold)
         flag = 1;
     }

src/molecules.hpp

@@ -71 +71 @@
 #define DistanceMultiMapPair pair <double, pair < PointMap::iterator, PointMap::iterator> >
 
+#define MoleculeList list <molecule *>
+#define MoleculeListTest pair <MoleculeList::iterator, bool>
+
 /******************************** Some small functions and/or structures **********************************/
 
@@ -116 +119 @@
   element *type;
 };
-
-
 
 /** Single atom.
@@ -131 +132 @@
     atom *father;   //!< In many-body bond order fragmentations points to originating atom
     atom *Ancestor; //!< "Father" in Depth-First-Search
-    char *Name;                 //!< unique name used during many-body bond-order fragmentation
+    char *Name;      //!< unique name used during many-body bond-order fragmentation
     int FixedIon;   //!< config variable that states whether forces act on the ion or not
     int *sort;      //!< sort criteria
@@ -146 +147 @@
   ~atom();
 
-  bool Output(int ElementNo, int AtomNo, ofstream *out) const;
+  bool Output(int ElementNo, int AtomNo, ofstream *out, const char *comment = NULL) const;
   bool OutputXYZLine(ofstream *out) const;
   atom *GetTrueFather();
@@ -163 +164 @@
 class bond {
   public:
-        atom *leftatom;         //!< first bond partner
-        atom *rightatom;        //!< second bond partner
+    atom *leftatom;    //!< first bond partner
+    atom *rightatom;  //!< second bond partner
     bond *previous; //!< previous atom in molecule list
     bond *next;     //!< next atom in molecule list
-        int HydrogenBond;       //!< Number of hydrogen atoms in the bond
-        int BondDegree;         //!< single, double, triple, ... bond
+    int HydrogenBond;  //!< Number of hydrogen atoms in the bond
+    int BondDegree;    //!< single, double, triple, ... bond
     int nr;           //!< unique number in a molecule, updated by molecule::CreateAdjacencyList()
     bool Cyclic;      //!< flag whether bond is part of a cycle or not, given in DepthFirstSearchAnalysis()
@@ -218 +219 @@
     int MDSteps;        //!< The number of MD steps in Trajectories
     int *NumberOfBondsPerAtom;  //!< Number of Bonds each atom has
-    int AtomCount;                                      //!< number of atoms, brought up-to-date by CountAtoms()
-    int BondCount;                                      //!< number of atoms, brought up-to-date by CountBonds()
+    int AtomCount;          //!< number of atoms, brought up-to-date by CountAtoms()
+    int BondCount;          //!< number of atoms, brought up-to-date by CountBonds()
     int ElementCount;       //!< how many unique elements are therein
     int ElementsInMolecule[MAX_ELEMENTS]; //!< list whether element (sorted by atomic number) is alread present or not
-    int NoNonHydrogen;  //!< number of non-hydrogen atoms in molecule
+    int NoNonHydrogen;  //!< number of non-hydrogen atoms in molecule
     int NoNonBonds;     //!< number of non-hydrogen bonds in molecule
     int NoCyclicBonds;  //!< number of cyclic bonds in molecule, by DepthFirstSearchAnalysis()
     double BondDistance;  //!< typical bond distance used in CreateAdjacencyList() and furtheron
+    bool ActiveFlag;    //!< in a MoleculeListClass used to discern active from inactive molecules
+    Vector Center;      //!< Center of molecule in a global box
+    char name[MAXSTRINGSIZE];         //!< arbitrary name
+    int IndexNr;        //!< index of molecule in a MoleculeListClass
 
   molecule(periodentafel *teil);
@@ -233 +238 @@
   bool AddAtom(atom *pointer);
   bool RemoveAtom(atom *pointer);
+  bool UnlinkAtom(atom *pointer);
   bool CleanupMolecule();
 
@@ -253 +259 @@
   bool CenterInBox(ofstream *out, Vector *BoxLengths);
   void CenterEdge(ofstream *out, Vector *max);
-  void CenterOrigin(ofstream *out, Vector *max);
-  void CenterGravity(ofstream *out, Vector *max);
+  void CenterOrigin(ofstream *out);
+  void CenterPeriodic(ofstream *out);
+  void CenterAtVector(ofstream *out, Vector *newcenter);
   void Translate(const Vector *x);
   void Mirror(const Vector *x);
   void Align(Vector *n);
   void Scale(double **factor);
-  void DetermineCenter(Vector &center);
+  void DeterminePeriodicCenter(Vector &center);
   Vector * DetermineCenterOfGravity(ofstream *out);
   Vector * DetermineCenterOfAll(ofstream *out);
+  void SetNameFromFilename(const char *filename);
   void SetBoxDimension(Vector *dim);
   double * ReturnFullMatrixforSymmetric(double *cell_size);
   void ScanForPeriodicCorrection(ofstream *out);
-        void PrincipalAxisSystem(ofstream *out, bool DoRotate);
-        double VolumeOfConvexEnvelope(ofstream *out, bool IsAngstroem);
-        
   bool VerletForceIntegration(ofstream *out, char *file, config &configuration);
   void Thermostats(config &configuration, double ActualTemp, int Thermostat);
+  void PrincipalAxisSystem(ofstream *out, bool DoRotate);
+  double VolumeOfConvexEnvelope(ofstream *out, bool IsAngstroem);
+  Vector* FindEmbeddingHole(ofstream *out, molecule *srcmol);
+
 
   double ConstrainedPotential(ofstream *out, atom **permutation, int start, int end, double *constants, bool IsAngstroem);
@@ -315 +324 @@
   /// -# BOSSANOVA
   void FragmentBOSSANOVA(ofstream *out, Graph *&FragmentList, KeyStack &RootStack, int *MinimumRingSize);
-        int PowerSetGenerator(ofstream *out, int Order, struct UniqueFragments &FragmentSearch, KeySet RestrictedKeySet);
+  int PowerSetGenerator(ofstream *out, int Order, struct UniqueFragments &FragmentSearch, KeySet RestrictedKeySet);
   bool BuildInducedSubgraph(ofstream *out, const molecule *Father);
   molecule * StoreFragmentFromKeySet(ofstream *out, KeySet &Leaflet, bool IsAngstroem);
@@ -343 +352 @@
 class MoleculeListClass {
   public:
-    molecule **ListOfMolecules;   //!< pointer list of fragment molecules to check for equality
-    int NumberOfMolecules;        //!< Number of entries in \a **FragmentList and of to be returned one.
-    int NumberOfTopAtoms;         //!< Number of atoms in the molecule from which all fragments originate
+    MoleculeList ListOfMolecules; //!< List of the contained molecules
+    int MaxIndex;
 
   MoleculeListClass();
-  MoleculeListClass(int Num, int NumAtoms);
   ~MoleculeListClass();
 
-  /// Output configs.
   bool AddHydrogenCorrection(ofstream *out, char *path);
   bool StoreForcesFile(ofstream *out, char *path, int *SortIndex);
-  bool OutputConfigForListOfFragments(ofstream *out, const char *fragmentprefix, config *configuration, int *SortIndex, bool DoPeriodic, bool DoCentering);
+  void insert(molecule *mol);
+  molecule * ReturnIndex(int index);
+  bool OutputConfigForListOfFragments(ofstream *out, config *configuration, int *SortIndex);
+  int NumberOfActiveMolecules();
+  void Enumerate(ofstream *out);
   void Output(ofstream *out);
+
+  // merging of molecules
+  bool SimpleMerge(molecule *mol, molecule *srcmol);
+  bool SimpleAdd(molecule *mol, molecule *srcmol);
+  bool SimpleMultiMerge(molecule *mol, int *src, int N);
+  bool SimpleMultiAdd(molecule *mol, int *src, int N);
+  bool ScatterMerge(molecule *mol, int *src, int N);
+  bool EmbedMerge(molecule *mol, molecule *srcmol);
 
   private:
@@ -479 +497 @@
   bool Save(const char *filename, periodentafel *periode, molecule *mol) const;
   bool SaveMPQC(const char *filename, molecule *mol) const;
-  void Edit(molecule *mol);
+  void Edit();
   bool GetIsAngstroem() const;
   char *GetDefaultPath() const;

src/parser.cpp

@@ -2 +2 @@
  *
  * Declarations of various class functions for the parsing of value files.
- *    
+ *
  */
 
 // ======================================= INCLUDES ==========================================
 
-#include "helpers.hpp" 
+#include "helpers.hpp"
 #include "parser.hpp"
 
@@ -25 +25 @@
 {
   ifstream input;
-  
+
   input.open(filename, ios::in);
   if (input == NULL) {
@@ -145 +145 @@
  * \param skiplines number of inital columns to skip
  * \param MatrixNr index number in Matrix array to parse into
- * \return parsing successful 
+ * \return parsing successful
  */
 bool MatrixContainer::ParseMatrix(const char *name, int skiplines, int skipcolumns, int MatrixNr)
@@ -183 +183 @@
   // scan rest for number of rows/lines
   RowCounter[MatrixNr]=-1;    // counts one line too much
-  while (!input.eof()) { 
+  while (!input.eof()) {
     input.getline(filename, 1023);
     //cout << "Comparing: " << strncmp(filename,"MeanForce",9) << endl;
@@ -194 +194 @@
   if (RowCounter[MatrixNr] == 0)
     cerr << "RowCounter[" << MatrixNr << "]: " << RowCounter[MatrixNr] << " from file " << name << ", this is probably an error!" << endl;
-  
+
   // allocate matrix if it's not zero dimension in one direction
   if ((ColumnCounter[MatrixNr] > 0) && (RowCounter[MatrixNr] > -1)) {
@@ -233 +233 @@
 /** Parsing a number of matrices.
  * -# First, count the number of matrices by counting lines in KEYSETFILE
- * -# Then, 
+ * -# Then,
  *    -# construct the fragment number
  *    -# open the matrix file
@@ -241 +241 @@
  *    -# allocate matrix
  *    -# loop over found column and row counts and parse in each entry
- * -# Finally, allocate one additional matrix (\a MatrixCounter) containing combined or temporary values 
+ * -# Finally, allocate one additional matrix (\a MatrixCounter) containing combined or temporary values
  * \param *name directory with files
  * \param *prefix prefix of each matrix file
@@ -247 +247 @@
  * \param skiplines number of inital lines to skip
  * \param skiplines number of inital columns to skip
- * \return parsing successful 
+ * \return parsing successful
  */
 bool MatrixContainer::ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns)
@@ -256 +256 @@
   stringstream file;
   string token;
-  
+
   // count the number of matrices
   MatrixCounter = -1; // we count one too much
@@ -270 +270 @@
     MatrixCounter++;
   }
-  input.close();  
+  input.close();
   cout << "Determined " << MatrixCounter << " fragments." << endl;
-  
+
   cout << "Parsing through each fragment and retrieving " << prefix << suffix << "." << endl;
   Header = (char **) ReAlloc(Header, sizeof(char *)*(MatrixCounter+1), "MatrixContainer::ParseFragmentMatrix: **Header"); // one more each for the total molecule
@@ -421 +421 @@
                 if (m == MatrixValues.Indices[ KeySet.OrderSet[Order][CurrentFragment] ][l]) {
                   m = l;
-                  break;  
+                  break;
                 }
               }
@@ -447 +447 @@
    //cout << "Final Fragments[ KeySet.OrderSet[" << Order << "][" << CurrentFragment << "]=" << KeySet.OrderSet[Order][CurrentFragment] << " ][" << KeySet.AtomCounter[0]-1 << "][" << 1 << "] = " <<  Matrix[ KeySet.OrderSet[Order][CurrentFragment] ][KeySet.AtomCounter[0]-1][1] << endl;
   }
-  
+
   return true;
 };
@@ -512 +512 @@
 
 // ======================================= CLASS EnergyMatrix =============================
+
+/** Create a trivial energy index mapping.
+ * This just maps 1 to 1, 2 to 2 and so on for all fragments.
+ * \return creation sucessful
+ */
+bool EnergyMatrix::ParseIndices()
+{
+  cout << "Parsing energy indices." << endl;
+  Indices = (int **) Malloc(sizeof(int *)*(MatrixCounter+1), "EnergyMatrix::ParseIndices: **Indices");
+  for(int i=MatrixCounter+1;i--;) {
+    Indices[i] = (int *) Malloc(sizeof(int)*RowCounter[i], "EnergyMatrix::ParseIndices: *Indices[]");
+    for(int j=RowCounter[i];j--;)
+      Indices[i][j] = j;
+  }
+  return true;
+};
 
 /** Sums the energy with each factor and put into last element of \a EnergyMatrix::Matrix.
@@ -545 +561 @@
  * \param skiplines number of inital columns to skip
  * \return parsing successful
- */ 
+ */
 bool EnergyMatrix::ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns)
 {
@@ -580 +596 @@
 /** Parsing force Indices of each fragment
  * \param *name directory with \a ForcesFile
- * \return parsing successful 
- */
-bool ForceMatrix::ParseIndices(char *name) 
+ * \return parsing successful
+ */
+bool ForceMatrix::ParseIndices(char *name)
 {
   ifstream input;
@@ -588 +604 @@
   char filename[1023];
   stringstream line;
-  
+
   cout << "Parsing force indices for " << MatrixCounter << " matrices." << endl;
   Indices = (int **) Malloc(sizeof(int *)*(MatrixCounter+1), "ForceMatrix::ParseIndices: **Indices");
@@ -659 +675 @@
  * \param skiplines number of inital columns to skip
  * \return parsing successful
- */ 
+ */
 bool ForceMatrix::ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns)
 {
@@ -932 +948 @@
     ParseMatrix(filename, skiplines, skipcolumns, MatrixCounter);
   }
- 
+
 
   return status;
@@ -974 +990 @@
   stringstream file;
   char filename[1023];
-  
+
   FragmentCounter = FCounter;
   cout << "Parsing key sets." << endl;
@@ -986 +1002 @@
     return false;
   }
-  
+
   AtomCounter = (int *) Malloc(sizeof(int)*FragmentCounter, "KeySetsContainer::ParseKeySets: *RowCounter");
   for(int i=0;(i<FragmentCounter) && (!input.eof());i++) {
@@ -1016 +1032 @@
 {
   int Counter;
-  
+
   cout << "Creating Fragment terms." << endl;
   // scan through all to determine maximum order
@@ -1029 +1045 @@
   }
   cout << "Found Order is " << Order << "." << endl;
-  
+
   // scan through all to determine fragments per order
   FragmentsPerOrder = (int *) Malloc(sizeof(int)*Order, "KeySetsContainer::ParseManyBodyTerms: *FragmentsPerOrder");
@@ -1043 +1059 @@
   for(int i=0;i<Order;i++)
     cout << "Found No. of Fragments of Order " << i+1 << " is " << FragmentsPerOrder[i] << "." << endl;
-    
+
   // scan through all to gather indices to each order set
   OrderSet = (int **) Malloc(sizeof(int *)*Order, "KeySetsContainer::ParseManyBodyTerms: **OrderSet");
@@ -1066 +1082 @@
   }
   cout << endl;
-  
-    
+
+
   return true;
 };

src/parser.hpp

@@ -2 +2 @@
  *
  * Definitions of various class functions for the parsing of value files.
- *    
+ *
  */
 
@@ -71 +71 @@
   bool WriteTotalFragments(const char *name, const char *prefix);
   bool WriteLastMatrix(const char *name, const char *prefix, const char *suffix);
-}; 
+};
 
 // ======================================= CLASS EnergyMatrix =============================
@@ -77 +77 @@
 class EnergyMatrix : public MatrixContainer {
   public:
+    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);
@@ -84 +85 @@
 
 class ForceMatrix : public MatrixContainer {
-  public: 
+  public:
     bool ParseIndices(char *name);
     bool SumSubForces(class ForceMatrix &Fragments, class KeySetsContainer &KeySet, int Order, double sign);
@@ -114 +115 @@
     int *FragmentsPerOrder;
     int **OrderSet;
-  
+
   KeySetsContainer();
   ~KeySetsContainer();
-   
+
   bool ParseKeySets(const char *name, const int *ACounter, const int FCounter);
   bool ParseManyBodyTerms();

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;
-  
-  private:
+        //> print element entries to screen
+        bool Output(ofstream *out) const;
+        bool Checkout(ofstream *out, const int No, const int NoOfAtoms) const;
+
+        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
-  
-  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;
-  
-  private:
+        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();
+
+        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;
+
+        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;
 };
 
 /** Test the functionality of the stack.
  * \param *out ofstream for debugging
- * \param *test one item to put on stack  
+ * \param *test one item to put on stack
  * \return true - all tests worked correctly
  */
 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));
+};
+
+/** Calculates distance between this and another vector in a periodic cell.
+ * \param *y array to second vector
+ * \param *cell_size 6-dimensional array with (xx, xy, yy, xz, yz, zz) entries specifying the periodic cell
+ * \return \f$| x - y |\f$
+ */
+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);
 };
 
@@ -51 +89 @@
  * \return \f$| x - y |^2\f$
  */
-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 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);
 };
 
@@ -90 +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;
 };
 
@@ -121 +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);
 
 };
@@ -151 +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);
 };
 
@@ -164 +202 @@
 double Vector::Projection(const Vector *y) const
 {
-  return (ScalarProduct(y));
+        return (ScalarProduct(y));
 };
 
@@ -172 +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));
 };
 
@@ -182 +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);
 };
 
@@ -194 +232 @@
 void Vector::Zero()
 {
-  for (int i=NDIM;i--;)
-    this->x[i] = 0.;
+        for (int i=NDIM;i--;)
+                this->x[i] = 0.;
 };
 
@@ -202 +240 @@
 void Vector::One(double one)
 {
-  for (int i=NDIM;i--;)
-    this->x[i] = one;
+        for (int i=NDIM;i--;)
+                this->x[i] = one;
 };
 
@@ -210 +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;
 };
 
@@ -221 +259 @@
 double Vector::Angle(const Vector *y) const
 {
-  return acos(this->ScalarProduct(y)/Norm()/y->Norm());
+        return acos(this->ScalarProduct(y)/Norm()/y->Norm());
 };
 
@@ -230 +268 @@
 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);
 };
 
@@ -254 +292 @@
 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.
@@ -264 +302 @@
 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
@@ -275 +313 @@
 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;
 };
 
@@ -288 +326 @@
 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;
 };
 
@@ -300 +338 @@
 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;
-};
-
-/** Prints a 3dim vector to a stream.
- * \param ost output stream
- * \param v Vector to be printed
- * \return output stream
- */
+        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;
 };
 
@@ -335 +368 @@
 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;
 };
 
@@ -356 +389 @@
 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];
 };
 
@@ -365 +398 @@
 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];
 };
 
@@ -380 +413 @@
 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;
+        }
 };
 
@@ -420 +453 @@
 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];
 };
 
@@ -429 +462 @@
 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;
 };
 
@@ -451 +484 @@
 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 ((x1.Norm()==0) || (x2.Norm()==0)) {
-    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;
 };
 
@@ -487 +520 @@
 bool Vector::MakeNormalVector(const Vector *y1, const Vector *y2)
 {
-  Vector x1,x2;
-  x1.CopyVector(y1);
-  x2.CopyVector(y2);
-  Zero();
-  if ((x1.Norm()==0) || (x2.Norm()==0)) {
-    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;
 };
 
@@ -517 +550 @@
 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;
 };
 
@@ -536 +569 @@
 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;
+        }
 };
 
@@ -582 +615 @@
 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);
 };
 
@@ -597 +630 @@
 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;
 };
 
@@ -679 +712 @@
 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];
 }
 
@@ -688 +721 @@
 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];
 }
 
@@ -697 +730 @@
 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];
 }
 
@@ -708 +741 @@
 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));
+        }
 };
 
@@ -736 +769 @@
 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 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);
+        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;
 };