Diff [06c7a3b2d6ce79572856fe678ea2a178eb974a6a:7326b21cef2429a9070eeb36352bb77cf6b12c2c] for / – MoleCuilder

configure.ac

-              r06c7a3
+              r7326b2
 # Boost libraries
 AX_BOOST_BASE([1.33.1])
 AX_BOOST_PROGRAM_OPTIONS
+#AX_BOOST_BASE([1.33.1])
+#AX_BOOST_PROGRAM_OPTIONS
 #AX_BOOST_FOREACH
 #AX_BOOST_FILESYSTEM

src/Makefile.am

-              r06c7a3
+              r7326b2
+SOURCE = analysis_correlation.cpp atom.cpp bond.cpp boundary.cpp config.cpp element.cpp ellipsoid.cpp graph.cpp helpers.cpp leastsquaremin.cpp linkedcell.cpp memoryusageobserver.cpp moleculelist.cpp molecule.cpp molecule_dynamics.cpp molecule_fragmentation.cpp molecule_geometry.cpp molecule_graph.cpp molecule_pointcloud.cpp parser.cpp periodentafel.cpp tesselation.cpp tesselationhelpers.cpp vector.cpp verbose.cpp
+HEADER = analysis_correlation.hpp atom.hpp bond.hpp boundary.hpp config.hpp defs.hpp element.hpp ellipsoid.hpp graph.hpp helpers.hpp leastsquaremin.hpp linkedcell.hpp lists.hpp memoryallocator.hpp memoryusageobserver.hpp molecule.hpp molecule_template.hpp parser.hpp periodentafel.hpp stackclass.hpp tesselation.hpp tesselationhelpers.hpp vector.hpp verbose.hpp
+ATOMSOURCE = atom.cpp atom_atominfo.cpp atom_bondedparticle.cpp atom_bondedparticleinfo.cpp atom_graphnode.cpp atom_graphnodeinfo.cpp atom_particleinfo.cpp atom_trajectoryparticle.cpp atom_trajectoryparticleinfo.cpp
+ATOMHEADER = atom.hpp atom_atominfo.hpp atom_bondedparticle.hpp atom_bondedparticleinfo.hpp atom_graphnode.hpp atom_graphnodeinfo.hpp atom_particleinfo.hpp atom_trajectoryparticle.hpp atom_trajectoryparticleinfo.hpp
+SOURCE = analysis_correlation.cpp ${ATOMSOURCE} bond.cpp bondgraph.cpp boundary.cpp config.cpp element.cpp ellipsoid.cpp errorLogger.cpp graph.cpp helpers.cpp leastsquaremin.cpp linkedcell.cpp log.cpp logger.cpp memoryusageobserver.cpp moleculelist.cpp molecule.cpp molecule_dynamics.cpp molecule_fragmentation.cpp molecule_geometry.cpp molecule_graph.cpp molecule_pointcloud.cpp parser.cpp periodentafel.cpp tesselation.cpp tesselationhelpers.cpp vector.cpp verbose.cpp
+HEADER = analysis_correlation.hpp ${ATOMHEADER} bond.hpp bondgraph.hpp boundary.hpp config.hpp defs.hpp element.hpp ellipsoid.hpp errorLogger.hpp graph.hpp helpers.hpp leastsquaremin.hpp linkedcell.hpp lists.hpp log.hpp logger.hpp memoryallocator.hpp memoryusageobserver.hpp molecule.hpp molecule_template.hpp parser.hpp periodentafel.hpp stackclass.hpp tesselation.hpp tesselationhelpers.hpp vector.hpp verbose.hpp
 BOOST_LIB = $(BOOST_LDFLAGS) $(BOOST_MPL_LIB)

src/analysis_correlation.cpp

-              r06c7a3
+              r7326b2
 #include "tesselationhelpers.hpp"
 #include "vector.hpp"
+#include "verbose.hpp"
 …
  * Note given element order is unimportant (i.e. g(Si, O) === g(O, Si))
  * \param *out output stream for debugging
  * \param *mol molecule with atoms
+ * \param *molecules list of molecules structure
  * \param *type1 first element or NULL (if any element)
  * \param *type2 second element or NULL (if any element)
  * \return Map of doubles with values the pair of the two atoms.
  */
 PairCorrelationMap *PairCorrelation( ofstream *out, molecule *mol, element *type1, element *type2 )
+PairCorrelationMap *PairCorrelation( ofstream * const out, MoleculeListClass * const &molecules, const element * const type1, const element * const type2 )
+{
   PairCorrelationMap *outmap = NULL;
   double distance = 0.;
   if ((mol == NULL)) {
     cout << "No molecule given." << endl;
+  if (molecules->ListOfMolecules.empty()) {
+    cerr << Verbose(1) <<"No molecule given." << endl;
     return outmap;
+  }
   outmap = new PairCorrelationMap;
+  atom *Walker = mol->start;
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    if ((type1 == NULL) || (Walker->type == type1)) {
+      atom *OtherWalker = mol->start;
+      while (OtherWalker->next != mol->end) { // only go up to Walker
+        OtherWalker = OtherWalker->next;
+        if (Walker->nr < OtherWalker->nr)
+          if ((type2 == NULL) || (OtherWalker->type == type2)) {
+            distance = Walker->node->Distance(OtherWalker->node);
+            //cout << "Inserting " << *Walker << " and " << *OtherWalker << endl;
+            outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> (Walker, OtherWalker) ) );
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+    if ((*MolWalker)->ActiveFlag) {
+      cerr << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl;
+      atom *Walker = (*MolWalker)->start;
+      while (Walker->next != (*MolWalker)->end) {
+        Walker = Walker->next;
+        *out << Verbose(3) << "Current atom is " << *Walker << "." << endl;
+        if ((type1 == NULL) || (Walker->type == type1)) {
+          for (MoleculeList::const_iterator MolOtherWalker = MolWalker; MolOtherWalker != molecules->ListOfMolecules.end(); MolOtherWalker++)
+            if ((*MolOtherWalker)->ActiveFlag) {
+              *out << Verbose(2) << "Current other molecule is " << *MolOtherWalker << "." << endl;
+              atom *OtherWalker = (*MolOtherWalker)->start;
+              while (OtherWalker->next != (*MolOtherWalker)->end) { // only go up to Walker
+                OtherWalker = OtherWalker->next;
+                *out << Verbose(3) << "Current otheratom is " << *OtherWalker << "." << endl;
+                if (Walker->nr < OtherWalker->nr)
+                  if ((type2 == NULL) || (OtherWalker->type == type2)) {
+                    distance = Walker->node->PeriodicDistance(OtherWalker->node, (*MolWalker)->cell_size);
+                    //*out << Verbose(1) <<"Inserting " << *Walker << " and " << *OtherWalker << endl;
+                    outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> (Walker, OtherWalker) ) );
+                  }
+              }
+          }
+      }
+    }
+  }
+        }
+      }
+    }
+  return outmap;
+};
+/** Calculates the pair correlation between given elements.
+ * Note given element order is unimportant (i.e. g(Si, O) === g(O, Si))
+ * \param *out output stream for debugging
+ * \param *molecules list of molecules structure
+ * \param *type1 first element or NULL (if any element)
+ * \param *type2 second element or NULL (if any element)
+ * \param ranges[NDIM] interval boundaries for the periodic images to scan also
+ * \return Map of doubles with values the pair of the two atoms.
+ */
+PairCorrelationMap *PeriodicPairCorrelation( ofstream * const out, MoleculeListClass * const &molecules, const element * const type1, const element * const type2, const int ranges[NDIM] )
+{
+  PairCorrelationMap *outmap = NULL;
+  double distance = 0.;
+  int n[NDIM];
+  Vector checkX;
+  Vector periodicX;
+  int Othern[NDIM];
+  Vector checkOtherX;
+  Vector periodicOtherX;
+  if (molecules->ListOfMolecules.empty()) {
+    cerr << Verbose(1) <<"No molecule given." << endl;
+    return outmap;
+  }
+  outmap = new PairCorrelationMap;
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+    if ((*MolWalker)->ActiveFlag) {
+      const double * const FullMatrix = ReturnFullMatrixforSymmetric((*MolWalker)->cell_size);
+      const double * const FullInverseMatrix = InverseMatrix(FullMatrix);
+      cerr << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl;
+      atom *Walker = (*MolWalker)->start;
+      while (Walker->next != (*MolWalker)->end) {
+        Walker = Walker->next;
+        *out << Verbose(3) << "Current atom is " << *Walker << "." << endl;
+        if ((type1 == NULL) || (Walker->type == type1)) {
+          periodicX.CopyVector(Walker->node);
+          periodicX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
+          // go through every range in xyz and get distance
+          for (n[0]=-ranges[0]; n[0] <= ranges[0]; n[0]++)
+            for (n[1]=-ranges[1]; n[1] <= ranges[1]; n[1]++)
+              for (n[2]=-ranges[2]; n[2] <= ranges[2]; n[2]++) {
+                checkX.Init(n[0], n[1], n[2]);
+                checkX.AddVector(&periodicX);
+                checkX.MatrixMultiplication(FullMatrix);
+                for (MoleculeList::const_iterator MolOtherWalker = MolWalker; MolOtherWalker != molecules->ListOfMolecules.end(); MolOtherWalker++)
+                  if ((*MolOtherWalker)->ActiveFlag) {
+                    *out << Verbose(2) << "Current other molecule is " << *MolOtherWalker << "." << endl;
+                    atom *OtherWalker = (*MolOtherWalker)->start;
+                    while (OtherWalker->next != (*MolOtherWalker)->end) { // only go up to Walker
+                      OtherWalker = OtherWalker->next;
+                      *out << Verbose(3) << "Current otheratom is " << *OtherWalker << "." << endl;
+                      if (Walker->nr < OtherWalker->nr)
+                        if ((type2 == NULL) || (OtherWalker->type == type2)) {
+                          periodicOtherX.CopyVector(OtherWalker->node);
+                          periodicOtherX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
+                          // go through every range in xyz and get distance
+                          for (Othern[0]=-ranges[0]; Othern[0] <= ranges[0]; Othern[0]++)
+                            for (Othern[1]=-ranges[1]; Othern[1] <= ranges[1]; Othern[1]++)
+                              for (Othern[2]=-ranges[2]; Othern[2] <= ranges[2]; Othern[2]++) {
+                                checkOtherX.Init(Othern[0], Othern[1], Othern[2]);
+                                checkOtherX.AddVector(&periodicOtherX);
+                                checkOtherX.MatrixMultiplication(FullMatrix);
+                                distance = checkX.Distance(&checkOtherX);
+                                //*out << Verbose(1) <<"Inserting " << *Walker << " and " << *OtherWalker << endl;
+                                outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> (Walker, OtherWalker) ) );
+                              }
+                        }
+                  }
+              }
+            }
+        }
+      }
+    }
   return outmap;
 …
 /** Calculates the distance (pair) correlation between a given element and a point.
  * \param *out output stream for debugging
  * \param *mol molecule with atoms
+ * \param *molecules list of molecules structure
  * \param *type element or NULL (if any element)
  * \param *point vector to the correlation point
  * \return Map of dobules with values as pairs of atom and the vector
  */
 CorrelationToPointMap *CorrelationToPoint( ofstream *out, molecule *mol, element *type, Vector *point )
+CorrelationToPointMap *CorrelationToPoint(  ofstream * const out, MoleculeListClass * const &molecules, const element * const type, const Vector *point )
+{
   CorrelationToPointMap *outmap = NULL;
   double distance = 0.;
   if ((mol == NULL)) {
     cout << "No molecule given." << endl;
+  if (molecules->ListOfMolecules.empty()) {
+    *out << Verbose(1) <<"No molecule given." << endl;
     return outmap;
+  }
   outmap = new CorrelationToPointMap;
+  atom *Walker = mol->start;
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    if ((type == NULL) || (Walker->type == type)) {
+      distance = Walker->node->Distance(point);
+      outmap->insert ( pair<double, pair<atom *, Vector*> >(distance, pair<atom *, Vector*> (Walker, point) ) );
+    }
+  }
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+    if ((*MolWalker)->ActiveFlag) {
+      *out << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl;
+      atom *Walker = (*MolWalker)->start;
+      while (Walker->next != (*MolWalker)->end) {
+        Walker = Walker->next;
+        *out << Verbose(3) << "Current atom is " << *Walker << "." << endl;
+        if ((type == NULL) || (Walker->type == type)) {
+          distance = Walker->node->PeriodicDistance(point, (*MolWalker)->cell_size);
+          *out << Verbose(4) << "Current distance is " << distance << "." << endl;
+          outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> (Walker, point) ) );
+        }
+      }
+    }
+  return outmap;
+};
+/** Calculates the distance (pair) correlation between a given element, all its periodic images and a point.
+ * \param *out output stream for debugging
+ * \param *molecules list of molecules structure
+ * \param *type element or NULL (if any element)
+ * \param *point vector to the correlation point
+ * \param ranges[NDIM] interval boundaries for the periodic images to scan also
+ * \return Map of dobules with values as pairs of atom and the vector
+ */
+CorrelationToPointMap *PeriodicCorrelationToPoint(  ofstream * const out, MoleculeListClass * const &molecules, const element * const type, const Vector *point, const int ranges[NDIM] )
+{
+  CorrelationToPointMap *outmap = NULL;
+  double distance = 0.;
+  int n[NDIM];
+  Vector periodicX;
+  Vector checkX;
+  if (molecules->ListOfMolecules.empty()) {
+    *out << Verbose(1) <<"No molecule given." << endl;
+    return outmap;
+  }
+  outmap = new CorrelationToPointMap;
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+    if ((*MolWalker)->ActiveFlag) {
+      const double * const FullMatrix = ReturnFullMatrixforSymmetric((*MolWalker)->cell_size);
+      const double * const FullInverseMatrix = InverseMatrix(FullMatrix);
+      *out << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl;
+      atom *Walker = (*MolWalker)->start;
+      while (Walker->next != (*MolWalker)->end) {
+        Walker = Walker->next;
+        *out << Verbose(3) << "Current atom is " << *Walker << "." << endl;
+        if ((type == NULL) || (Walker->type == type)) {
+          periodicX.CopyVector(Walker->node);
+          periodicX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
+          // go through every range in xyz and get distance
+          for (n[0]=-ranges[0]; n[0] <= ranges[0]; n[0]++)
+            for (n[1]=-ranges[1]; n[1] <= ranges[1]; n[1]++)
+              for (n[2]=-ranges[2]; n[2] <= ranges[2]; n[2]++) {
+                checkX.Init(n[0], n[1], n[2]);
+                checkX.AddVector(&periodicX);
+                checkX.MatrixMultiplication(FullMatrix);
+                distance = checkX.Distance(point);
+                *out << Verbose(4) << "Current distance is " << distance << "." << endl;
+                outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> (Walker, point) ) );
+              }
+        }
+      }
+    }
   return outmap;
 …
 /** Calculates the distance (pair) correlation between a given element and a surface.
  * \param *out output stream for debugging
  * \param *mol molecule with atoms
+ * \param *molecules list of molecules structure
  * \param *type element or NULL (if any element)
  * \param *Surface pointer to Tesselation class surface
 …
  * \return Map of doubles with values as pairs of atom and the BoundaryTriangleSet that's closest
  */
+CorrelationToSurfaceMap *CorrelationToSurface( ofstream *out, molecule *mol, element *type, Tesselation *Surface, LinkedCell *LC )
+{
+CorrelationToSurfaceMap *CorrelationToSurface( ofstream * const out, MoleculeListClass * const &molecules, const element * const type, const Tesselation * const Surface, const LinkedCell *LC )
+{
   CorrelationToSurfaceMap *outmap = NULL;
   double distance = 0.;
+  double distance = 0;
   class BoundaryTriangleSet *triangle = NULL;
   Vector centroid;
   if ((Surface == NULL) || (LC == NULL) || (mol == NULL)) {
     cout << "No Tesselation, no LinkedCell or no molecule given." << endl;
+  if ((Surface == NULL) || (LC == NULL) || (molecules->ListOfMolecules.empty())) {
+    *out << Verbose(1) <<"No Tesselation, no LinkedCell or no molecule given." << endl;
     return outmap;
+  }
   outmap = new CorrelationToSurfaceMap;
+  atom *Walker = mol->start;
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    if ((type == NULL) || (Walker->type == type)) {
+      triangle = Surface->FindClosestTriangleToPoint(out, Walker->node, LC );
+      if (triangle != NULL) {
+        distance = DistanceToTrianglePlane(out, Walker->node, triangle);
+        outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(distance, pair<atom *, BoundaryTriangleSet*> (Walker, triangle) ) );
+      }
+    }
+  }
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+    if ((*MolWalker)->ActiveFlag) {
+      *out << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl;
+      atom *Walker = (*MolWalker)->start;
+      while (Walker->next != (*MolWalker)->end) {
+        Walker = Walker->next;
+        *out << Verbose(3) << "Current atom is " << *Walker << "." << endl;
+        if ((type == NULL) || (Walker->type == type)) {
+          triangle = Surface->FindClosestTriangleToPoint(out, Walker->node, LC );
+          if (triangle != NULL) {
+            distance = DistanceToTrianglePlane(out, Walker->node, triangle);
+            outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(distance, pair<atom *, BoundaryTriangleSet*> (Walker, triangle) ) );
+          }
+        }
+      }
+    }
+  return outmap;
+};
+/** Calculates the distance (pair) correlation between a given element, all its periodic images and and a surface.
+ * Note that we also put all periodic images found in the cells given by [ -ranges[i], ranges[i] ] and i=0,...,NDIM-1.
+ * I.e. We multiply the atom::node with the inverse of the domain matrix, i.e. transform it to \f$[0,0^3\f$, then add per
+ * axis an integer from [ -ranges[i], ranges[i] ] onto it and multiply with the domain matrix to bring it back into
+ * the real space. Then, we Tesselation::FindClosestTriangleToPoint() and DistanceToTrianglePlane().
+ * \param *out output stream for debugging
+ * \param *molecules list of molecules structure
+ * \param *type element or NULL (if any element)
+ * \param *Surface pointer to Tesselation class surface
+ * \param *LC LinkedCell structure to quickly find neighbouring atoms
+ * \param ranges[NDIM] interval boundaries for the periodic images to scan also
+ * \return Map of doubles with values as pairs of atom and the BoundaryTriangleSet that's closest
+ */
+CorrelationToSurfaceMap *PeriodicCorrelationToSurface( ofstream * const out, MoleculeListClass * const &molecules, const element * const type, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] )
+{
+  CorrelationToSurfaceMap *outmap = NULL;
+  double distance = 0;
+  class BoundaryTriangleSet *triangle = NULL;
+  Vector centroid;
+  int n[NDIM];
+  Vector periodicX;
+  Vector checkX;
+  if ((Surface == NULL) || (LC == NULL) || (molecules->ListOfMolecules.empty())) {
+    *out << Verbose(1) <<"No Tesselation, no LinkedCell or no molecule given." << endl;
+    return outmap;
+  }
+  outmap = new CorrelationToSurfaceMap;
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+    if ((*MolWalker)->ActiveFlag) {
+      const double * const FullMatrix = ReturnFullMatrixforSymmetric((*MolWalker)->cell_size);
+      const double * const FullInverseMatrix = InverseMatrix(FullMatrix);
+      *out << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl;
+      atom *Walker = (*MolWalker)->start;
+      while (Walker->next != (*MolWalker)->end) {
+        Walker = Walker->next;
+        *out << Verbose(3) << "Current atom is " << *Walker << "." << endl;
+        if ((type == NULL) || (Walker->type == type)) {
+          periodicX.CopyVector(Walker->node);
+          periodicX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
+          // go through every range in xyz and get distance
+          for (n[0]=-ranges[0]; n[0] <= ranges[0]; n[0]++)
+            for (n[1]=-ranges[1]; n[1] <= ranges[1]; n[1]++)
+              for (n[2]=-ranges[2]; n[2] <= ranges[2]; n[2]++) {
+                checkX.Init(n[0], n[1], n[2]);
+                checkX.AddVector(&periodicX);
+                checkX.MatrixMultiplication(FullMatrix);
+                triangle = Surface->FindClosestTriangleToPoint(out, &checkX, LC );
+                if (triangle != NULL) {
+                  distance = DistanceToTrianglePlane(out, &checkX, triangle);
+                  outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(distance, pair<atom *, BoundaryTriangleSet*> (Walker, triangle) ) );
+                }
+          }
+        }
+      }
+    }
   return outmap;
 …
  * \param BinStart first bin
  */
 double GetBin ( double value, double BinWidth, double BinStart )
+double GetBin ( const double value, const double BinWidth, const double BinStart )
+{
   double bin =(double) (floor((value - BinStart)/BinWidth));
 …
  * \param *map map to write
  */
 void OutputCorrelation( ofstream *file, BinPairMap *map )
+void OutputCorrelation( ofstream * const file, const BinPairMap * const map )
+{
   *file << "# BinStart\tCount" << endl;
   for (BinPairMap::iterator runner = map->begin(); runner != map->end(); ++runner) {
+  for (BinPairMap::const_iterator runner = map->begin(); runner != map->end(); ++runner) {
     *file << runner->first << "\t" << runner->second << endl;
+  }
 };
+/** Prints correlation (double, (atom*,atom*) ) pairs to file.
+ * \param *file file to write to
+ * \param *map map to write
+ */
+void OutputPairCorrelation( ofstream * const file, const PairCorrelationMap * const map )
+{
+  *file << "# BinStart\tAtom1\tAtom2" << endl;
+  for (PairCorrelationMap::const_iterator runner = map->begin(); runner != map->end(); ++runner) {
+    *file << runner->first << "\t" << *(runner->second.first) << "\t" << *(runner->second.second) << endl;
+  }
+};
+/** Prints correlation (double, int) pairs to file.
+ * \param *file file to write to
+ * \param *map map to write
+ */
+void OutputCorrelationToPoint( ofstream * const file, const CorrelationToPointMap * const map )
+{
+  *file << "# BinStart\tAtom::x[i]-point.x[i]" << endl;
+  for (CorrelationToPointMap::const_iterator runner = map->begin(); runner != map->end(); ++runner) {
+    *file << runner->first;
+    for (int i=0;i<NDIM;i++)
+      *file << "\t" << (runner->second.first->node->x[i] - runner->second.second->x[i]);
+    *file << endl;
+  }
+};
+/** Prints correlation (double, int) pairs to file.
+ * \param *file file to write to
+ * \param *map map to write
+ */
+void OutputCorrelationToSurface( ofstream * const file, const CorrelationToSurfaceMap * const map )
+{
+  *file << "# BinStart\tTriangle" << endl;
+  for (CorrelationToSurfaceMap::const_iterator runner = map->begin(); runner != map->end(); ++runner) {
+    *file << runner->first << "\t" << *(runner->second.second) << endl;
+  }
+};

src/analysis_correlation.hpp

-              r06c7a3
+              r7326b2
 class element;
 class LinkedCell;
 class molecule;
+class MoleculeListClass;
 class Tesselation;
 class Vector;
 …
 typedef multimap<double, pair<atom *, atom *> > PairCorrelationMap;
 typedef multimap<double, pair<atom *, Vector *> > CorrelationToPointMap;
+typedef multimap<double, pair<atom *, const Vector *> > CorrelationToPointMap;
 typedef multimap<double, pair<atom *, BoundaryTriangleSet *> > CorrelationToSurfaceMap;
 typedef map<double, int> BinPairMap;
 …
 /********************************************** declarations *******************************/
+PairCorrelationMap *PairCorrelation( ofstream *out, molecule *mol, element *type1, element *type2 );
+CorrelationToPointMap *CorrelationToPoint( ofstream *out, molecule *mol, element *type, Vector *point );
+CorrelationToSurfaceMap *CorrelationToSurface( ofstream *out, molecule *mol, element *type, Tesselation *Surface, LinkedCell *LC );
+double GetBin ( double value, double BinWidth, double BinStart );
+void OutputCorrelation( ofstream *file, BinPairMap *map );
+PairCorrelationMap *PairCorrelation( ofstream * const out, MoleculeListClass * const &molecules, const element * const type1, const element * const  type2 );
+CorrelationToPointMap *CorrelationToPoint( ofstream * const out, MoleculeListClass * const &molecules, const element * const type, const Vector *point );
+CorrelationToSurfaceMap *CorrelationToSurface( ofstream * const out, MoleculeListClass * const &molecules, const element * const type, const Tesselation * const Surface, const LinkedCell *LC );
+PairCorrelationMap *PeriodicPairCorrelation( ofstream * const out, MoleculeListClass * const &molecules, const element * const type1, const element * const  type2, const int ranges[NDIM] );
+CorrelationToPointMap *PeriodicCorrelationToPoint( ofstream * const out, MoleculeListClass * const &molecules, const element * const type, const Vector *point, const int ranges[NDIM] );
+CorrelationToSurfaceMap *PeriodicCorrelationToSurface( ofstream * const out, MoleculeListClass * const &molecules, const element * const type, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] );
+double GetBin ( const double value, const double BinWidth, const double BinStart );
+void OutputCorrelation( ofstream * const file, const BinPairMap * const map );
+void OutputPairCorrelation( ofstream * const file, const BinPairMap * const map );
+void OutputCorrelationToPoint( ofstream * const file, const BinPairMap * const map );
+void OutputCorrelationToSurface( ofstream * const file, const BinPairMap * const map );
 …
   bool FirstMinFound = false;
   bool FirstMaxFound = false;
+  if (map == NULL) {
+    cerr << "Nothing to min/max, map is NULL!" << endl;
+    return;
+  }
   for (typename T::iterator runner = map->begin(); runner != map->end(); ++runner) {
 …
  * \return Map of doubles (the bins) with counts as values
  */
 template <typename T> BinPairMap *BinData ( ofstream *out,  T *map, double BinWidth, double BinStart, double BinEnd )
+template <typename T> BinPairMap *BinData ( ofstream *out,  T *map, const double BinWidth, const double BinStart, const double BinEnd )
+{
   BinPairMap *outmap = new BinPairMap;
 …
   pair <BinPairMap::iterator, bool > BinPairMapInserter;
+  if (map == NULL) {
+    cerr << "Nothing to bin, is NULL!" << endl;
+    return outmap;
+  }
   if (BinStart == BinEnd) { // if same, find range ourselves
     GetMinMax( map, start, end);
 …
     end = BinEnd;
     for (double runner = start; runner <= end; runner += BinWidth)
       outmap->insert( pair<double, int> (runner, 0.) );
+      outmap->insert( pair<double, int> (runner, 0) );
+  }

src/analyzer.cpp

r06c7a3	r7326b2
59	59	bool NoTime = false;
60	60	bool NoHCorrection = true;
61		int counter;
	61	int counter = 0;
62	62
63	63	cout << "ANOVA Analyzer" << endl;

src/atom.cpp

-              r06c7a3
+              r7326b2
 #include "config.hpp"
 #include "element.hpp"
+#include "lists.hpp"
 #include "memoryallocator.hpp"
 #include "parser.hpp"
 …
 /************************************* Functions for class atom *************************************/
 /** Constructor of class atom.
  */
+atom::atom()
+{
+  father = this;  // generally, father is itself
+  previous = NULL;
+  next = NULL;
+  Ancestor = NULL;
+  type = NULL;
+  sort = NULL;
+  FixedIon = 0;
+  GraphNr = -1;
+  ComponentNr = NULL;
+  IsCyclic = false;
+  SeparationVertex = false;
+  LowpointNr = -1;
+  AdaptiveOrder = 0;
+  MaxOrder = false;
+  // set LCNode::Vector to our Vector
+  node = &x;
+atom::atom() : previous(NULL), next(NULL), father(this), sort(&nr)
+{
+  node = &x;  // TesselPoint::x can only be referenced from here
 };
 /** Constructor of class atom.
  */
+atom::atom(atom *pointer)
+{
+  Name = NULL;
+  previous = NULL;
+  next = NULL;
+  father = pointer;  // generally, father is itself
+  Ancestor = NULL;
+  GraphNr = -1;
+  ComponentNr = NULL;
+  IsCyclic = false;
+  SeparationVertex = false;
+  LowpointNr = -1;
+  AdaptiveOrder = 0;
+  MaxOrder = false;
+atom::atom(atom *pointer) : previous(NULL), next(NULL), father(pointer), sort(&nr)
+{
   type = pointer->type;  // copy element of atom
   x.CopyVector(&pointer->x); // copy coordination
   v.CopyVector(&pointer->v); // copy velocity
   FixedIon = pointer->FixedIon;
-  nr = -1;
-  sort = &nr;
   node = &x;
+}
+};
 …
 atom::~atom()
+{
+  Free<int>(&ComponentNr, "atom::~atom: *ComponentNr");
+  Free<char>(&Name, "atom::~atom: *Name");
+  Trajectory.R.clear();
+  Trajectory.U.clear();
+  Trajectory.F.clear();
+  unlink(this);
 };
 …
  * \param **res return value (only set if atom::father is equal to \a *ptr)
  */
 void atom::EqualsFather ( atom *ptr, atom **res )
+void atom::EqualsFather ( const atom *ptr, const atom **res ) const
+{
   if ( ptr == father )
 …
  * \return true - is inside, false - is not
  */
 bool atom::IsInParallelepiped(Vector offset, double *parallelepiped)
+bool atom::IsInParallelepiped(const Vector offset, const double *parallelepiped) const
+{
   return (node->IsInParallelepiped(offset, parallelepiped));
 };
+/** Output of a single atom.
+/** Counts the number of bonds weighted by bond::BondDegree.
+ * \param bonds times bond::BondDegree
+ */
+int BondedParticle::CountBonds() const
+{
+  int NoBonds = 0;
+  for (BondList::const_iterator Runner = ListOfBonds.begin(); Runner != ListOfBonds.end(); (++Runner))
+    NoBonds += (*Runner)->BondDegree;
+  return NoBonds;
+};
+/** Output of a single atom with given numbering.
  * \param ElementNo cardinal number of the element
  * \param AtomNo cardinal number among these atoms of the same element
 …
   * \return true - \a *out present, false - \a *out is NULL
  */
 bool atom::Output(ofstream *out, int ElementNo, int AtomNo, const char *comment) const
+bool atom::OutputIndexed(ofstream *out, const int ElementNo, const int AtomNo, const char *comment) const
+{
   if (out != NULL) {
 …
     return false;
 };
+bool atom::Output(ofstream *out, int *ElementNo, int *AtomNo, const char *comment)
+/** Output of a single atom with numbering from array according to atom::type.
+ * \param *ElementNo cardinal number of the element
+ * \param *AtomNo cardinal number among these atoms of the same element
+ * \param *out stream to output to
+ * \param *comment commentary after '#' sign
+  * \return true - \a *out present, false - \a *out is NULL
+ */
+bool atom::OutputArrayIndexed(ofstream *out, const int *ElementNo, int *AtomNo, const char *comment) const
+{
   AtomNo[type->Z]++;  // increment number
 …
   * \return true - \a *out present, false - \a *out is NULL
  */
 bool atom::OutputTrajectory(ofstream *out, int *ElementNo, int *AtomNo, int step) const
+bool atom::OutputTrajectory(ofstream *out, const int *ElementNo, int *AtomNo, const int step) const
+{
   AtomNo[type->Z]++;
 …
  * \return true - \a *out present, false - \a *out is NULL
  */
 bool atom::OutputTrajectoryXYZ(ofstream *out, int step) const
+bool atom::OutputTrajectoryXYZ(ofstream *out, const int step) const
+{
   if (out != NULL) {
 …
 };
+/** Prints all bonds of this atom from given global lists.
+ * \param *out stream to output to
+ * \param *NumberOfBondsPerAtom array with number of bonds per atomic index
+ * \param ***ListOfBondsPerAtom array per atomic index of array with pointer to bond
+ * \return true - \a *out present, false - \a *out is NULL
+ */
+bool atom::OutputBondOfAtom(ofstream *out, int *NumberOfBondsPerAtom, bond ***ListOfBondsPerAtom) const
+{
+  if (out != NULL) {
+#ifdef ADDHYDROGEN
+    if (type->Z != 1) {   // regard only non-hydrogen
+#endif
+      *out << Verbose(4) << "Atom " << Name << "/" << nr << " with " << NumberOfBondsPerAtom[nr] << " bonds: ";
+      int TotalDegree = 0;
+      for (int j=0;j<NumberOfBondsPerAtom[nr];j++) {
+        *out << *ListOfBondsPerAtom[nr][j] << "\t";
+        TotalDegree += ListOfBondsPerAtom[nr][j]->BondDegree;
+      }
+      *out << " -- TotalDegree: " << TotalDegree << endl;
+#ifdef ADDHYDROGEN
+    }
+#endif
+    return true;
+  } else
+    return false;
+};
+ostream & operator << (ostream &ost, const atom &a)
+{
+  ost << "[" << a.Name << "|" << &a << "]";
+  return ost;
+};
+ostream & atom::operator << (ostream &ost)
+{
+  ost << "[" << Name << "|" << this << "]";
+  return ost;
+/** Outputs the MPQC configuration line for this atom.
+ * \param *out output stream
+ * \param *center center of molecule subtracted from position
+ * \param *AtomNo pointer to atom counter that is increased by one
+ */
+void atom::OutputMPQCLine(ofstream *out, const Vector *center, int *AtomNo = NULL) const
+{
+  *out << "\t\t" << type->symbol << " [ " << x.x[0]-center->x[0] << "\t" << x.x[1]-center->x[1] << "\t" << x.x[2]-center->x[2] << " ]" << endl;
+  if (AtomNo != NULL)
+    *AtomNo++;
 };
 …
  * \return true - this one's is smaller, false - not
  */
 bool atom::Compare(const atom &ptr)
+bool atom::Compare(const atom &ptr) const
+{
   if (nr < ptr.nr)
 …
     return false;
 };
-/** Extends the trajectory STL vector to the new size.
- * Does nothing if \a MaxSteps is smaller than current size.
- * \param MaxSteps
- */
-void atom::ResizeTrajectory(int MaxSteps)
+{
-  if (Trajectory.R.size() <= (unsigned int)(MaxSteps)) {
-    //cout << "Increasing size for trajectory array of " << keyword << " to " << (MaxSteps+1) << "." << endl;
-    Trajectory.R.resize(MaxSteps+1);
-    Trajectory.U.resize(MaxSteps+1);
-    Trajectory.F.resize(MaxSteps+1);
+  }
-};
-/** Copies a given trajectory step \a src onto another \a dest
- * \param dest index of destination step
- * \param src index of source step
- */
-void atom::CopyStepOnStep(int dest, int src)
+{
-  if (dest == src)  // self assignment check
-    return;
-  for (int n=NDIM;n--;) {
-    Trajectory.R.at(dest).x[n] = Trajectory.R.at(src).x[n];
-    Trajectory.U.at(dest).x[n] = Trajectory.U.at(src).x[n];
-    Trajectory.F.at(dest).x[n] = Trajectory.F.at(src).x[n];
+  }
-};
-/** Performs a velocity verlet update of the trajectory.
- * Parameters are according to those in configuration class.
- * \param NextStep index of sequential step to set
- * \param *configuration pointer to configuration with parameters
- * \param *Force matrix with forces
- */
-void atom::VelocityVerletUpdate(int NextStep, config *configuration, ForceMatrix *Force)
+{
-  //a = configuration.Deltat*0.5/walker->type->mass;        // (F+F_old)/2m = a and thus: v = (F+F_old)/2m * t = (F + F_old) * a
-  for (int d=0; d<NDIM; d++) {
-    Trajectory.F.at(NextStep).x[d] = -Force->Matrix[0][nr][d+5]*(configuration->GetIsAngstroem() ? AtomicLengthToAngstroem : 1.);
-    Trajectory.R.at(NextStep).x[d] = Trajectory.R.at(NextStep-1).x[d];
-    Trajectory.R.at(NextStep).x[d] += configuration->Deltat*(Trajectory.U.at(NextStep-1).x[d]);     // s(t) = s(0) + v * deltat + 1/2 a * deltat^2
-    Trajectory.R.at(NextStep).x[d] += 0.5*configuration->Deltat*configuration->Deltat*(Trajectory.F.at(NextStep).x[d]/type->mass);     // F = m * a and s = 0.5 * F/m * t^2 = F * a * t
+  }
-  // Update U
-  for (int d=0; d<NDIM; d++) {
-    Trajectory.U.at(NextStep).x[d] = Trajectory.U.at(NextStep-1).x[d];
-    Trajectory.U.at(NextStep).x[d] += configuration->Deltat * (Trajectory.F.at(NextStep).x[d]+Trajectory.F.at(NextStep-1).x[d]/type->mass); // v = F/m * t
+  }
-  // Update R (and F)
-//      out << "Integrated position&velocity of step " << (NextStep) << ": (";
-//      for (int d=0;d<NDIM;d++)
-//        out << Trajectory.R.at(NextStep).x[d] << " ";          // next step
-//      out << ")\t(";
-//      for (int d=0;d<NDIM;d++)
-//        cout << Trajectory.U.at(NextStep).x[d] << " ";          // next step
-//      out << ")" << endl;
-};
-/** Sums up mass and kinetics.
- * \param Step step to sum for
- * \param *TotalMass pointer to total mass sum
- * \param *TotalVelocity pointer to tota velocity sum
- */
-void atom::SumUpKineticEnergy( int Step, double *TotalMass, Vector *TotalVelocity )
+{
-  *TotalMass += type->mass;  // sum up total mass
-  for(int d=0;d<NDIM;d++) {
-    TotalVelocity->x[d] += Trajectory.U.at(Step).x[d]*type->mass;
+  }
-};
-/** Outputs the current atom::AdaptiveOrder and atom::MaxOrder to \a *file.
- * \param *file output stream
- */
-void atom::OutputOrder(ofstream *file)
+{
-  *file << nr << "\t" << (int)AdaptiveOrder << "\t" << (int)MaxOrder << endl;
-  //cout << Verbose(2) << "Storing: " << Walker->nr << "\t" << (int)Walker->AdaptiveOrder << "\t" << (int)Walker->MaxOrder << "." << endl;
+}
 /** Returns squared distance to a given vector.
 …
  * \return distance squared
  */
 double atom::DistanceSquaredToVector(Vector &origin)
+double atom::DistanceSquaredToVector(const Vector &origin) const
+{
   return origin.DistanceSquared(&x);
-};
-/** Adds kinetic energy of this atom to given temperature value.
- * \param *temperature add on this value
- * \param step given step of trajectory to add
- */
-void atom::AddKineticToTemperature(double *temperature, int step) const
+{
-  for (int i=NDIM;i--;)
-    *temperature += type->mass * Trajectory.U.at(step).x[i]* Trajectory.U.at(step).x[i];
 };
 …
  * \return distance
  */
 double atom::DistanceToVector(Vector &origin)
+double atom::DistanceToVector(const Vector &origin) const
+{
   return origin.Distance(&x);
 };
+/** Initialises the component number array.
+ * Size is set to atom::ListOfBonds.size()+1 (last is th encode end by -1)
+ */
+void atom::InitComponentNr()
+{
+  if (ComponentNr != NULL)
+    Free(&ComponentNr);
+  ComponentNr = Malloc<int>(ListOfBonds.size()+1, "atom::InitComponentNumbers: *ComponentNr");
+  for (int i=ListOfBonds.size()+1;i--;)
+    ComponentNr[i] = -1;
+};
 bool operator < (atom &a, atom &b)
+{
 …
 };
-/** Evaluates some constraint potential if atom moves from \a startstep at once to \endstep in trajectory.
- * \param startstep trajectory begins at
- * \param endstep trajectory ends at
- * \param **PermutationMap if atom switches places with some other atom, there is no translation but a permutaton noted here (not in the trajectories of each).
- * \param *Force Force matrix to store result in
- */
-void atom::EvaluateConstrainedForce(int startstep, int endstep, atom **PermutationMap, ForceMatrix *Force)
+{
-  double constant = 10.;
-  atom *Sprinter = PermutationMap[nr];
-  // set forces
-  for (int i=NDIM;i++;)
-    Force->Matrix[0][nr][5+i] += 2.*constant*sqrt(Trajectory.R.at(startstep).Distance(&Sprinter->Trajectory.R.at(endstep)));
-};
-/** Correct velocity against the summed \a CoGVelocity for \a step.
- * \param *ActualTemp sum up actual temperature meanwhile
- * \param Step MD step in atom::Tracjetory
- * \param *CoGVelocity remnant velocity (i.e. vector sum of all atom velocities)
- */
-void atom::CorrectVelocity(double *ActualTemp, int Step, Vector *CoGVelocity)
+{
-  for(int d=0;d<NDIM;d++) {
-    Trajectory.U.at(Step).x[d] -= CoGVelocity->x[d];
-    *ActualTemp += 0.5 * type->mass * Trajectory.U.at(Step).x[d] * Trajectory.U.at(Step).x[d];
+  }
-};
-/** Scales velocity of atom according to Woodcock thermostat.
- * \param ScaleTempFactor factor to scale the velocities with (i.e. sqrt of energy scale factor)
- * \param Step MD step to scale
- * \param *ekin sum of kinetic energy
- */
-void atom::Thermostat_Woodcock(double ScaleTempFactor, int Step, double *ekin)
+{
-  double *U = Trajectory.U.at(Step).x;
-  if (FixedIon == 0) // even FixedIon moves, only not by other's forces
-    for (int d=0; d<NDIM; d++) {
-      U[d] *= ScaleTempFactor;
-      *ekin += 0.5*type->mass * U[d]*U[d];
+    }
-};
-/** Scales velocity of atom according to Gaussian thermostat.
- * \param Step MD step to scale
- * \param *G
- * \param *E
- */
-void atom::Thermostat_Gaussian_init(int Step, double *G, double *E)
+{
-  double *U = Trajectory.U.at(Step).x;
-  double *F = Trajectory.F.at(Step).x;
-  if (FixedIon == 0) // even FixedIon moves, only not by other's forces
-    for (int d=0; d<NDIM; d++) {
-      *G += U[d] * F[d];
-      *E += U[d]*U[d]*type->mass;
+    }
-};
-/** Determines scale factors according to Gaussian thermostat.
- * \param Step MD step to scale
- * \param GE G over E ratio
- * \param *ekin sum of kinetic energy
- * \param *configuration configuration class with TempFrequency and TargetTemp
- */
-void atom::Thermostat_Gaussian_least_constraint(int Step, double G_over_E, double *ekin, config *configuration)
+{
-  double *U = Trajectory.U.at(Step).x;
-  if (FixedIon == 0) // even FixedIon moves, only not by other's forces
-    for (int d=0; d<NDIM; d++) {
-      U[d] += configuration->Deltat/type->mass * ( (G_over_E) * (U[d]*type->mass) );
-      *ekin += type->mass * U[d]*U[d];
+    }
-};
-/** Scales velocity of atom according to Langevin thermostat.
- * \param Step MD step to scale
- * \param *r random number generator
- * \param *ekin sum of kinetic energy
- * \param *configuration configuration class with TempFrequency and TargetTemp
- */
-void atom::Thermostat_Langevin(int Step, gsl_rng * r, double *ekin, config *configuration)
+{
-  double sigma  = sqrt(configuration->TargetTemp/type->mass); // sigma = (k_b T)/m (Hartree/atomicmass = atomiclength/atomictime)
-  double *U = Trajectory.U.at(Step).x;
-  if (FixedIon == 0) { // even FixedIon moves, only not by other's forces
-    // throw a dice to determine whether it gets hit by a heat bath particle
-    if (((((rand()/(double)RAND_MAX))*configuration->TempFrequency) < 1.)) {
-      cout << Verbose(3) << "Particle " << *this << " was hit (sigma " << sigma << "): " << sqrt(U[0]*U[0]+U[1]*U[1]+U[2]*U[2]) << " -> ";
-      // pick three random numbers from a Boltzmann distribution around the desired temperature T for each momenta axis
-      for (int d=0; d<NDIM; d++) {
-        U[d] = gsl_ran_gaussian (r, sigma);
+      }
-      cout << sqrt(U[0]*U[0]+U[1]*U[1]+U[2]*U[2]) << endl;
+    }
-    for (int d=0; d<NDIM; d++)
-      *ekin += 0.5*type->mass * U[d]*U[d];
+  }
-};
-/** Scales velocity of atom according to Berendsen thermostat.
- * \param Step MD step to scale
- * \param ScaleTempFactor factor to scale energy (not velocity!) with
- * \param *ekin sum of kinetic energy
- * \param *configuration configuration class with TempFrequency and Deltat
- */
-void atom::Thermostat_Berendsen(int Step, double ScaleTempFactor, double *ekin, config *configuration)
+{
-  double *U = Trajectory.U.at(Step).x;
-  if (FixedIon == 0) { // even FixedIon moves, only not by other's forces
-    for (int d=0; d<NDIM; d++) {
-      U[d] *= sqrt(1+(configuration->Deltat/configuration->TempFrequency)*(ScaleTempFactor-1));
-      *ekin += 0.5*type->mass * U[d]*U[d];
+    }
+  }
-};
-/** Initializes current run of NoseHoover thermostat.
- * \param Step MD step to scale
- * \param *delta_alpha additional sum of kinetic energy on return
- */
-void atom::Thermostat_NoseHoover_init(int Step, double *delta_alpha)
+{
-  double *U = Trajectory.U.at(Step).x;
-  if (FixedIon == 0) { // even FixedIon moves, only not by other's forces
-    for (int d=0; d<NDIM; d++) {
-      *delta_alpha += U[d]*U[d]*type->mass;
+    }
+  }
-};
-/** Initializes current run of NoseHoover thermostat.
- * \param Step MD step to scale
- * \param *ekin sum of kinetic energy
- * \param *configuration configuration class with TempFrequency and Deltat
- */
-void atom::Thermostat_NoseHoover_scale(int Step, double *ekin, config *configuration)
+{
-  double *U = Trajectory.U.at(Step).x;
-  if (FixedIon == 0) { // even FixedIon moves, only not by other's forces
-    for (int d=0; d<NDIM; d++) {
-        U[d] += configuration->Deltat/type->mass * (configuration->alpha * (U[d] * type->mass));
-        *ekin += (0.5*type->mass) * U[d]*U[d];
+      }
+  }
-};

src/atom.hpp

-              r06c7a3
+              r7326b2
 #include <iostream>
+#include <list>
 #include <vector>
+#include <gsl/gsl_randist.h>
+#include "atom_atominfo.hpp"
+#include "atom_bondedparticle.hpp"
+#include "atom_graphnode.hpp"
+#include "atom_particleinfo.hpp"
+#include "atom_trajectoryparticle.hpp"
 #include "tesselation.hpp"
 /****************************************** forward declarations *****************************/
-class bond;
-class config;
-class element;
-class ForceMatrix;
 class Vector;
 …
  * Class incorporates position, type
  */
 class atom : public TesselPoint {
+class atom : public TesselPoint, public TrajectoryParticle, public GraphNode, public BondedParticle, public virtual ParticleInfo, public virtual AtomInfo {
   public:
-    struct
+    {
-      vector<Vector> R;  //!< position vector
-      vector<Vector> U;  //!< velocity vector
-      vector<Vector> F;  //!< last force vector
-    } Trajectory;
-    Vector x;       //!< coordinate vector of atom, giving last position within cell
-    Vector v;       //!< velocity vector of atom, giving last velocity within cell
-    Vector F;       //!< Force vector of atom, giving last force within cell
-    element *type;  //!< pointing to element
     atom *previous; //!< previous atom in molecule list
     atom *next;     //!< next atom in molecule list
     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, comes from TesselPoint
-    int FixedIon;   //!< config variable that states whether forces act on the ion or not
     int *sort;      //!< sort criteria
-    //int nr;         //!< continuous, unique number, comes from TesselPoint
-    int GraphNr;      //!< unique number, given in DepthFirstSearchAnalysis()
-    int *ComponentNr;//!< belongs to this nonseparable components, given in DepthFirstSearchAnalysis() (if more than one, then is SeparationVertex)
-    int LowpointNr; //!< needed in DepthFirstSearchAnalysis() to detect nonseparable components, is the lowest possible number of an atom to reach via tree edges only followed by at most one back edge.
-    bool SeparationVertex; //!< whether this atom separates off subsets of atoms or not, determined in DepthFirstSearchAnalysis()
-    bool IsCyclic;        //!< whether atom belong to as cycle or not, determined in DepthFirstSearchAnalysis()
-    unsigned char AdaptiveOrder;  //!< current present bond order at site (0 means "not set")
-    bool MaxOrder;  //!< whether this atom as a root in fragmentation still creates more fragments on higher orders or not
   atom();
 …
   virtual ~atom();
   bool Output(ofstream *out, int ElementNo, int AtomNo, const char *comment = NULL) const;
   bool Output(ofstream *out, int *ElementNo, int *AtomNo, const char *comment = NULL);
+  bool OutputIndexed(ofstream *out, const int ElementNo, const int AtomNo, const char *comment = NULL) const;
+  bool OutputArrayIndexed(ofstream *out, const int *ElementNo, int *AtomNo, const char *comment = NULL) const;
   bool OutputXYZLine(ofstream *out) const;
   bool OutputTrajectory(ofstream *out, int *ElementNo, int *AtomNo, int step) const;
   bool OutputTrajectoryXYZ(ofstream *out, int step) const;
   bool OutputBondOfAtom(ofstream *out, int *NumberOfBondsPerAtom, bond ***ListOfBondsPerAtom) const;
+  bool OutputTrajectory(ofstream *out, const int *ElementNo, int *AtomNo, const int step) const;
+  bool OutputTrajectoryXYZ(ofstream *out, const int step) const;
+  void OutputMPQCLine(ofstream *out, const Vector *center, int *AtomNo) const;
+  void EqualsFather ( atom *ptr, atom **res );
+  void InitComponentNr();
+  void EqualsFather ( const atom *ptr, const atom **res ) const;
   void CorrectFather();
   atom *GetTrueFather();
   bool Compare(const atom &ptr);
+  bool Compare(const atom &ptr) const;
+  // trajectory stuff
+  void ResizeTrajectory(int MaxSteps);
+  void CopyStepOnStep(int dest, int src);
+  void VelocityVerletUpdate(int MDSteps, config *configuration, ForceMatrix *Force);
+  void SumUpKineticEnergy( int Step, double *TotalMass, Vector *TotalVelocity );
+  double DistanceToVector(Vector &origin);
+  double DistanceSquaredToVector(Vector &origin);
+  bool IsInParallelepiped(Vector offset, double *parallelepiped);
+  // bond order stuff
+  void OutputOrder(ofstream *file);
+  // constraint potential and dynamics stuff
+  void AddKineticToTemperature(double *temperature, int step) const;
+  void EvaluateConstrainedForce(int startstep, int endstep, atom **PermutationMap, ForceMatrix *Force);
+  void CorrectVelocity(double *ActualTemp, int Step, Vector *CoGVelocity);
+  // thermostats
+  void Thermostat_Woodcock(double ScaleTempFactor, int Step, double *ekin);
+  void Thermostat_Gaussian_init(int Step, double *G, double *E);
+  void Thermostat_Gaussian_least_constraint(int Step, double G_over_E, double *ekin, config *configuration);
+  void Thermostat_Langevin(int Step, gsl_rng * r, double *ekin, config *configuration);
+  void Thermostat_Berendsen(int Step, double ScaleTempFactor, double *ekin, config *configuration);
+  void Thermostat_NoseHoover_init(int Step, double *delta_alpha);
+  void Thermostat_NoseHoover_scale(int Step, double *ekin, config *configuration);
+  ostream & operator << (ostream &ost);
+  double DistanceToVector(const Vector &origin) const;
+  double DistanceSquaredToVector(const Vector &origin) const;
+  bool IsInParallelepiped(const Vector offset, const double *parallelepiped) const;
   private:
 };
-ostream & operator << (ostream &ost, const atom &a);
 #endif /* ATOM_HPP_ */

src/bond.cpp

-              r06c7a3
+              r7326b2
 /** Empty Constructor for class bond.
  */
 bond::bond()
+bond::bond() : leftatom(NULL), rightatom(NULL), previous(NULL), next(NULL), HydrogenBond(0), BondDegree(0), nr(-1), Cyclic(false), Type(Undetermined), Used(white)
+{
-  leftatom = NULL;
-  rightatom = NULL;
-  previous = NULL;
-  next = NULL;
-  nr = -1;
-  HydrogenBond = 0;
-  BondDegree = 0;
-  Used = white;
-  Cyclic = false;
-  Type = Undetermined;
 };
 …
  * \param number increasing index
  */
 bond::bond(atom *left, atom *right, int degree=1, int number=0)
+bond::bond(atom *left, atom *right, const int degree, const int number) : leftatom(left), rightatom(right), previous(NULL), next(NULL), HydrogenBond(0), BondDegree(degree), nr(number), Cyclic(false), Type(Undetermined), Used(white)
+{
-  leftatom = left;
-  rightatom = right;
-  previous = NULL;
-  next = NULL;
-  HydrogenBond = 0;
   if ((left != NULL) && (right != NULL)) {
     if ((left->type != NULL) && (left->type->Z == 1))
 …
       HydrogenBond++;
+  }
-  BondDegree = degree;
-  nr = number;
-  Used = white;
-  Cyclic = false;
-};
-bond::bond(atom *left, atom *right)
+{
-  leftatom = left;
-  rightatom = right;
-  previous = NULL;
-  next = NULL;
-  HydrogenBond = 0;
-  if ((left != NULL) && (right != NULL)) {
-    if ((left->type != NULL) && (left->type->Z == 1))
-      HydrogenBond++;
-    if ((right->type != NULL) && (right->type->Z == 1))
-      HydrogenBond++;
+  }
-  BondDegree = 1;
-  nr = 0;
-  Used = white;
-  Cyclic = false;
 };
 …
+{
   // remove this node from the list structure
+  if (previous != NULL) {
+    previous->next = next;
+  }
+  if (next != NULL) {
+    next->previous = previous;
+  }
+  if (leftatom != NULL)
+    leftatom->UnregisterBond(this);
+  if (rightatom != NULL)
+  rightatom->UnregisterBond(this);
+  unlink(this);
 };
 ostream & operator << (ostream &ost, const bond &b)
+ostream & operator << (ostream &ost, const bond &b)
+{
   ost << "[" << b.leftatom->Name << " <" << b.BondDegree << "(H" << b.HydrogenBond << ")>" << b.rightatom->Name << "]";
 …
  * \return pointer to the other atom in the bond, NULL if no match (indicates something's wrong with the bond)
  */
 atom * bond::GetOtherAtom(atom *Atom) const
+atom * bond::GetOtherAtom(const ParticleInfo * const Atom) const
+{
   if(leftatom == Atom)
 …
 };
-/** Get the other atom in a bond if one is specified.
- * \param *Atom the pointer to the one atom
- * \return pointer to the other atom in the bond, NULL if no match (indicates something's wrong with the bond)
- */
-bond * bond::GetFirstBond()
+{
-  return GetFirst(this);
-};
-/** Get the other atom in a bond if one is specified.
- * \param *Atom the pointer to the one atom
- * \return pointer to the other atom in the bond, NULL if no match (indicates something's wrong with the bond)
- */
-bond * bond::GetLastBond()
+{
-  return GetLast(this);
-};
 /** Returns whether vertex was used in DFS.
 …
  * \return true if it is either bond::leftatom or bond::rightatom, false otherwise
  */
 bool bond::Contains(const atom *ptr)
+bool bond::Contains(const ParticleInfo * const ptr)
+{
   return ((leftatom == ptr) || (rightatom == ptr));
 …
  * \return bond::Used, false if bond was already marked used
  */
 bool bond::MarkUsed(enum Shading color) {
+bool bond::MarkUsed(const enum Shading color) {
   if (Used == black) {
     cerr << "ERROR: Bond " << this << " was already marked black!." << endl;

src/bond.hpp

-              r06c7a3
+              r7326b2
 class atom;
+class ParticleInfo;
 /********************************************** declarations *******************************/
 /** Bonds between atoms.
+ * Class incorporates bonds between atoms in a molecule,
+ * used to derive tge fragments in many-body bond order
+ * calculations.
+ * Class incorporates bonds between atoms in a molecule.
+ * Note that we regard bond always as something in a molecule,
+ * as it is the glue making up the connected subgrapgh and
+ * hence the molecule. Thus, bonds belong globally to the molecule
+ * (and are free'd there) and only locally to the atom classs.
  */
 class bond {
 …
     enum EdgeType Type;//!< whether this is a tree or back edge
+  atom * GetOtherAtom(atom *Atom) const;
+  bond * GetFirstBond();
+  bond * GetLastBond();
+  atom * GetOtherAtom(const ParticleInfo * const Atom) const;
   bool MarkUsed(enum Shading color);
+  bool MarkUsed(const enum Shading color);
   enum Shading IsUsed();
   void ResetUsed();
   bool Contains(const atom *ptr);
+  bool Contains(const ParticleInfo * const ptr);
   bool Contains(const int nr);
   bond();
+  bond(atom *left, atom *right);
+  bond(atom *left, atom *right, int degree);
+  bond(atom *left, atom *right, int degree, int number);
+  bond(atom *left, atom *right, const int degree=1, const int number=0);
   ~bond();

src/boundary.cpp

-              r06c7a3
+              r7326b2
  * \param *BoundaryPoints NDIM set of boundary points defining the convex envelope on each projected plane
  * \param *mol molecule structure representing the cluster
+ * \param *&TesselStruct Tesselation structure with triangles
  * \param IsAngstroem whether we have angstroem or atomic units
  * \return NDIM array of the diameters
  */
 double *GetDiametersOfCluster(ofstream *out, Boundaries *BoundaryPtr, molecule *mol, bool IsAngstroem)
+double *GetDiametersOfCluster(ofstream *out, const Boundaries *BoundaryPtr, const molecule *mol, Tesselation *&TesselStruct, const bool IsAngstroem)
+{
   // get points on boundary of NULL was given as parameter
   bool BoundaryFreeFlag = false;
+  Boundaries *BoundaryPoints = BoundaryPtr;
+  if (BoundaryPoints == NULL) {
+  double OldComponent = 0.;
+  double tmp = 0.;
+  double w1 = 0.;
+  double w2 = 0.;
+  Vector DistanceVector;
+  Vector OtherVector;
+  int component = 0;
+  int Othercomponent = 0;
+  Boundaries::const_iterator Neighbour;
+  Boundaries::const_iterator OtherNeighbour;
+  double *GreatestDiameter = new double[NDIM];
+  const Boundaries *BoundaryPoints;
+  if (BoundaryPtr == NULL) {
     BoundaryFreeFlag = true;
     BoundaryPoints = GetBoundaryPoints(out, mol);
+    BoundaryPoints = GetBoundaryPoints(out, mol, TesselStruct);
   } else {
+    BoundaryPoints = BoundaryPtr;
     *out << Verbose(1) << "Using given boundary points set." << endl;
+  }
   // determine biggest "diameter" of cluster for each axis
-  Boundaries::iterator Neighbour, OtherNeighbour;
-  double *GreatestDiameter = new double[NDIM];
   for (int i = 0; i < NDIM; i++)
     GreatestDiameter[i] = 0.;
-  double OldComponent, tmp, w1, w2;
-  Vector DistanceVector, OtherVector;
-  int component, Othercomponent;
   for (int axis = 0; axis < NDIM; axis++)
     { // regard each projected plane
 …
           Othercomponent = (axis + 1 + ((j + 1) & 1)) % NDIM;
           //*out << Verbose(1) << "Current component is " << component << ", Othercomponent is " << Othercomponent << "." << endl;
+          for (Boundaries::iterator runner = BoundaryPoints[axis].begin(); runner
+              != BoundaryPoints[axis].end(); runner++)
+            {
+          for (Boundaries::const_iterator runner = BoundaryPoints[axis].begin(); runner != BoundaryPoints[axis].end(); runner++) {
               //*out << Verbose(2) << "Current runner is " << *(runner->second.second) << "." << endl;
               // seek for the neighbours pair where the Othercomponent sign flips
 …
               DistanceVector.CopyVector(&runner->second.second->x);
               DistanceVector.SubtractVector(&Neighbour->second.second->x);
+              do
+                { // seek for neighbour pair where it flips
+              do { // seek for neighbour pair where it flips
                   OldComponent = DistanceVector.x[Othercomponent];
                   Neighbour++;
 …
                   DistanceVector.SubtractVector(&Neighbour->second.second->x);
                   //*out << Verbose(3) << "OldComponent is " << OldComponent << ", new one is " << DistanceVector.x[Othercomponent] << "." << endl;
+                }
+              while ((runner != Neighbour) && (fabs(OldComponent / fabs(
+                } while ((runner != Neighbour) && (fabs(OldComponent / fabs(
                   OldComponent) - DistanceVector.x[Othercomponent] / fabs(
                   DistanceVector.x[Othercomponent])) < MYEPSILON)); // as long as sign does not flip
+              if (runner != Neighbour)
+                {
+              if (runner != Neighbour) {
                   OtherNeighbour = Neighbour;
                   if (OtherNeighbour == BoundaryPoints[axis].begin()) // make it wrap around
 …
  * \param *out output stream for debugging
  * \param *mol molecule structure representing the cluster
+ */
+Boundaries *GetBoundaryPoints(ofstream *out, molecule *mol)
+ * \param *&TesselStruct pointer to Tesselation structure
+ */
+Boundaries *GetBoundaryPoints(ofstream *out, const molecule *mol, Tesselation *&TesselStruct)
+{
   atom *Walker = NULL;
 …
   Vector *MolCenter = mol->DetermineCenterOfAll(out);
   Vector helper;
+  BoundariesTestPair BoundaryTestPair;
+  Vector AxisVector;
+  Vector AngleReferenceVector;
+  Vector AngleReferenceNormalVector;
+  Vector ProjectedVector;
+  Boundaries *BoundaryPoints = new Boundaries[NDIM]; // first is alpha, second is (r, nr)
+  double angle = 0.;
   *out << Verbose(1) << "Finding all boundary points." << endl;
-  Boundaries *BoundaryPoints = new Boundaries[NDIM]; // first is alpha, second is (r, nr)
-  BoundariesTestPair BoundaryTestPair;
-  Vector AxisVector, AngleReferenceVector, AngleReferenceNormalVector;
-  double radius, angle;
   // 3a. Go through every axis
   for (int axis = 0; axis < NDIM; axis++) {
 …
     while (Walker->next != mol->end) {
       Walker = Walker->next;
-      Vector ProjectedVector;
       ProjectedVector.CopyVector(&Walker->x);
       ProjectedVector.SubtractVector(MolCenter);
 …
       // correct for negative side
       radius = ProjectedVector.NormSquared();
+      const double radius = ProjectedVector.NormSquared();
       if (fabs(radius) > MYEPSILON)
         angle = ProjectedVector.Angle(&AngleReferenceVector);
 …
         *out << Verbose(2) << "Present vector: " << *BoundaryTestPair.first->second.second << endl;
         *out << Verbose(2) << "New vector: " << *Walker << endl;
         double tmp = ProjectedVector.NormSquared();
         if ((tmp - BoundaryTestPair.first->second.first) > MYEPSILON) {
           BoundaryTestPair.first->second.first = tmp;
+        const double ProjectedVectorNorm = ProjectedVector.NormSquared();
+        if ((ProjectedVectorNorm - BoundaryTestPair.first->second.first) > MYEPSILON) {
+          BoundaryTestPair.first->second.first = ProjectedVectorNorm;
           BoundaryTestPair.first->second.second = Walker;
           *out << Verbose(2) << "Keeping new vector due to larger projected distance " << tmp << "." << endl;
         } else if (fabs(tmp - BoundaryTestPair.first->second.first) < MYEPSILON) {
+          *out << Verbose(2) << "Keeping new vector due to larger projected distance " << ProjectedVectorNorm << "." << endl;
+        } else if (fabs(ProjectedVectorNorm - BoundaryTestPair.first->second.first) < MYEPSILON) {
           helper.CopyVector(&Walker->x);
           helper.SubtractVector(MolCenter);
           tmp = helper.NormSquared();
+          const double oldhelperNorm = helper.NormSquared();
           helper.CopyVector(&BoundaryTestPair.first->second.second->x);
           helper.SubtractVector(MolCenter);
           if (helper.NormSquared() < tmp) {
+          if (helper.NormSquared() < oldhelperNorm) {
             BoundaryTestPair.first->second.second = Walker;
             *out << Verbose(2) << "Keeping new vector due to larger distance to molecule center " << helper.NormSquared() << "." << endl;
           } else {
             *out << Verbose(2) << "Keeping present vector due to larger distance to molecule center " << tmp << "." << endl;
+            *out << Verbose(2) << "Keeping present vector due to larger distance to molecule center " << oldhelperNorm << "." << endl;
+          }
         } else {
           *out << Verbose(2) << "Keeping present vector due to larger projected distance " << tmp << "." << endl;
+          *out << Verbose(2) << "Keeping present vector due to larger projected distance " << ProjectedVectorNorm << "." << endl;
+        }
+      }
 …
           // calculate each length
           double a = SideA.Norm();
           //double b = SideB.Norm();
           //double c = SideC.Norm();
           double h = SideH.Norm();
+          const double a = SideA.Norm();
+          //const double b = SideB.Norm();
+          //const double c = SideC.Norm();
+          const double h = SideH.Norm();
           // calculate the angles
           double alpha = SideA.Angle(&SideH);
           double beta = SideA.Angle(&SideC);
           double gamma = SideB.Angle(&SideH);
           double delta = SideC.Angle(&SideH);
           double MinDistance = a * sin(beta) / (sin(delta)) * (((alpha < M_PI / 2.) || (gamma < M_PI / 2.)) ? 1. : -1.);
+          const double alpha = SideA.Angle(&SideH);
+          const double beta = SideA.Angle(&SideC);
+          const double gamma = SideB.Angle(&SideH);
+          const double delta = SideC.Angle(&SideH);
+          const double MinDistance = a * sin(beta) / (sin(delta)) * (((alpha < M_PI / 2.) || (gamma < M_PI / 2.)) ? 1. : -1.);
           //*out << Verbose(2) << " I calculated: a = " << a << ", h = " << h << ", beta(" << left->second.second->Name << "," << left->second.second->Name << "-" << right->second.second->Name << ") = " << beta << ", delta(" << left->second.second->Name << "," << runner->second.second->Name << ") = " << delta << ", Min = " << MinDistance << "." << endl;
           *out << Verbose(1) << "Checking CoG distance of runner " << *runner->second.second << " " << h << " against triangle's side length spanned by (" << *left->second.second << "," << *right->second.second << ") of " << MinDistance << "." << endl;
 …
 /** Tesselates the convex boundary by finding all boundary points.
  * \param *out output stream for debugging
  * \param *mol molecule structure with Atom's and Bond's
+ * \param *mol molecule structure with Atom's and Bond's.
  * \param *TesselStruct Tesselation filled with points, lines and triangles on boundary on return
  * \param *LCList atoms in LinkedCell list
 …
  * \return *TesselStruct is filled with convex boundary and tesselation is stored under \a *filename.
  */
 void FindConvexBorder(ofstream *out, molecule* mol, class LinkedCell *LCList, const char *filename)
+void FindConvexBorder(ofstream *out, const molecule* mol, Tesselation *&TesselStruct, const LinkedCell *LCList, const char *filename)
+{
   bool BoundaryFreeFlag = false;
 …
   cout << Verbose(1) << "Begin of FindConvexBorder" << endl;
   if (mol->TesselStruct != NULL) // free if allocated
     delete(mol->TesselStruct);
   mol->TesselStruct = new class Tesselation;
+  if (TesselStruct != NULL) // free if allocated
+    delete(TesselStruct);
+  TesselStruct = new class Tesselation;
   // 1. Find all points on the boundary
   if (BoundaryPoints == NULL) {
       BoundaryFreeFlag = true;
       BoundaryPoints = GetBoundaryPoints(out, mol);
+      BoundaryPoints = GetBoundaryPoints(out, mol, TesselStruct);
   } else {
       *out << Verbose(1) << "Using given boundary points set." << endl;
 …
   for (int axis = 0; axis < NDIM; axis++)
     for (Boundaries::iterator runner = BoundaryPoints[axis].begin(); runner != BoundaryPoints[axis].end(); runner++)
         if (!mol->TesselStruct->AddBoundaryPoint(runner->second.second, 0))
+        if (!TesselStruct->AddBoundaryPoint(runner->second.second, 0))
           *out << Verbose(3) << "WARNING: Point " << *(runner->second.second) << " is already present!" << endl;
   *out << Verbose(2) << "I found " << mol->TesselStruct->PointsOnBoundaryCount << " points on the convex boundary." << endl;
+  *out << Verbose(2) << "I found " << TesselStruct->PointsOnBoundaryCount << " points on the convex boundary." << endl;
   // now we have the whole set of edge points in the BoundaryList
 …
   // 3a. guess starting triangle
   mol->TesselStruct->GuessStartingTriangle(out);
+  TesselStruct->GuessStartingTriangle(out);
   // 3b. go through all lines, that are not yet part of two triangles (only of one so far)
   mol->TesselStruct->TesselateOnBoundary(out, mol);
+  TesselStruct->TesselateOnBoundary(out, mol);
   // 3c. check whether all atoms lay inside the boundary, if not, add to boundary points, segment triangle into three with the new point
   if (!mol->TesselStruct->InsertStraddlingPoints(out, mol, LCList))
+  if (!TesselStruct->InsertStraddlingPoints(out, mol, LCList))
     *out << Verbose(1) << "Insertion of straddling points failed!" << endl;
   *out << Verbose(2) << "I created " << mol->TesselStruct->TrianglesOnBoundary.size() << " intermediate triangles with " << mol->TesselStruct->LinesOnBoundary.size() << " lines and " << mol->TesselStruct->PointsOnBoundary.size() << " points." << endl;
+  *out << Verbose(2) << "I created " << TesselStruct->TrianglesOnBoundary.size() << " intermediate triangles with " << TesselStruct->LinesOnBoundary.size() << " lines and " << TesselStruct->PointsOnBoundary.size() << " points." << endl;
   // 4. Store triangles in tecplot file
 …
       OutputName.append(TecplotSuffix);
       ofstream *tecplot = new ofstream(OutputName.c_str());
       WriteTecplotFile(out, tecplot, mol->TesselStruct, mol, 0);
+      WriteTecplotFile(out, tecplot, TesselStruct, mol, 0);
       tecplot->close();
       delete(tecplot);
 …
       OutputName.append(Raster3DSuffix);
       ofstream *rasterplot = new ofstream(OutputName.c_str());
       WriteRaster3dFile(out, rasterplot, mol->TesselStruct, mol);
+      WriteRaster3dFile(out, rasterplot, TesselStruct, mol);
       rasterplot->close();
       delete(rasterplot);
 …
   // 3d. check all baselines whether the peaks of the two adjacent triangles with respect to center of baseline are convex, if not, make the baseline between the two peaks and baseline endpoints become the new peaks
   bool AllConvex;
+  bool AllConvex = true;
   class BoundaryLineSet *line = NULL;
   do {
     AllConvex = true;
     for (LineMap::iterator LineRunner = mol->TesselStruct->LinesOnBoundary.begin(); LineRunner != mol->TesselStruct->LinesOnBoundary.end(); LineRunner++) {
+    for (LineMap::iterator LineRunner = TesselStruct->LinesOnBoundary.begin(); LineRunner != TesselStruct->LinesOnBoundary.end(); LineRunner++) {
       line = LineRunner->second;
       *out << Verbose(1) << "INFO: Current line is " << *line << "." << endl;
 …
         // flip the line
         if (mol->TesselStruct->PickFarthestofTwoBaselines(out, line) == 0.)
+        if (TesselStruct->PickFarthestofTwoBaselines(out, line) == 0.)
           *out << Verbose(1) << "ERROR: Correction of concave baselines failed!" << endl;
         else {
           mol->TesselStruct->FlipBaseline(out, line);
+          TesselStruct->FlipBaseline(out, line);
           *out << Verbose(1) << "INFO: Correction of concave baselines worked." << endl;
+        }
 …
   // 3e. we need another correction here, for TesselPoints that are below the surface (i.e. have an odd number of concave triangles surrounding it)
 //  if (!mol->TesselStruct->CorrectConcaveTesselPoints(out))
+//  if (!TesselStruct->CorrectConcaveTesselPoints(out))
 //    *out << Verbose(1) << "Correction of concave tesselpoints failed!" << endl;
   *out << Verbose(2) << "I created " << mol->TesselStruct->TrianglesOnBoundary.size() << " triangles with " << mol->TesselStruct->LinesOnBoundary.size() << " lines and " << mol->TesselStruct->PointsOnBoundary.size() << " points." << endl;
+  *out << Verbose(2) << "I created " << TesselStruct->TrianglesOnBoundary.size() << " triangles with " << TesselStruct->LinesOnBoundary.size() << " lines and " << TesselStruct->PointsOnBoundary.size() << " points." << endl;
   // 4. Store triangles in tecplot file
 …
       OutputName.append(TecplotSuffix);
       ofstream *tecplot = new ofstream(OutputName.c_str());
       WriteTecplotFile(out, tecplot, mol->TesselStruct, mol, 0);
+      WriteTecplotFile(out, tecplot, TesselStruct, mol, 0);
       tecplot->close();
       delete(tecplot);
 …
       OutputName.append(Raster3DSuffix);
       ofstream *rasterplot = new ofstream(OutputName.c_str());
       WriteRaster3dFile(out, rasterplot, mol->TesselStruct, mol);
+      WriteRaster3dFile(out, rasterplot, TesselStruct, mol);
       rasterplot->close();
       delete(rasterplot);
 …
  * \return true - all removed, false - something went wrong
  */
 bool RemoveAllBoundaryPoints(ofstream *out, class Tesselation *TesselStruct, molecule *mol, char *filename)
+bool RemoveAllBoundaryPoints(ofstream *out, class Tesselation *&TesselStruct, const molecule * const mol, const char * const filename)
+{
   int i=0;
 …
     // store envelope
     sprintf(number, "-%04d", i++);
     StoreTrianglesinFile(out, mol, filename, number);
+    StoreTrianglesinFile(out, mol, (const Tesselation *&)TesselStruct, filename, number);
+  }
 …
  * \return volume difference between the non- and the created convex envelope
  */
 double ConvexizeNonconvexEnvelope(ofstream *out, class Tesselation *TesselStruct, molecule *mol, char *filename)
+double ConvexizeNonconvexEnvelope(ofstream *out, class Tesselation *&TesselStruct, const molecule * const mol, const char * const filename)
+{
   double volume = 0;
   class BoundaryPointSet *point = NULL;
   class BoundaryLineSet *line = NULL;
   bool Concavity;
+  bool Concavity = false;
   char dummy[MAXSTRINGSIZE];
+  PointMap::iterator PointRunner, PointAdvance;
+  LineMap::iterator LineRunner, LineAdvance;
+  TriangleMap::iterator TriangleRunner, TriangleAdvance;
+  PointMap::iterator PointRunner;
+  PointMap::iterator PointAdvance;
+  LineMap::iterator LineRunner;
+  LineMap::iterator LineAdvance;
+  TriangleMap::iterator TriangleRunner;
+  TriangleMap::iterator TriangleAdvance;
+  int run = 0;
   *out << Verbose(0) << "Begin of ConvexizeNonconvexEnvelope" << endl;
 …
   // First step: RemovePointFromTesselatedSurface
-  int run = 0;
-  double tmp;
   do {
     Concavity = false;
     sprintf(dummy, "-first-%d", run);
     //CalculateConcavityPerBoundaryPoint(out, TesselStruct);
     StoreTrianglesinFile(out, mol, filename, dummy);
+    StoreTrianglesinFile(out, mol, (const Tesselation *&)TesselStruct, filename, dummy);
     PointRunner = TesselStruct->PointsOnBoundary.begin();
 …
           volume += TesselStruct->RemovePointFromTesselatedSurface(out, point);
           sprintf(dummy, "-first-%d", ++run);
           StoreTrianglesinFile(out, mol, filename, dummy);
+          StoreTrianglesinFile(out, mol, (const Tesselation *&)TesselStruct, filename, dummy);
           Concavity = true;
           break;
 …
     sprintf(dummy, "-second-%d", run);
     //CalculateConcavityPerBoundaryPoint(out, TesselStruct);
     StoreTrianglesinFile(out, mol, filename, dummy);
+    StoreTrianglesinFile(out, mol, (const Tesselation *&)TesselStruct, filename, dummy);
     // second step: PickFarthestofTwoBaselines
 …
       // take highest of both lines
       if (TesselStruct->IsConvexRectangle(out, line) == NULL) {
         tmp = TesselStruct->PickFarthestofTwoBaselines(out, line);
+        const double tmp = TesselStruct->PickFarthestofTwoBaselines(out, line);
         volume += tmp;
         if (tmp != 0) {
           mol->TesselStruct->FlipBaseline(out, line);
+        if (tmp != 0.) {
+          TesselStruct->FlipBaseline(out, line);
           Concavity = true;
+        }
 …
   CalculateConcavityPerBoundaryPoint(out, TesselStruct);
   StoreTrianglesinFile(out, mol, filename, "");
+  StoreTrianglesinFile(out, mol, (const Tesselation *&)TesselStruct, filename, "");
   // end
 …
   bool IsAngstroem = configuration->GetIsAngstroem();
   double volume = 0.;
+  double PyramidVolume = 0.;
+  double G, h;
+  Vector x, y;
+  double a, b, c;
+  Vector x;
+  Vector y;
   // 6a. Every triangle forms a pyramid with the center of gravity as its peak, sum up the volumes
 …
       y.CopyVector(runner->second->endpoints[0]->node->node);
       y.SubtractVector(runner->second->endpoints[2]->node->node);
       a = sqrt(runner->second->endpoints[0]->node->node->DistanceSquared(runner->second->endpoints[1]->node->node));
       b = sqrt(runner->second->endpoints[0]->node->node->DistanceSquared(runner->second->endpoints[2]->node->node));
       c = sqrt(runner->second->endpoints[2]->node->node->DistanceSquared(runner->second->endpoints[1]->node->node));
       G = sqrt(((a + b + c) * (a + b + c) - 2 * (a * a + b * b + c * c)) / 16.); // area of tesselated triangle
+      const double a = sqrt(runner->second->endpoints[0]->node->node->DistanceSquared(runner->second->endpoints[1]->node->node));
+      const double b = sqrt(runner->second->endpoints[0]->node->node->DistanceSquared(runner->second->endpoints[2]->node->node));
+      const double c = sqrt(runner->second->endpoints[2]->node->node->DistanceSquared(runner->second->endpoints[1]->node->node));
+      const double 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->node, runner->second->endpoints[1]->node->node, runner->second->endpoints[2]->node->node);
       x.Scale(runner->second->endpoints[1]->node->node->ScalarProduct(&x));
       h = x.Norm(); // distance of CoG to triangle
       PyramidVolume = (1. / 3.) * G * h; // this formula holds for _all_ pyramids (independent of n-edge base or (not) centered peak)
       *out << Verbose(2) << "Area of triangle is " << G << " "
+      const double h = x.Norm(); // distance of CoG to triangle
+      const double PyramidVolume = (1. / 3.) * G * h; // this formula holds for _all_ pyramids (independent of n-edge base or (not) centered peak)
+      *out << Verbose(2) << "Area of triangle is " << setprecision(10) << G << " "
           << (IsAngstroem ? "angstrom" : "atomiclength") << "^2, height is "
           << h << " and the volume is " << PyramidVolume << " "
 …
       volume += PyramidVolume;
+    }
   *out << Verbose(0) << "RESULT: The summed volume is " << setprecision(10)
+  *out << Verbose(0) << "RESULT: The summed volume is " << setprecision(6)
       << volume << " " << (IsAngstroem ? "angstrom" : "atomiclength") << "^3."
       << endl;
 …
  * \param *out output stream for debugging
  * \param *mol molecule with atoms and bonds
+ * \param *&TesselStruct Tesselation with boundary triangles
  * \param *filename prefix of filename
  * \param *extraSuffix intermediate suffix
  */
 void StoreTrianglesinFile(ofstream *out, molecule *mol, const char *filename, const char *extraSuffix)
+void StoreTrianglesinFile(ofstream *out, const molecule * const mol, const Tesselation *&TesselStruct, const char *filename, const char *extraSuffix)
+{
   // 4. Store triangles in tecplot file
 …
       OutputName.append(TecplotSuffix);
       ofstream *tecplot = new ofstream(OutputName.c_str());
       WriteTecplotFile(out, tecplot, mol->TesselStruct, mol, 0);
+      WriteTecplotFile(out, tecplot, TesselStruct, mol, 0);
       tecplot->close();
       delete(tecplot);
 …
       OutputName.append(Raster3DSuffix);
       ofstream *rasterplot = new ofstream(OutputName.c_str());
       WriteRaster3dFile(out, rasterplot, mol->TesselStruct, mol);
+      WriteRaster3dFile(out, rasterplot, TesselStruct, mol);
       rasterplot->close();
       delete(rasterplot);
 …
  * \param *configuration needed for path to store convex envelope file
  * \param *mol molecule structure representing the cluster
+ * \param *&TesselStruct Tesselation structure with triangles on return
  * \param ClusterVolume guesstimated cluster volume, if equal 0 we used VolumeOfConvexEnvelope() instead.
  * \param celldensity desired average density in final cell
  */
+void
+PrepareClustersinWater(ofstream *out, config *configuration, molecule *mol,
+    double ClusterVolume, double celldensity)
+void PrepareClustersinWater(ofstream *out, config *configuration, molecule *mol, double ClusterVolume, double celldensity)
+{
+  bool IsAngstroem = true;
+  double *GreatestDiameter = NULL;
+  Boundaries *BoundaryPoints = NULL;
+  class Tesselation *TesselStruct = NULL;
+  Vector BoxLengths;
+  int repetition[NDIM] = { 1, 1, 1 };
+  int TotalNoClusters = 1;
+  atom *Walker = NULL;
+  double totalmass = 0.;
+  double clustervolume = 0.;
+  double cellvolume = 0.;
   // transform to PAS
   mol->PrincipalAxisSystem(out, true);
+  IsAngstroem = configuration->GetIsAngstroem();
+  GreatestDiameter = GetDiametersOfCluster(out, BoundaryPoints, mol, TesselStruct, IsAngstroem);
+  BoundaryPoints = GetBoundaryPoints(out, mol, TesselStruct);
+  LinkedCell LCList(mol, 10.);
+  FindConvexBorder(out, mol, TesselStruct, &LCList, NULL);
   // some preparations beforehand
-  bool IsAngstroem = configuration->GetIsAngstroem();
-  Boundaries *BoundaryPoints = GetBoundaryPoints(out, mol);
-  class Tesselation *TesselStruct = NULL;
-  LinkedCell LCList(mol, 10.);
-  FindConvexBorder(out, mol, &LCList, NULL);
-  double clustervolume;
   if (ClusterVolume == 0)
     clustervolume = VolumeOfConvexEnvelope(out, TesselStruct, configuration);
   else
     clustervolume = ClusterVolume;
+  double *GreatestDiameter = GetDiametersOfCluster(out, BoundaryPoints, mol, IsAngstroem);
+  Vector BoxLengths;
+  int repetition[NDIM] =
+    { 1, 1, 1 };
+  int TotalNoClusters = 1;
   for (int i = 0; i < NDIM; i++)
     TotalNoClusters *= repetition[i];
   // sum up the atomic masses
+  double totalmass = 0.;
+  atom *Walker = mol->start;
+  while (Walker->next != mol->end)
+    {
+  Walker = mol->start;
+  while (Walker->next != mol->end) {
       Walker = Walker->next;
       totalmass += Walker->type->mass;
+    }
+  *out << Verbose(0) << "RESULT: The summed mass is " << setprecision(10)
+      << totalmass << " atomicmassunit." << endl;
+  *out << Verbose(0) << "RESULT: The average density is " << setprecision(10)
+      << totalmass / clustervolume << " atomicmassunit/"
+      << (IsAngstroem ? "angstrom" : "atomiclength") << "^3." << endl;
+  }
+  *out << Verbose(0) << "RESULT: The summed mass is " << setprecision(10) << totalmass << " atomicmassunit." << endl;
+  *out << Verbose(0) << "RESULT: The average density is " << setprecision(10) << totalmass / clustervolume << " atomicmassunit/" << (IsAngstroem ? "angstrom" : "atomiclength") << "^3." << endl;
   // solve cubic polynomial
+  *out << Verbose(1) << "Solving equidistant suspension in water problem ..."
+      << endl;
+  double cellvolume;
+  *out << Verbose(1) << "Solving equidistant suspension in water problem ..." << endl;
   if (IsAngstroem)
+    cellvolume = (TotalNoClusters * totalmass / SOLVENTDENSITY_A - (totalmass
+        / clustervolume)) / (celldensity - 1);
+    cellvolume = (TotalNoClusters * totalmass / SOLVENTDENSITY_A - (totalmass / clustervolume)) / (celldensity - 1);
   else
+    cellvolume = (TotalNoClusters * totalmass / SOLVENTDENSITY_a0 - (totalmass
+        / clustervolume)) / (celldensity - 1);
+  *out << Verbose(1) << "Cellvolume needed for a density of " << celldensity
+      << " g/cm^3 is " << cellvolume << " " << (IsAngstroem ? "angstrom"
+      : "atomiclength") << "^3." << endl;
+  double minimumvolume = TotalNoClusters * (GreatestDiameter[0]
+      * GreatestDiameter[1] * GreatestDiameter[2]);
+  *out << Verbose(1)
+      << "Minimum volume of the convex envelope contained in a rectangular box is "
+      << minimumvolume << " atomicmassunit/" << (IsAngstroem ? "angstrom"
+      : "atomiclength") << "^3." << endl;
+  if (minimumvolume > cellvolume)
+    {
+      cerr << Verbose(0)
+          << "ERROR: the containing box already has a greater volume than the envisaged cell volume!"
+          << endl;
+      cout << Verbose(0)
+          << "Setting Box dimensions to minimum possible, the greatest diameters."
+          << endl;
+      for (int i = 0; i < NDIM; i++)
+        BoxLengths.x[i] = GreatestDiameter[i];
+      mol->CenterEdge(out, &BoxLengths);
+    }
+  else
+    {
+      BoxLengths.x[0] = (repetition[0] * GreatestDiameter[0] + repetition[1]
+          * GreatestDiameter[1] + repetition[2] * GreatestDiameter[2]);
+      BoxLengths.x[1] = (repetition[0] * repetition[1] * GreatestDiameter[0]
+          * GreatestDiameter[1] + repetition[0] * repetition[2]
+          * GreatestDiameter[0] * GreatestDiameter[2] + repetition[1]
+          * repetition[2] * GreatestDiameter[1] * GreatestDiameter[2]);
+      BoxLengths.x[2] = minimumvolume - cellvolume;
+      double x0 = 0., x1 = 0., x2 = 0.;
+      if (gsl_poly_solve_cubic(BoxLengths.x[0], BoxLengths.x[1],
+          BoxLengths.x[2], &x0, &x1, &x2) == 1) // either 1 or 3 on return
+        *out << Verbose(0) << "RESULT: The resulting spacing is: " << x0
+            << " ." << endl;
+      else
+        {
+          *out << Verbose(0) << "RESULT: The resulting spacings are: " << x0
+              << " and " << x1 << " and " << x2 << " ." << endl;
+          x0 = x2; // sorted in ascending order
+        }
+      cellvolume = 1;
+      for (int i = 0; i < NDIM; i++)
+        {
+          BoxLengths.x[i] = repetition[i] * (x0 + GreatestDiameter[i]);
+          cellvolume *= BoxLengths.x[i];
+        }
+      // set new box dimensions
+      *out << Verbose(0) << "Translating to box with these boundaries." << endl;
+      mol->SetBoxDimension(&BoxLengths);
+      mol->CenterInBox((ofstream *) &cout);
+    }
+    cellvolume = (TotalNoClusters * totalmass / SOLVENTDENSITY_a0 - (totalmass / clustervolume)) / (celldensity - 1);
+  *out << Verbose(1) << "Cellvolume needed for a density of " << celldensity << " g/cm^3 is " << cellvolume << " " << (IsAngstroem ? "angstrom" : "atomiclength") << "^3." << endl;
+  double minimumvolume = TotalNoClusters * (GreatestDiameter[0] * GreatestDiameter[1] * GreatestDiameter[2]);
+  *out << Verbose(1) << "Minimum volume of the convex envelope contained in a rectangular box is " << minimumvolume << " atomicmassunit/" << (IsAngstroem ? "angstrom" : "atomiclength") << "^3." << endl;
+  if (minimumvolume > cellvolume) {
+    cerr << Verbose(0) << "ERROR: the containing box already has a greater volume than the envisaged cell volume!" << endl;
+    cout << Verbose(0) << "Setting Box dimensions to minimum possible, the greatest diameters." << endl;
+    for (int i = 0; i < NDIM; i++)
+      BoxLengths.x[i] = GreatestDiameter[i];
+    mol->CenterEdge(out, &BoxLengths);
+  } else {
+    BoxLengths.x[0] = (repetition[0] * GreatestDiameter[0] + repetition[1] * GreatestDiameter[1] + repetition[2] * GreatestDiameter[2]);
+    BoxLengths.x[1] = (repetition[0] * repetition[1] * GreatestDiameter[0] * GreatestDiameter[1] + repetition[0] * repetition[2] * GreatestDiameter[0] * GreatestDiameter[2] + repetition[1] * repetition[2] * GreatestDiameter[1] * GreatestDiameter[2]);
+    BoxLengths.x[2] = minimumvolume - cellvolume;
+    double x0 = 0.;
+    double x1 = 0.;
+    double x2 = 0.;
+    if (gsl_poly_solve_cubic(BoxLengths.x[0], BoxLengths.x[1], BoxLengths.x[2], &x0, &x1, &x2) == 1) // either 1 or 3 on return
+      *out << Verbose(0) << "RESULT: The resulting spacing is: " << x0 << " ." << endl;
+    else {
+      *out << Verbose(0) << "RESULT: The resulting spacings are: " << x0 << " and " << x1 << " and " << x2 << " ." << endl;
+      x0 = x2; // sorted in ascending order
+    }
+    cellvolume = 1.;
+    for (int i = 0; i < NDIM; i++) {
+      BoxLengths.x[i] = repetition[i] * (x0 + GreatestDiameter[i]);
+      cellvolume *= BoxLengths.x[i];
+    }
+    // set new box dimensions
+    *out << Verbose(0) << "Translating to box with these boundaries." << endl;
+    mol->SetBoxDimension(&BoxLengths);
+    mol->CenterInBox((ofstream *) &cout);
+  }
   // update Box of atoms by boundary
   mol->SetBoxDimension(&BoxLengths);
+  *out << Verbose(0) << "RESULT: The resulting cell dimensions are: "
+      << BoxLengths.x[0] << " and " << BoxLengths.x[1] << " and "
+      << BoxLengths.x[2] << " with total volume of " << cellvolume << " "
+      << (IsAngstroem ? "angstrom" : "atomiclength") << "^3." << endl;
+}
+;
+  *out << Verbose(0) << "RESULT: The resulting cell dimensions are: " << BoxLengths.x[0] << " and " << BoxLengths.x[1] << " and " << BoxLengths.x[2] << " with total volume of " << cellvolume << " " << (IsAngstroem ? "angstrom" : "atomiclength") << "^3." << endl;
+};
 …
   atom *Walker = NULL;
   bond *Binder = NULL;
   int i;
+  int i = 0;
   LinkedCell *LCList[List->ListOfMolecules.size()];
+  double phi[NDIM];
+  class Tesselation *TesselStruct[List->ListOfMolecules.size()];
   *out << Verbose(0) << "Begin of FillBoxWithMolecule" << endl;
 …
     *out << Verbose(1) << "Pre-creating linked cell lists for molecule " << *ListRunner << "." << endl;
     LCList[i] = new LinkedCell((*ListRunner), 5.); // get linked cell list
     if ((*ListRunner)->TesselStruct == NULL) {
+    if (TesselStruct[i] == NULL) {
       *out << Verbose(1) << "Pre-creating tesselation for molecule " << *ListRunner << "." << endl;
       FindNonConvexBorder((ofstream *)&cout, (*ListRunner), LCList[i], 5., NULL);
+      FindNonConvexBorder((ofstream *)&cout, (*ListRunner), TesselStruct[i], (const LinkedCell *&)LCList[i], 5., NULL);
+    }
     i++;
 …
   filler->CountAtoms(out);
   atom * CopyAtoms[filler->AtomCount];
-  int nr = 0;
   // calculate filler grid in [0,1]^3
 …
         for (MoleculeList::iterator ListRunner = List->ListOfMolecules.begin(); ListRunner != List->ListOfMolecules.end(); ListRunner++) {
           // get linked cell list
           if ((*ListRunner)->TesselStruct == NULL) {
+          if (TesselStruct[i] == NULL) {
             *out << Verbose(1) << "ERROR: TesselStruct of " << (*ListRunner) << " is NULL. Didn't we pre-create it?" << endl;
             FillIt = false;
+          } else
+            FillIt = FillIt && (!(*ListRunner)->TesselStruct->IsInnerPoint(out, CurrentPosition, LCList[i++]));
+          } else {
+            FillIt = FillIt && (!TesselStruct[i]->IsInnerPoint(out, CurrentPosition, LCList[i]));
+            i++;
+          }
+        }
 …
           // go through all atoms
-          nr=0;
           Walker = filler->start;
           while (Walker->next != filler->end) {
 …
             // ... and rotation matrix
             if (DoRandomRotation) {
-              double phi[NDIM];
               for (int i=0;i<NDIM;i++) {
                 phi[i] = rand()/(RAND_MAX/(2.*M_PI));
 …
  * \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 atoms in LinkedCell list
+ * \param *&TesselStruct Tesselation filled with points, lines and triangles on boundary on return
+ * \param *&LCList atoms in LinkedCell list
  * \param RADIUS radius of the virtual sphere
  * \param *filename filename prefix for output of vertex data
  */
 void FindNonConvexBorder(ofstream *out, molecule* mol, class LinkedCell *LCList, const double RADIUS, const char *filename = NULL)
+void FindNonConvexBorder(ofstream *out, const molecule* const mol, Tesselation *&TesselStruct, const LinkedCell *&LCList, const double RADIUS, const char *filename = NULL)
+{
   bool freeLC = false;
-  *out << Verbose(1) << "Entering search for non convex hull. " << endl;
-  if (mol->TesselStruct == NULL) {
-    *out << Verbose(1) << "Allocating Tesselation struct ..." << endl;
-    mol->TesselStruct = new Tesselation;
-  } else {
-    delete(mol->TesselStruct);
-    *out << Verbose(1) << "Re-Allocating Tesselation struct ..." << endl;
-    mol->TesselStruct = new Tesselation;
+  }
   LineMap::iterator baseline;
   LineMap::iterator testline;
-  *out << Verbose(0) << "Begin of FindNonConvexBorder\n";
   bool OneLoopWithoutSuccessFlag = false;  // marks whether we went once through all baselines without finding any without two triangles
   bool TesselationFailFlag = false;
+  *out << Verbose(1) << "Entering search for non convex hull. " << endl;
+  if (TesselStruct == NULL) {
+    *out << Verbose(1) << "Allocating Tesselation struct ..." << endl;
+    TesselStruct= new Tesselation;
+  } else {
+    delete(TesselStruct);
+    *out << Verbose(1) << "Re-Allocating Tesselation struct ..." << endl;
+    TesselStruct = new Tesselation;
+  }
+  *out << Verbose(0) << "Begin of FindNonConvexBorder\n";
   // initialise Linked Cell
 …
   // 1. get starting triangle
   mol->TesselStruct->FindStartingTriangle(out, RADIUS, LCList);
+  TesselStruct->FindStartingTriangle(out, RADIUS, LCList);
   // 2. expand from there
   baseline = mol->TesselStruct->LinesOnBoundary.begin();
+  baseline = TesselStruct->LinesOnBoundary.begin();
   baseline++; // skip first line
   while ((baseline != mol->TesselStruct->LinesOnBoundary.end()) || (OneLoopWithoutSuccessFlag)) {
+  while ((baseline != TesselStruct->LinesOnBoundary.end()) || (OneLoopWithoutSuccessFlag)) {
     if (baseline->second->triangles.size() == 1) {
       // 3. find next triangle
       TesselationFailFlag = mol->TesselStruct->FindNextSuitableTriangle(out, *(baseline->second), *(((baseline->second->triangles.begin()))->second), RADIUS, LCList); //the line is there, so there is a triangle, but only one.
+      TesselationFailFlag = TesselStruct->FindNextSuitableTriangle(out, *(baseline->second), *(((baseline->second->triangles.begin()))->second), RADIUS, LCList); //the line is there, so there is a triangle, but only one.
       OneLoopWithoutSuccessFlag = OneLoopWithoutSuccessFlag || TesselationFailFlag;
       if (!TesselationFailFlag)
 …
       // write temporary envelope
       if (filename != NULL) {
         if ((DoSingleStepOutput && ((mol->TesselStruct->TrianglesOnBoundary.size() % SingleStepWidth == 0)))) { // if we have a new triangle and want to output each new triangle configuration
           mol->TesselStruct->Output(out, filename, mol);
+        if ((DoSingleStepOutput && ((TesselStruct->TrianglesOnBoundary.size() % SingleStepWidth == 0)))) { // if we have a new triangle and want to output each new triangle configuration
+          TesselStruct->Output(out, filename, mol);
+        }
+      }
       baseline = mol->TesselStruct->LinesOnBoundary.end();
+      baseline = TesselStruct->LinesOnBoundary.end();
       *out << Verbose(2) << "Baseline set to end." << endl;
     } else {
 …
+    }
     if ((baseline == mol->TesselStruct->LinesOnBoundary.end()) && (OneLoopWithoutSuccessFlag)) {
       baseline = mol->TesselStruct->LinesOnBoundary.begin();   // restart if we reach end due to newly inserted lines
+    if ((baseline == TesselStruct->LinesOnBoundary.end()) && (OneLoopWithoutSuccessFlag)) {
+      baseline = TesselStruct->LinesOnBoundary.begin();   // restart if we reach end due to newly inserted lines
       OneLoopWithoutSuccessFlag = false;
+    }
 …
+  }
   // check envelope for consistency
   CheckListOfBaselines(out, mol->TesselStruct);
+  CheckListOfBaselines(out, TesselStruct);
   // look whether all points are inside of the convex envelope, otherwise add them via degenerated triangles
   //mol->TesselStruct->InsertStraddlingPoints(out, mol, LCList);
+  //->InsertStraddlingPoints(out, mol, LCList);
 //  mol->GoToFirst();
 //  class TesselPoint *Runner = NULL;
 …
 //    Runner = mol->GetPoint();
 //    *out << Verbose(1) << "Checking on " << Runner->Name << " ... " << endl;
 //    if (!mol->TesselStruct->IsInnerPoint(out, Runner, LCList)) {
+//    if (!->IsInnerPoint(out, Runner, LCList)) {
 //      *out << Verbose(2) << Runner->Name << " is outside of envelope, adding via degenerated triangles." << endl;
 //      mol->TesselStruct->AddBoundaryPointByDegeneratedTriangle(out, Runner, LCList);
+//      ->AddBoundaryPointByDegeneratedTriangle(out, Runner, LCList);
 //    } else {
 //      *out << Verbose(2) << Runner->Name << " is inside of or on envelope." << endl;
 …
   // Purges surplus triangles.
   mol->TesselStruct->RemoveDegeneratedTriangles();
+  TesselStruct->RemoveDegeneratedTriangles();
   // check envelope for consistency
   CheckListOfBaselines(out, mol->TesselStruct);
+  CheckListOfBaselines(out, TesselStruct);
   // write final envelope
   CalculateConcavityPerBoundaryPoint(out, mol->TesselStruct);
   StoreTrianglesinFile(out, mol, filename, "");
+  CalculateConcavityPerBoundaryPoint(out, TesselStruct);
+  StoreTrianglesinFile(out, mol, (const Tesselation *&)TesselStruct, filename, "");
   if (freeLC)
 …
 /** Finds a hole of sufficient size in \a this molecule to embed \a *srcmol into it.
+/** Finds a hole of sufficient size in \a *mols to embed \a *srcmol into it.
  * \param *out output stream for debugging
+ * \param *srcmol molecule to embed into
+ * \param *mols molecules in the domain to embed in between
+ * \param *srcmol embedding molecule
  * \return *Vector new center of \a *srcmol for embedding relative to \a this
  */
 Vector* molecule::FindEmbeddingHole(ofstream *out, molecule *srcmol)
+Vector* FindEmbeddingHole(ofstream *out, MoleculeListClass *mols, molecule *srcmol)
+{
   Vector *Center = new Vector;

src/boundary.hpp

-              r06c7a3
+              r7326b2
 /********************************************** declarations *******************************/
+double ConvexizeNonconvexEnvelope(ofstream *out, class Tesselation *&TesselStruct, const molecule * const mol, const char * const filename);
+molecule * FillBoxWithMolecule(ofstream *out, MoleculeListClass *List, molecule *filler, config &configuration, double distance[NDIM], double RandAtomDisplacement, double RandMolDisplacement, bool DoRandomRotation);
+void FindConvexBorder(ofstream *out, const molecule* const mol, Tesselation *&TesselStruct, const LinkedCell *LCList, const char *filename);
+Vector* FindEmbeddingHole(ofstream *out, MoleculeListClass *mols, molecule *srcmol);
+void FindNextSuitablePoint(class BoundaryTriangleSet *BaseTriangle, class BoundaryLineSet *BaseLine, atom*& OptCandidate, Vector *OptCandidateCenter, double *ShortestAngle, const double RADIUS, LinkedCell *LC);
+void FindNonConvexBorder(ofstream *out, const molecule* const mol, Tesselation *&TesselStruct, const LinkedCell *&LC, const double RADIUS, const char *tempbasename);
+Boundaries *GetBoundaryPoints(ofstream *out, const molecule *mol, Tesselation *&TesselStruct);
+double * GetDiametersOfCluster(ofstream *out, const Boundaries *BoundaryPtr, const molecule *mol, Tesselation *&TesselStruct, const bool IsAngstroem);
+void PrepareClustersinWater(ofstream *out, config *configuration, molecule *mol, double ClusterVolume, double celldensity);
+bool RemoveAllBoundaryPoints(ofstream *out, class Tesselation *&TesselStruct, const molecule * const mol, const char * const filename);
+void StoreTrianglesinFile(ofstream *out, const molecule * const mol, const Tesselation *&TesselStruct, const char *filename, const char *extraSuffix);
 double VolumeOfConvexEnvelope(ofstream *out, class Tesselation *TesselStruct, class config *configuration);
-double * GetDiametersOfCluster(ofstream *out, Boundaries *BoundaryPtr, molecule *mol, bool IsAngstroem);
-void PrepareClustersinWater(ofstream *out, config *configuration, molecule *mol, double ClusterVolume, double celldensity);
-molecule * FillBoxWithMolecule(ofstream *out, MoleculeListClass *List, molecule *filler, config &configuration, double distance[NDIM], double RandAtomDisplacement, double RandMolDisplacement, bool DoRandomRotation);
-void FindConvexBorder(ofstream *out, molecule* mol, class LinkedCell *LCList, const char *filename);
-void FindNonConvexBorder(ofstream *out, molecule* mol, class LinkedCell *LC, const double RADIUS, const char *tempbasename);
-double ConvexizeNonconvexEnvelope(ofstream *out, class Tesselation *TesselStruct, molecule *mol, char *filename);
-void FindNextSuitablePoint(class BoundaryTriangleSet *BaseTriangle, class BoundaryLineSet *BaseLine, atom*& OptCandidate, Vector *OptCandidateCenter, double *ShortestAngle, const double RADIUS, LinkedCell *LC);
-Boundaries *GetBoundaryPoints(ofstream *out, molecule *mol);
-void StoreTrianglesinFile(ofstream *out, molecule *mol, const char *filename, const char *extraSuffix);
-bool RemoveAllBoundaryPoints(ofstream *out, class Tesselation *TesselStruct, molecule *mol, char *filename);

src/builder.cpp

-              r06c7a3
+              r7326b2
 using namespace std;
+#include "analysis_correlation.hpp"
 #include "atom.hpp"
 #include "bond.hpp"
+#include "bondgraph.hpp"
 #include "boundary.hpp"
 #include "config.hpp"
 …
         } while ((j != -1) && (i<128));
         if (i >= 2) {
           first->x.LSQdistance(atoms, i);
+          first->x.LSQdistance((const Vector **)atoms, i);
           first->x.Output((ofstream *)&cout);
 …
+      {
         cout << Verbose(0) << "Evaluating volume of the convex envelope.";
-        LinkedCell LCList(mol, 10.);
         class Tesselation *TesselStruct = NULL;
+        FindConvexBorder((ofstream *)&cout, mol, &LCList, NULL);
+        const LinkedCell *LCList = NULL;
+        LCList = new LinkedCell(mol, 10.);
+        FindConvexBorder((ofstream *)&cout, mol, TesselStruct, LCList, NULL);
         double clustervolume = VolumeOfConvexEnvelope((ofstream *)&cout, TesselStruct, configuration);
+        cout << Verbose(0) << "The tesselated surface area is " << clustervolume << "." << endl;
+        cout << Verbose(0) << "The tesselated surface area is " << clustervolume << "." << endl;\
+        delete(LCList);
         delete(TesselStruct);
+      }
 …
        cin >> factor[2];
        valid = true;
        mol->Scale(&factor);
+       mol->Scale((const double ** const)&factor);
        delete[](factor);
+      }
 …
+          }
           if (mol->first->next != mol->last) // if connect matrix is present already, redo it
             mol->CreateAdjacencyList((ofstream *)&cout, mol->BondDistance, configuration->GetIsAngstroem());
+            mol->CreateAdjacencyList((ofstream *)&cout, mol->BondDistance, configuration->GetIsAngstroem(), &BondGraph::CovalentMinMaxDistance, NULL);
           // free memory
           delete[](Elements);
 …
           cin >> bonddistance;
           start = clock();
+          mol->CreateAdjacencyList((ofstream *)&cout, bonddistance, configuration->GetIsAngstroem());
+          mol->CreateListOfBondsPerAtom((ofstream *)&cout);
+          mol->CreateAdjacencyList((ofstream *)&cout, bonddistance, configuration->GetIsAngstroem(), &BondGraph::CovalentMinMaxDistance, NULL);
           end = clock();
           cout << Verbose(0) << "Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s." << endl;
 …
   // translate each to its center and merge all molecules in MoleculeListClass into this molecule
   int N = molecules->ListOfMolecules.size();
   int *src = new int(N);
+  int *src = new int[N];
   N=0;
   for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++) {
 …
+  }
   molecules->SimpleMultiAdd(mol, src, N);
   delete(src);
+  delete[](src);
   // ... and translate back
 …
   int argptr;
   molecule *mol = NULL;
+  string BondGraphFileName("");
   strncpy(configuration.databasepath, LocalPath, MAXSTRINGSIZE-1);
 …
             cout << "\t-B xx xy xz yy yz zz\tBound atoms by domain with given symmetric matrix of (xx,xy,xz,yy,yz,zz)." << endl;
             cout << "\t-c x1 x2 x3\tCenter atoms in domain with a minimum distance to boundary of (x1,x2,x3)." << endl;
+            cout << "\t-C\tPair Correlation analysis." << endl;
             cout << "\t-d x1 x2 x3\tDuplicate cell along each axis by given factor." << endl;
             cout << "\t-D <bond distance>\tDepth-First-Search Analysis of the molecule, giving cycles and tree/back edges." << endl;
 …
             cout << "\t-E <id> <Z>\tChange atom <id>'s element to <Z>, <id> begins at 0." << endl;
             cout << "\t-f/F <dist> <order>\tFragments the molecule in BOSSANOVA manner (with/out rings compressed) and stores config files in same dir as config (return code 0 - fragmented, 2 - no fragmentation necessary)." << endl;
+            cout << "\t-g <file>\tParses a bond length table from the given file." << endl;
             cout << "\t-h/-H/-?\tGive this help screen." << endl;
             cout << "\t-L <step0> <step1> <prefix>\tStore a linear interpolation between two configurations <step0> and <step1> into single config files with prefix <prefix> and as Trajectories into the current config file." << endl;
 …
+            }
             break;
+          case 'g':
+            if ((argptr >= argc) || (argv[argptr][0] == '-')) {
+              cerr << "Not enough or invalid arguments for specifying bond length table: -g <table file>" << endl;
+            } else {
+              BondGraphFileName = argv[argptr];
+              cout << "Using " << BondGraphFileName << " as bond length table." << endl;
+              argptr+=1;
+            }
+            break;
           case 'n':
             cout << "I won't parse trajectories." << endl;
 …
     } while (argptr < argc);
     // 2. Parse the element database
+    // 3a. Parse the element database
     if (periode->LoadPeriodentafel(configuration.databasepath)) {
       cout << Verbose(0) << "Element list loaded successfully." << endl;
 …
       return 1;
+    }
     // 3. Find config file name and parse if possible
+    // 3b. Find config file name and parse if possible, also BondGraphFileName
     if (argv[1][0] != '-') {
       // simply create a new molecule, wherein the config file is loaded and the manipulation takes place
-      mol = new molecule(periode);
-      mol->ActiveFlag = true;
-      molecules->insert(mol);
       cout << Verbose(0) << "Config file given." << endl;
       test.open(argv[1], ios::in);
 …
         ConfigFileName = argv[1];
         cout << Verbose(1) << "Specified config file found, parsing ... ";
         switch (configuration.TestSyntax(ConfigFileName, periode, mol)) {
+        switch (configuration.TestSyntax(ConfigFileName, periode)) {
           case 1:
             cout << "new syntax." << endl;
             configuration.Load(ConfigFileName, periode, mol);
+            configuration.Load(ConfigFileName, BondGraphFileName, periode, molecules);
             configPresent = present;
             break;
           case 0:
             cout << "old syntax." << endl;
             configuration.LoadOld(ConfigFileName, periode, mol);
+            configuration.LoadOld(ConfigFileName, BondGraphFileName, periode, molecules);
             configPresent = present;
             break;
 …
     } else
       configPresent = absent;
+     // set mol to first active molecule
+     if (molecules->ListOfMolecules.size() != 0) {
+       for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+         if ((*ListRunner)->ActiveFlag) {
+           mol = *ListRunner;
+           break;
+         }
+     }
+     if (mol == NULL) {
+       mol = new molecule(periode);
+       mol->ActiveFlag = true;
+       molecules->insert(mol);
+     }
     // 4. parse again through options, now for those depending on elements db and config presence
     argptr = 1;
 …
             case 'a':
               if (ExitFlag == 0) ExitFlag = 1;
               if ((argptr >= argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr+1]))) {
+              if ((argptr >= argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) || (!IsValidNumber(argv[argptr+3]))) {
                 ExitFlag = 255;
                 cerr << "Not enough or invalid arguments for adding atom: -a <element> <x> <y> <z>" << endl;
 …
                 int *MinimumRingSize = new int[mol->AtomCount];
                 atom ***ListOfLocalAtoms = NULL;
-                int FragmentCounter = 0;
                 class StackClass<bond *> *BackEdgeStack = NULL;
                 class StackClass<bond *> *LocalBackEdgeStack = NULL;
+                mol->CreateAdjacencyList((ofstream *)&cout, atof(argv[argptr]), configuration.GetIsAngstroem());
+                mol->CreateListOfBondsPerAtom((ofstream *)&cout);
+                mol->CreateAdjacencyList((ofstream *)&cout, atof(argv[argptr]), configuration.GetIsAngstroem(), &BondGraph::CovalentMinMaxDistance, NULL);
                 Subgraphs = mol->DepthFirstSearchAnalysis((ofstream *)&cout, BackEdgeStack);
                 if (Subgraphs != NULL) {
                   Subgraphs->next->FillBondStructureFromReference((ofstream *)&cout, mol, (FragmentCounter = 0), ListOfLocalAtoms, false);  // we want to keep the created ListOfLocalAtoms
+                  int FragmentCounter = 0;
                   while (Subgraphs->next != NULL) {
                     Subgraphs = Subgraphs->next;
+                    Subgraphs->FillBondStructureFromReference((ofstream *)&cout, mol, FragmentCounter, ListOfLocalAtoms, false);  // we want to keep the created ListOfLocalAtoms
                     LocalBackEdgeStack = new StackClass<bond *> (Subgraphs->Leaf->BondCount);
                     Subgraphs->Leaf->PickLocalBackEdges((ofstream *)&cout, ListOfLocalAtoms[FragmentCounter++], BackEdgeStack, LocalBackEdgeStack);
                     Subgraphs->Leaf->CyclicStructureAnalysis((ofstream *)&cout, BackEdgeStack, MinimumRingSize);
+                    Subgraphs->Leaf->PickLocalBackEdges((ofstream *)&cout, ListOfLocalAtoms[FragmentCounter], BackEdgeStack, LocalBackEdgeStack);
+                    Subgraphs->Leaf->CyclicStructureAnalysis((ofstream *)&cout, LocalBackEdgeStack, MinimumRingSize);
                     delete(LocalBackEdgeStack);
                     delete(Subgraphs->previous);
+                    FragmentCounter++;
+                  }
                   delete(Subgraphs);
                   for (int i=0;i<FragmentCounter;i++)
                     Free(&ListOfLocalAtoms[FragmentCounter]);
+                    Free(&ListOfLocalAtoms[i]);
                   Free(&ListOfLocalAtoms);
+                }
 …
+              }
               //argptr+=1;
+              break;
+            case 'C':
+              if (ExitFlag == 0) ExitFlag = 1;
+              if ((argptr+2 >= argc) || (!IsValidNumber(argv[argptr])) || (argv[argptr][0] == '-') || (argv[argptr+1][0] == '-') || (argv[argptr+2][0] == '-')) {
+                ExitFlag = 255;
+                cerr << "Not enough or invalid arguments given for pair correlation analysis: -C <Z> <output> <bin output>" << endl;
+              } else {
+                SaveFlag = false;
+                ofstream output(argv[argptr+1]);
+                ofstream binoutput(argv[argptr+2]);
+                const double radius = 5.;
+                // get the boundary
+                class molecule *Boundary = NULL;
+                class Tesselation *TesselStruct = NULL;
+                const LinkedCell *LCList = NULL;
+                // find biggest molecule
+                int counter  = 0;
+                for (MoleculeList::iterator BigFinder = molecules->ListOfMolecules.begin(); BigFinder != molecules->ListOfMolecules.end(); BigFinder++) {
+                  if ((Boundary == NULL) || (Boundary->AtomCount < (*BigFinder)->AtomCount)) {
+                    Boundary = *BigFinder;
+                  }
+                  counter++;
+                }
+                bool *Actives = Malloc<bool>(counter, "ParseCommandLineOptions() - case C -- *Actives");
+                counter = 0;
+                for (MoleculeList::iterator BigFinder = molecules->ListOfMolecules.begin(); BigFinder != molecules->ListOfMolecules.end(); BigFinder++) {
+                  Actives[counter] = (*BigFinder)->ActiveFlag;
+                  (*BigFinder)->ActiveFlag = (*BigFinder == Boundary) ? false : true;
+                }
+                LCList = new LinkedCell(Boundary, 2.*radius);
+                element *elemental = periode->FindElement((const int) atoi(argv[argptr]));
+                FindNonConvexBorder((ofstream *)&cout, Boundary, TesselStruct, LCList, radius, NULL);
+                int ranges[NDIM] = {1,1,1};
+                CorrelationToSurfaceMap *surfacemap = PeriodicCorrelationToSurface( (ofstream *)&cout, molecules, elemental, TesselStruct, LCList, ranges );
+                BinPairMap *binmap = BinData( (ofstream *)&cout, surfacemap, 0.5, 0., 0. );
+                OutputCorrelation ( &binoutput, binmap );
+                output.close();
+                binoutput.close();
+                for (MoleculeList::iterator BigFinder = molecules->ListOfMolecules.begin(); BigFinder != molecules->ListOfMolecules.end(); BigFinder++)
+                  (*BigFinder)->ActiveFlag = Actives[counter];
+                Free(&Actives);
+                delete(LCList);
+                delete(TesselStruct);
+                argptr+=3;
+              }
               break;
             case 'E':
 …
                 cout << "Parsing bonds from " << argv[argptr] << "." << endl;
                 ifstream *input = new ifstream(argv[argptr]);
                 mol->CreateAdjacencyList2((ofstream *)&cout, input);
+                mol->CreateAdjacencyListFromDbondFile((ofstream *)&cout, input);
                 input->close();
                 argptr+=1;
 …
                 cerr << "Not enough or invalid arguments given for non-convex envelope: -o <radius> <tecplot output file>" << endl;
               } else {
+                class Tesselation T;
+                class Tesselation *T = NULL;
+                const LinkedCell *LCList = NULL;
                 string filename(argv[argptr+1]);
                 filename.append(".csv");
 …
                 cout << Verbose(1) << "Using rolling ball of radius " << atof(argv[argptr]) << " and storing tecplot data in " << argv[argptr+1] << "." << endl;
                 start = clock();
                 LinkedCell LCList(mol, atof(argv[argptr])*2.);
                 FindNonConvexBorder((ofstream *)&cout, mol, &LCList, atof(argv[argptr]), argv[argptr+1]);
                 //FindDistributionOfEllipsoids((ofstream *)&cout, &T, &LCList, N, number, filename.c_str());
+                LCList = new LinkedCell(mol, atof(argv[argptr])*2.);
+                FindNonConvexBorder((ofstream *)&cout, mol, T, LCList, atof(argv[argptr]), argv[argptr+1]);
+                //FindDistributionOfEllipsoids((ofstream *)&cout, T, &LCList, N, number, filename.c_str());
                 end = clock();
                 cout << Verbose(0) << "Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s." << endl;
+                delete(LCList);
                 argptr+=2;
+              }
 …
             case 't':
               if (ExitFlag == 0) ExitFlag = 1;
               if ((argptr+2 >= argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
+              if ((argptr+2 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
                 ExitFlag = 255;
                 cerr << "Not enough or invalid arguments given for translation: -t <x> <y> <z>" << endl;
 …
             case 'T':
               if (ExitFlag == 0) ExitFlag = 1;
               if ((argptr+2 >= argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
+              if ((argptr+2 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
                 ExitFlag = 255;
                 cerr << "Not enough or invalid arguments given for periodic translation: -T <x> <y> <z>" << endl;
 …
             case 's':
               if (ExitFlag == 0) ExitFlag = 1;
               if ((argptr >= argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr])) ) {
+              if ((argptr >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
                 ExitFlag = 255;
                 cerr << "Not enough or invalid arguments given for scaling: -s <factor/[factor_x]> [factor_y] [factor_z]" << endl;
+                cerr << "Not enough or invalid arguments given for scaling: -s <factor_x> [factor_y] [factor_z]" << endl;
               } else {
                 SaveFlag = true;
 …
                 factor = new double[NDIM];
                 factor[0] = atof(argv[argptr]);
+                if ((argptr < argc) && (IsValidNumber(argv[argptr])))
+                  argptr++;
+                factor[1] = atof(argv[argptr]);
+                if ((argptr < argc) && (IsValidNumber(argv[argptr])))
+                  argptr++;
+                factor[2] = atof(argv[argptr]);
+                mol->Scale(&factor);
+                factor[1] = atof(argv[argptr+1]);
+                factor[2] = atof(argv[argptr+2]);
+                mol->Scale((const double ** const)&factor);
                 for (int i=0;i<NDIM;i++) {
                   j += i+1;
 …
+                }
                 delete[](factor);
                 argptr+=1;
+                argptr+=3;
+              }
               break;
 …
                 cout << Verbose(0) << "Creating connection matrix..." << endl;
                 start = clock();
                 mol->CreateAdjacencyList((ofstream *)&cout, atof(argv[argptr++]), configuration.GetIsAngstroem());
+                mol->CreateAdjacencyList((ofstream *)&cout, atof(argv[argptr++]), configuration.GetIsAngstroem(), &BondGraph::CovalentMinMaxDistance, NULL);
                 cout << Verbose(0) << "Fragmenting molecule with current connection matrix ..." << endl;
                 if (mol->first->next != mol->last) {
 …
                 cerr << "Not enough or invalid arguments given for convex envelope: -o <convex output file> <non-convex output file>" << endl;
               } else {
+                class Tesselation *TesselStruct = NULL;
+                const LinkedCell *LCList = NULL;
                 cout << Verbose(0) << "Evaluating volume of the convex envelope.";
                 cout << Verbose(1) << "Storing tecplot convex data in " << argv[argptr] << "." << endl;
                 cout << Verbose(1) << "Storing tecplot non-convex data in " << argv[argptr+1] << "." << endl;
                 LinkedCell LCList(mol, 10.);
                 //FindConvexBorder((ofstream *)&cout, mol, &LCList, argv[argptr]);
                 FindNonConvexBorder((ofstream *)&cout, mol, &LCList, 5., argv[argptr+1]);
 //                RemoveAllBoundaryPoints((ofstream *)&cout, mol->TesselStruct, mol, argv[argptr]);
                 double volumedifference = ConvexizeNonconvexEnvelope((ofstream *)&cout, mol->TesselStruct, mol, argv[argptr]);
                 double clustervolume = VolumeOfConvexEnvelope((ofstream *)&cout, mol->TesselStruct, &configuration);
+                LCList = new LinkedCell(mol, 10.);
+                //FindConvexBorder((ofstream *)&cout, mol, LCList, argv[argptr]);
+                FindNonConvexBorder((ofstream *)&cout, mol, TesselStruct, LCList, 5., argv[argptr+1]);
+//                RemoveAllBoundaryPoints((ofstream *)&cout, TesselStruct, mol, argv[argptr]);
+                double volumedifference = ConvexizeNonconvexEnvelope((ofstream *)&cout, TesselStruct, mol, argv[argptr]);
+                double clustervolume = VolumeOfConvexEnvelope((ofstream *)&cout, TesselStruct, &configuration);
                 cout << Verbose(0) << "The tesselated volume area is " << clustervolume << " " << (configuration.GetIsAngstroem() ? "angstrom" : "atomiclength") << "^3." << endl;
                 cout << Verbose(0) << "The non-convex tesselated volume area is " << clustervolume-volumedifference << " " << (configuration.GetIsAngstroem() ? "angstrom" : "atomiclength") << "^3." << endl;
+                delete(TesselStruct);
+                delete(LCList);
                 argptr+=2;
+              }
 …
   MoleculeListClass *molecules = new MoleculeListClass;  // list of all molecules
   molecule *mol = NULL;
   config configuration;
+  config *configuration = new config;
   char choice;  // menu choice char
   Vector x,y,z,n;  // coordinates for absolute point in cell volume
 …
   // =========================== PARSE COMMAND LINE OPTIONS ====================================
   j = ParseCommandLineOptions(argc, argv, molecules, periode, configuration, ConfigFileName);
+  j = ParseCommandLineOptions(argc, argv, molecules, periode, *configuration, ConfigFileName);
   switch(j) {
     case 255:  // something went wrong
+    case 2:  // just for -f option
+    case 1:  // just for -v and -h options
       delete(molecules); // also free's all molecules contained
       delete(periode);
+      delete(configuration);
       cout << Verbose(0) <<  "Maximum of allocated memory: "
         << MemoryUsageObserver::getInstance()->getMaximumUsedMemory() << endl;
       cout << Verbose(0) <<  "Remaining non-freed memory: "
         << MemoryUsageObserver::getInstance()->getUsedMemorySize() << endl;
+     return j;
+      break;
+    case 1:  // just for -v and -h options
+      delete(molecules); // also free's all molecules contained
+      delete(periode);
+      cout << Verbose(0) <<  "Maximum of allocated memory: "
+        << MemoryUsageObserver::getInstance()->getMaximumUsedMemory() << endl;
+      cout << Verbose(0) <<  "Remaining non-freed memory: "
+        << MemoryUsageObserver::getInstance()->getUsedMemorySize() << endl;
+      return 0;
+      break;
+    case 2:  // just for -f option
+      delete(molecules); // also free's all molecules contained
+      delete(periode);
+      cout << Verbose(0) <<  "Maximum of allocated memory: "
+        << MemoryUsageObserver::getInstance()->getMaximumUsedMemory() << endl;
+      cout << Verbose(0) <<  "Remaining non-freed memory: "
+        << MemoryUsageObserver::getInstance()->getUsedMemorySize() << endl;
+      return 2;
+      break;
+      MemoryUsageObserver::getInstance()->purgeInstance();
+     return (j == 1 ? 0 : j);
     default:
       break;
 …
+      }
+    }
+    mol->ActiveFlag = true;
     molecules->insert(mol);
+  }
 …
       case 'c': // edit each field of the configuration
        configuration.Edit();
+       configuration->Edit();
        break;
 …
       case 'g': // manipulate molecules
         ManipulateMolecules(periode, molecules, &configuration);
+        ManipulateMolecules(periode, molecules, configuration);
         break;
 …
       case 'm': // manipulate atoms
         ManipulateAtoms(periode, molecules, &configuration);
+        ManipulateAtoms(periode, molecules, configuration);
         break;
 …
       case 's': // save to config file
         SaveConfig(ConfigFileName, &configuration, periode, molecules);
+        SaveConfig(ConfigFileName, configuration, periode, molecules);
         break;
 …
   // save element data base
   if (periode->StorePeriodentafel(configuration.databasepath)) //ElementsFileName
+  if (periode->StorePeriodentafel(configuration->databasepath)) //ElementsFileName
     cout << Verbose(0) << "Saving of elements.db successful." << endl;
   else
 …
   delete(molecules); // also free's all molecules contained
   delete(periode);
+  delete(configuration);
   cout << Verbose(0) <<  "Maximum of allocated memory: "
 …
   cout << Verbose(0) <<  "Remaining non-freed memory: "
     << MemoryUsageObserver::getInstance()->getUsedMemorySize() << endl;
+  MemoryUsageObserver::purgeInstance();
   return (0);

src/config.cpp

Property mode changed from 100755 to 100644

-              r06c7a3
+              r7326b2
 #include "config.hpp"
 #include "element.hpp"
+#include "helpers.hpp"
+#include "lists.hpp"
+#include "molecule.hpp"
 #include "memoryallocator.hpp"
 #include "molecule.hpp"
 …
 /** Constructor for ConfigFileBuffer class.
  */
 ConfigFileBuffer::ConfigFileBuffer()
+ConfigFileBuffer::ConfigFileBuffer() : buffer(NULL), LineMapping(NULL), CurrentLine(0), NoLines(0)
+{
+  NoLines = 0;
+  CurrentLine = 0;
+  buffer = NULL;
+  LineMapping = NULL;
+}
+};
 /** Constructor for ConfigFileBuffer class with filename to be parsed.
  * \param *filename file name
  */
 ConfigFileBuffer::ConfigFileBuffer(char *filename)
+ConfigFileBuffer::ConfigFileBuffer(const char * const filename) : buffer(NULL), LineMapping(NULL), CurrentLine(0), NoLines(0)
+{
-  NoLines = 0;
-  CurrentLine = 0;
-  buffer = NULL;
-  LineMapping = NULL;
   ifstream *file = NULL;
   char line[MAXSTRINGSIZE];
 …
  * \param NoAtoms of subsequent lines to look at
  */
 void ConfigFileBuffer::MapIonTypesInBuffer(int NoAtoms)
+void ConfigFileBuffer::MapIonTypesInBuffer(const int NoAtoms)
+{
   map<const char *, int, IonTypeCompare> LineList;
 …
 /** Constructor for config file class.
  */
+config::config()
+{
+config::config() : BG(NULL), PsiType(0), MaxPsiDouble(0), PsiMaxNoUp(0), PsiMaxNoDown(0), MaxMinStopStep(1), InitMaxMinStopStep(1), ProcPEGamma(8), ProcPEPsi(1), configpath(NULL),
+    configname(NULL), FastParsing(false), Deltat(0.01), basis(""), databasepath(NULL), DoConstrainedMD(0), MaxOuterStep(0), Thermostat(4), ThermostatImplemented(NULL),
+    ThermostatNames(NULL), TempFrequency(2.5), alpha(0.), HooverMass(0.), TargetTemp(0.00095004455), ScaleTempStep(25),  mainname(NULL), defaultpath(NULL), pseudopotpath(NULL),
+    DoOutVis(0), DoOutMes(1), DoOutNICS(0), DoOutOrbitals(0), DoOutCurrent(0), DoFullCurrent(0), DoPerturbation(0), DoWannier(0), CommonWannier(0), SawtoothStart(0.01),
+    VectorPlane(0), VectorCut(0.), UseAddGramSch(1), Seed(1), OutVisStep(10), OutSrcStep(5), MaxPsiStep(0), EpsWannier(1e-7), MaxMinStep(100), RelEpsTotalEnergy(1e-7),
+    RelEpsKineticEnergy(1e-5), MaxMinGapStopStep(0), MaxInitMinStep(100), InitRelEpsTotalEnergy(1e-5), InitRelEpsKineticEnergy(1e-4), InitMaxMinGapStopStep(0), ECut(128.),
+    MaxLevel(5), RiemannTensor(0), LevRFactor(0), RiemannLevel(0), Lev0Factor(2), RTActualUse(0), AddPsis(0), RCut(20.), StructOpt(0), IsAngstroem(1), RelativeCoord(0),
+    MaxTypes(0) {
   mainname = Malloc<char>(MAXSTRINGSIZE,"config constructor: mainname");
   defaultpath = Malloc<char>(MAXSTRINGSIZE,"config constructor: defaultpath");
 …
   configpath = Malloc<char>(MAXSTRINGSIZE,"config constructor: configpath");
   configname = Malloc<char>(MAXSTRINGSIZE,"config constructor: configname");
-  ThermostatImplemented = Malloc<int>(MaxThermostats, "config constructor: *ThermostatImplemented");
-  ThermostatNames = Malloc<char*>(MaxThermostats, "config constructor: *ThermostatNames");
-  for (int j=0;j<MaxThermostats;j++)
-    ThermostatNames[j] = Malloc<char>(12, "config constructor: ThermostatNames[]");
-  Thermostat = 4;
-  alpha = 0.;
-  ScaleTempStep = 25;
-  TempFrequency = 2.5;
   strcpy(mainname,"pcp");
   strcpy(defaultpath,"not specified");
 …
   basis = "3-21G";
+  strcpy(ThermostatNames[0],"None");
+  ThermostatImplemented[0] = 1;
+  strcpy(ThermostatNames[1],"Woodcock");
+  ThermostatImplemented[1] = 1;
+  strcpy(ThermostatNames[2],"Gaussian");
+  ThermostatImplemented[2] = 1;
+  strcpy(ThermostatNames[3],"Langevin");
+  ThermostatImplemented[3] = 1;
+  strcpy(ThermostatNames[4],"Berendsen");
+  ThermostatImplemented[4] = 1;
+  strcpy(ThermostatNames[5],"NoseHoover");
+  ThermostatImplemented[5] = 1;
+  FastParsing = false;
+  ProcPEGamma=8;
+  ProcPEPsi=1;
+  DoOutVis=0;
+  DoOutMes=1;
+  DoOutNICS=0;
+  DoOutOrbitals=0;
+  DoOutCurrent=0;
+  DoPerturbation=0;
+  DoFullCurrent=0;
+  DoWannier=0;
+  DoConstrainedMD=0;
+  CommonWannier=0;
+  SawtoothStart=0.01;
+  VectorPlane=0;
+  VectorCut=0;
+  UseAddGramSch=1;
+  Seed=1;
+  MaxOuterStep=0;
+  Deltat=0.01;
+  OutVisStep=10;
+  OutSrcStep=5;
+  TargetTemp=0.00095004455;
+  ScaleTempStep=25;
+  MaxPsiStep=0;
+  EpsWannier=1e-7;
+  MaxMinStep=100;
+  RelEpsTotalEnergy=1e-7;
+  RelEpsKineticEnergy=1e-5;
+  MaxMinStopStep=1;
+  MaxMinGapStopStep=0;
+  MaxInitMinStep=100;
+  InitRelEpsTotalEnergy=1e-5;
+  InitRelEpsKineticEnergy=1e-4;
+  InitMaxMinStopStep=1;
+  InitMaxMinGapStopStep=0;
+  //BoxLength[NDIM*NDIM];
+  ECut=128.;
+  MaxLevel=5;
+  RiemannTensor=0;
+  LevRFactor=0;
+  RiemannLevel=0;
+  Lev0Factor=2;
+  RTActualUse=0;
+  PsiType=0;
+  MaxPsiDouble=0;
+  PsiMaxNoUp=0;
+  PsiMaxNoDown=0;
+  AddPsis=0;
+  RCut=20.;
+  StructOpt=0;
+  IsAngstroem=1;
+  RelativeCoord=0;
+  MaxTypes=0;
+  InitThermostats();
 };
 /** Destructor for config file class.
 …
     Free(&ThermostatNames[j]);
   Free(&ThermostatNames);
+  if (BG != NULL)
+    delete(BG);
+};
+/** Initialises variables in class config for Thermostats.
+ */
+void config::InitThermostats()
+{
+  ThermostatImplemented = Malloc<int>(MaxThermostats, "config constructor: *ThermostatImplemented");
+  ThermostatNames = Malloc<char*>(MaxThermostats, "config constructor: *ThermostatNames");
+  for (int j=0;j<MaxThermostats;j++)
+    ThermostatNames[j] = Malloc<char>(12, "config constructor: ThermostatNames[]");
+  strcpy(ThermostatNames[0],"None");
+  ThermostatImplemented[0] = 1;
+  strcpy(ThermostatNames[1],"Woodcock");
+  ThermostatImplemented[1] = 1;
+  strcpy(ThermostatNames[2],"Gaussian");
+  ThermostatImplemented[2] = 1;
+  strcpy(ThermostatNames[3],"Langevin");
+  ThermostatImplemented[3] = 1;
+  strcpy(ThermostatNames[4],"Berendsen");
+  ThermostatImplemented[4] = 1;
+  strcpy(ThermostatNames[5],"NoseHoover");
+  ThermostatImplemented[5] = 1;
 };
 …
  * \param *fb file buffer containing the config file
  */
 void config::InitThermostats(class ConfigFileBuffer *fb)
+void config::ParseThermostats(class ConfigFileBuffer * const fb)
+{
   char *thermo = Malloc<char>(12, "IonsInitRead: thermo");
   int verbose = 0;
+  char * const thermo = Malloc<char>(12, "IonsInitRead: thermo");
+  const int verbose = 0;
   // read desired Thermostat from file along with needed additional parameters
 …
     Thermostat = None;
+  }
   Free(&thermo);
+  Free(thermo);
 };
 …
  * \param *filename filename of config file to be tested
  * \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
  */
 int config::TestSyntax(char *filename, periodentafel *periode, molecule *mol)
+int config::TestSyntax(const char * const filename, const periodentafel * const periode) const
+{
   int test;
 …
  * \return *defaultpath
  */
 void config::SetDefaultPath(const char *path)
+void config::SetDefaultPath(const char * const path)
+{
   strcpy(defaultpath, path);
 …
  * \param filename config file string
  */
 void config::RetrieveConfigPathAndName(string filename)
+void config::RetrieveConfigPathAndName(const string filename)
+{
   char *ptr = NULL;
 …
 };
+/** Initializes config file structure by loading elements from a give file.
+/** Initializes ConfigFileBuffer from a file.
  * \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
+ */
+void config::Load(char *filename, periodentafel *periode, molecule *mol)
+ * \param *FileBuffer pointer to FileBuffer on return, should point to NULL
+ */
+void PrepareFileBuffer(const char * const filename, struct ConfigFileBuffer *&FileBuffer)
+{
+  ifstream *file = new ifstream(filename);
+  if (file == NULL) {
+    cerr << "ERROR: config file " << filename << " missing!" << endl;
+    return;
+  }
+  file->close();
+  delete(file);
+  RetrieveConfigPathAndName(filename);
+  // ParseParameterFile
+  struct ConfigFileBuffer *FileBuffer = new ConfigFileBuffer(filename);
+  if (FileBuffer != NULL) {
+    cerr << Verbose(1) << "WARNING: deleting present FileBuffer in PrepareFileBuffer()." << endl;
+    delete(FileBuffer);
+  }
+  FileBuffer = new ConfigFileBuffer(filename);
   FileBuffer->InitMapping();
+  /* Oeffne Hauptparameterdatei */
+  int di;
+  double BoxLength[9];
+  string zeile;
+  string dummy;
+};
+/** Loads a molecule from a ConfigFileBuffer.
+ * \param *mol molecule to load
+ * \param *FileBuffer ConfigFileBuffer to use
+ * \param *periode periodentafel for finding elements
+ * \param FastParsing whether to parse trajectories or not
+ */
+void LoadMolecule(molecule * const &mol, struct ConfigFileBuffer * const &FileBuffer, const periodentafel * const periode, const bool FastParsing)
+{
+  int MaxTypes = 0;
   element *elementhash[MAX_ELEMENTS];
   char name[MAX_ELEMENTS];
   char keyword[MAX_ELEMENTS];
+  int Z, No[MAX_ELEMENTS];
+  int Z = -1;
+  int No[MAX_ELEMENTS];
   int verbose = 0;
   double value[3];
+  InitThermostats(FileBuffer);
+  /* Namen einlesen */
+  ParseForParameter(verbose,FileBuffer, "mainname", 0, 1, 1, string_type, (config::mainname), 1, critical);
+  ParseForParameter(verbose,FileBuffer, "defaultpath", 0, 1, 1, string_type, (config::defaultpath), 1, critical);
+  ParseForParameter(verbose,FileBuffer, "pseudopotpath", 0, 1, 1, string_type, (config::pseudopotpath), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"ProcPEGamma", 0, 1, 1, int_type, &(config::ProcPEGamma), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"ProcPEPsi", 0, 1, 1, int_type, &(config::ProcPEPsi), 1, critical);
+  if (!ParseForParameter(verbose,FileBuffer,"Seed", 0, 1, 1, int_type, &(config::Seed), 1, optional))
+    config::Seed = 1;
+  if(!ParseForParameter(verbose,FileBuffer,"DoOutOrbitals", 0, 1, 1, int_type, &(config::DoOutOrbitals), 1, optional)) {
+    config::DoOutOrbitals = 0;
+  } else {
+    if (config::DoOutOrbitals < 0) config::DoOutOrbitals = 0;
+    if (config::DoOutOrbitals > 1) config::DoOutOrbitals = 1;
+  }
+  ParseForParameter(verbose,FileBuffer,"DoOutVis", 0, 1, 1, int_type, &(config::DoOutVis), 1, critical);
+  if (config::DoOutVis < 0) config::DoOutVis = 0;
+  if (config::DoOutVis > 1) config::DoOutVis = 1;
+  if (!ParseForParameter(verbose,FileBuffer,"VectorPlane", 0, 1, 1, int_type, &(config::VectorPlane), 1, optional))
+    config::VectorPlane = -1;
+  if (!ParseForParameter(verbose,FileBuffer,"VectorCut", 0, 1, 1, double_type, &(config::VectorCut), 1, optional))
+    config::VectorCut = 0.;
+  ParseForParameter(verbose,FileBuffer,"DoOutMes", 0, 1, 1, int_type, &(config::DoOutMes), 1, critical);
+  if (config::DoOutMes < 0) config::DoOutMes = 0;
+  if (config::DoOutMes > 1) config::DoOutMes = 1;
+  if (!ParseForParameter(verbose,FileBuffer,"DoOutCurr", 0, 1, 1, int_type, &(config::DoOutCurrent), 1, optional))
+    config::DoOutCurrent = 0;
+  if (config::DoOutCurrent < 0) config::DoOutCurrent = 0;
+  if (config::DoOutCurrent > 1) config::DoOutCurrent = 1;
+  ParseForParameter(verbose,FileBuffer,"AddGramSch", 0, 1, 1, int_type, &(config::UseAddGramSch), 1, critical);
+  if (config::UseAddGramSch < 0) config::UseAddGramSch = 0;
+  if (config::UseAddGramSch > 2) config::UseAddGramSch = 2;
+  if(!ParseForParameter(verbose,FileBuffer,"DoWannier", 0, 1, 1, int_type, &(config::DoWannier), 1, optional)) {
+    config::DoWannier = 0;
+  } else {
+    if (config::DoWannier < 0) config::DoWannier = 0;
+    if (config::DoWannier > 1) config::DoWannier = 1;
+  }
+  if(!ParseForParameter(verbose,FileBuffer,"CommonWannier", 0, 1, 1, int_type, &(config::CommonWannier), 1, optional)) {
+    config::CommonWannier = 0;
+  } else {
+    if (config::CommonWannier < 0) config::CommonWannier = 0;
+    if (config::CommonWannier > 4) config::CommonWannier = 4;
+  }
+  if(!ParseForParameter(verbose,FileBuffer,"SawtoothStart", 0, 1, 1, double_type, &(config::SawtoothStart), 1, optional)) {
+    config::SawtoothStart = 0.01;
+  } else {
+    if (config::SawtoothStart < 0.) config::SawtoothStart = 0.;
+    if (config::SawtoothStart > 1.) config::SawtoothStart = 1.;
+  }
+  if (ParseForParameter(verbose,FileBuffer,"DoConstrainedMD", 0, 1, 1, int_type, &(config::DoConstrainedMD), 1, optional))
+    if (config::DoConstrainedMD < 0)
+      config::DoConstrainedMD = 0;
+  ParseForParameter(verbose,FileBuffer,"MaxOuterStep", 0, 1, 1, int_type, &(config::MaxOuterStep), 1, critical);
+  if (!ParseForParameter(verbose,FileBuffer,"Deltat", 0, 1, 1, double_type, &(config::Deltat), 1, optional))
+    config::Deltat = 1;
+  ParseForParameter(verbose,FileBuffer,"OutVisStep", 0, 1, 1, int_type, &(config::OutVisStep), 1, optional);
+  ParseForParameter(verbose,FileBuffer,"OutSrcStep", 0, 1, 1, int_type, &(config::OutSrcStep), 1, optional);
+  ParseForParameter(verbose,FileBuffer,"TargetTemp", 0, 1, 1, double_type, &(config::TargetTemp), 1, optional);
+  //ParseForParameter(verbose,FileBuffer,"Thermostat", 0, 1, 1, int_type, &(config::ScaleTempStep), 1, optional);
+  if (!ParseForParameter(verbose,FileBuffer,"EpsWannier", 0, 1, 1, double_type, &(config::EpsWannier), 1, optional))
+    config::EpsWannier = 1e-8;
+  // stop conditions
+  //if (config::MaxOuterStep <= 0) config::MaxOuterStep = 1;
+  ParseForParameter(verbose,FileBuffer,"MaxPsiStep", 0, 1, 1, int_type, &(config::MaxPsiStep), 1, critical);
+  if (config::MaxPsiStep <= 0) config::MaxPsiStep = 3;
+  ParseForParameter(verbose,FileBuffer,"MaxMinStep", 0, 1, 1, int_type, &(config::MaxMinStep), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"RelEpsTotalE", 0, 1, 1, double_type, &(config::RelEpsTotalEnergy), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"RelEpsKineticE", 0, 1, 1, double_type, &(config::RelEpsKineticEnergy), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"MaxMinStopStep", 0, 1, 1, int_type, &(config::MaxMinStopStep), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"MaxMinGapStopStep", 0, 1, 1, int_type, &(config::MaxMinGapStopStep), 1, critical);
+  if (config::MaxMinStep <= 0) config::MaxMinStep = config::MaxPsiStep;
+  if (config::MaxMinStopStep < 1) config::MaxMinStopStep = 1;
+  if (config::MaxMinGapStopStep < 1) config::MaxMinGapStopStep = 1;
+  ParseForParameter(verbose,FileBuffer,"MaxInitMinStep", 0, 1, 1, int_type, &(config::MaxInitMinStep), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"InitRelEpsTotalE", 0, 1, 1, double_type, &(config::InitRelEpsTotalEnergy), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"InitRelEpsKineticE", 0, 1, 1, double_type, &(config::InitRelEpsKineticEnergy), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"InitMaxMinStopStep", 0, 1, 1, int_type, &(config::InitMaxMinStopStep), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"InitMaxMinGapStopStep", 0, 1, 1, int_type, &(config::InitMaxMinGapStopStep), 1, critical);
+  if (config::MaxInitMinStep <= 0) config::MaxInitMinStep = config::MaxPsiStep;
+  if (config::InitMaxMinStopStep < 1) config::InitMaxMinStopStep = 1;
+  if (config::InitMaxMinGapStopStep < 1) config::InitMaxMinGapStopStep = 1;
+  // Unit cell and magnetic field
+  ParseForParameter(verbose,FileBuffer, "BoxLength", 0, 3, 3, lower_trigrid, BoxLength, 1, critical); /* Lattice->RealBasis */
+  mol->cell_size[0] = BoxLength[0];
+  mol->cell_size[1] = BoxLength[3];
+  mol->cell_size[2] = BoxLength[4];
+  mol->cell_size[3] = BoxLength[6];
+  mol->cell_size[4] = BoxLength[7];
+  mol->cell_size[5] = BoxLength[8];
+  //if (1) fprintf(stderr,"\n");
+  ParseForParameter(verbose,FileBuffer,"DoPerturbation", 0, 1, 1, int_type, &(config::DoPerturbation), 1, optional);
+  ParseForParameter(verbose,FileBuffer,"DoOutNICS", 0, 1, 1, int_type, &(config::DoOutNICS), 1, optional);
+  if (!ParseForParameter(verbose,FileBuffer,"DoFullCurrent", 0, 1, 1, int_type, &(config::DoFullCurrent), 1, optional))
+    config::DoFullCurrent = 0;
+  if (config::DoFullCurrent < 0) config::DoFullCurrent = 0;
+  if (config::DoFullCurrent > 2) config::DoFullCurrent = 2;
+  if (config::DoOutNICS < 0) config::DoOutNICS = 0;
+  if (config::DoOutNICS > 2) config::DoOutNICS = 2;
+  if (config::DoPerturbation == 0) {
+    config::DoFullCurrent = 0;
+    config::DoOutNICS = 0;
+  }
+  ParseForParameter(verbose,FileBuffer,"ECut", 0, 1, 1, double_type, &(config::ECut), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"MaxLevel", 0, 1, 1, int_type, &(config::MaxLevel), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"Level0Factor", 0, 1, 1, int_type, &(config::Lev0Factor), 1, critical);
+  if (config::Lev0Factor < 2) {
+    config::Lev0Factor = 2;
+  }
+  ParseForParameter(verbose,FileBuffer,"RiemannTensor", 0, 1, 1, int_type, &di, 1, critical);
+  if (di >= 0 && di < 2) {
+    config::RiemannTensor = di;
+  } else {
+    fprintf(stderr, "0 <= RiemanTensor < 2: 0 UseNotRT, 1 UseRT");
+    exit(1);
+  }
+  switch (config::RiemannTensor) {
+    case 0: //UseNoRT
+      if (config::MaxLevel < 2) {
+        config::MaxLevel = 2;
+      }
+      config::LevRFactor = 2;
+      config::RTActualUse = 0;
+      break;
+    case 1: // UseRT
+      if (config::MaxLevel < 3) {
+        config::MaxLevel = 3;
+      }
+      ParseForParameter(verbose,FileBuffer,"RiemannLevel", 0, 1, 1, int_type, &(config::RiemannLevel), 1, critical);
+      if (config::RiemannLevel < 2) {
+        config::RiemannLevel = 2;
+      }
+      if (config::RiemannLevel > config::MaxLevel-1) {
+        config::RiemannLevel = config::MaxLevel-1;
+      }
+      ParseForParameter(verbose,FileBuffer,"LevRFactor", 0, 1, 1, int_type, &(config::LevRFactor), 1, critical);
+      if (config::LevRFactor < 2) {
+        config::LevRFactor = 2;
+      }
+      config::Lev0Factor = 2;
+      config::RTActualUse = 2;
+      break;
+  }
+  ParseForParameter(verbose,FileBuffer,"PsiType", 0, 1, 1, int_type, &di, 1, critical);
+  if (di >= 0 && di < 2) {
+    config::PsiType = di;
+  } else {
+    fprintf(stderr, "0 <= PsiType < 2: 0 UseSpinDouble, 1 UseSpinUpDown");
+    exit(1);
+  }
+  switch (config::PsiType) {
+  case 0: // SpinDouble
+    ParseForParameter(verbose,FileBuffer,"MaxPsiDouble", 0, 1, 1, int_type, &(config::MaxPsiDouble), 1, critical);
+    ParseForParameter(verbose,FileBuffer,"AddPsis", 0, 1, 1, int_type, &(config::AddPsis), 1, optional);
+    break;
+  case 1: // SpinUpDown
+    if (config::ProcPEGamma % 2) config::ProcPEGamma*=2;
+    ParseForParameter(verbose,FileBuffer,"PsiMaxNoUp", 0, 1, 1, int_type, &(config::PsiMaxNoUp), 1, critical);
+    ParseForParameter(verbose,FileBuffer,"PsiMaxNoDown", 0, 1, 1, int_type, &(config::PsiMaxNoDown), 1, critical);
+    ParseForParameter(verbose,FileBuffer,"AddPsis", 0, 1, 1, int_type, &(config::AddPsis), 1, optional);
+    break;
+  }
+  // IonsInitRead
+  ParseForParameter(verbose,FileBuffer,"RCut", 0, 1, 1, double_type, &(config::RCut), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"IsAngstroem", 0, 1, 1, int_type, &(config::IsAngstroem), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"MaxTypes", 0, 1, 1, int_type, &(config::MaxTypes), 1, critical);
+  if (!ParseForParameter(verbose,FileBuffer,"RelativeCoord", 0, 1, 1, int_type, &(config::RelativeCoord) , 1, optional))
+    config::RelativeCoord = 0;
+  if (!ParseForParameter(verbose,FileBuffer,"StructOpt", 0, 1, 1, int_type, &(config::StructOpt), 1, optional))
+    config::StructOpt = 0;
+  if (mol == NULL) {
+    cerr << "Molecule is not allocated in LoadMolecule(), exit.";
+    performCriticalExit();
+  }
+  ParseForParameter(verbose,FileBuffer,"MaxTypes", 0, 1, 1, int_type, &(MaxTypes), 1, critical);
   if (MaxTypes == 0) {
     cerr << "There are no atoms according to MaxTypes in this config file." << endl;
 …
     cout << Verbose(0) << "Prescanning ions per type: " << endl;
     int NoAtoms = 0;
     for (int i=0; i < config::MaxTypes; i++) {
+    for (int i=0; i < MaxTypes; i++) {
       sprintf(name,"Ion_Type%i",i+1);
       ParseForParameter(verbose,FileBuffer, (const char*)name, 0, 1, 1, int_type, &No[i], 1, critical);
 …
     // sort the lines via the LineMapping
     sprintf(name,"Ion_Type%i",config::MaxTypes);
+    sprintf(name,"Ion_Type%i",MaxTypes);
     if (!ParseForParameter(verbose,FileBuffer, (const char*)name, 1, 1, 1, int_type, &value[0], 1, critical)) {
       cerr << "There are no atoms in the config file!" << endl;
 …
     //}
     map<int, atom *> AtomList[config::MaxTypes];
+    map<int, atom *> AtomList[MaxTypes];
     map<int, atom *> LinearList;
     atom *neues = NULL;
 …
       while (status) {
         cout << "Currently parsing MD step " << repetition << "." << endl;
         for (int i=0; i < config::MaxTypes; i++) {
+        for (int i=0; i < MaxTypes; i++) {
           sprintf(name,"Ion_Type%i",i+1);
           for(int j=0;j<No[i];j++) {
 …
       cout << "I found " << repetition << " times the keyword Ion_Type1_1." << endl;
       // parse in molecule coordinates
       for (int i=0; i < config::MaxTypes; i++) {
+      for (int i=0; i < MaxTypes; i++) {
         sprintf(name,"Ion_Type%i",i+1);
         for(int j=0;j<No[i];j++) {
 …
+    }
+  }
-  delete(FileBuffer);
 };
+/** Initializes config file structure by loading elements from a give file with old pcp syntax.
+ * \param *file input file stream being the opened config file with old pcp syntax
+/** Initializes config file structure by loading elements from a give file.
+ * \param *file input file stream being the opened config file
+ * \param BondGraphFileName file name of the bond length table file, if string is left blank, no table is parsed.
  * \param *periode pointer to a periodentafel class with all elements
  * \param *mol pointer to molecule containing all atoms of the molecule
  */
 void config::LoadOld(char *filename, periodentafel *periode, molecule *mol)
+ * \param *&MolList pointer to MoleculeListClass, on return containing all parsed molecules in system
+ */
+void config::Load(const char * const filename, const string &BondGraphFileName, const periodentafel * const periode, MoleculeListClass * const &MolList)
+{
+  molecule *mol = new molecule(periode);
   ifstream *file = new ifstream(filename);
   if (file == NULL) {
 …
     return;
+  }
+  file->close();
+  delete(file);
+  RetrieveConfigPathAndName(filename);
+  // ParseParameterFile
+  struct ConfigFileBuffer *FileBuffer = NULL;
+  PrepareFileBuffer(filename,FileBuffer);
+  /* Oeffne Hauptparameterdatei */
+  int di = 0;
+  double BoxLength[9];
+  string zeile;
+  string dummy;
+  int verbose = 0;
+  ParseThermostats(FileBuffer);
+  /* Namen einlesen */
+  // 1. parse in options
+  ParseForParameter(verbose,FileBuffer, "mainname", 0, 1, 1, string_type, (config::mainname), 1, critical);
+  ParseForParameter(verbose,FileBuffer, "defaultpath", 0, 1, 1, string_type, (config::defaultpath), 1, critical);
+  ParseForParameter(verbose,FileBuffer, "pseudopotpath", 0, 1, 1, string_type, (config::pseudopotpath), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"ProcPEGamma", 0, 1, 1, int_type, &(config::ProcPEGamma), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"ProcPEPsi", 0, 1, 1, int_type, &(config::ProcPEPsi), 1, critical);
+  if (!ParseForParameter(verbose,FileBuffer,"Seed", 0, 1, 1, int_type, &(config::Seed), 1, optional))
+    config::Seed = 1;
+  if(!ParseForParameter(verbose,FileBuffer,"DoOutOrbitals", 0, 1, 1, int_type, &(config::DoOutOrbitals), 1, optional)) {
+    config::DoOutOrbitals = 0;
+  } else {
+    if (config::DoOutOrbitals < 0) config::DoOutOrbitals = 0;
+    if (config::DoOutOrbitals > 1) config::DoOutOrbitals = 1;
+  }
+  ParseForParameter(verbose,FileBuffer,"DoOutVis", 0, 1, 1, int_type, &(config::DoOutVis), 1, critical);
+  if (config::DoOutVis < 0) config::DoOutVis = 0;
+  if (config::DoOutVis > 1) config::DoOutVis = 1;
+  if (!ParseForParameter(verbose,FileBuffer,"VectorPlane", 0, 1, 1, int_type, &(config::VectorPlane), 1, optional))
+    config::VectorPlane = -1;
+  if (!ParseForParameter(verbose,FileBuffer,"VectorCut", 0, 1, 1, double_type, &(config::VectorCut), 1, optional))
+    config::VectorCut = 0.;
+  ParseForParameter(verbose,FileBuffer,"DoOutMes", 0, 1, 1, int_type, &(config::DoOutMes), 1, critical);
+  if (config::DoOutMes < 0) config::DoOutMes = 0;
+  if (config::DoOutMes > 1) config::DoOutMes = 1;
+  if (!ParseForParameter(verbose,FileBuffer,"DoOutCurr", 0, 1, 1, int_type, &(config::DoOutCurrent), 1, optional))
+    config::DoOutCurrent = 0;
+  if (config::DoOutCurrent < 0) config::DoOutCurrent = 0;
+  if (config::DoOutCurrent > 1) config::DoOutCurrent = 1;
+  ParseForParameter(verbose,FileBuffer,"AddGramSch", 0, 1, 1, int_type, &(config::UseAddGramSch), 1, critical);
+  if (config::UseAddGramSch < 0) config::UseAddGramSch = 0;
+  if (config::UseAddGramSch > 2) config::UseAddGramSch = 2;
+  if(!ParseForParameter(verbose,FileBuffer,"DoWannier", 0, 1, 1, int_type, &(config::DoWannier), 1, optional)) {
+    config::DoWannier = 0;
+  } else {
+    if (config::DoWannier < 0) config::DoWannier = 0;
+    if (config::DoWannier > 1) config::DoWannier = 1;
+  }
+  if(!ParseForParameter(verbose,FileBuffer,"CommonWannier", 0, 1, 1, int_type, &(config::CommonWannier), 1, optional)) {
+    config::CommonWannier = 0;
+  } else {
+    if (config::CommonWannier < 0) config::CommonWannier = 0;
+    if (config::CommonWannier > 4) config::CommonWannier = 4;
+  }
+  if(!ParseForParameter(verbose,FileBuffer,"SawtoothStart", 0, 1, 1, double_type, &(config::SawtoothStart), 1, optional)) {
+    config::SawtoothStart = 0.01;
+  } else {
+    if (config::SawtoothStart < 0.) config::SawtoothStart = 0.;
+    if (config::SawtoothStart > 1.) config::SawtoothStart = 1.;
+  }
+  if (ParseForParameter(verbose,FileBuffer,"DoConstrainedMD", 0, 1, 1, int_type, &(config::DoConstrainedMD), 1, optional))
+    if (config::DoConstrainedMD < 0)
+      config::DoConstrainedMD = 0;
+  ParseForParameter(verbose,FileBuffer,"MaxOuterStep", 0, 1, 1, int_type, &(config::MaxOuterStep), 1, critical);
+  if (!ParseForParameter(verbose,FileBuffer,"Deltat", 0, 1, 1, double_type, &(config::Deltat), 1, optional))
+    config::Deltat = 1;
+  ParseForParameter(verbose,FileBuffer,"OutVisStep", 0, 1, 1, int_type, &(config::OutVisStep), 1, optional);
+  ParseForParameter(verbose,FileBuffer,"OutSrcStep", 0, 1, 1, int_type, &(config::OutSrcStep), 1, optional);
+  ParseForParameter(verbose,FileBuffer,"TargetTemp", 0, 1, 1, double_type, &(config::TargetTemp), 1, optional);
+  //ParseForParameter(verbose,FileBuffer,"Thermostat", 0, 1, 1, int_type, &(config::ScaleTempStep), 1, optional);
+  if (!ParseForParameter(verbose,FileBuffer,"EpsWannier", 0, 1, 1, double_type, &(config::EpsWannier), 1, optional))
+    config::EpsWannier = 1e-8;
+  // stop conditions
+  //if (config::MaxOuterStep <= 0) config::MaxOuterStep = 1;
+  ParseForParameter(verbose,FileBuffer,"MaxPsiStep", 0, 1, 1, int_type, &(config::MaxPsiStep), 1, critical);
+  if (config::MaxPsiStep <= 0) config::MaxPsiStep = 3;
+  ParseForParameter(verbose,FileBuffer,"MaxMinStep", 0, 1, 1, int_type, &(config::MaxMinStep), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"RelEpsTotalE", 0, 1, 1, double_type, &(config::RelEpsTotalEnergy), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"RelEpsKineticE", 0, 1, 1, double_type, &(config::RelEpsKineticEnergy), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"MaxMinStopStep", 0, 1, 1, int_type, &(config::MaxMinStopStep), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"MaxMinGapStopStep", 0, 1, 1, int_type, &(config::MaxMinGapStopStep), 1, critical);
+  if (config::MaxMinStep <= 0) config::MaxMinStep = config::MaxPsiStep;
+  if (config::MaxMinStopStep < 1) config::MaxMinStopStep = 1;
+  if (config::MaxMinGapStopStep < 1) config::MaxMinGapStopStep = 1;
+  ParseForParameter(verbose,FileBuffer,"MaxInitMinStep", 0, 1, 1, int_type, &(config::MaxInitMinStep), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"InitRelEpsTotalE", 0, 1, 1, double_type, &(config::InitRelEpsTotalEnergy), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"InitRelEpsKineticE", 0, 1, 1, double_type, &(config::InitRelEpsKineticEnergy), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"InitMaxMinStopStep", 0, 1, 1, int_type, &(config::InitMaxMinStopStep), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"InitMaxMinGapStopStep", 0, 1, 1, int_type, &(config::InitMaxMinGapStopStep), 1, critical);
+  if (config::MaxInitMinStep <= 0) config::MaxInitMinStep = config::MaxPsiStep;
+  if (config::InitMaxMinStopStep < 1) config::InitMaxMinStopStep = 1;
+  if (config::InitMaxMinGapStopStep < 1) config::InitMaxMinGapStopStep = 1;
+  // Unit cell and magnetic field
+  ParseForParameter(verbose,FileBuffer, "BoxLength", 0, 3, 3, lower_trigrid, BoxLength, 1, critical); /* Lattice->RealBasis */
+  mol->cell_size[0] = BoxLength[0];
+  mol->cell_size[1] = BoxLength[3];
+  mol->cell_size[2] = BoxLength[4];
+  mol->cell_size[3] = BoxLength[6];
+  mol->cell_size[4] = BoxLength[7];
+  mol->cell_size[5] = BoxLength[8];
+  //if (1) fprintf(stderr,"\n");
+  ParseForParameter(verbose,FileBuffer,"DoPerturbation", 0, 1, 1, int_type, &(config::DoPerturbation), 1, optional);
+  ParseForParameter(verbose,FileBuffer,"DoOutNICS", 0, 1, 1, int_type, &(config::DoOutNICS), 1, optional);
+  if (!ParseForParameter(verbose,FileBuffer,"DoFullCurrent", 0, 1, 1, int_type, &(config::DoFullCurrent), 1, optional))
+    config::DoFullCurrent = 0;
+  if (config::DoFullCurrent < 0) config::DoFullCurrent = 0;
+  if (config::DoFullCurrent > 2) config::DoFullCurrent = 2;
+  if (config::DoOutNICS < 0) config::DoOutNICS = 0;
+  if (config::DoOutNICS > 2) config::DoOutNICS = 2;
+  if (config::DoPerturbation == 0) {
+    config::DoFullCurrent = 0;
+    config::DoOutNICS = 0;
+  }
+  ParseForParameter(verbose,FileBuffer,"ECut", 0, 1, 1, double_type, &(config::ECut), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"MaxLevel", 0, 1, 1, int_type, &(config::MaxLevel), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"Level0Factor", 0, 1, 1, int_type, &(config::Lev0Factor), 1, critical);
+  if (config::Lev0Factor < 2) {
+    config::Lev0Factor = 2;
+  }
+  ParseForParameter(verbose,FileBuffer,"RiemannTensor", 0, 1, 1, int_type, &di, 1, critical);
+  if (di >= 0 && di < 2) {
+    config::RiemannTensor = di;
+  } else {
+    fprintf(stderr, "0 <= RiemanTensor < 2: 0 UseNotRT, 1 UseRT");
+    exit(1);
+  }
+  switch (config::RiemannTensor) {
+    case 0: //UseNoRT
+      if (config::MaxLevel < 2) {
+        config::MaxLevel = 2;
+      }
+      config::LevRFactor = 2;
+      config::RTActualUse = 0;
+      break;
+    case 1: // UseRT
+      if (config::MaxLevel < 3) {
+        config::MaxLevel = 3;
+      }
+      ParseForParameter(verbose,FileBuffer,"RiemannLevel", 0, 1, 1, int_type, &(config::RiemannLevel), 1, critical);
+      if (config::RiemannLevel < 2) {
+        config::RiemannLevel = 2;
+      }
+      if (config::RiemannLevel > config::MaxLevel-1) {
+        config::RiemannLevel = config::MaxLevel-1;
+      }
+      ParseForParameter(verbose,FileBuffer,"LevRFactor", 0, 1, 1, int_type, &(config::LevRFactor), 1, critical);
+      if (config::LevRFactor < 2) {
+        config::LevRFactor = 2;
+      }
+      config::Lev0Factor = 2;
+      config::RTActualUse = 2;
+      break;
+  }
+  ParseForParameter(verbose,FileBuffer,"PsiType", 0, 1, 1, int_type, &di, 1, critical);
+  if (di >= 0 && di < 2) {
+    config::PsiType = di;
+  } else {
+    fprintf(stderr, "0 <= PsiType < 2: 0 UseSpinDouble, 1 UseSpinUpDown");
+    exit(1);
+  }
+  switch (config::PsiType) {
+  case 0: // SpinDouble
+    ParseForParameter(verbose,FileBuffer,"MaxPsiDouble", 0, 1, 1, int_type, &(config::MaxPsiDouble), 1, critical);
+    ParseForParameter(verbose,FileBuffer,"AddPsis", 0, 1, 1, int_type, &(config::AddPsis), 1, optional);
+    break;
+  case 1: // SpinUpDown
+    if (config::ProcPEGamma % 2) config::ProcPEGamma*=2;
+    ParseForParameter(verbose,FileBuffer,"PsiMaxNoUp", 0, 1, 1, int_type, &(config::PsiMaxNoUp), 1, critical);
+    ParseForParameter(verbose,FileBuffer,"PsiMaxNoDown", 0, 1, 1, int_type, &(config::PsiMaxNoDown), 1, critical);
+    ParseForParameter(verbose,FileBuffer,"AddPsis", 0, 1, 1, int_type, &(config::AddPsis), 1, optional);
+    break;
+  }
+  // IonsInitRead
+  ParseForParameter(verbose,FileBuffer,"RCut", 0, 1, 1, double_type, &(config::RCut), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"IsAngstroem", 0, 1, 1, int_type, &(config::IsAngstroem), 1, critical);
+  ParseForParameter(verbose,FileBuffer,"MaxTypes", 0, 1, 1, int_type, &(MaxTypes), 1, critical);
+  if (!ParseForParameter(verbose,FileBuffer,"RelativeCoord", 0, 1, 1, int_type, &(config::RelativeCoord) , 1, optional))
+    config::RelativeCoord = 0;
+  if (!ParseForParameter(verbose,FileBuffer,"StructOpt", 0, 1, 1, int_type, &(config::StructOpt), 1, optional))
+    config::StructOpt = 0;
+  // 2. parse the bond graph file if given
+  BG = new BondGraph(IsAngstroem);
+  if (BG->LoadBondLengthTable((ofstream *)&cout, BondGraphFileName)) {
+    cout << Verbose(0) << "Bond length table loaded successfully." << endl;
+  } else {
+    cout << Verbose(0) << "Bond length table loading failed." << endl;
+  }
+  // 3. parse the molecule in
+  LoadMolecule(mol, FileBuffer, periode, FastParsing);
+  // 4. split into connected subgraphs
+  MolList->DissectMoleculeIntoConnectedSubgraphs((ofstream *)&cout, mol, this);
+  delete(mol);
+  delete(FileBuffer);
+};
+/** Initializes config file structure by loading elements from a give file with old pcp syntax.
+ * \param *file input file stream being the opened config file with old pcp syntax
+ * \param BondGraphFileName file name of the bond length table file, if string is left blank, no table is parsed.
+ * \param *periode pointer to a periodentafel class with all elements
+ * \param *&MolList pointer to MoleculeListClass, on return containing all parsed molecules in system
+ */
+void config::LoadOld(const char * const filename, const string &BondGraphFileName, const periodentafel * const periode, MoleculeListClass * const &MolList)
+{
+  molecule *mol = new molecule(periode);
+  ifstream *file = new ifstream(filename);
+  if (file == NULL) {
+    cerr << "ERROR: config file " << filename << " missing!" << endl;
+    return;
+  }
   RetrieveConfigPathAndName(filename);
   // ParseParameters
   /* Oeffne Hauptparameterdatei */
+  int l, i, di;
+  double a,b;
+  int l = 0;
+  int i = 0;
+  int di = 0;
+  double a = 0.;
+  double b = 0.;
   double BoxLength[9];
   string zeile;
   string dummy;
   element *elementhash[128];
+  int Z, No, AtomNo, found;
+  int Z = -1;
+  int No = -1;
+  int AtomNo = -1;
+  int found = 0;
   int verbose = 0;
+  mol->ActiveFlag = true;
+  MolList->insert(mol);
   /* Namen einlesen */
 …
   config::StructOpt = 0;
+  // 2. parse the bond graph file if given
+  BG = new BondGraph(IsAngstroem);
+  if (BG->LoadBondLengthTable((ofstream *)&cout, BondGraphFileName)) {
+    cout << Verbose(0) << "Bond length table loaded successfully." << endl;
+  } else {
+    cout << Verbose(0) << "Bond length table loading failed." << endl;
+  }
   // Routine from builder.cpp
   for (i=MAX_ELEMENTS;i--;)
 …
  * \param *mol pointer to molecule containing all atoms of the molecule
  */
 bool config::Save(const char *filename, periodentafel *periode, molecule *mol) const
+bool config::Save(const char * const filename, const periodentafel * const periode, molecule * const mol) const
+{
   bool result = true;
   // bring MaxTypes up to date
   mol->CountElements();
+  ofstream *output = NULL;
+  output = new ofstream(filename, ios::out);
+  ofstream * const output = new ofstream(filename, ios::out);
   if (output != NULL) {
     *output << "# ParallelCarParinello - main configuration file - created with molecuilder" << endl;
 …
  * \param *mol pointer to molecule containing all atoms of the molecule
  */
 bool config::SaveMPQC(const char *filename, molecule *mol) const
+bool config::SaveMPQC(const char * const filename, const molecule * const mol) const
+{
+  int ElementNo = 0;
+  int AtomNo;
+  atom *Walker = NULL;
+  element *runner = NULL;
+  int AtomNo = -1;
   Vector *center = NULL;
   ofstream *output = NULL;
-  stringstream *fname = NULL;
   // first without hessian
+  fname = new stringstream;
+  *fname << filename << ".in";
+  output = new ofstream(fname->str().c_str(), ios::out);
+  *output << "% Created by MoleCuilder" << endl;
+  *output << "mpqc: (" << endl;
+  *output << "\tsavestate = no" << endl;
+  *output << "\tdo_gradient = yes" << 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;
+  *output << "molecule<Molecule>: (" << endl;
+  *output << "\tunit = " << (IsAngstroem ? "angstrom" : "bohr" ) << endl;
+  *output << "\t{ atoms geometry } = {" << endl;
+  center = mol->DetermineCenterOfAll(output);
+  // output of atoms
+  runner = mol->elemente->start;
+  while (runner->next != mol->elemente->end) { // go through every element
+    runner = runner->next;
+    if (mol->ElementsInMolecule[runner->Z]) { // if this element got atoms
+      ElementNo++;
+      AtomNo = 0;
+      Walker = mol->start;
+      while (Walker->next != mol->end) { // go through every atom of this element
+        Walker = Walker->next;
+        if (Walker->type == runner) { // if this atom fits to element
+          AtomNo++;
+          *output << "\t\t" << Walker->type->symbol << " [ " << Walker->x.x[0]-center->x[0] << "\t" << Walker->x.x[1]-center->x[1] << "\t" << Walker->x.x[2]-center->x[2] << " ]" << endl;
+        }
+      }
+    }
+  }
+  delete(center);
+  *output << "\t}" << endl;
+  *output << ")" << endl;
+  *output << "basis<GaussianBasisSet>: (" << endl;
+  *output << "\tname = \"" << basis << "\"" << endl;
+  *output << "\tmolecule = $:molecule" << endl;
+  *output << ")" << endl;
+  output->close();
+  delete(output);
+  delete(fname);
+  {
+    stringstream * const fname = new stringstream;;
+    *fname << filename << ".in";
+    output = new ofstream(fname->str().c_str(), ios::out);
+    *output << "% Created by MoleCuilder" << endl;
+    *output << "mpqc: (" << endl;
+    *output << "\tsavestate = no" << endl;
+    *output << "\tdo_gradient = yes" << 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;
+    *output << "molecule<Molecule>: (" << endl;
+    *output << "\tunit = " << (IsAngstroem ? "angstrom" : "bohr" ) << endl;
+    *output << "\t{ atoms geometry } = {" << endl;
+    center = mol->DetermineCenterOfAll(output);
+    // output of atoms
+    AtomNo = 0;
+    mol->ActOnAllAtoms( &atom::OutputMPQCLine, output, (const Vector *)center, &AtomNo );
+    delete(center);
+    *output << "\t}" << endl;
+    *output << ")" << endl;
+    *output << "basis<GaussianBasisSet>: (" << endl;
+    *output << "\tname = \"" << basis << "\"" << endl;
+    *output << "\tmolecule = $:molecule" << endl;
+    *output << ")" << endl;
+    output->close();
+    delete(output);
+    delete(fname);
+  }
   // second with hessian
+  fname = new stringstream;
+  *fname << filename << ".hess.in";
+  output = new ofstream(fname->str().c_str(), ios::out);
+  *output << "% Created by MoleCuilder" << endl;
+  *output << "mpqc: (" << endl;
+  *output << "\tsavestate = no" << endl;
+  *output << "\tdo_gradient = yes" << endl;
+  *output << "\tmole<CLHF>: (" << endl;
+  *output << "\t\tmaxiter = 200" << endl;
+  *output << "\t\tbasis = $:basis" << endl;
+  *output << "\t\tmolecule = $:molecule" << endl;
+  *output << "\t)" << endl;
+  *output << "\tfreq<MolecularFrequencies>: (" << endl;
+  *output << "\t\tmolecule=$:molecule" << endl;
+  *output << "\t)" << endl;
+  *output << ")" << endl;
+  *output << "molecule<Molecule>: (" << endl;
+  *output << "\tunit = " << (IsAngstroem ? "angstrom" : "bohr" ) << endl;
+  *output << "\t{ atoms geometry } = {" << endl;
+  center = mol->DetermineCenterOfAll(output);
+  // output of atoms
+  runner = mol->elemente->start;
+  while (runner->next != mol->elemente->end) { // go through every element
+    runner = runner->next;
+    if (mol->ElementsInMolecule[runner->Z]) { // if this element got atoms
+      ElementNo++;
+      AtomNo = 0;
+      Walker = mol->start;
+      while (Walker->next != mol->end) { // go through every atom of this element
+        Walker = Walker->next;
+        if (Walker->type == runner) { // if this atom fits to element
+          AtomNo++;
+          *output << "\t\t" << Walker->type->symbol << " [ " << Walker->x.x[0]-center->x[0] << "\t" << Walker->x.x[1]-center->x[1] << "\t" << Walker->x.x[2]-center->x[2] << " ]" << endl;
+        }
+      }
+    }
+  }
+  delete(center);
+  *output << "\t}" << endl;
+  *output << ")" << endl;
+  *output << "basis<GaussianBasisSet>: (" << endl;
+  *output << "\tname = \"3-21G\"" << endl;
+  *output << "\tmolecule = $:molecule" << endl;
+  *output << ")" << endl;
+  output->close();
+  delete(output);
+  delete(fname);
+  {
+    stringstream * const fname = new stringstream;
+    *fname << filename << ".hess.in";
+    output = new ofstream(fname->str().c_str(), ios::out);
+    *output << "% Created by MoleCuilder" << endl;
+    *output << "mpqc: (" << endl;
+    *output << "\tsavestate = no" << endl;
+    *output << "\tdo_gradient = yes" << endl;
+    *output << "\tmole<CLHF>: (" << endl;
+    *output << "\t\tmaxiter = 200" << endl;
+    *output << "\t\tbasis = $:basis" << endl;
+    *output << "\t\tmolecule = $:molecule" << endl;
+    *output << "\t)" << endl;
+    *output << "\tfreq<MolecularFrequencies>: (" << endl;
+    *output << "\t\tmolecule=$:molecule" << endl;
+    *output << "\t)" << endl;
+    *output << ")" << endl;
+    *output << "molecule<Molecule>: (" << endl;
+    *output << "\tunit = " << (IsAngstroem ? "angstrom" : "bohr" ) << endl;
+    *output << "\t{ atoms geometry } = {" << endl;
+    center = mol->DetermineCenterOfAll(output);
+    // output of atoms
+    AtomNo = 0;
+    mol->ActOnAllAtoms( &atom::OutputMPQCLine, output, (const Vector *)center, &AtomNo );
+    delete(center);
+    *output << "\t}" << endl;
+    *output << ")" << endl;
+    *output << "basis<GaussianBasisSet>: (" << endl;
+    *output << "\tname = \"3-21G\"" << endl;
+    *output << "\tmolecule = $:molecule" << endl;
+    *output << ")" << endl;
+    output->close();
+    delete(output);
+    delete(fname);
+  }
   return true;
 …
  * \note Routine is taken from the pcp project and hack-a-slack adapted to C++
  */
+int config::ParseForParameter(int verbose, ifstream *file, const char *name, int sequential, int const xth, int const yth, int type, void *value, int repetition, int critical) {
+  int i,j;  // loop variables
+  int length = 0, maxlength = -1;
+int ParseForParameter(const int verbose, ifstream * const file, const char * const name, const int sequential, const int xth, const int yth, const int type, void * value, const int repetition, const int critical) {
+  int i = 0;
+  int j = 0;  // loop variables
+  int length = 0;
+  int maxlength = -1;
   long file_position = file->tellg(); // mark current position
+  char *dummy1, *dummy, *free_dummy;    // pointers in the line that is read in per step
+  dummy1 = free_dummy = Malloc<char>(256, "config::ParseForParameter: *free_dummy");
+  char *dummy1 = NULL;
+  char *dummy = NULL;
+  char * const free_dummy = Malloc<char>(256, "config::ParseForParameter: *free_dummy");    // pointers in the line that is read in per step
+  dummy1 = free_dummy;
   //fprintf(stderr,"Parsing for %s\n",name);
 …
       if (file->eof()) {
         if ((critical) && (found == 0)) {
           Free(&free_dummy);
+          Free(free_dummy);
           //Error(InitReading, name);
           fprintf(stderr,"Error:InitReading, critical %s not found\n", name);
 …
           file->clear();
           file->seekg(file_position, ios::beg);  // rewind to start position
           Free(&free_dummy);
+          Free(free_dummy);
           return 0;
+        }
 …
               if (file->eof()) {
                 if ((critical) && (found == 0)) {
                   Free(&free_dummy);
+                  Free(free_dummy);
                   //Error(InitReading, name);
                   fprintf(stderr,"Error:InitReading, critical %s not found\n", name);
 …
                   file->clear();
                   file->seekg(file_position, ios::beg);  // rewind to start position
                   Free(&free_dummy);
+                  Free(free_dummy);
                   return 0;
+                }
 …
                   if (critical) {
                     if (verbose) fprintf(stderr,"Error: EoL at %i and still missing %i value(s) for parameter %s\n", line, yth-j, name);
                     Free(&free_dummy);
+                    Free(free_dummy);
                     //return 0;
                     exit(255);
 …
                     file->clear();
                     file->seekg(file_position, ios::beg);  // rewind to start position
                     Free(&free_dummy);
+                    Free(free_dummy);
                     return 0;
+                  }
 …
                   file->seekg(file_position, ios::beg);  // rewind to start position
+                }
                 Free(&free_dummy);
+                Free(free_dummy);
                 return 0;
+              }
 …
   if ((type >= row_int) && (verbose))
     fprintf(stderr,"\n");
   Free(&free_dummy);
+  Free(free_dummy);
   if (!sequential) {
     file->clear();
 …
  * \note Routine is taken from the pcp project and hack-a-slack adapted to C++
  */
+int config::ParseForParameter(int verbose, struct ConfigFileBuffer *FileBuffer, const char *name, int sequential, int const xth, int const yth, int type, void *value, int repetition, int critical) {
+  int i,j;  // loop variables
+  int length = 0, maxlength = -1;
+int ParseForParameter(const int verbose, struct ConfigFileBuffer * const FileBuffer, const char * const name, const int sequential, const int xth, const int yth, const int type, void * value, const int repetition, const int critical) {
+  int i = 0;
+  int j = 0;  // loop variables
+  int length = 0;
+  int maxlength = -1;
   int OldCurrentLine = FileBuffer->CurrentLine;
+  char *dummy1, *dummy;    // pointers in the line that is read in per step
+  char *dummy1 = NULL;
+  char *dummy = NULL;    // pointers in the line that is read in per step
   //fprintf(stderr,"Parsing for %s\n",name);

src/config.hpp

-              r06c7a3
+              r7326b2
 using namespace std;
+class MoleculeListClass;
 /*********************************************** includes ***********************************/
 …
 #include <string>
+#include "bondgraph.hpp"
 /****************************************** forward declarations *****************************/
 …
     ConfigFileBuffer();
     ConfigFileBuffer(char *filename);
+    ConfigFileBuffer(const char * const filename);
     ~ConfigFileBuffer();
     void InitMapping();
     void MapIonTypesInBuffer(int NoAtoms);
+    void MapIonTypesInBuffer(const int NoAtoms);
 };
 …
 class config {
   public:
+    class BondGraph *BG;
     int PsiType;
     int MaxPsiDouble;
 …
-  int ParseForParameter(int verbose, ifstream *file, const char *name, int sequential, int const xth, int const yth, int type, void *value, int repetition, int critical);
-  int ParseForParameter(int verbose, struct ConfigFileBuffer *FileBuffer, const char *name, int sequential, int const xth, int const yth, int type, void *value, int repetition, int critical);
   public:
   config();
   ~config();
   int TestSyntax(char *filename, periodentafel *periode, molecule *mol);
   void Load(char *filename, periodentafel *periode, molecule *mol);
   void LoadOld(char *filename, periodentafel *periode, molecule *mol);
   void RetrieveConfigPathAndName(string filename);
   bool Save(const char *filename, periodentafel *periode, molecule *mol) const;
   bool SaveMPQC(const char *filename, molecule *mol) const;
+  int TestSyntax(const char * const filename, const periodentafel * const periode) const;
+  void Load(const char * const filename, const string &BondGraphFileName, const periodentafel * const periode, MoleculeListClass * const &MolList);
+  void LoadOld(const char * const filename, const string &BondGraphFileName, const periodentafel * const periode, MoleculeListClass * const &MolList);
+  void RetrieveConfigPathAndName(const string filename);
+  bool Save(const char * const filename, const periodentafel * const periode, molecule * const mol) const;
+  bool SaveMPQC(const char * const filename, const molecule * const mol) const;
   void Edit();
   bool GetIsAngstroem() const;
   char *GetDefaultPath() const;
+  void SetDefaultPath(const char *path);
+  void InitThermostats(class ConfigFileBuffer *fb);
+  void SetDefaultPath(const char * const path);
+  void InitThermostats();
+  void ParseThermostats(class ConfigFileBuffer * const fb);
 };
+int ParseForParameter(const int verbose, ifstream * const file, const char * const name, const int sequential, const int xth, const int yth, const int type, void * value, const int repetition, const int critical);
+int ParseForParameter(const int verbose, struct ConfigFileBuffer * const FileBuffer, const char * const name, const int sequential, const int xth, const int yth, const int type, void * value, const int repetition, const int critical);
+void LoadMolecule(molecule * const &mol, struct ConfigFileBuffer * const &FileBuffer, const periodentafel * const periode, const bool FastParsing);
+void PrepareFileBuffer(const char * const filename, struct ConfigFileBuffer *&FileBuffer);
 #endif /* CONFIG_HPP_ */

src/ellipsoid.cpp

-              r06c7a3
+              r7326b2
   int index;
   TesselPoint *Candidate = NULL;
-  LinkedNodes *List = NULL;
   *out << Verbose(2) << "Begin of PickRandomPointSet" << endl;
 …
     *out << Verbose(2) << "INFO: Center cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " ... ";
     // get random cell
     List = LC->GetCurrentCell();
+    const LinkedNodes *List = LC->GetCurrentCell();
     if (List == NULL) {  // set index to it
       continue;
 …
       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();
+          const LinkedNodes *List = LC->GetCurrentCell();
           PointsLeft += List->size();
+        }
 …
       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();
+          const LinkedNodes *List = LC->GetCurrentCell();
 //          *out << Verbose(2) << "Current cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << " containing " << List->size() << " points." << endl;
           if (List != NULL) {
 …
 //            else
 //              *out << Verbose(2) << "Cell is empty ... " << endl;
             for (LinkedNodes::iterator Runner = List->begin(); Runner != List->end(); Runner++) {
+            for (LinkedNodes::const_iterator Runner = List->begin(); Runner != List->end(); Runner++) {
               if ((current != PickedAtomNrs.end()) && (*current == index)) {
                 Candidate = (*Runner);

src/helpers.cpp

-              r06c7a3
+              r7326b2
 #include "helpers.hpp"
+#include "memoryusageobserver.hpp"
 /********************************************** helpful functions *********************************/
 …
   while (*b < lower_bound)
     *b += step;
-};
-/** Flips two doubles.
- * \param *x pointer to first double
- * \param *y pointer to second double
- */
-void flip(double *x, double *y)
+{
-  double tmp;
-  tmp = *x;
-  *x = *y;
-  *y = tmp;
 };
 …
  * \return allocated NDIM*NDIM array with the symmetric matrix
  */
 double * ReturnFullMatrixforSymmetric(double *symm)
+double * ReturnFullMatrixforSymmetric(const double * const symm)
+{
   double *matrix = Malloc<double>(NDIM * NDIM, "molecule::ReturnFullMatrixforSymmetric: *matrix");
 …
 };
+/** Calculate the inverse of a 3x3 matrix.
+ * \param *matrix NDIM_NDIM array
+ */
+double * InverseMatrix( const double * const A)
+{
+  double *B = Malloc<double>(NDIM * NDIM, "Vector::InverseMatrix: *B");
+  double detA = RDET3(A);
+  double detAReci;
+  for (int i=0;i<NDIM*NDIM;++i)
+    B[i] = 0.;
+  // calculate the inverse B
+  if (fabs(detA) > MYEPSILON) {;  // RDET3(A) yields precisely zero if A irregular
+    detAReci = 1./detA;
+    B[0] =  detAReci*RDET2(A[4],A[5],A[7],A[8]);    // A_11
+    B[1] = -detAReci*RDET2(A[1],A[2],A[7],A[8]);    // A_12
+    B[2] =  detAReci*RDET2(A[1],A[2],A[4],A[5]);    // A_13
+    B[3] = -detAReci*RDET2(A[3],A[5],A[6],A[8]);    // A_21
+    B[4] =  detAReci*RDET2(A[0],A[2],A[6],A[8]);    // A_22
+    B[5] = -detAReci*RDET2(A[0],A[2],A[3],A[5]);    // A_23
+    B[6] =  detAReci*RDET2(A[3],A[4],A[6],A[7]);    // A_31
+    B[7] = -detAReci*RDET2(A[0],A[1],A[6],A[7]);    // A_32
+    B[8] =  detAReci*RDET2(A[0],A[1],A[3],A[4]);    // A_33
+  }
+  return B;
+};
+/** hard-coded determinant of a 3x3 matrix.
+ * \param a[9] matrix
+ * \return \f$det(a)\f$
+ */
+double RDET3(const double a[NDIM*NDIM])
+{
+  return ((a)[0]*(a)[4]*(a)[8] + (a)[3]*(a)[7]*(a)[2] + (a)[6]*(a)[1]*(a)[5] - (a)[2]*(a)[4]*(a)[6] - (a)[5]*(a)[7]*(a)[0] - (a)[8]*(a)[1]*(a)[3]);
+};
+/** hard-coded determinant of a 2x2 matrix.
+ * \param a[4] matrix
+ * \return \f$det(a)\f$
+ */
+double RDET2(const double a[4])
+{
+  return ((a[0])*(a[3])-(a[1])*(a[2]));
+};
+/** hard-coded determinant of a 2x2 matrix.
+ * \param a0 (0,0) entry of matrix
+ * \param a1 (0,1) entry of matrix
+ * \param a2 (1,0) entry of matrix
+ * \param a3 (1,1) entry of matrix
+ * \return \f$det(a)\f$
+ */
+double RDET2(const double a0, const double a1, const double a2, const double a3)
+{
+  return ((a0)*(a3)-(a1)*(a2));
+};
 /** Comparison function for GSL heapsort on distances in two molecules.
  * \param *a
 …
  * Frees all memory registered by the memory observer and calls exit(225) afterwards.
  */
 static void performCriticalExit() {
+void performCriticalExit() {
   map<void*, size_t> pointers = MemoryUsageObserver::getInstance()->getPointersToAllocatedMemory();
   for (map<void*, size_t>::iterator runner = pointers.begin(); runner != pointers.end(); runner++) {

src/helpers.hpp

Property mode changed from 100755 to 100644

-              r06c7a3
+              r7326b2
 #include <fstream>
+#include "defs.hpp"
 #include "memoryallocator.hpp"
+/********************************************** definitions *********************************/
+// some algebraic matrix stuff
+double RDET3(const double a[NDIM*NDIM]);
+double RDET2(const double a[4]);
+double RDET2(const double a0, const double a1, const double a2, const double a3);
 /********************************************** helpful functions *********************************/
 …
 bool check_bounds(double *x, double *cell_size);
 void bound(double *b, double lower_bound, double upper_bound);
-void flip(double *x, double *y);
 int pot(int base, int n);
 int CountLinesinFile(ifstream &InputFile);
 …
 bool IsValidNumber( const char *string);
 int CompareDoubles (const void * a, const void * b);
+double * ReturnFullMatrixforSymmetric(double *cell_size);
+static void performCriticalExit();
+double * ReturnFullMatrixforSymmetric(const double * const cell_size);
+double * InverseMatrix(const double * const A);
+void performCriticalExit();
 /********************************************** helpful template functions *********************************/
+/** Flips two values.
+ * \param x first value
+ * \param y second value
+ */
+template <typename T> void flip(T &x, T &y)
+{
+  T tmp;
+  tmp = x;
+  x = y;
+  y = tmp;
+};
 /** Creates a lookup table for true father's Atom::Nr -> atom ptr.
 …
  * \paran *end end of chain list
  * \param **Lookuptable pointer to return allocated lookup table (should be NULL on start)
  * \param count optional predetermined count for table (otherwise we set the count to highest true father id)
+ * \param count optional predetermined size for table (otherwise we set the count to highest true father id)
  * \return true - success, false - failure
  */
 …
+  }
   // allocat and fill
   LookupTable = Malloc<T*>(count, "CreateFatherLookupTable - **LookupTable");
+  // allocate and fill
+  LookupTable = Calloc<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

src/leastsquaremin.cpp

-              r06c7a3
+              r7326b2
  * \return sum of square distances
  */
 double LSQ (const gsl_vector * x, void * params)
+double LSQ (const gsl_vector * const x, void * params)
+{
   double sum = 0.;
   struct LSQ_params *par = (struct LSQ_params *)params;
   Vector **vectors = par->vectors;
+  const Vector ** vectors = par->vectors;
   int num = par->num;

src/leastsquaremin.hpp

-              r06c7a3
+              r7326b2
  */
 struct LSQ_params {
   Vector **vectors;
+  const Vector **vectors;
   int num;
 };
 double LSQ(const gsl_vector * x, void * params);
+double LSQ(const gsl_vector * const x, void * params);
 /** Parameter structure for least square minimsation.

src/linkedcell.cpp

-              r06c7a3
+              r7326b2
  * \param RADIUS edge length of cells
  */
 LinkedCell::LinkedCell(PointCloud *set, double radius)
+LinkedCell::LinkedCell(const PointCloud * const set, const double radius)
+{
   TesselPoint *Walker = NULL;
 …
  * \param RADIUS edge length of cells
  */
 LinkedCell::LinkedCell(LinkedNodes *set, double radius)
+LinkedCell::LinkedCell(LinkedNodes *set, const double radius)
+{
   class TesselPoint *Walker = NULL;
 …
  * \return if all in intervals - true, else -false
  */
 bool LinkedCell::CheckBounds()
+bool LinkedCell::CheckBounds() const
+{
   bool status = true;
 …
 };
+/** Checks whether LinkedCell::n[] plus relative offset is each within [0,N[]].
+ * Note that for this check we don't admonish if out of bounds.
+ * \param relative[NDIM] relative offset to current cell
+ * \return if all in intervals - true, else -false
+ */
+bool LinkedCell::CheckBounds(const int relative[NDIM]) const
+{
+  bool status = true;
+  for(int i=0;i<NDIM;i++)
+    status = status && ((n[i]+relative[i] >=0) && (n[i]+relative[i] < N[i]));
+  return status;
+};
 /** Returns a pointer to the current cell.
  * \return LinkedAtoms pointer to current cell, NULL if LinkedCell::n[] are out of bounds.
  */
+LinkedNodes* LinkedCell::GetCurrentCell()
+const LinkedNodes* LinkedCell::GetCurrentCell() const
+{
   if (CheckBounds()) {
 …
 };
+/** Returns a pointer to the current cell.
+ * \param relative[NDIM] offset for each axis with respect to the current cell LinkedCell::n[NDIM]
+ * \return LinkedAtoms pointer to current cell, NULL if LinkedCell::n[]+relative[] are out of bounds.
+ */
+const LinkedNodes* LinkedCell::GetRelativeToCurrentCell(const int relative[NDIM]) const
+{
+  if (CheckBounds(relative)) {
+    index = (n[0]+relative[0]) * N[1] * N[2] + (n[1]+relative[1]) * N[2] + (n[2]+relative[2]);
+    return (&(LC[index]));
+  } else {
+    return NULL;
+  }
+};
 /** Calculates the index for a given LCNode *Walker.
  * \param *Walker LCNode to set index tos
  * \return if the atom is also found in this cell - true, else - false
  */
 bool LinkedCell::SetIndexToNode(const TesselPoint *Walker)
+bool LinkedCell::SetIndexToNode(const TesselPoint * const Walker) const
+{
   bool status = false;
 …
  * \param *upper upper bounds
  */
 void LinkedCell::GetNeighbourBounds(int lower[NDIM], int upper[NDIM])
+void LinkedCell::GetNeighbourBounds(int lower[NDIM], int upper[NDIM]) const
+{
   for (int i=0;i<NDIM;i++) {
 …
  * \return Vector is inside bounding box - true, else - false
  */
 bool LinkedCell::SetIndexToVector(const Vector *x)
+bool LinkedCell::SetIndexToVector(const Vector * const x) const
+{
   bool status = true;

src/linkedcell.hpp

-              r06c7a3
+              r7326b2
     double RADIUS;    // cell edge length
     int N[NDIM];      // number of cells per axis
     int n[NDIM];      // temporary variable for current cell per axis
     int index;        // temporary index variable , access by index = n[0] * N[1] * N[2] + n[1] * N[2] + n[2];
+    mutable int n[NDIM];      // temporary variable for current cell per axis
+    mutable int index;        // temporary index variable , access by index = n[0] * N[1] * N[2] + n[1] * N[2] + n[2];
     LinkedCell();
     LinkedCell(PointCloud *set, double RADIUS);
     LinkedCell(LinkedNodes *set, double radius);
+    LinkedCell(const  PointCloud * const set, const double RADIUS);
+    LinkedCell(LinkedNodes *set, const double radius);
     ~LinkedCell();
+    LinkedNodes* GetCurrentCell();
+    bool SetIndexToNode(const TesselPoint *Walker);
+    bool SetIndexToVector(const Vector *x);
+    bool CheckBounds();
+    void GetNeighbourBounds(int lower[NDIM], int upper[NDIM]);
+    const LinkedNodes* GetCurrentCell()const ;
+    const LinkedNodes* GetRelativeToCurrentCell(const int relative[NDIM])const ;
+    bool SetIndexToNode(const TesselPoint * const Walker)const ;
+    bool SetIndexToVector(const Vector * const x)const ;
+    bool CheckBounds()const ;
+    bool CheckBounds(const int relative[NDIM])const ;
+    void GetNeighbourBounds(int lower[NDIM], int upper[NDIM])const ;
     // not implemented yet

src/lists.hpp

-              r06c7a3
+              r7326b2
   if (walker->previous != NULL)
     walker->previous->next = walker->next;
+  walker->next = NULL;
+  walker->previous= NULL;
 };
 …
+{
   X *pointer = start->next;
   X *walker;
+  X *walker = NULL;
   while (pointer != end) { // go through list
     walker = pointer; // mark current
     pointer = pointer->next; // step onward beforehand
     // remove walker
+    unlink(walker);
+    delete(walker);
+    walker = NULL;
+    removewithoutcheck(walker);
+  }
   return true;

src/memoryallocator.hpp

-              r06c7a3
+              r7326b2
 template <> char* Malloc<char>(size_t size, const char* output);
 /** Allocates a memory range using calloc().
+/* Allocates a memory range using calloc().
  * Prints the provided error message in case of a failure.
+ *
 …
  * \param failure message which is printed if the allocation fails
  * \return pointer to the allocated memory range, will be NULL if a failure occurred
  */
+*/
 template <typename X> X* Calloc(size_t size, const char* output)
+{
   X* buffer = NULL;
   buffer = (X*) calloc(sizeof(X) * size, (size_t) 0);
+  buffer = (X*) calloc(size, sizeof(X));
   if (buffer != NULL) {
 …
   return buffer;
 };
 /** Reallocates a memory range using realloc(). If the provided pointer to the old
 …
 };
 /** Frees allocated memory range using free().
+/** Frees allocated memory range using free(), NULL'ing \a **buffer.
+ *
  * \param pointer to the allocated memory range to free; may be NULL, this function is a no-op then
+ * \param **buffer to the allocated memory range to free; may be NULL, this function is a no-op then
  * \param *msg optional error message
  */
 …
 };
+/** Frees allocated memory range using free() for ... * const \a buffer types.
+ *
+ * \param *buffer to the allocated memory range to free; may be NULL, this function is a no-op then
+ * \param *msg optional error message
+ */
+template <typename X> void Free(X* const buffer, const char *msg = NULL)
+{
+  if ((buffer == NULL))
+    return;
+  MemoryUsageObserver::getInstance()->removeMemory(buffer, msg);
+  free(buffer);
+};
 #endif /*MEMORYALLOCATOR_HPP_*/

src/memoryusageobserver.cpp

-              r06c7a3
+              r7326b2
  */
 MemoryUsageObserver::~MemoryUsageObserver() {
+  for (map<void*, size_t>::iterator current = memoryUsers.begin(); current != memoryUsers.end(); current++) {
+  while (!memoryUsers.empty()) {
+    map<void*, size_t>::iterator current = memoryUsers.begin();
+    free(current->first);
     memoryUsers.erase(current);
+  }

src/molecule.cpp

-              r06c7a3
+              r7326b2
  * Initialises molecule list with correctly referenced start and end, and sets molecule::last_atom to zero.
  */
+molecule::molecule(periodentafel *teil)
+molecule::molecule(const periodentafel * const teil) : elemente(teil), start(new atom), end(new atom),
+  first(new bond(start, end, 1, -1)), last(new bond(start, end, 1, -1)), MDSteps(0), AtomCount(0),
+  BondCount(0), ElementCount(0), NoNonHydrogen(0), NoNonBonds(0), NoCyclicBonds(0), BondDistance(0.),
+  ActiveFlag(false), IndexNr(-1), last_atom(0), InternalPointer(start)
+{
   // init atom chain list
-  start = new atom;
-  end = new atom;
   start->father = NULL;
   end->father = NULL;
   link(start,end);
+  InternalPointer = start;
   // init bond chain list
-  first = new bond(start, end, 1, -1);
-  last = new bond(start, end, 1, -1);
   link(first,last);
   // other stuff
-  MDSteps = 0;
-  last_atom = 0;
-  elemente = teil;
-  AtomCount = 0;
-  BondCount = 0;
-  NoNonBonds = 0;
-  NoNonHydrogen = 0;
-  NoCyclicBonds = 0;
-  ListOfBondsPerAtom = NULL;
-  NumberOfBondsPerAtom = NULL;
-  ElementCount = 0;
   for(int i=MAX_ELEMENTS;i--;)
     ElementsInMolecule[i] = 0;
 …
   cell_size[1] = cell_size[3] = cell_size[4]= 0.;
   strcpy(name,"none");
-  IndexNr  = -1;
-  ActiveFlag = false;
-  TesselStruct = NULL;
 };
 …
 molecule::~molecule()
+{
-  if (ListOfBondsPerAtom != NULL)
-    for(int i=AtomCount;i--;)
-      Free(&ListOfBondsPerAtom[i]);
-  Free(&ListOfBondsPerAtom);
-  Free(&NumberOfBondsPerAtom);
-  if (TesselStruct != NULL)
-    delete(TesselStruct);
   CleanupMolecule();
   delete(first);
 …
  * \param *origin pointer to atom which acts as the origin for scaling the added hydrogen to correct bond length
  * \param *replacement pointer to the atom which shall be copied as a hydrogen atom in this molecule
- * \param **BondList list of bonds \a *replacement has (necessary to determine plane for double and triple bonds)
- * \param NumBond  number of bonds in \a **BondList
  * \param isAngstroem whether the coordination of the given atoms is in AtomicLength (false) or Angstrom(true)
  * \return number of atoms added, if < bond::BondDegree then something went wrong
  * \todo double and triple bonds splitting (always use the tetraeder angle!)
  */
 bool molecule::AddHydrogenReplacementAtom(ofstream *out, bond *TopBond, atom *BottomOrigin, atom *TopOrigin, atom *TopReplacement, bond **BondList, int NumBond, bool IsAngstroem)
+bool molecule::AddHydrogenReplacementAtom(ofstream *out, bond *TopBond, atom *BottomOrigin, atom *TopOrigin, atom *TopReplacement, bool IsAngstroem)
+{
   double bondlength;  // bond length of the bond to be replaced/cut
 …
   Vector Orthovector1, Orthovector2;  // temporary vectors in coordination construction
   Vector InBondvector;    // vector in direction of *Bond
+  double *matrix;
   bond *Binder = NULL;
-  double *matrix;
 //  *out << Verbose(3) << "Begin of AddHydrogenReplacementAtom." << endl;
 …
     case 2:
       // determine two other bonds (warning if there are more than two other) plus valence sanity check
       for (int i=0;i<NumBond;i++) {
         if (BondList[i] != TopBond) {
+      for (BondList::const_iterator Runner = TopOrigin->ListOfBonds.begin(); Runner != TopOrigin->ListOfBonds.end(); (++Runner)) {
+        if ((*Runner) != TopBond) {
           if (FirstBond == NULL) {
             FirstBond = BondList[i];
             FirstOtherAtom = BondList[i]->GetOtherAtom(TopOrigin);
+            FirstBond = (*Runner);
+            FirstOtherAtom = (*Runner)->GetOtherAtom(TopOrigin);
           } else if (SecondBond == NULL) {
             SecondBond = BondList[i];
             SecondOtherAtom = BondList[i]->GetOtherAtom(TopOrigin);
+            SecondBond = (*Runner);
+            SecondOtherAtom = (*Runner)->GetOtherAtom(TopOrigin);
           } else {
             *out << Verbose(3) << "WARNING: Detected more than four bonds for atom " << TopOrigin->Name;
 …
     // get the pendant atoms of current bond in the copy molecule
     copy->ActOnAllAtoms( &atom::EqualsFather, Binder->leftatom, &LeftAtom );
     copy->ActOnAllAtoms( &atom::EqualsFather, Binder->rightatom, &RightAtom );
+    copy->ActOnAllAtoms( &atom::EqualsFather, (const atom *)Binder->leftatom, (const atom **)&LeftAtom );
+    copy->ActOnAllAtoms( &atom::EqualsFather, (const atom *)Binder->rightatom, (const atom **)&RightAtom );
     NewBond = copy->AddBond(LeftAtom, RightAtom, Binder->BondDegree);
 …
   if (first->next != last) {  // if adjaceny list is present
     copy->BondDistance = BondDistance;
-    copy->CreateListOfBondsPerAtom((ofstream *)&cout);
+  }
 …
  * @param three vectors forming the matrix that defines the shape of the parallelpiped
  */
 molecule* molecule::CopyMoleculeFromSubRegion(Vector offset, double *parallelepiped) {
+molecule* molecule::CopyMoleculeFromSubRegion(const Vector offset, const double *parallelepiped) const {
   molecule *copy = new molecule(elemente);
 …
   if ((atom1 != NULL) && (FindAtom(atom1->nr) != NULL) && (atom2 != NULL) && (FindAtom(atom2->nr) != NULL)) {
     Binder = new bond(atom1, atom2, degree, BondCount++);
+    atom1->RegisterBond(Binder);
+    atom2->RegisterBond(Binder);
     if ((atom1->type != NULL) && (atom1->type->Z != 1) && (atom2->type != NULL) && (atom2->type->Z != 1))
       NoNonBonds++;
 …
 };
 /** Remove bond from bond chain list.
+/** Remove bond from bond chain list and from the both atom::ListOfBonds.
  * \todo Function not implemented yet
  * \param *pointer bond pointer
 …
+{
   //cerr << Verbose(1) << "molecule::RemoveBond: Function not implemented yet." << endl;
+  pointer->leftatom->RegisterBond(pointer);
+  pointer->rightatom->RegisterBond(pointer);
   removewithoutcheck(pointer);
   return true;
 …
 bool molecule::RemoveBonds(atom *BondPartner)
+{
+  cerr << Verbose(1) << "molecule::RemoveBond: Function not implemented yet." << endl;
+  //cerr << Verbose(1) << "molecule::RemoveBond: Function not implemented yet." << endl;
+  BondList::const_iterator ForeRunner;
+  while (!BondPartner->ListOfBonds.empty()) {
+    ForeRunner = BondPartner->ListOfBonds.begin();
+    RemoveBond(*ForeRunner);
+  }
   return false;
 };
 …
   if (ElementsInMolecule[pointer->type->Z] == 0)  // was last atom of this element?
     ElementCount--;
+  RemoveBonds(pointer);
   return remove(pointer, start, end);
 };
 …
 bool molecule::CleanupMolecule()
+{
   return (cleanup(start,end) && cleanup(first,last));
+  return (cleanup(first,last) && cleanup(start,end));
 };
 …
         ElementNo[i] = current++;
+    }
     ActOnAllAtoms( &atom::Output, out, ElementNo, AtomNo, (const char *) NULL ); // (bool (atom::*)(int *, int *, ofstream *, const char *))
+    ActOnAllAtoms( &atom::OutputArrayIndexed, (ofstream *)out, (const int *)ElementNo, (int *)AtomNo, (const char *) NULL );
     return true;
+  }
 …
           ElementNo[i] = current++;
+      }
       ActOnAllAtoms( &atom::OutputTrajectory, out, ElementNo, AtomNo, step );
+      ActOnAllAtoms( &atom::OutputTrajectory, out, (const int *)ElementNo, AtomNo, (const int)step );
+    }
     return true;
 …
 };
 /** Outputs contents of molecule::ListOfBondsPerAtom.
+/** Outputs contents of each atom::ListOfBonds.
  * \param *out output stream
  */
 void molecule::OutputListOfBonds(ofstream *out) const
+{
   *out << Verbose(2) << endl << "From Contents of ListOfBondsPerAtom, all non-hydrogen atoms:" << endl;
   ActOnAllAtoms (&atom::OutputBondOfAtom, out, NumberOfBondsPerAtom, ListOfBondsPerAtom);
+  *out << Verbose(2) << endl << "From Contents of ListOfBonds, all non-hydrogen atoms:" << endl;
+  ActOnAllAtoms (&atom::OutputBondOfAtom, out);
   *out << endl;
 };
 …
 };
-/** Creates an 2d array of pointer with an entry for each atom and each bond it has.
- * Updates molecule::ListOfBondsPerAtom, molecule::NumberOfBondsPerAtom by parsing through
- * bond chain list, using molecule::AtomCount and molecule::BondCount.
- * Allocates memory, fills the array and exits
- * \param *out output stream for debugging
- */
-void molecule::CreateListOfBondsPerAtom(ofstream *out)
+{
-  bond *Binder = NULL;
-  *out << Verbose(1) << "Begin of Creating ListOfBondsPerAtom: AtomCount = " << AtomCount << "\tBondCount = " << BondCount << "\tNoNonBonds = " << NoNonBonds << "." << endl;
-  // re-allocate memory
-  *out << Verbose(2) << "(Re-)Allocating memory." << endl;
-  if (ListOfBondsPerAtom != NULL) {
-    for(int i=AtomCount;i--;)
-      Free(&ListOfBondsPerAtom[i]);
-    Free(&ListOfBondsPerAtom);
+  }
-  if (NumberOfBondsPerAtom != NULL)
-    Free(&NumberOfBondsPerAtom);
-  ListOfBondsPerAtom = Malloc<bond**>(AtomCount, "molecule::CreateListOfBondsPerAtom: ***ListOfBondsPerAtom");
-  NumberOfBondsPerAtom = Malloc<int>(AtomCount, "molecule::CreateListOfBondsPerAtom: *NumberOfBondsPerAtom");
-  // reset bond counts per atom
-  for(int i=AtomCount;i--;)
-    NumberOfBondsPerAtom[i] = 0;
-  // count bonds per atom
-  Binder = first;
-  while (Binder->next != last) {
-    Binder = Binder->next;
-    NumberOfBondsPerAtom[Binder->leftatom->nr]++;
-    NumberOfBondsPerAtom[Binder->rightatom->nr]++;
+  }
-  for(int i=AtomCount;i--;) {
-    // allocate list of bonds per atom
-    ListOfBondsPerAtom[i] = Malloc<bond*>(NumberOfBondsPerAtom[i], "molecule::CreateListOfBondsPerAtom: **ListOfBondsPerAtom[]");
-    // clear the list again, now each NumberOfBondsPerAtom marks current free field
-    NumberOfBondsPerAtom[i] = 0;
+  }
-  // fill the list
-  Binder = first;
-  while (Binder->next != last) {
-    Binder = Binder->next;
-    ListOfBondsPerAtom[Binder->leftatom->nr][NumberOfBondsPerAtom[Binder->leftatom->nr]++] = Binder;
-    ListOfBondsPerAtom[Binder->rightatom->nr][NumberOfBondsPerAtom[Binder->rightatom->nr]++] = Binder;
+  }
-  // output list for debugging
-  *out << Verbose(3) << "ListOfBondsPerAtom for each atom:" << endl;
-  ActOnAllAtoms( &atom::OutputBondOfAtom, out, NumberOfBondsPerAtom, ListOfBondsPerAtom );
-  *out << Verbose(1) << "End of Creating ListOfBondsPerAtom." << endl << endl;
-};
 /** Determines whether two molecules actually contain the same atoms and coordination.
  * \param *out output stream for debugging
 …
   if (result) {
     *out << Verbose(5) << "Calculating distances" << endl;
     Distances = Malloc<double>(AtomCount, "molecule::IsEqualToWithinThreshold: Distances");
     OtherDistances = Malloc<double>(AtomCount, "molecule::IsEqualToWithinThreshold: OtherDistances");
     SetIndexedArrayForEachAtomTo ( Distances, &atom::nr, &atom::DistanceSquaredToVector, CenterOfGravity);
     SetIndexedArrayForEachAtomTo ( OtherDistances, &atom::nr, &atom::DistanceSquaredToVector, CenterOfGravity);
+    Distances = Calloc<double>(AtomCount, "molecule::IsEqualToWithinThreshold: Distances");
+    OtherDistances = Calloc<double>(AtomCount, "molecule::IsEqualToWithinThreshold: OtherDistances");
+    SetIndexedArrayForEachAtomTo ( Distances, &atom::nr, &atom::DistanceSquaredToVector, (const Vector &)CenterOfGravity);
+    SetIndexedArrayForEachAtomTo ( OtherDistances, &atom::nr, &atom::DistanceSquaredToVector, (const Vector &)CenterOfGravity);
     /// ... sort each list (using heapsort (o(N log N)) from GSL)
     *out << Verbose(5) << "Sorting distances" << endl;
     PermMap = Malloc<size_t>(AtomCount, "molecule::IsEqualToWithinThreshold: *PermMap");
     OtherPermMap = Malloc<size_t>(AtomCount, "molecule::IsEqualToWithinThreshold: *OtherPermMap");
+    PermMap = Calloc<size_t>(AtomCount, "molecule::IsEqualToWithinThreshold: *PermMap");
+    OtherPermMap = Calloc<size_t>(AtomCount, "molecule::IsEqualToWithinThreshold: *OtherPermMap");
     gsl_heapsort_index (PermMap, Distances, AtomCount, sizeof(double), CompareDoubles);
     gsl_heapsort_index (OtherPermMap, OtherDistances, AtomCount, sizeof(double), CompareDoubles);
     PermutationMap = Malloc<int>(AtomCount, "molecule::IsEqualToWithinThreshold: *PermutationMap");
+    PermutationMap = Calloc<int>(AtomCount, "molecule::IsEqualToWithinThreshold: *PermutationMap");
     *out << Verbose(5) << "Combining Permutation Maps" << endl;
     for(int i=AtomCount;i--;)
 …
   for (int step=startstep;step < endstep; step++) { // loop over all time steps
     temperature = 0.;
     ActOnAllAtoms( &atom::AddKineticToTemperature, &temperature, step);
+    ActOnAllAtoms( &TrajectoryParticle::AddKineticToTemperature, &temperature, step);
     *output << step << "\t" << temperature*AtomicEnergyToKelvin << "\t" << temperature << endl;
+  }
 …
 };
 void molecule::SetIndexedArrayForEachAtomTo ( atom **array, int TesselPoint::*index)
+void molecule::SetIndexedArrayForEachAtomTo ( atom **array, int ParticleInfo::*index) const
+{
   atom *Walker = start;

src/molecule.hpp

-              r06c7a3
+              r7326b2
 class atom;
 class bond;
+class BondedParticle;
+class BondGraph;
 class element;
 class ForceMatrix;
 …
   public:
     double cell_size[6];//!< cell size
     periodentafel *elemente; //!< periodic table with each element
+    const periodentafel * const elemente; //!< periodic table with each element
     atom *start;        //!< start of atom list
     atom *end;          //!< end of atom list
     bond *first;        //!< start of bond list
     bond *last;         //!< end of bond list
-    bond ***ListOfBondsPerAtom; //!< pointer list for each atom and each bond it has
     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 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 NoNonBonds;     //!< number of non-hydrogen bonds in molecule
     int NoCyclicBonds;  //!< number of cyclic bonds in molecule, by DepthFirstSearchAnalysis()
+    mutable int NoNonHydrogen;  //!< number of non-hydrogen atoms in molecule
+    mutable int NoNonBonds;     //!< number of non-hydrogen bonds in molecule
+    mutable 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
 …
     char name[MAXSTRINGSIZE];         //!< arbitrary name
     int IndexNr;        //!< index of molecule in a MoleculeListClass
+    class Tesselation *TesselStruct;
+  molecule(periodentafel *teil);
+  molecule(const periodentafel * const teil);
   virtual ~molecule();
   // re-definition of virtual functions from PointCloud
   Vector *GetCenter(ofstream *out);
   TesselPoint *GetPoint();
   TesselPoint *GetTerminalPoint();
   void GoToNext();
   void GoToPrevious();
   void GoToFirst();
   void GoToLast();
   bool IsEmpty();
   bool IsEnd();
+  Vector *GetCenter(ofstream *out) const ;
+  TesselPoint *GetPoint() const ;
+  TesselPoint *GetTerminalPoint() const ;
+  void GoToNext() const ;
+  void GoToPrevious() const ;
+  void GoToFirst() const ;
+  void GoToLast() const ;
+  bool IsEmpty() const ;
+  bool IsEnd() const ;
   // templates for allowing global manipulation of all vectors
-  template <typename res> void ActOnAllVectors( res (Vector::*f)() );
-  template <typename res> void ActOnAllVectors( res (Vector::*f)() const);
   template <typename res> void ActOnAllVectors( res (Vector::*f)() ) const;
   template <typename res> void ActOnAllVectors( res (Vector::*f)() const) const;
-  template <typename res, typename T> void ActOnAllVectors( res (Vector::*f)(T), T t );
-  template <typename res, typename T> void ActOnAllVectors( res (Vector::*f)(T) const, T t );
   template <typename res, typename T> void ActOnAllVectors( res (Vector::*f)(T), T t ) const;
   template <typename res, typename T> void ActOnAllVectors( res (Vector::*f)(T) const, T t ) const;
-  template <typename res, typename T, typename U> void ActOnAllVectors( res (Vector::*f)(T, U), T t, U u );
-  template <typename res, typename T, typename U> void ActOnAllVectors( res (Vector::*f)(T, U) const, T t, U u );
   template <typename res, typename T, typename U> void ActOnAllVectors( res (Vector::*f)(T, U), T t, U u ) const;
   template <typename res, typename T, typename U> void ActOnAllVectors( res (Vector::*f)(T, U) const, T t, U u ) const;
-  template <typename res, typename T, typename U, typename V> void ActOnAllVectors( res (Vector::*f)(T, U, V), T t, U u, V v);
-  template <typename res, typename T, typename U, typename V> void ActOnAllVectors( res (Vector::*f)(T, U, V) const, T t, U u, V v);
   template <typename res, typename T, typename U, typename V> void ActOnAllVectors( res (Vector::*f)(T, U, V), T t, U u, V v) const;
   template <typename res, typename T, typename U, typename V> void ActOnAllVectors( res (Vector::*f)(T, U, V) const, T t, U u, V v) const;
   // templates for allowing global manipulation of molecule with each atom as single argument
-  template <typename res> void ActWithEachAtom( res (molecule::*f)(atom *) );
-  template <typename res> void ActWithEachAtom( res (molecule::*f)(atom *) const);
   template <typename res> void ActWithEachAtom( res (molecule::*f)(atom *) ) const;
   template <typename res> void ActWithEachAtom( res (molecule::*f)(atom *) const) const;
   // templates for allowing global copying of molecule with each atom as single argument
-  template <typename res> void ActOnCopyWithEachAtom( res (molecule::*f)(atom *) , molecule *copy);
-  template <typename res> void ActOnCopyWithEachAtom( res (molecule::*f)(atom *) const , molecule *copy);
   template <typename res> void ActOnCopyWithEachAtom( res (molecule::*f)(atom *) , molecule *copy) const;
   template <typename res> void ActOnCopyWithEachAtom( res (molecule::*f)(atom *) const, molecule *copy) const;
   // templates for allowing global manipulation of all atoms
+  template <typename res> void ActOnAllAtoms( res (atom::*f)() );
+  template <typename res> void ActOnAllAtoms( res (atom::*f)() const );
+  template <typename res> void ActOnAllAtoms( res (atom::*f)() ) const;
+  template <typename res> void ActOnAllAtoms( res (atom::*f)() const) const;
+  template <typename res, typename T> void ActOnAllAtoms( res (atom::*f)(T), T t );
+  template <typename res, typename T> void ActOnAllAtoms( res (atom::*f)(T) const, T t );
+  template <typename res, typename T> void ActOnAllAtoms( res (atom::*f)(T), T t ) const;
+  template <typename res, typename T> void ActOnAllAtoms( res (atom::*f)(T) const, T t ) const;
+  template <typename res, typename T, typename U> void ActOnAllAtoms( res (atom::*f)(T, U), T t, U u );
+  template <typename res, typename T, typename U> void ActOnAllAtoms( res (atom::*f)(T, U) const, T t, U u );
+  template <typename res, typename T, typename U> void ActOnAllAtoms( res (atom::*f)(T, U), T t, U u ) const;
+  template <typename res, typename T, typename U> void ActOnAllAtoms( res (atom::*f)(T, U) const, T t, U u ) const;
+  template <typename res, typename T, typename U, typename V> void ActOnAllAtoms( res (atom::*f)(T, U, V), T t, U u, V v);
+  template <typename res, typename T, typename U, typename V> void ActOnAllAtoms( res (atom::*f)(T, U, V) const, T t, U u, V v);
+  template <typename res, typename T, typename U, typename V> void ActOnAllAtoms( res (atom::*f)(T, U, V), T t, U u, V v) const;
+  template <typename res, typename T, typename U, typename V> void ActOnAllAtoms( res (atom::*f)(T, U, V) const, T t, U u, V v) const;
+  template <typename res, typename T, typename U, typename V, typename W> void ActOnAllAtoms( res (atom::*f)(T, U, V, W), T t, U u, V v, W w);
+  template <typename res, typename T, typename U, typename V, typename W> void ActOnAllAtoms( res (atom::*f)(T, U, V, W) const, T t, U u, V v, W w);
+  template <typename res, typename T, typename U, typename V, typename W> void ActOnAllAtoms( res (atom::*f)(T, U, V, W), T t, U u, V v, W w) const;
+  template <typename res, typename T, typename U, typename V, typename W> void ActOnAllAtoms( res (atom::*f)(T, U, V, W) const, T t, U u, V v, W w) const;
+  template <typename res, typename typ> void ActOnAllAtoms( res (typ::*f)() ) const;
+  template <typename res, typename typ> void ActOnAllAtoms( res (typ::*f)() const) const;
+  template <typename res, typename typ, typename T> void ActOnAllAtoms( res (typ::*f)(T), T t ) const;
+  template <typename res, typename typ, typename T> void ActOnAllAtoms( res (typ::*f)(T) const, T t ) const;
+  template <typename res, typename typ, typename T, typename U> void ActOnAllAtoms( res (typ::*f)(T, U), T t, U u ) const;
+  template <typename res, typename typ, typename T, typename U> void ActOnAllAtoms( res (typ::*f)(T, U) const, T t, U u ) const;
+  template <typename res, typename typ, typename T, typename U, typename V> void ActOnAllAtoms( res (typ::*f)(T, U, V), T t, U u, V v) const;
+  template <typename res, typename typ, typename T, typename U, typename V> void ActOnAllAtoms( res (typ::*f)(T, U, V) const, T t, U u, V v) const;
+  template <typename res, typename typ, typename T, typename U, typename V, typename W> void ActOnAllAtoms( res (typ::*f)(T, U, V, W), T t, U u, V v, W w) const;
+  template <typename res, typename typ, typename T, typename U, typename V, typename W> void ActOnAllAtoms( res (typ::*f)(T, U, V, W) const, T t, U u, V v, W w) const;
   // templates for allowing conditional global copying of molecule with each atom as single argument
+  template <typename res> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () );
+  template <typename res, typename T> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T), T t );
+  template <typename res, typename T, typename U> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U), T t, U u );
+  template <typename res, typename T, typename U, typename V> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U, V), T t, U u, V v );
+  template <typename res> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () ) const;
+  template <typename res> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () const ) const;
+  template <typename res> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) () ) const;
+  template <typename res> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) () const ) const;
+  template <typename res, typename T> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T), T t ) const;
+  template <typename res, typename T> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T) const, T t ) const;
+  template <typename res, typename T> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) (T), T t ) const;
+  template <typename res, typename T> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) (T) const, T t ) const;
+  template <typename res, typename T, typename U> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U), T t, U u ) const;
+  template <typename res, typename T, typename U> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U) const, T t, U u ) const;
+  template <typename res, typename T, typename U> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) (T, U), T t, U u ) const;
+  template <typename res, typename T, typename U> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) (T, U) const, T t, U u ) const;
+  template <typename res, typename T, typename U, typename V> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U, V), T t, U u, V v ) const;
+  template <typename res, typename T, typename U, typename V> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U, V) const, T t, U u, V v ) const;
+  template <typename res, typename T, typename U, typename V> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) (T, U, V), T t, U u, V v ) const;
+  template <typename res, typename T, typename U, typename V> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) (T, U, V) const, T t, U u, V v ) const;
   // templates for allowing global manipulation of an array with one entry per atom
+  void SetIndexedArrayForEachAtomTo ( atom **array, int TesselPoint::* index);
+  template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int TesselPoint::* index, void (*Setor)(T *, T *));
+  template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int TesselPoint::* index, void (*Setor)(T *, T *), T t);
+  template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int TesselPoint::* index, void (*Setor)(T *, T *), T *t);
+  template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *));
+  template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *), T t);
+  template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *), T *t);
+  template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int TesselPoint::* index, T (atom::*Setor)(Vector &), Vector atom::*value);
+  template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int TesselPoint::*index, T (atom::*Setor)(Vector &), Vector &vect );
+  void SetIndexedArrayForEachAtomTo ( atom **array, int ParticleInfo::* index) const;
+  template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::* index, void (*Setor)(T *, T *)) const;
+  template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::* index, void (*Setor)(T *, T *), T t) const;
+  template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::* index, void (*Setor)(T *, T *), T *t) const;
+  template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int element::* index, void (*Setor)(T *, T *)) const;
+  template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int element::* index, void (*Setor)(T *, T *), T t) const;
+  template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int element::* index, void (*Setor)(T *, T *), T *t) const;
+  template <typename T, typename typ> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &), typ atom::*value) const;
+  template <typename T, typename typ> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &) const, typ atom::*value) const;
+  template <typename T, typename typ> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &), typ &vect ) const;
+  template <typename T, typename typ> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &) const, typ &vect ) const;
   // templates for allowing global manipulation of each atom by entries in an array
+  template <typename T> void SetAtomValueToIndexedArray ( T *array, int TesselPoint::*index, T atom::*value );
+  template <typename T> void SetAtomValueToIndexedArray ( T *array, int element::*index, T atom::*value );
+  template <typename T, typename typ, typename typ2> void SetAtomValueToIndexedArray ( T *array, int typ::*index, T typ2::*value ) const;
+  template <typename T, typename typ> void SetAtomValueToValue ( T value, T typ::*ptr ) const;
+  template <typename res, typename typ> res SumPerAtom(res (typ::*f)() ) const;
+  template <typename res, typename typ> res SumPerAtom(res (typ::*f)() const ) const;
+  template <typename res, typename typ, typename T> res SumPerAtom(res (typ::*f)(T) , T t ) const;
+  template <typename res, typename typ, typename T> res SumPerAtom(res (typ::*f)(T) const, T t ) const;
   /// remove atoms from molecule.
 …
   atom * AddCopyAtom(atom *pointer);
   bool AddXYZFile(string filename);
   bool AddHydrogenReplacementAtom(ofstream *out, bond *Bond, atom *BottomOrigin, atom *TopOrigin, atom *TopReplacement, bond **BondList, int NumBond, bool IsAngstroem);
+  bool AddHydrogenReplacementAtom(ofstream *out, bond *Bond, atom *BottomOrigin, atom *TopOrigin, atom *TopReplacement, bool IsAngstroem);
   bond * AddBond(atom *first, atom *second, int degree = 1);
   bool RemoveBond(bond *pointer);
 …
   void Mirror(const Vector *x);
   void Align(Vector *n);
   void Scale(double **factor);
+  void Scale(const double ** const factor);
   void DeterminePeriodicCenter(Vector &center);
   Vector * DetermineCenterOfGravity(ofstream *out);
   Vector * DetermineCenterOfAll(ofstream *out);
+  Vector * DetermineCenterOfAll(ofstream *out) const;
   void SetNameFromFilename(const char *filename);
   void SetBoxDimension(Vector *dim);
 …
   void PrincipalAxisSystem(ofstream *out, bool DoRotate);
   double VolumeOfConvexEnvelope(ofstream *out, bool IsAngstroem);
-  Vector* FindEmbeddingHole(ofstream *out, molecule *srcmol);
   double ConstrainedPotential(ofstream *out, struct EvaluatePotential &Params);
 …
   /// Initialising routines in fragmentation
+  void CreateAdjacencyList2(ofstream *out, ifstream *output);
+  void CreateAdjacencyList(ofstream *out, double bonddistance, bool IsAngstroem);
+  void CreateListOfBondsPerAtom(ofstream *out);
+  void CreateAdjacencyListFromDbondFile(ofstream *out, ifstream *output);
+  void CreateAdjacencyList(ofstream *out, double bonddistance, bool IsAngstroem, void (BondGraph::*f)(BondedParticle * const , BondedParticle * const , double &, double &, bool), BondGraph *BG = NULL);
+  int CorrectBondDegree(ofstream *out) const;
+  void OutputBondsList(ofstream *out) const;
+  void CyclicBondAnalysis() const;
+  void OutputGraphInfoPerAtom(ofstream *out) const;
+  void OutputGraphInfoPerBond(ofstream *out) const;
   // Graph analysis
+  MoleculeLeafClass * DepthFirstSearchAnalysis(ofstream *out, class StackClass<bond *> *&BackEdgeStack);
+  void CyclicStructureAnalysis(ofstream *out, class StackClass<bond *> *BackEdgeStack, int *&MinimumRingSize);
+  bool PickLocalBackEdges(ofstream *out, atom **ListOfLocalAtoms, class StackClass<bond *> *&ReferenceStack, class StackClass<bond *> *&LocalStack);
+  bond * FindNextUnused(atom *vertex);
+  void SetNextComponentNumber(atom *vertex, int nr);
+  void InitComponentNumbers();
+  void OutputComponentNumber(ofstream *out, atom *vertex);
+  void ResetAllBondsToUnused();
+  void ResetAllAtomNumbers();
+  MoleculeLeafClass * DepthFirstSearchAnalysis(ofstream *out, class StackClass<bond *> *&BackEdgeStack) const;
+  void CyclicStructureAnalysis(ofstream *out, class StackClass<bond *> *BackEdgeStack, int *&MinimumRingSize) const;
+  bool PickLocalBackEdges(ofstream *out, atom **ListOfLocalAtoms, class StackClass<bond *> *&ReferenceStack, class StackClass<bond *> *&LocalStack) const;
+  bond * FindNextUnused(atom *vertex) const;
+  void SetNextComponentNumber(atom *vertex, int nr) const;
+  void ResetAllBondsToUnused() const;
   int CountCyclicBonds(ofstream *out);
   bool CheckForConnectedSubgraph(ofstream *out, KeySet *Fragment);
+  string GetColor(enum Shading color);
+  string GetColor(enum Shading color) const;
+  bond * CopyBond(atom *left, atom *right, bond *CopyBond);
   molecule *CopyMolecule();
   molecule* CopyMoleculeFromSubRegion(Vector offset, double *parallelepiped);
+  molecule* CopyMoleculeFromSubRegion(const Vector offset, const double *parallelepiped) const;
   /// Fragment molecule by two different approaches:
 …
   private:
   int last_atom;      //!< number given to last atom
   atom *InternalPointer;  //!< internal pointer for PointCloud
+  mutable atom *InternalPointer;  //!< internal pointer for PointCloud
 };
 …
   void Enumerate(ofstream *out);
   void Output(ofstream *out);
+  void DissectMoleculeIntoConnectedSubgraphs(ofstream * const out, molecule * const mol, config * const configuration);
   // merging of molecules
 …
   bool AddLeaf(molecule *ptr, MoleculeLeafClass *Previous);
   bool FillBondStructureFromReference(ofstream *out, molecule *reference, int &FragmentCounter, atom ***&ListOfLocalAtoms, bool FreeList = false);
+  bool FillBondStructureFromReference(ofstream *out, const molecule * const reference, int &FragmentCounter, atom ***&ListOfLocalAtoms, bool FreeList = false);
   bool FillRootStackForSubgraphs(ofstream *out, KeyStack *&RootStack, bool *AtomMask, int &FragmentCounter);
   bool AssignKeySetsToFragment(ofstream *out, molecule *reference, Graph *KeySetList, atom ***&ListOfLocalAtoms, Graph **&FragmentList, int &FragmentCounter, bool FreeList = false);

src/molecule_dynamics.cpp

-              r06c7a3
+              r7326b2
+{
   stringstream zeile1, zeile2;
   int *DoubleList = Malloc<int>(AtomCount, "PrintPermutationMap: *DoubleList");
+  int *DoubleList = Calloc<int>(AtomCount, "PrintPermutationMap: *DoubleList");
   int doubles = 0;
-  for (int i=0;i<AtomCount;i++)
-    DoubleList[i] = 0;
   zeile1 << "PermutationMap: ";
   zeile2 << "                ";
 …
 void CreateInitialLists(ofstream *out, molecule *mol, struct EvaluatePotential &Params)
+{
-  for (int i=mol->AtomCount; i--;)
-    Params.DoubleList[i] = 0;  // stores for how many atoms in startstep this atom is a target in endstep
   atom *Walker = mol->start;
   while (Walker->next != mol->end) {
 …
   double Potential, OldPotential, OlderPotential;
   struct EvaluatePotential Params;
   Params.PermutationMap = Malloc<atom*>(AtomCount, "molecule::MinimiseConstrainedPotential: Params.**PermutationMap");
+  Params.PermutationMap = Calloc<atom*>(AtomCount, "molecule::MinimiseConstrainedPotential: Params.**PermutationMap");
   Params.DistanceList = Malloc<DistanceMap*>(AtomCount, "molecule::MinimiseConstrainedPotential: Params.**DistanceList");
   Params.DistanceIterators = Malloc<DistanceMap::iterator>(AtomCount, "molecule::MinimiseConstrainedPotential: Params.*DistanceIterators");
   Params.DoubleList = Malloc<int>(AtomCount, "molecule::MinimiseConstrainedPotential: Params.*DoubleList");
+  Params.DoubleList = Calloc<int>(AtomCount, "molecule::MinimiseConstrainedPotential: Params.*DoubleList");
   Params.StepList = Malloc<DistanceMap::iterator>(AtomCount, "molecule::MinimiseConstrainedPotential: Params.*StepList");
   int round;

src/molecule_fragmentation.cpp

-              r06c7a3
+              r7326b2
 int molecule::GuesstimateFragmentCount(ofstream *out, int order)
+{
   int c = 0;
+  size_t c = 0;
   int FragmentCount;
   // get maximum bond degree
 …
   while (Walker->next != end) {
     Walker = Walker->next;
     c = (NumberOfBondsPerAtom[Walker->nr] > c) ? NumberOfBondsPerAtom[Walker->nr] : c;
+    c = (Walker->ListOfBonds.size() > c) ? Walker->ListOfBonds.size() : c;
+  }
   FragmentCount = NoNonHydrogen*(1 << (c*order));
 …
+  }
+  Free(&filename);
   return status;
 };
 …
   // ===== 1. Check whether bond structure is same as stored in files ====
-  // fill the adjacency list
-  CreateListOfBondsPerAtom(out);
   // create lookup table for Atom::nr
   FragmentationToDo = FragmentationToDo && CreateFatherLookupTable(out, start, end, ListOfAtoms, AtomCount);
 …
   // ===== 2. perform a DFS analysis to gather info on cyclic structure and a list of disconnected subgraphs =====
   Subgraphs = DepthFirstSearchAnalysis(out, BackEdgeStack);
+  // fill the bond structure of the individually stored subgraphs
+  Subgraphs->next->FillBondStructureFromReference(out, this, (FragmentCounter = 0), ListOfLocalAtoms, false);  // we want to keep the created ListOfLocalAtoms
   // analysis of the cycles (print rings, get minimum cycle length) for each subgraph
   for(int i=AtomCount;i--;)
 …
   while (MolecularWalker->next != NULL) {
     MolecularWalker = MolecularWalker->next;
+    // fill the bond structure of the individually stored subgraphs
+  MolecularWalker->FillBondStructureFromReference(out, this, FragmentCounter, ListOfLocalAtoms, false);  // we want to keep the created ListOfLocalAtoms
     *out << Verbose(0) << "Analysing the cycles of subgraph " << MolecularWalker->Leaf << " with nr. " << FragmentCounter << "." << endl;
     LocalBackEdgeStack = new StackClass<bond *> (MolecularWalker->Leaf->BondCount);
 …
     delete(LocalBackEdgeStack);
+  }
+  delete(BackEdgeStack);
   // ===== 3. if structure still valid, parse key set file and others =====
 …
       MolecularWalker = MolecularWalker->next;
       *out << Verbose(1) << "Fragmenting subgraph " << MolecularWalker << "." << endl;
       //MolecularWalker->Leaf->OutputListOfBonds(out);  // output ListOfBondsPerAtom for debugging
+      //MolecularWalker->Leaf->OutputListOfBonds(out);  // output atom::ListOfBonds for debugging
       if (MolecularWalker->Leaf->first->next != MolecularWalker->Leaf->last) {
         // call BOSSANOVA method
 …
+    }
+  }
+  *out << Verbose(2) << "CheckOrder is " << CheckOrder << "." << endl;
   delete[](RootStack);
   delete[](AtomMask);
 …
   // ===== 8b. gather keyset lists (graphs) from all subgraphs and transform into MoleculeListClass =====
   //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();
     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->insert(StoreFragmentFromKeySet(out, test, configuration));
       k++;
+    }
     *out << k << "/" << BondFragments->ListOfMolecules.size() << " fragments generated from the keysets." << endl;
     // ===== 9. Save fragments' configuration and keyset files et al to disk ===
     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->ListOfMolecules.size() << " possible bond fragmentation configs" << endl;
       if (BondFragments->OutputConfigForListOfFragments(out, configuration, SortIndex))
         *out << Verbose(1) << "All configs written." << endl;
       else
         *out << Verbose(1) << "Some config writing failed." << endl;
       // store force index reference file
       BondFragments->StoreForcesFile(out, configuration->configpath, SortIndex);
       // store keysets file
       StoreKeySetFile(out, TotalGraph, configuration->configpath);
       // store Adjacency file
       StoreAdjacencyToFile(out, configuration->configpath);
       // store Hydrogen saturation correction file
       BondFragments->AddHydrogenCorrection(out, configuration->configpath);
       // store adaptive orders into file
       StoreOrderAtSiteFile(out, configuration->configpath);
       // restore orbital and Stop values
       CalculateOrbitals(*configuration);
       // free memory for bond part
       *out << Verbose(1) << "Freeing bond memory" << endl;
       delete(FragmentList); // remove bond molecule from memory
       Free(&SortIndex);
     } else
       *out << Verbose(1) << "FragmentList is zero on return, splitting failed." << endl;
   //} else
   //  *out << Verbose(1) << "No fragments to store." << endl;
+  // allocate memory for the pointer array and transmorph graphs into full molecular fragments
+  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->insert(StoreFragmentFromKeySet(out, test, configuration));
+    k++;
+  }
+  *out << k << "/" << BondFragments->ListOfMolecules.size() << " fragments generated from the keysets." << endl;
+  // ===== 9. Save fragments' configuration and keyset files et al to disk ===
+  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->ListOfMolecules.size() << " possible bond fragmentation configs" << endl;
+    if (BondFragments->OutputConfigForListOfFragments(out, configuration, SortIndex))
+      *out << Verbose(1) << "All configs written." << endl;
+    else
+      *out << Verbose(1) << "Some config writing failed." << endl;
+    // store force index reference file
+    BondFragments->StoreForcesFile(out, configuration->configpath, SortIndex);
+    // store keysets file
+    StoreKeySetFile(out, TotalGraph, configuration->configpath);
+    // store Adjacency file
+    StoreAdjacencyToFile(out, configuration->configpath);
+    // store Hydrogen saturation correction file
+    BondFragments->AddHydrogenCorrection(out, configuration->configpath);
+    // store adaptive orders into file
+    StoreOrderAtSiteFile(out, configuration->configpath);
+    // restore orbital and Stop values
+    CalculateOrbitals(*configuration);
+    // free memory for bond part
+    *out << Verbose(1) << "Freeing bond memory" << endl;
+    delete(FragmentList); // remove bond molecule from memory
+    Free(&SortIndex);
+  } else {
+    *out << Verbose(1) << "FragmentList is zero on return, splitting failed." << endl;
+  }
+  delete(BondFragments);
   *out << Verbose(0) << "End of bond fragmentation." << endl;
 …
 bool molecule::ParseOrderAtSiteFromFile(ofstream *out, char *path)
+{
   unsigned char *OrderArray = Malloc<unsigned char>(AtomCount, "molecule::ParseOrderAtSiteFromFile - *OrderArray");
   bool *MaxArray = Malloc<bool>(AtomCount, "molecule::ParseOrderAtSiteFromFile - *MaxArray");
+  unsigned char *OrderArray = Calloc<unsigned char>(AtomCount, "molecule::ParseOrderAtSiteFromFile - *OrderArray");
+  bool *MaxArray = Calloc<bool>(AtomCount, "molecule::ParseOrderAtSiteFromFile - *MaxArray");
   bool status;
   int AtomNr, value;
 …
   *out << Verbose(1) << "Begin of ParseOrderAtSiteFromFile" << endl;
-  for(int i=AtomCount;i--;)
-    OrderArray[i] = 0;
   line << path << "/" << FRAGMENTPREFIX << ORDERATSITEFILE;
   file.open(line.str().c_str());
   if (file != NULL) {
-    for (int i=AtomCount;i--;) { // initialise with 0
-      OrderArray[i] = 0;
-      MaxArray[i] = 0;
+    }
     while (!file.eof()) { // parse from file
       AtomNr = -1;
 …
  * \param *Leaf fragment molecule
  * \param &Leaflet pointer to KeySet structure
  * \param **SonList list which atom of \a *Leaf is a son of which atom in \a *mol
+ * \param **SonList calloc'd list which atom of \a *Leaf is a son of which atom in \a *mol
  * \return number of atoms in fragment
  */
 …
   for(int i=NDIM*2;i--;)
     Leaf->cell_size[i] = mol->cell_size[i];
-  // initialise SonList (indicates when we need to replace a bond with hydrogen instead)
-  for(int i=mol->AtomCount;i--;)
-    SonList[i] = NULL;
   // first create the minimal set of atoms from the KeySet
 …
     if (SonList[FatherOfRunner->nr] != NULL)  {  // check if this, our father, is present in list
       // create all bonds
       for (int i=0;i<mol->NumberOfBondsPerAtom[FatherOfRunner->nr];i++) { // go through every bond of father
         OtherFather = mol->ListOfBondsPerAtom[FatherOfRunner->nr][i]->GetOtherAtom(FatherOfRunner);
+      for (BondList::const_iterator BondRunner = FatherOfRunner->ListOfBonds.begin(); BondRunner != FatherOfRunner->ListOfBonds.end(); (++BondRunner)) {
+        OtherFather = (*BondRunner)->GetOtherAtom(FatherOfRunner);
 //        *out << Verbose(2) << "Father " << *FatherOfRunner << " of son " << *SonList[FatherOfRunner->nr] << " is bound to " << *OtherFather;
         if (SonList[OtherFather->nr] != NULL) {
 …
 //            *out << Verbose(3) << "Adding Bond: ";
 //            *out <<
             Leaf->AddBond(Runner, SonList[OtherFather->nr], mol->ListOfBondsPerAtom[FatherOfRunner->nr][i]->BondDegree);
+            Leaf->AddBond(Runner, SonList[OtherFather->nr], (*BondRunner)->BondDegree);
 //            *out << "." << endl;
             //NumBonds[Runner->nr]++;
 …
 #ifdef ADDHYDROGEN
           //*out << Verbose(3) << "Adding Hydrogen to " << Runner->Name << " and a bond in between." << endl;
           if(!Leaf->AddHydrogenReplacementAtom(out, mol->ListOfBondsPerAtom[FatherOfRunner->nr][i], Runner, FatherOfRunner, OtherFather, mol->ListOfBondsPerAtom[FatherOfRunner->nr],mol->NumberOfBondsPerAtom[FatherOfRunner->nr], IsAngstroem))
+          if(!Leaf->AddHydrogenReplacementAtom(out, (*BondRunner), Runner, FatherOfRunner, OtherFather, IsAngstroem))
             exit(1);
 #endif
           //NumBonds[Runner->nr] += ListOfBondsPerAtom[FatherOfRunner->nr][i]->BondDegree;
+          //NumBonds[Runner->nr] += Binder->BondDegree;
+        }
+      }
 …
 molecule * molecule::StoreFragmentFromKeySet(ofstream *out, KeySet &Leaflet, bool IsAngstroem)
+{
   atom **SonList = Malloc<atom*>(AtomCount, "molecule::StoreFragmentFromStack: **SonList");
+  atom **SonList = Calloc<atom*>(AtomCount, "molecule::StoreFragmentFromStack: **SonList");
   molecule *Leaf = new molecule(elemente);
 …
   CreateInducedSubgraphOfFragment(out, this, Leaf, SonList, IsAngstroem);
-  Leaf->CreateListOfBondsPerAtom(out);
   //Leaflet->Leaf->ScanForPeriodicCorrection(out);
   Free(&SonList);
 …
     if (bit) {  // if bit is set, we add this bond partner
       OtherWalker = BondsSet[j]->rightatom;  // rightatom is always the one more distant, i.e. the one to add
       //*out << Verbose(1+verbosity) << "Current Bond is " << ListOfBondsPerAtom[Walker->nr][CurrentCombination] << ", checking on " << *OtherWalker << "." << endl;
+      //*out << Verbose(1+verbosity) << "Current Bond is " << BondsSet[j] << ", checking on " << *OtherWalker << "." << endl;
       *out << Verbose(2+verbosity) << "Adding " << *OtherWalker << " with nr " << OtherWalker->nr << "." << endl;
       TestKeySetInsert = FragmentSet->insert(OtherWalker->nr);
 …
   NumCombinations = 1 << SetDimension;
   // Hier muessen von 1 bis NumberOfBondsPerAtom[Walker->nr] alle Kombinationen
   // von Endstuecken (aus den Bonds) hinzugefuegt werden und fuer verbleibende ANOVAOrder
   // rekursiv GraphCrawler in der naechsten Ebene aufgerufen werden
+  // here for all bonds of Walker all combinations of end pieces (from the bonds)
+  // have to be added and for the remaining ANOVA order GraphCrawler be called
+  // recursively for the next level
   *out << Verbose(1+verbosity) << "Begin of SPFragmentGenerator." << endl;
 …
   atom *OtherWalker = NULL;
   atom *Predecessor = NULL;
+  bond *CurrentEdge = NULL;
   bond *Binder = NULL;
-  bond *CurrentEdge = NULL;
   int RootKeyNr = FragmentSearch.Root->GetTrueFather()->nr;
   int RemainingWalkers = -1;
 …
       // go through all its bonds
       *out << Verbose(1) << "Going through all bonds of Walker." << endl;
+      for (int i=0;i<mol->NumberOfBondsPerAtom[AtomKeyNr];i++) {
+        Binder = mol->ListOfBondsPerAtom[AtomKeyNr][i];
+        OtherWalker = Binder->GetOtherAtom(Walker);
+      for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
+        OtherWalker = (*Runner)->GetOtherAtom(Walker);
         if ((RestrictedKeySet.find(OtherWalker->nr) != RestrictedKeySet.end())
   #ifdef ADDHYDROGEN
 …
   #endif
                                                               ) {  // skip hydrogens and restrict to fragment
           *out << Verbose(2) << "Current partner is " << *OtherWalker << " with nr " << OtherWalker->nr << " in bond " << *Binder << "." << endl;
+          *out << Verbose(2) << "Current partner is " << *OtherWalker << " with nr " << OtherWalker->nr << " in bond " << *(*Runner) << "." << endl;
           // set the label if not set (and push on root stack as well)
           if ((OtherWalker != Predecessor) && (OtherWalker->GetTrueFather()->nr > RootKeyNr)) { // only pass through those with label bigger than Root's
 …
     // prepare the subset and call the generator
     BondsList = Malloc<bond*>(FragmentSearch.BondsPerSPCount[0], "molecule::PowerSetGenerator: **BondsList");
+    BondsList = Calloc<bond*>(FragmentSearch.BondsPerSPCount[0], "molecule::PowerSetGenerator: **BondsList");
     BondsList[0] = FragmentSearch.BondsPerSPList[0]->next;  // on SP level 0 there's only the root bond
 …
   // FragmentLowerOrdersList is a 2D-array of pointer to MoleculeListClass objects, one dimension represents the ANOVA expansion of a single order (i.e. 5)
   // with all needed lower orders that are subtracted, the other dimension is the BondOrder (i.e. from 1 to 5)
   NumMoleculesOfOrder = Malloc<int>(UpgradeCount, "molecule::FragmentBOSSANOVA: *NumMoleculesOfOrder");
   FragmentLowerOrdersList = Malloc<Graph**>(UpgradeCount, "molecule::FragmentBOSSANOVA: ***FragmentLowerOrdersList");
+  NumMoleculesOfOrder = Calloc<int>(UpgradeCount, "molecule::FragmentBOSSANOVA: *NumMoleculesOfOrder");
+  FragmentLowerOrdersList = Calloc<Graph**>(UpgradeCount, "molecule::FragmentBOSSANOVA: ***FragmentLowerOrdersList");
   // initialise the fragments structure
-  FragmentSearch.ShortestPathList = Malloc<int>(AtomCount, "molecule::PowerSetGenerator: *ShortestPathList");
   FragmentSearch.FragmentCounter = 0;
   FragmentSearch.FragmentSet = new KeySet;
   FragmentSearch.Root = FindAtom(RootKeyNr);
+  FragmentSearch.ShortestPathList = Malloc<int>(AtomCount, "molecule::PowerSetGenerator: *ShortestPathList");
   for (int i=AtomCount;i--;) {
     FragmentSearch.ShortestPathList[i] = -1;
 …
       // allocate memory for all lower level orders in this 1D-array of ptrs
       NumLevels = 1 << (Order-1); // (int)pow(2,Order);
+      FragmentLowerOrdersList[RootNr] = Malloc<Graph*>(NumLevels, "molecule::FragmentBOSSANOVA: **FragmentLowerOrdersList[]");
+      for (int i=0;i<NumLevels;i++)
+        FragmentLowerOrdersList[RootNr][i] = NULL;
+      FragmentLowerOrdersList[RootNr] = Calloc<Graph*>(NumLevels, "molecule::FragmentBOSSANOVA: **FragmentLowerOrdersList[]");
       // create top order where nothing is reduced
 …
   *out << Verbose(2) << "Begin of ScanForPeriodicCorrection." << endl;
   ColorList = Malloc<enum Shading>(AtomCount, "molecule::ScanForPeriodicCorrection: *ColorList");
+  ColorList = Calloc<enum Shading>(AtomCount, "molecule::ScanForPeriodicCorrection: *ColorList");
   while (flag) {
     // remove bonds that are beyond bonddistance
 …
         ColorList[Walker->nr] = black;    // mark as explored
         Walker->x.AddVector(&Translationvector); // translate
         for (int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) {  // go through all binding partners
           if (ListOfBondsPerAtom[Walker->nr][i] != Binder) {
             OtherWalker = ListOfBondsPerAtom[Walker->nr][i]->GetOtherAtom(Walker);
+        for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
+          if ((*Runner) != Binder) {
+            OtherWalker = (*Runner)->GetOtherAtom(Walker);
             if (ColorList[OtherWalker->nr] == white) {
               AtomStack->Push(OtherWalker); // push if yet unexplored

src/molecule_geometry.cpp

-              r06c7a3
+              r7326b2
+{
   bool status = true;
-  Vector x;
   const Vector *Center = DetermineCenterOfAll(out);
   double *M = ReturnFullMatrixforSymmetric(cell_size);
   double *Minv = x.InverseMatrix(M);
+  double *Minv = InverseMatrix(M);
   // go through all atoms
 …
+{
   bool status = true;
-  Vector x;
   double *M = ReturnFullMatrixforSymmetric(cell_size);
   double *Minv = x.InverseMatrix(M);
+  double *Minv = InverseMatrix(M);
   // go through all atoms
 …
  * \return pointer to center of all vector
  */
 Vector * molecule::DetermineCenterOfAll(ofstream *out)
+Vector * molecule::DetermineCenterOfAll(ofstream *out) const
+{
   atom *ptr = start->next;  // start at first in list
 …
  * \param *factor pointer to scaling factor
  */
 void molecule::Scale(double **factor)
+void molecule::Scale(const double ** const factor)
+{
   atom *ptr = start;
 …
 void molecule::TranslatePeriodically(const Vector *trans)
+{
-  Vector x;
   double *M = ReturnFullMatrixforSymmetric(cell_size);
   double *Minv = x.InverseMatrix(M);
+  double *Minv = InverseMatrix(M);
   // go through all atoms
 …
+{
   atom *Walker = start;
-  bond *Binder = NULL;
   double *matrix = ReturnFullMatrixforSymmetric(cell_size);
   double tmp;
 …
         Testvector.InverseMatrixMultiplication(matrix);
         Translationvector.Zero();
+        for (int i=0;i<NumberOfBondsPerAtom[Walker->nr]; i++) {
+          Binder = ListOfBondsPerAtom[Walker->nr][i];
+          if (Walker->nr < Binder->GetOtherAtom(Walker)->nr) // otherwise we shift one to, the other fro and gain nothing
+        for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
+         if (Walker->nr < (*Runner)->GetOtherAtom(Walker)->nr) // otherwise we shift one to, the other fro and gain nothing
             for (int j=0;j<NDIM;j++) {
               tmp = Walker->x.x[j] - Binder->GetOtherAtom(Walker)->x.x[j];
+              tmp = Walker->x.x[j] - (*Runner)->GetOtherAtom(Walker)->x.x[j];
               if ((fabs(tmp)) > BondDistance) {
                 flag = false;
                 cout << Verbose(0) << "Hit: atom " << Walker->Name << " in bond " << *Binder << " has to be shifted due to " << tmp << "." << endl;
+                cout << Verbose(0) << "Hit: atom " << Walker->Name << " in bond " << *(*Runner) << " has to be shifted due to " << tmp << "." << endl;
                 if (tmp > 0)
                   Translationvector.x[j] -= 1.;
 …
 #ifdef ADDHYDROGEN
         // now also change all hydrogens
+        for (int i=0;i<NumberOfBondsPerAtom[Walker->nr]; i++) {
+          Binder = ListOfBondsPerAtom[Walker->nr][i];
+          if (Binder->GetOtherAtom(Walker)->type->Z == 1) {
+            Testvector.CopyVector(&Binder->GetOtherAtom(Walker)->x);
+        for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
+          if ((*Runner)->GetOtherAtom(Walker)->type->Z == 1) {
+            Testvector.CopyVector(&(*Runner)->GetOtherAtom(Walker)->x);
             Testvector.InverseMatrixMultiplication(matrix);
             Testvector.AddVector(&Translationvector);

src/molecule_graph.cpp

-              r06c7a3
+              r7326b2
 #include "atom.hpp"
 #include "bond.hpp"
+#include "bondgraph.hpp"
 #include "config.hpp"
 #include "element.hpp"
 #include "helpers.hpp"
+#include "linkedcell.hpp"
 #include "lists.hpp"
 #include "memoryallocator.hpp"
 #include "molecule.hpp"
+struct BFSAccounting
+{
+  atom **PredecessorList;
+  int *ShortestPathList;
+  enum Shading *ColorList;
+  class StackClass<atom *> *BFSStack;
+  class StackClass<atom *> *TouchedStack;
+  int AtomCount;
+  int BondOrder;
+  atom *Root;
+  bool BackStepping;
+  int CurrentGraphNr;
+  int ComponentNr;
+};
+/** Accounting data for Depth First Search.
+ */
+struct DFSAccounting
+{
+  class StackClass<atom *> *AtomStack;
+  class StackClass<bond *> *BackEdgeStack;
+  int CurrentGraphNr;
+  int ComponentNumber;
+  atom *Root;
+  bool BackStepping;
+};
 /************************************* Functions for class molecule *********************************/
 /** Creates an adjacency list of the molecule.
  * We obtain an outside file with the indices of atoms which are bondmembers.
  */
 void molecule::CreateAdjacencyList2(ofstream *out, ifstream *input)
+void molecule::CreateAdjacencyListFromDbondFile(ofstream *out, ifstream *input)
+{
   // 1 We will parse bonds out of the dbond file created by tremolo.
+      int atom1, atom2, temp;
+      atom *Walker, *OtherWalker;
+          if (!input)
+          {
+            cout << Verbose(1) << "Opening silica failed \n";
+          };
+      *input >> ws >> atom1;
+      *input >> ws >> atom2;
+          cout << Verbose(1) << "Scanning file\n";
+          while (!input->eof()) // Check whether we read everything already
+          {
+        *input >> ws >> atom1;
+        *input >> ws >> atom2;
+            if(atom2<atom1) //Sort indices of atoms in order
+            {
+              temp=atom1;
+              atom1=atom2;
+              atom2=temp;
+            };
+            Walker=start;
+            while(Walker-> nr != atom1) // Find atom corresponding to first index
+            {
+              Walker = Walker->next;
+            };
+            OtherWalker = Walker->next;
+            while(OtherWalker->nr != atom2) // Find atom corresponding to second index
+            {
+              OtherWalker= OtherWalker->next;
+            };
+            AddBond(Walker, OtherWalker); //Add the bond between the two atoms with respective indices.
+          }
+          CreateListOfBondsPerAtom(out);
+};
+  int atom1, atom2;
+  atom *Walker, *OtherWalker;
+  if (!input) {
+    cout << Verbose(1) << "Opening silica failed \n";
+  };
+  *input >> ws >> atom1;
+  *input >> ws >> atom2;
+  cout << Verbose(1) << "Scanning file\n";
+  while (!input->eof()) // Check whether we read everything already
+  {
+    *input >> ws >> atom1;
+    *input >> ws >> atom2;
+    if (atom2 < atom1) //Sort indices of atoms in order
+      flip(atom1, atom2);
+    Walker = FindAtom(atom1);
+    OtherWalker = FindAtom(atom2);
+    AddBond(Walker, OtherWalker); //Add the bond between the two atoms with respective indices.
+  }
+}
+;
 /** Creates an adjacency list of the molecule.
 …
  *  -# put each atom into its corresponding cell
  *  -# go through every cell, check the atoms therein against all possible bond partners in the 27 adjacent cells, add bond if true
- *  -# create the list of bonds via CreateListOfBondsPerAtom()
  *  -# correct the bond degree iteratively (single->double->triple bond)
  *  -# finally print the bond list to \a *out if desired
 …
  * \param bonddistance length of linked cells (i.e. maximum minimal length checked)
  * \param IsAngstroem whether coordinate system is gauged to Angstroem or Bohr radii
+ */
+void molecule::CreateAdjacencyList(ofstream *out, double bonddistance, bool IsAngstroem)
+{
+  atom *Walker = NULL, *OtherWalker = NULL, *Candidate = NULL;
+  int No, NoBonds, CandidateBondNo;
+  int NumberCells, divisor[NDIM], n[NDIM], N[NDIM], index, Index, j;
+  molecule **CellList;
+  double distance, MinDistance, MaxDistance;
+  double *matrix = ReturnFullMatrixforSymmetric(cell_size);
+  Vector x;
+  int FalseBondDegree = 0;
+ * \param *minmaxdistance function to give upper and lower bound on whether particle is bonded to some other
+ * \param *BG BondGraph with the member function above or NULL, if just standard covalent should be used.
+ */
+void molecule::CreateAdjacencyList(ofstream *out, double bonddistance, bool IsAngstroem, void (BondGraph::*minmaxdistance)(BondedParticle * const , BondedParticle * const , double &, double &, bool), BondGraph *BG)
+{
+  atom *Walker = NULL;
+  atom *OtherWalker = NULL;
+  atom **AtomMap = NULL;
+  int n[NDIM];
+  double MinDistance, MaxDistance;
+  LinkedCell *LC = NULL;
+  bool free_BG = false;
+  if (BG == NULL) {
+    BG = new BondGraph(IsAngstroem);
+    free_BG = true;
+  }
   BondDistance = bonddistance; // * ((IsAngstroem) ? 1. : 1./AtomicLengthToAngstroem);
   *out << Verbose(0) << "Begin of CreateAdjacencyList." << endl;
   // remove every bond from the list
+  if ((first->next != last) && (last->previous != first)) {  // there are bonds present
+    cleanup(first,last);
+  }
+  bond *Binder = NULL;
+  while (last->previous != first) {
+    Binder = last->previous;
+    Binder->leftatom->UnregisterBond(Binder);
+    Binder->rightatom->UnregisterBond(Binder);
+    removewithoutcheck(Binder);
+  }
+  BondCount = 0;
   // count atoms in molecule = dimension of matrix (also give each unique name and continuous numbering)
   CountAtoms(out);
+  *out << Verbose(1) << "AtomCount " << AtomCount << "." << endl;
+  if (AtomCount != 0) {
+    // 1. find divisor for each axis, such that a sphere with radius of at least bonddistance can be placed into each cell
+    j=-1;
+    for (int i=0;i<NDIM;i++) {
+      j += i+1;
+      divisor[i] = (int)floor(cell_size[j]/bonddistance); // take smaller value such that size of linked cell is at least bonddistance
+      //*out << Verbose(1) << "divisor[" << i << "]  = " << divisor[i] << "." << endl;
+    }
+    // 2a. allocate memory for the cell list
+    NumberCells = divisor[0]*divisor[1]*divisor[2];
+    *out << Verbose(1) << "Allocating " << NumberCells << " cells." << endl;
+    CellList = Malloc<molecule*>(NumberCells, "molecule::CreateAdjacencyList - ** CellList");
+    for (int i=NumberCells;i--;)
+      CellList[i] = NULL;
+    // 2b. put all atoms into its corresponding list
+  *out << Verbose(1) << "AtomCount " << AtomCount << " and bonddistance is " << bonddistance << "." << endl;
+  if ((AtomCount > 1) && (bonddistance > 1.)) {
+    *out << Verbose(2) << "Creating Linked Cell structure ... " << endl;
+    LC = new LinkedCell(this, bonddistance);
+    // create a list to map Tesselpoint::nr to atom *
+    *out << Verbose(2) << "Creating TesselPoint to atom map ... " << endl;
+    AtomMap = Calloc<atom *> (AtomCount, "molecule::CreateAdjacencyList - **AtomCount");
     Walker = start;
     while(Walker->next != end) {
+    while (Walker->next != end) {
       Walker = Walker->next;
+      //*out << Verbose(1) << "Current atom is " << *Walker << " with coordinates ";
+      //Walker->x.Output(out);
+      //*out << "." << endl;
+      // compute the cell by the atom's coordinates
+      j=-1;
+      for (int i=0;i<NDIM;i++) {
+        j += i+1;
+        x.CopyVector(&(Walker->x));
+        x.KeepPeriodic(out, matrix);
+        n[i] = (int)floor(x.x[i]/cell_size[j]*(double)divisor[i]);
+      }
+      index = n[2] + (n[1] + n[0] * divisor[1]) * divisor[2];
+      //*out << Verbose(1) << "Atom " << *Walker << " goes into cell number [" << n[0] << "," << n[1] << "," << n[2] << "] = " << index << "." << endl;
+      // add copy atom to this cell
+      if (CellList[index] == NULL)  // allocate molecule if not done
+        CellList[index] = new molecule(elemente);
+      OtherWalker = CellList[index]->AddCopyAtom(Walker); // add a copy of walker to this atom, father will be walker for later reference
+      //*out << Verbose(1) << "Copy Atom is " << *OtherWalker << "." << endl;
+    }
+    //for (int i=0;i<NumberCells;i++)
+      //*out << Verbose(1) << "Cell number " << i << ": " << CellList[i] << "." << endl;
+      AtomMap[Walker->nr] = Walker;
+    }
     // 3a. go through every cell
+    for (N[0]=divisor[0];N[0]--;)
+      for (N[1]=divisor[1];N[1]--;)
+        for (N[2]=divisor[2];N[2]--;) {
+          Index = N[2] + (N[1] + N[0] * divisor[1]) * divisor[2];
+          if (CellList[Index] != NULL) { // if there atoms in this cell
+            //*out << Verbose(1) << "Current cell is " << Index << "." << endl;
+            // 3b. for every atom therein
+            Walker = CellList[Index]->start;
+            while (Walker->next != CellList[Index]->end) {  // go through every atom
+              Walker = Walker->next;
+    *out << Verbose(2) << "Celling ... " << endl;
+    for (LC->n[0] = 0; LC->n[0] < LC->N[0]; LC->n[0]++)
+      for (LC->n[1] = 0; LC->n[1] < LC->N[1]; LC->n[1]++)
+        for (LC->n[2] = 0; LC->n[2] < LC->N[2]; LC->n[2]++) {
+          const LinkedNodes *List = LC->GetCurrentCell();
+          //*out << Verbose(2) << "Current cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << " containing " << List->size() << " points." << endl;
+          if (List != NULL) {
+            for (LinkedNodes::const_iterator Runner = List->begin(); Runner != List->end(); Runner++) {
+              Walker = AtomMap[(*Runner)->nr];
               //*out << Verbose(0) << "Current Atom is " << *Walker << "." << endl;
               // 3c. check for possible bond between each atom in this and every one in the 27 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]++) {
+                     // compute the index of this comparison cell and make it periodic
+                    index = ((N[2]+n[2]+divisor[2])%divisor[2]) + (((N[1]+n[1]+divisor[1])%divisor[1]) + ((N[0]+n[0]+divisor[0])%divisor[0]) * divisor[1]) * divisor[2];
+                    //*out << Verbose(1) << "Number of comparison cell is " << index << "." << endl;
+                    if (CellList[index] != NULL) {  // if there are any atoms in this cell
+                      OtherWalker = CellList[index]->start;
+                      while(OtherWalker->next != CellList[index]->end) {  // go through every atom in this cell
+                        OtherWalker = OtherWalker->next;
+                        //*out << Verbose(0) << "Current comparison atom is " << *OtherWalker << "." << endl;
+                        /// \todo periodic check is missing here!
+                        //*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.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(1) << "Adding Bond between " << *Walker << " and " << *OtherWalker << " in distance " << sqrt(distance) << "." << endl;
+                          AddBond(Walker->father, OtherWalker->father, 1);  // also increases molecule::BondCount
+                        } else {
+                          //*out << Verbose(1) << "Not Adding: Wrong label order or distance too great." << endl;
+              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]++) {
+                    const LinkedNodes *OtherList = LC->GetRelativeToCurrentCell(n);
+                    //*out << Verbose(2) << "Current relative cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << " containing " << List->size() << " points." << endl;
+                    if (OtherList != NULL) {
+                      for (LinkedNodes::const_iterator OtherRunner = OtherList->begin(); OtherRunner != OtherList->end(); OtherRunner++) {
+                        if ((*OtherRunner)->nr > Walker->nr) {
+                          OtherWalker = AtomMap[(*OtherRunner)->nr];
+                          //*out << Verbose(1) << "Checking distance " << OtherWalker->x.PeriodicDistanceSquared(&(Walker->x), cell_size) << " against typical bond length of " << bonddistance*bonddistance << "." << endl;
+                          (BG->*minmaxdistance)(Walker, OtherWalker, MinDistance, MaxDistance, IsAngstroem);
+                          const double distance = OtherWalker->x.PeriodicDistanceSquared(&(Walker->x), cell_size);
+                          const bool status = (distance <= MaxDistance * MaxDistance) && (distance >= MinDistance * MinDistance);
+                          if ((OtherWalker->father->nr > Walker->father->nr) && (status)) { // create bond if distance is smaller
+                            //*out << Verbose(1) << "Adding Bond between " << *Walker << " and " << *OtherWalker << " in distance " << sqrt(distance) << "." << endl;
+                            AddBond(Walker->father, OtherWalker->father, 1); // also increases molecule::BondCount
+                          } else {
+                            //*out << Verbose(1) << "Not Adding: Wrong label order or distance too great." << endl;
+                          }
+                        }
+                      }
 …
+          }
+        }
+    // 4. free the cell again
+    for (int i=NumberCells;i--;)
+      if (CellList[i] != NULL) {
+        delete(CellList[i]);
+      }
+    Free(&CellList);
+    // create the adjacency list per atom
+    CreateListOfBondsPerAtom(out);
+    // correct Bond degree of each bond by checking both bond partners for a mismatch between valence and current sum of bond degrees,
+    // iteratively increase the one first where the other bond partner has the fewest number of bonds (i.e. in general bonds oxygene
+    // preferred over carbon bonds). Beforehand, we had picked the first mismatching partner, which lead to oxygenes with single instead of
+    // double bonds as was expected.
+    if (BondCount != 0) {
+      NoCyclicBonds = 0;
+      *out << Verbose(1) << "Correcting Bond degree of each bond ... ";
+      do {
+        No = 0; // No acts as breakup flag (if 1 we still continue)
+        Walker = start;
+        while (Walker->next != end) { // go through every atom
+          Walker = Walker->next;
+          // count valence of first partner
+          NoBonds = 0;
+          for(j=0;j<NumberOfBondsPerAtom[Walker->nr];j++)
+            NoBonds += ListOfBondsPerAtom[Walker->nr][j]->BondDegree;
+          *out << Verbose(3) << "Walker " << *Walker << ": " << (int)Walker->type->NoValenceOrbitals << " > " << NoBonds << "?" << endl;
+          if ((int)(Walker->type->NoValenceOrbitals) > NoBonds) { // we have a mismatch, check all bonding partners for mismatch
+            Candidate = NULL;
+            CandidateBondNo = -1;
+            for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) { // go through each of its bond partners
+              OtherWalker = ListOfBondsPerAtom[Walker->nr][i]->GetOtherAtom(Walker);
+              // count valence of second partner
+              NoBonds = 0;
+              for(j=0;j<NumberOfBondsPerAtom[OtherWalker->nr];j++)
+                NoBonds += ListOfBondsPerAtom[OtherWalker->nr][j]->BondDegree;
+              *out << Verbose(3) << "OtherWalker " << *OtherWalker << ": " << (int)OtherWalker->type->NoValenceOrbitals << " > " << NoBonds << "?" << endl;
+              if ((int)(OtherWalker->type->NoValenceOrbitals) > NoBonds) { // check if possible candidate
+                if ((Candidate == NULL) || (NumberOfBondsPerAtom[Candidate->nr] > NumberOfBondsPerAtom[OtherWalker->nr])) { // pick the one with fewer number of bonds first
+                  Candidate = OtherWalker;
+                  CandidateBondNo = i;
+                  *out << Verbose(3) << "New candidate is " << *Candidate << "." << endl;
+                }
+              }
+            }
+            if ((Candidate != NULL) && (CandidateBondNo != -1)) {
+              ListOfBondsPerAtom[Walker->nr][CandidateBondNo]->BondDegree++;
+              *out << Verbose(2) << "Increased bond degree for bond " << *ListOfBondsPerAtom[Walker->nr][CandidateBondNo] << "." << endl;
+            } else
+              *out << Verbose(2) << "Could not find correct degree for atom " << *Walker << "." << endl;
+              FalseBondDegree++;
+          }
+        }
+      } while (No);
+    *out << " done." << endl;
+    } else
+      *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;
+    Free(&AtomMap);
+    delete (LC);
+    *out << Verbose(1) << "I detected " << BondCount << " bonds in the molecule with distance " << BondDistance << "." << endl;
+    // correct bond degree by comparing valence and bond degree
+    *out << Verbose(2) << "Correcting bond degree ... " << endl;
+    CorrectBondDegree(out);
     // output bonds for debugging (if bond chain list was correctly installed)
+    *out << Verbose(1) << endl << "From contents of bond chain list:";
+    bond *Binder = first;
+    while(Binder->next != last) {
+      Binder = Binder->next;
+      *out << *Binder << "\t" << endl;
+    }
+    *out << endl;
+    ActOnAllAtoms(&atom::OutputBondOfAtom, out);
   } else
     *out << Verbose(1) << "AtomCount is " << AtomCount << ", thus no bonds, no connections!." << endl;
   *out << Verbose(0) << "End of CreateAdjacencyList." << endl;
+  Free(&matrix);
+};
+  if (free_BG)
+    delete(BG);
+}
+;
+/** Prints a list of all bonds to \a *out.
+ * \param output stream
+ */
+void molecule::OutputBondsList(ofstream *out) const
+{
+  *out << Verbose(1) << endl << "From contents of bond chain list:";
+  bond *Binder = first;
+  while (Binder->next != last) {
+    Binder = Binder->next;
+    *out << *Binder << "\t" << endl;
+  }
+  *out << endl;
+}
+;
+/** correct bond degree by comparing valence and bond degree.
+ * correct Bond degree of each bond by checking both bond partners for a mismatch between valence and current sum of bond degrees,
+ * iteratively increase the one first where the other bond partner has the fewest number of bonds (i.e. in general bonds oxygene
+ * preferred over carbon bonds). Beforehand, we had picked the first mismatching partner, which lead to oxygenes with single instead of
+ * double bonds as was expected.
+ * \param *out output stream for debugging
+ * \return number of bonds that could not be corrected
+ */
+int molecule::CorrectBondDegree(ofstream *out) const
+{
+  int No = 0, OldNo = -1;
+  if (BondCount != 0) {
+    *out << Verbose(1) << "Correcting Bond degree of each bond ... " << endl;
+    do {
+      OldNo = No;
+      No = SumPerAtom(&atom::CorrectBondDegree, out);
+    } while (OldNo != No);
+    *out << " done." << endl;
+  } else {
+    *out << Verbose(1) << "BondCount is " << BondCount << ", no bonds between any of the " << AtomCount << " atoms." << endl;
+  }
+  *out << No << " bonds could not be corrected." << endl;
+  return (No);
+}
+;
 /** Counts all cyclic bonds and returns their number.
 …
 int molecule::CountCyclicBonds(ofstream *out)
+{
   int No = 0;
+  NoCyclicBonds = 0;
   int *MinimumRingSize = NULL;
   MoleculeLeafClass *Subgraphs = NULL;
 …
     while (Subgraphs->next != NULL) {
       Subgraphs = Subgraphs->next;
       delete(Subgraphs->previous);
+    }
     delete(Subgraphs);
     delete[](MinimumRingSize);
+  }
   while(Binder->next != last) {
+      delete (Subgraphs->previous);
+    }
+    delete (Subgraphs);
+    delete[] (MinimumRingSize);
+  }
+  while (Binder->next != last) {
     Binder = Binder->next;
     if (Binder->Cyclic)
+      No++;
+  }
+  delete(BackEdgeStack);
+  return No;
+};
+      NoCyclicBonds++;
+  }
+  delete (BackEdgeStack);
+  return NoCyclicBonds;
+}
+;
 /** Returns Shading as a char string.
  * \param color the Shading
  * \return string of the flag
  */
 string molecule::GetColor(enum Shading color)
+{
   switch(color) {
+string molecule::GetColor(enum Shading color) const
+{
+  switch (color) {
     case white:
       return "white";
 …
       break;
   };
+};
+}
+;
+/** Sets atom::GraphNr and atom::LowpointNr to BFSAccounting::CurrentGraphNr.
+ * \param *out output stream for debugging
+ * \param *Walker current node
+ * \param &BFS structure with accounting data for BFS
+ */
+void DepthFirstSearchAnalysis_SetWalkersGraphNr(ofstream *out, atom *&Walker, struct DFSAccounting &DFS)
+{
+  if (!DFS.BackStepping) { // if we don't just return from (8)
+    Walker->GraphNr = DFS.CurrentGraphNr;
+    Walker->LowpointNr = DFS.CurrentGraphNr;
+    *out << Verbose(1) << "Setting Walker[" << Walker->Name << "]'s number to " << Walker->GraphNr << " with Lowpoint " << Walker->LowpointNr << "." << endl;
+    DFS.AtomStack->Push(Walker);
+    DFS.CurrentGraphNr++;
+  }
+}
+;
+/** During DFS goes along unvisited bond and touches other atom.
+ * Sets bond::type, if
+ *  -# BackEdge: set atom::LowpointNr and push on \a BackEdgeStack
+ *  -# TreeEgde: set atom::Ancestor and continue with Walker along this edge
+ * Continue until molecule::FindNextUnused() finds no more unused bonds.
+ * \param *out output stream for debugging
+ * \param *mol molecule with atoms and finding unused bonds
+ * \param *&Binder current edge
+ * \param &DFS DFS accounting data
+ */
+void DepthFirstSearchAnalysis_ProbeAlongUnusedBond(ofstream *out, const molecule * const mol, atom *&Walker, bond *&Binder, struct DFSAccounting &DFS)
+{
+  atom *OtherAtom = NULL;
+  do { // (3) if Walker has no unused egdes, go to (5)
+    DFS.BackStepping = false; // reset backstepping flag for (8)
+    if (Binder == NULL) // if we don't just return from (11), Binder is already set to next unused
+      Binder = mol->FindNextUnused(Walker);
+    if (Binder == NULL)
+      break;
+    *out << Verbose(2) << "Current Unused Bond is " << *Binder << "." << endl;
+    // (4) Mark Binder used, ...
+    Binder->MarkUsed(black);
+    OtherAtom = Binder->GetOtherAtom(Walker);
+    *out << Verbose(2) << "(4) OtherAtom is " << OtherAtom->Name << "." << endl;
+    if (OtherAtom->GraphNr != -1) {
+      // (4a) ... if "other" atom has been visited (GraphNr != 0), set lowpoint to minimum of both, go to (3)
+      Binder->Type = BackEdge;
+      DFS.BackEdgeStack->Push(Binder);
+      Walker->LowpointNr = (Walker->LowpointNr < OtherAtom->GraphNr) ? Walker->LowpointNr : OtherAtom->GraphNr;
+      *out << Verbose(3) << "(4a) Visited: Setting Lowpoint of Walker[" << Walker->Name << "] to " << Walker->LowpointNr << "." << endl;
+    } else {
+      // (4b) ... otherwise set OtherAtom as Ancestor of Walker and Walker as OtherAtom, go to (2)
+      Binder->Type = TreeEdge;
+      OtherAtom->Ancestor = Walker;
+      Walker = OtherAtom;
+      *out << Verbose(3) << "(4b) Not Visited: OtherAtom[" << OtherAtom->Name << "]'s Ancestor is now " << OtherAtom->Ancestor->Name << ", Walker is OtherAtom " << OtherAtom->Name << "." << endl;
+      break;
+    }
+    Binder = NULL;
+  } while (1); // (3)
+}
+;
+/** Checks whether we have a new component.
+ * if atom::LowpointNr of \a *&Walker is greater than atom::GraphNr of its atom::Ancestor, we have a new component.
+ * Meaning that if we touch upon a node who suddenly has a smaller atom::LowpointNr than its ancestor, then we
+ * have a found a new branch in the graph tree.
+ * \param *out output stream for debugging
+ * \param *mol molecule with atoms and finding unused bonds
+ * \param *&Walker current node
+ * \param &DFS DFS accounting data
+ */
+void DepthFirstSearchAnalysis_CheckForaNewComponent(ofstream *out, const molecule * const mol, atom *&Walker, struct DFSAccounting &DFS, MoleculeLeafClass *&LeafWalker)
+{
+  atom *OtherAtom = NULL;
+  // (5) if Ancestor of Walker is ...
+  *out << Verbose(1) << "(5) Number of Walker[" << Walker->Name << "]'s Ancestor[" << Walker->Ancestor->Name << "] is " << Walker->Ancestor->GraphNr << "." << endl;
+  if (Walker->Ancestor->GraphNr != DFS.Root->GraphNr) {
+    // (6)  (Ancestor of Walker is not Root)
+    if (Walker->LowpointNr < Walker->Ancestor->GraphNr) {
+      // (6a) set Ancestor's Lowpoint number to minimum of of its Ancestor and itself, go to Step(8)
+      Walker->Ancestor->LowpointNr = (Walker->Ancestor->LowpointNr < Walker->LowpointNr) ? Walker->Ancestor->LowpointNr : Walker->LowpointNr;
+      *out << Verbose(2) << "(6) Setting Walker[" << Walker->Name << "]'s Ancestor[" << Walker->Ancestor->Name << "]'s Lowpoint to " << Walker->Ancestor->LowpointNr << "." << endl;
+    } else {
+      // (7) (Ancestor of Walker is a separating vertex, remove all from stack till Walker (including), these and Ancestor form a component
+      Walker->Ancestor->SeparationVertex = true;
+      *out << Verbose(2) << "(7) Walker[" << Walker->Name << "]'s Ancestor[" << Walker->Ancestor->Name << "]'s is a separating vertex, creating component." << endl;
+      mol->SetNextComponentNumber(Walker->Ancestor, DFS.ComponentNumber);
+      *out << Verbose(3) << "(7) Walker[" << Walker->Name << "]'s Ancestor's Compont is " << DFS.ComponentNumber << "." << endl;
+      mol->SetNextComponentNumber(Walker, DFS.ComponentNumber);
+      *out << Verbose(3) << "(7) Walker[" << Walker->Name << "]'s Compont is " << DFS.ComponentNumber << "." << endl;
+      do {
+        OtherAtom = DFS.AtomStack->PopLast();
+        LeafWalker->Leaf->AddCopyAtom(OtherAtom);
+        mol->SetNextComponentNumber(OtherAtom, DFS.ComponentNumber);
+        *out << Verbose(3) << "(7) Other[" << OtherAtom->Name << "]'s Compont is " << DFS.ComponentNumber << "." << endl;
+      } while (OtherAtom != Walker);
+      DFS.ComponentNumber++;
+    }
+    // (8) Walker becomes its Ancestor, go to (3)
+    *out << Verbose(2) << "(8) Walker[" << Walker->Name << "] is now its Ancestor " << Walker->Ancestor->Name << ", backstepping. " << endl;
+    Walker = Walker->Ancestor;
+    DFS.BackStepping = true;
+  }
+}
+;
+/** Cleans the root stack when we have found a component.
+ * If we are not DFSAccounting::BackStepping, then we clear the root stack by putting everything into a
+ * component down till we meet DFSAccounting::Root.
+ * \param *out output stream for debugging
+ * \param *mol molecule with atoms and finding unused bonds
+ * \param *&Walker current node
+ * \param *&Binder current edge
+ * \param &DFS DFS accounting data
+ */
+void DepthFirstSearchAnalysis_CleanRootStackDownTillWalker(ofstream *out, const molecule * const mol, atom *&Walker, bond *&Binder, struct DFSAccounting &DFS, MoleculeLeafClass *&LeafWalker)
+{
+  atom *OtherAtom = NULL;
+  if (!DFS.BackStepping) { // coming from (8) want to go to (3)
+    // (9) remove all from stack till Walker (including), these and Root form a component
+    //DFS.AtomStack->Output(out);
+    mol->SetNextComponentNumber(DFS.Root, DFS.ComponentNumber);
+    *out << Verbose(3) << "(9) Root[" << DFS.Root->Name << "]'s Component is " << DFS.ComponentNumber << "." << endl;
+    mol->SetNextComponentNumber(Walker, DFS.ComponentNumber);
+    *out << Verbose(3) << "(9) Walker[" << Walker->Name << "]'s Component is " << DFS.ComponentNumber << "." << endl;
+    do {
+      OtherAtom = DFS.AtomStack->PopLast();
+      LeafWalker->Leaf->AddCopyAtom(OtherAtom);
+      mol->SetNextComponentNumber(OtherAtom, DFS.ComponentNumber);
+      *out << Verbose(3) << "(7) Other[" << OtherAtom->Name << "]'s Compont is " << DFS.ComponentNumber << "." << endl;
+    } while (OtherAtom != Walker);
+    DFS.ComponentNumber++;
+    // (11) Root is separation vertex,  set Walker to Root and go to (4)
+    Walker = DFS.Root;
+    Binder = mol->FindNextUnused(Walker);
+    *out << Verbose(1) << "(10) Walker is Root[" << DFS.Root->Name << "], next Unused Bond is " << Binder << "." << endl;
+    if (Binder != NULL) { // Root is separation vertex
+      *out << Verbose(1) << "(11) Root is a separation vertex." << endl;
+      Walker->SeparationVertex = true;
+    }
+  }
+}
+;
+/** Initializes DFSAccounting structure.
+ * \param *out output stream for debugging
+ * \param &DFS accounting structure to allocate
+ * \param *mol molecule with AtomCount, BondCount and all atoms
+ */
+void DepthFirstSearchAnalysis_Init(ofstream *out, struct DFSAccounting &DFS, const molecule * const mol)
+{
+  DFS.AtomStack = new StackClass<atom *> (mol->AtomCount);
+  DFS.CurrentGraphNr = 0;
+  DFS.ComponentNumber = 0;
+  DFS.BackStepping = false;
+  mol->ResetAllBondsToUnused();
+  mol->SetAtomValueToValue(-1, &atom::GraphNr);
+  mol->ActOnAllAtoms(&atom::InitComponentNr);
+  DFS.BackEdgeStack->ClearStack();
+}
+;
+/** Free's DFSAccounting structure.
+ * \param *out output stream for debugging
+ * \param &DFS accounting structure to free
+ */
+void DepthFirstSearchAnalysis_Finalize(ofstream *out, struct DFSAccounting &DFS)
+{
+  delete (DFS.AtomStack);
+  // delete (DFS.BackEdgeStack); // DON'T free, see DepthFirstSearchAnalysis(), is returned as allocated
+}
+;
 /** Performs a Depth-First search on this molecule.
 …
  * \return list of each disconnected subgraph as an individual molecule class structure
  */
 MoleculeLeafClass * molecule::DepthFirstSearchAnalysis(ofstream *out, class StackClass<bond *> *&BackEdgeStack)
+{
   class StackClass<atom *> *AtomStack = new StackClass<atom *>(AtomCount);
+MoleculeLeafClass * molecule::DepthFirstSearchAnalysis(ofstream *out, class StackClass<bond *> *&BackEdgeStack) const
+{
+  struct DFSAccounting DFS;
   BackEdgeStack = new StackClass<bond *> (BondCount);
+  DFS.BackEdgeStack = BackEdgeStack;
   MoleculeLeafClass *SubGraphs = new MoleculeLeafClass(NULL);
   MoleculeLeafClass *LeafWalker = SubGraphs;
+  int CurrentGraphNr = 0, OldGraphNr;
+  int ComponentNumber = 0;
+  atom *Walker = NULL, *OtherAtom = NULL, *Root = start->next;
+  int OldGraphNr = 0;
+  atom *Walker = NULL;
   bond *Binder = NULL;
-  bool BackStepping = false;
   *out << Verbose(0) << "Begin of DepthFirstSearchAnalysis" << endl;
+  ResetAllBondsToUnused();
+  ResetAllAtomNumbers();
+  InitComponentNumbers();
+  BackEdgeStack->ClearStack();
+  while (Root != end) { // if there any atoms at all
+    // (1) mark all edges unused, empty stack, set atom->GraphNr = 0 for all
+    AtomStack->ClearStack();
+  DepthFirstSearchAnalysis_Init(out, DFS, this);
+  DFS.Root = start->next;
+  while (DFS.Root != end) { // if there any atoms at all
+    // (1) mark all edges unused, empty stack, set atom->GraphNr = -1 for all
+    DFS.AtomStack->ClearStack();
     // put into new subgraph molecule and add this to list of subgraphs
     LeafWalker = new MoleculeLeafClass(LeafWalker);
     LeafWalker->Leaf = new molecule(elemente);
     LeafWalker->Leaf->AddCopyAtom(Root);
     OldGraphNr = CurrentGraphNr;
     Walker = Root;
+    LeafWalker->Leaf->AddCopyAtom(DFS.Root);
+    OldGraphNr = DFS.CurrentGraphNr;
+    Walker = DFS.Root;
     do { // (10)
       do { // (2) set number and Lowpoint of Atom to i, increase i, push current atom
+        if (!BackStepping) { // if we don't just return from (8)
+          Walker->GraphNr = CurrentGraphNr;
+          Walker->LowpointNr = CurrentGraphNr;
+          *out << Verbose(1) << "Setting Walker[" << Walker->Name << "]'s number to " << Walker->GraphNr << " with Lowpoint " << Walker->LowpointNr << "." << endl;
+          AtomStack->Push(Walker);
+          CurrentGraphNr++;
+        }
+        do { // (3) if Walker has no unused egdes, go to (5)
+          BackStepping = false; // reset backstepping flag for (8)
+          if (Binder == NULL) // if we don't just return from (11), Binder is already set to next unused
+            Binder = FindNextUnused(Walker);
+          if (Binder == NULL)
+            break;
+          *out << Verbose(2) << "Current Unused Bond is " << *Binder << "." << endl;
+          // (4) Mark Binder used, ...
+          Binder->MarkUsed(black);
+          OtherAtom = Binder->GetOtherAtom(Walker);
+          *out << Verbose(2) << "(4) OtherAtom is " << OtherAtom->Name << "." << endl;
+          if (OtherAtom->GraphNr != -1) {
+            // (4a) ... if "other" atom has been visited (GraphNr != 0), set lowpoint to minimum of both, go to (3)
+            Binder->Type = BackEdge;
+            BackEdgeStack->Push(Binder);
+            Walker->LowpointNr = ( Walker->LowpointNr < OtherAtom->GraphNr ) ? Walker->LowpointNr : OtherAtom->GraphNr;
+            *out << Verbose(3) << "(4a) Visited: Setting Lowpoint of Walker[" << Walker->Name << "] to " << Walker->LowpointNr << "." << endl;
+          } else {
+            // (4b) ... otherwise set OtherAtom as Ancestor of Walker and Walker as OtherAtom, go to (2)
+            Binder->Type = TreeEdge;
+            OtherAtom->Ancestor = Walker;
+            Walker = OtherAtom;
+            *out << Verbose(3) << "(4b) Not Visited: OtherAtom[" << OtherAtom->Name << "]'s Ancestor is now " << OtherAtom->Ancestor->Name << ", Walker is OtherAtom " << OtherAtom->Name << "." << endl;
+            break;
+          }
+          Binder = NULL;
+        } while (1);  // (3)
+        DepthFirstSearchAnalysis_SetWalkersGraphNr(out, Walker, DFS);
+        DepthFirstSearchAnalysis_ProbeAlongUnusedBond(out, this, Walker, Binder, DFS);
         if (Binder == NULL) {
           *out << Verbose(2) << "No more Unused Bonds." << endl;
 …
         } else
           Binder = NULL;
       } while (1);  // (2)
+      } while (1); // (2)
       // if we came from backstepping, yet there were no more unused bonds, we end up here with no Ancestor, because Walker is Root! Then we are finished!
       if ((Walker == Root) && (Binder == NULL))
+      if ((Walker == DFS.Root) && (Binder == NULL))
         break;
+      // (5) if Ancestor of Walker is ...
+      *out << Verbose(1) << "(5) Number of Walker[" << Walker->Name << "]'s Ancestor[" << Walker->Ancestor->Name << "] is " << Walker->Ancestor->GraphNr << "." << endl;
+      if (Walker->Ancestor->GraphNr != Root->GraphNr) {
+        // (6)  (Ancestor of Walker is not Root)
+        if (Walker->LowpointNr < Walker->Ancestor->GraphNr) {
+          // (6a) set Ancestor's Lowpoint number to minimum of of its Ancestor and itself, go to Step(8)
+          Walker->Ancestor->LowpointNr = (Walker->Ancestor->LowpointNr < Walker->LowpointNr) ? Walker->Ancestor->LowpointNr : Walker->LowpointNr;
+          *out << Verbose(2) << "(6) Setting Walker[" << Walker->Name << "]'s Ancestor[" << Walker->Ancestor->Name << "]'s Lowpoint to " << Walker->Ancestor->LowpointNr << "." << endl;
+        } else {
+          // (7) (Ancestor of Walker is a separating vertex, remove all from stack till Walker (including), these and Ancestor form a component
+          Walker->Ancestor->SeparationVertex = true;
+          *out << Verbose(2) << "(7) Walker[" << Walker->Name << "]'s Ancestor[" << Walker->Ancestor->Name << "]'s is a separating vertex, creating component." << endl;
+          SetNextComponentNumber(Walker->Ancestor, ComponentNumber);
+          *out << Verbose(3) << "(7) Walker[" << Walker->Name << "]'s Ancestor's Compont is " << ComponentNumber << "." << endl;
+          SetNextComponentNumber(Walker, ComponentNumber);
+          *out << Verbose(3) << "(7) Walker[" << Walker->Name << "]'s Compont is " << ComponentNumber << "." << endl;
+          do {
+            OtherAtom = AtomStack->PopLast();
+            LeafWalker->Leaf->AddCopyAtom(OtherAtom);
+            SetNextComponentNumber(OtherAtom, ComponentNumber);
+            *out << Verbose(3) << "(7) Other[" << OtherAtom->Name << "]'s Compont is " << ComponentNumber << "." << endl;
+          } while (OtherAtom != Walker);
+          ComponentNumber++;
+        }
+        // (8) Walker becomes its Ancestor, go to (3)
+        *out << Verbose(2) << "(8) Walker[" << Walker->Name << "] is now its Ancestor " << Walker->Ancestor->Name << ", backstepping. " << endl;
+        Walker = Walker->Ancestor;
+        BackStepping = true;
+      }
+      if (!BackStepping) {  // coming from (8) want to go to (3)
+        // (9) remove all from stack till Walker (including), these and Root form a component
+        AtomStack->Output(out);
+        SetNextComponentNumber(Root, ComponentNumber);
+        *out << Verbose(3) << "(9) Root[" << Root->Name << "]'s Component is " << ComponentNumber << "." << endl;
+        SetNextComponentNumber(Walker, ComponentNumber);
+        *out << Verbose(3) << "(9) Walker[" << Walker->Name << "]'s Component is " << ComponentNumber << "." << endl;
+        do {
+          OtherAtom = AtomStack->PopLast();
+          LeafWalker->Leaf->AddCopyAtom(OtherAtom);
+          SetNextComponentNumber(OtherAtom, ComponentNumber);
+          *out << Verbose(3) << "(7) Other[" << OtherAtom->Name << "]'s Compont is " << ComponentNumber << "." << endl;
+        } while (OtherAtom != Walker);
+        ComponentNumber++;
+        // (11) Root is separation vertex,  set Walker to Root and go to (4)
+        Walker = Root;
+        Binder = FindNextUnused(Walker);
+        *out << Verbose(1) << "(10) Walker is Root[" << Root->Name << "], next Unused Bond is " << Binder << "." << endl;
+        if (Binder != NULL) { // Root is separation vertex
+          *out << Verbose(1) << "(11) Root is a separation vertex." << endl;
+          Walker->SeparationVertex = true;
+        }
+      }
+    } while ((BackStepping) || (Binder != NULL)); // (10) halt only if Root has no unused edges
+      DepthFirstSearchAnalysis_CheckForaNewComponent(out, this, Walker, DFS, LeafWalker);
+      DepthFirstSearchAnalysis_CleanRootStackDownTillWalker(out, this, Walker, Binder, DFS, LeafWalker);
+    } while ((DFS.BackStepping) || (Binder != NULL)); // (10) halt only if Root has no unused edges
     // From OldGraphNr to CurrentGraphNr ranges an disconnected subgraph
     *out << Verbose(0) << "Disconnected subgraph ranges from " << OldGraphNr << " to " << CurrentGraphNr << "." << endl;
+    *out << Verbose(0) << "Disconnected subgraph ranges from " << OldGraphNr << " to " << DFS.CurrentGraphNr << "." << endl;
     LeafWalker->Leaf->Output(out);
     *out << endl;
     // step on to next root
     while ((Root != end) && (Root->GraphNr != -1)) {
+    while ((DFS.Root != end) && (DFS.Root->GraphNr != -1)) {
       //*out << Verbose(1) << "Current next subgraph root candidate is " << Root->Name << "." << endl;
       if (Root->GraphNr != -1) // if already discovered, step on
         Root = Root->next;
+      if (DFS.Root->GraphNr != -1) // if already discovered, step on
+        DFS.Root = DFS.Root->next;
+    }
+  }
   // set cyclic bond criterium on "same LP" basis
+  Binder = first;
+  while(Binder->next != last) {
+  CyclicBondAnalysis();
+  OutputGraphInfoPerAtom(out);
+  OutputGraphInfoPerBond(out);
+  // free all and exit
+  DepthFirstSearchAnalysis_Finalize(out, DFS);
+  *out << Verbose(0) << "End of DepthFirstSearchAnalysis" << endl;
+  return SubGraphs;
+}
+;
+/** Scans through all bonds and set bond::Cyclic to true where atom::LowpointNr of both ends is equal: LP criterion.
+ */
+void molecule::CyclicBondAnalysis() const
+{
+  NoCyclicBonds = 0;
+  bond *Binder = first;
+  while (Binder->next != last) {
     Binder = Binder->next;
     if (Binder->rightatom->LowpointNr == Binder->leftatom->LowpointNr) { // cyclic ??
 …
+    }
+  }
+}
+;
+/** Output graph information per atom.
+ * \param *out output stream
+ */
+void molecule::OutputGraphInfoPerAtom(ofstream *out) const
+{
   *out << Verbose(1) << "Final graph info for each atom is:" << endl;
+  Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    *out << Verbose(2) << "Atom " << Walker->Name << " is " << ((Walker->SeparationVertex) ? "a" : "not a") << " separation vertex, components are ";
+    OutputComponentNumber(out, Walker);
+    *out << " with Lowpoint " << Walker->LowpointNr << " and Graph Nr. " << Walker->GraphNr << "." << endl;
+  }
+  ActOnAllAtoms(&atom::OutputGraphInfo, out);
+}
+;
+/** Output graph information per bond.
+ * \param *out output stream
+ */
+void molecule::OutputGraphInfoPerBond(ofstream *out) const
+{
   *out << Verbose(1) << "Final graph info for each bond is:" << endl;
   Binder = first;
   while(Binder->next != last) {
+  bond *Binder = first;
+  while (Binder->next != last) {
     Binder = Binder->next;
     *out << Verbose(2) << ((Binder->Type == TreeEdge) ? "TreeEdge " : "BackEdge ") << *Binder << ": <";
     *out << ((Binder->leftatom->SeparationVertex) ? "SP," : "") << "L" << Binder->leftatom->LowpointNr << " G" << Binder->leftatom->GraphNr << " Comp.";
     OutputComponentNumber(out, Binder->leftatom);
+    Binder->leftatom->OutputComponentNumber(out);
     *out << " ===  ";
     *out << ((Binder->rightatom->SeparationVertex) ? "SP," : "") << "L" << Binder->rightatom->LowpointNr << " G" << Binder->rightatom->GraphNr << " Comp.";
     OutputComponentNumber(out, Binder->rightatom);
+    Binder->rightatom->OutputComponentNumber(out);
     *out << ">." << endl;
     if (Binder->Cyclic) // cyclic ??
       *out << Verbose(3) << "Lowpoint at each side are equal: CYCLIC!" << endl;
+  }
+  // free all and exit
+  delete(AtomStack);
+  *out << Verbose(0) << "End of DepthFirstSearchAnalysis" << endl;
+  return SubGraphs;
+}
+;
+/** Initialise each vertex as white with no predecessor, empty queue, color Root lightgray.
+ * \param *out output stream for debugging
+ * \param &BFS accounting structure
+ * \param AtomCount number of entries in the array to allocate
+ */
+void InitializeBFSAccounting(ofstream *out, struct BFSAccounting &BFS, int AtomCount)
+{
+  BFS.AtomCount = AtomCount;
+  BFS.PredecessorList = Calloc<atom*> (AtomCount, "molecule::BreadthFirstSearchAdd_Init: **PredecessorList");
+  BFS.ShortestPathList = Malloc<int> (AtomCount, "molecule::BreadthFirstSearchAdd_Init: *ShortestPathList");
+  BFS.ColorList = Calloc<enum Shading> (AtomCount, "molecule::BreadthFirstSearchAdd_Init: *ColorList");
+  BFS.BFSStack = new StackClass<atom *> (AtomCount);
+  for (int i = AtomCount; i--;)
+    BFS.ShortestPathList[i] = -1;
 };
+/** Free's accounting structure.
+ * \param *out output stream for debugging
+ * \param &BFS accounting structure
+ */
+void FinalizeBFSAccounting(ofstream *out, struct BFSAccounting &BFS)
+{
+  Free(&BFS.PredecessorList);
+  Free(&BFS.ShortestPathList);
+  Free(&BFS.ColorList);
+  delete (BFS.BFSStack);
+  BFS.AtomCount = 0;
+};
+/** Clean the accounting structure.
+ * \param *out output stream for debugging
+ * \param &BFS accounting structure
+ */
+void CleanBFSAccounting(ofstream *out, struct BFSAccounting &BFS)
+{
+  atom *Walker = NULL;
+  while (!BFS.TouchedStack->IsEmpty()) {
+    Walker = BFS.TouchedStack->PopFirst();
+    BFS.PredecessorList[Walker->nr] = NULL;
+    BFS.ShortestPathList[Walker->nr] = -1;
+    BFS.ColorList[Walker->nr] = white;
+  }
+};
+/** Resets shortest path list and BFSStack.
+ * \param *out output stream for debugging
+ * \param *&Walker current node, pushed onto BFSAccounting::BFSStack and BFSAccounting::TouchedStack
+ * \param &BFS accounting structure
+ */
+void ResetBFSAccounting(ofstream *out, atom *&Walker, struct BFSAccounting &BFS)
+{
+  BFS.ShortestPathList[Walker->nr] = 0;
+  BFS.BFSStack->ClearStack(); // start with empty BFS stack
+  BFS.BFSStack->Push(Walker);
+  BFS.TouchedStack->Push(Walker);
+};
+/** Performs a BFS from \a *Root, trying to find the same node and hence a cycle.
+ * \param *out output stream for debugging
+ * \param *&BackEdge the edge from root that we don't want to move along
+ * \param &BFS accounting structure
+ */
+void CyclicStructureAnalysis_CyclicBFSFromRootToRoot(ofstream *out, bond *&BackEdge, struct BFSAccounting &BFS)
+{
+  atom *Walker = NULL;
+  atom *OtherAtom = NULL;
+  do { // look for Root
+    Walker = BFS.BFSStack->PopFirst();
+    *out << Verbose(2) << "Current Walker is " << *Walker << ", we look for SP to Root " << *BFS.Root << "." << endl;
+    for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
+      if ((*Runner) != BackEdge) { // only walk along DFS spanning tree (otherwise we always find SP of one being backedge Binder)
+        OtherAtom = (*Runner)->GetOtherAtom(Walker);
+#ifdef ADDHYDROGEN
+        if (OtherAtom->type->Z != 1) {
+#endif
+        *out << Verbose(2) << "Current OtherAtom is: " << OtherAtom->Name << " for bond " << *(*Runner) << "." << endl;
+        if (BFS.ColorList[OtherAtom->nr] == white) {
+          BFS.TouchedStack->Push(OtherAtom);
+          BFS.ColorList[OtherAtom->nr] = lightgray;
+          BFS.PredecessorList[OtherAtom->nr] = Walker; // Walker is the predecessor
+          BFS.ShortestPathList[OtherAtom->nr] = BFS.ShortestPathList[Walker->nr] + 1;
+          *out << Verbose(2) << "Coloring OtherAtom " << OtherAtom->Name << " lightgray, its predecessor is " << Walker->Name << " and its Shortest Path is " << BFS.ShortestPathList[OtherAtom->nr] << " egde(s) long." << endl;
+          //if (BFS.ShortestPathList[OtherAtom->nr] < MinimumRingSize[Walker->GetTrueFather()->nr]) { // Check for maximum distance
+          *out << Verbose(3) << "Putting OtherAtom into queue." << endl;
+          BFS.BFSStack->Push(OtherAtom);
+          //}
+        } else {
+          *out << Verbose(3) << "Not Adding, has already been visited." << endl;
+        }
+        if (OtherAtom == BFS.Root)
+          break;
+#ifdef ADDHYDROGEN
+      } else {
+        *out << Verbose(2) << "Skipping hydrogen atom " << *OtherAtom << "." << endl;
+        BFS.ColorList[OtherAtom->nr] = black;
+      }
+#endif
+      } else {
+        *out << Verbose(2) << "Bond " << *(*Runner) << " not Visiting, is the back edge." << endl;
+      }
+    }
+    BFS.ColorList[Walker->nr] = black;
+    *out << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl;
+    if (OtherAtom == BFS.Root) { // if we have found the root, check whether this cycle wasn't already found beforehand
+      // step through predecessor list
+      while (OtherAtom != BackEdge->rightatom) {
+        if (!OtherAtom->GetTrueFather()->IsCyclic) // if one bond in the loop is not marked as cyclic, we haven't found this cycle yet
+          break;
+        else
+          OtherAtom = BFS.PredecessorList[OtherAtom->nr];
+      }
+      if (OtherAtom == BackEdge->rightatom) { // if each atom in found cycle is cyclic, loop's been found before already
+        *out << Verbose(3) << "This cycle was already found before, skipping and removing seeker from search." << endl;
+        do {
+          OtherAtom = BFS.TouchedStack->PopLast();
+          if (BFS.PredecessorList[OtherAtom->nr] == Walker) {
+            *out << Verbose(4) << "Removing " << *OtherAtom << " from lists and stacks." << endl;
+            BFS.PredecessorList[OtherAtom->nr] = NULL;
+            BFS.ShortestPathList[OtherAtom->nr] = -1;
+            BFS.ColorList[OtherAtom->nr] = white;
+            BFS.BFSStack->RemoveItem(OtherAtom);
+          }
+        } while ((!BFS.TouchedStack->IsEmpty()) && (BFS.PredecessorList[OtherAtom->nr] == NULL));
+        BFS.TouchedStack->Push(OtherAtom); // last was wrongly popped
+        OtherAtom = BackEdge->rightatom; // set to not Root
+      } else
+        OtherAtom = BFS.Root;
+    }
+  } while ((!BFS.BFSStack->IsEmpty()) && (OtherAtom != BFS.Root) && (OtherAtom != NULL)); // || (ShortestPathList[OtherAtom->nr] < MinimumRingSize[Walker->GetTrueFather()->nr])));
+};
+/** Climb back the BFSAccounting::PredecessorList and find cycle members.
+ * \param *out output stream for debugging
+ * \param *&OtherAtom
+ * \param *&BackEdge denotes the edge we did not want to travel along when doing CyclicBFSFromRootToRoot()
+ * \param &BFS accounting structure
+ * \param *&MinimumRingSize minimum distance from this node possible without encountering oneself, set on return for each atom
+ * \param &MinRingSize global minimum distance from one node without encountering oneself, set on return
+ */
+void CyclicStructureAnalysis_RetrieveCycleMembers(ofstream *out, atom *&OtherAtom, bond *&BackEdge, struct BFSAccounting &BFS, int *&MinimumRingSize, int &MinRingSize)
+{
+  atom *Walker = NULL;
+  int NumCycles = 0;
+  int RingSize = -1;
+  if (OtherAtom == BFS.Root) {
+    // now climb back the predecessor list and thus find the cycle members
+    NumCycles++;
+    RingSize = 1;
+    BFS.Root->GetTrueFather()->IsCyclic = true;
+    *out << Verbose(1) << "Found ring contains: ";
+    Walker = BFS.Root;
+    while (Walker != BackEdge->rightatom) {
+      *out << Walker->Name << " <-> ";
+      Walker = BFS.PredecessorList[Walker->nr];
+      Walker->GetTrueFather()->IsCyclic = true;
+      RingSize++;
+    }
+    *out << Walker->Name << "  with a length of " << RingSize << "." << endl << endl;
+    // walk through all and set MinimumRingSize
+    Walker = BFS.Root;
+    MinimumRingSize[Walker->GetTrueFather()->nr] = RingSize;
+    while (Walker != BackEdge->rightatom) {
+      Walker = BFS.PredecessorList[Walker->nr];
+      if (RingSize < MinimumRingSize[Walker->GetTrueFather()->nr])
+        MinimumRingSize[Walker->GetTrueFather()->nr] = RingSize;
+    }
+    if ((RingSize < MinRingSize) || (MinRingSize == -1))
+      MinRingSize = RingSize;
+  } else {
+    *out << Verbose(1) << "No ring containing " << *BFS.Root << " with length equal to or smaller than " << MinimumRingSize[Walker->GetTrueFather()->nr] << " found." << endl;
+  }
+};
+/** From a given node performs a BFS to touch the next cycle, for whose nodes \a *&MinimumRingSize is set and set it accordingly.
+ * \param *out output stream for debugging
+ * \param *&Root node to look for closest cycle from, i.e. \a *&MinimumRingSize is set for this node
+ * \param *&MinimumRingSize minimum distance from this node possible without encountering oneself, set on return for each atom
+ * \param AtomCount number of nodes in graph
+ */
+void CyclicStructureAnalysis_BFSToNextCycle(ofstream *out, atom *&Root, atom *&Walker, int *&MinimumRingSize, int AtomCount)
+{
+  struct BFSAccounting BFS;
+  atom *OtherAtom = Walker;
+  InitializeBFSAccounting(out, BFS, AtomCount);
+  ResetBFSAccounting(out, Walker, BFS);
+  while (OtherAtom != NULL) { // look for Root
+    Walker = BFS.BFSStack->PopFirst();
+    //*out << Verbose(2) << "Current Walker is " << *Walker << ", we look for SP to Root " << *Root << "." << endl;
+    for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
+      // "removed (*Runner) != BackEdge) || " from next if, is u
+      if ((Walker->ListOfBonds.size() == 1)) { // only walk along DFS spanning tree (otherwise we always find SP of 1 being backedge Binder), but terminal hydrogens may be connected via backedge, hence extra check
+        OtherAtom = (*Runner)->GetOtherAtom(Walker);
+        //*out << Verbose(2) << "Current OtherAtom is: " << OtherAtom->Name << " for bond " << *Binder << "." << endl;
+        if (BFS.ColorList[OtherAtom->nr] == white) {
+          BFS.TouchedStack->Push(OtherAtom);
+          BFS.ColorList[OtherAtom->nr] = lightgray;
+          BFS.PredecessorList[OtherAtom->nr] = Walker; // Walker is the predecessor
+          BFS.ShortestPathList[OtherAtom->nr] = BFS.ShortestPathList[Walker->nr] + 1;
+          //*out << Verbose(2) << "Coloring OtherAtom " << OtherAtom->Name << " lightgray, its predecessor is " << Walker->Name << " and its Shortest Path is " << ShortestPathList[OtherAtom->nr] << " egde(s) long." << endl;
+          if (OtherAtom->GetTrueFather()->IsCyclic) { // if the other atom is connected to a ring
+            MinimumRingSize[Root->GetTrueFather()->nr] = BFS.ShortestPathList[OtherAtom->nr] + MinimumRingSize[OtherAtom->GetTrueFather()->nr];
+            OtherAtom = NULL; //break;
+            break;
+          } else
+            BFS.BFSStack->Push(OtherAtom);
+        } else {
+          //*out << Verbose(3) << "Not Adding, has already been visited." << endl;
+        }
+      } else {
+        //*out << Verbose(3) << "Not Visiting, is a back edge." << endl;
+      }
+    }
+    BFS.ColorList[Walker->nr] = black;
+    //*out << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl;
+  }
+  //CleanAccountingLists(TouchedStack, PredecessorList, ShortestPathList, ColorList);
+  FinalizeBFSAccounting(out, BFS);
+}
+;
+/** All nodes that are not in cycles get assigned a \a *&MinimumRingSizeby BFS to next cycle.
+ * \param *out output stream for debugging
+ * \param *&MinimumRingSize array with minimum distance without encountering onself for each atom
+ * \param &MinRingSize global minium distance
+ * \param &NumCyles number of cycles in graph
+ * \param *mol molecule with atoms
+ */
+void CyclicStructureAnalysis_AssignRingSizetoNonCycleMembers(ofstream *out, int *&MinimumRingSize, int &MinRingSize, int &NumCycles, const molecule * const mol)
+{
+  atom *Root = NULL;
+  atom *Walker = NULL;
+  if (MinRingSize != -1) { // if rings are present
+    // go over all atoms
+    Root = mol->start;
+    while (Root->next != mol->end) {
+      Root = Root->next;
+      if (MinimumRingSize[Root->GetTrueFather()->nr] == mol->AtomCount) { // check whether MinimumRingSize is set, if not BFS to next where it is
+        Walker = Root;
+        //*out << Verbose(1) << "---------------------------------------------------------------------------------------------------------" << endl;
+        CyclicStructureAnalysis_BFSToNextCycle(out, Root, Walker, MinimumRingSize, mol->AtomCount);
+      }
+      *out << Verbose(1) << "Minimum ring size of " << *Root << " is " << MinimumRingSize[Root->GetTrueFather()->nr] << "." << endl;
+    }
+    *out << Verbose(1) << "Minimum ring size is " << MinRingSize << ", over " << NumCycles << " cycles total." << endl;
+  } else
+    *out << Verbose(1) << "No rings were detected in the molecular structure." << endl;
+}
+;
 /** Analyses the cycles found and returns minimum of all cycle lengths.
 …
  * \todo BFS from the not-same-LP to find back to starting point of tributary cycle over more than one bond
  */
+void molecule::CyclicStructureAnalysis(ofstream *out, class StackClass<bond *> *  BackEdgeStack, int *&MinimumRingSize)
+{
+  atom **PredecessorList = Malloc<atom*>(AtomCount, "molecule::CyclicStructureAnalysis: **PredecessorList");
+  int *ShortestPathList = Malloc<int>(AtomCount, "molecule::CyclicStructureAnalysis: *ShortestPathList");
+  enum Shading *ColorList = Malloc<enum Shading>(AtomCount, "molecule::CyclicStructureAnalysis: *ColorList");
+  class StackClass<atom *> *BFSStack = new StackClass<atom *> (AtomCount);   // will hold the current ring
+  class StackClass<atom *> *TouchedStack = new StackClass<atom *> (AtomCount);   // contains all "touched" atoms (that need to be reset after BFS loop)
+  atom *Walker = NULL, *OtherAtom = NULL, *Root = NULL;
+  bond *Binder = NULL, *BackEdge = NULL;
+  int RingSize, NumCycles, MinRingSize = -1;
+  // initialise each vertex as white with no predecessor, empty queue, color Root lightgray
+  for (int i=AtomCount;i--;) {
+    PredecessorList[i] = NULL;
+    ShortestPathList[i] = -1;
+    ColorList[i] = white;
+  }
+  *out << Verbose(1) << "Back edge list - ";
+  BackEdgeStack->Output(out);
+void molecule::CyclicStructureAnalysis(ofstream *out, class StackClass<bond *> * BackEdgeStack, int *&MinimumRingSize) const
+{
+  struct BFSAccounting BFS;
+  atom *Walker = NULL;
+  atom *OtherAtom = NULL;
+  bond *BackEdge = NULL;
+  int NumCycles = 0;
+  int MinRingSize = -1;
+  InitializeBFSAccounting(out, BFS, AtomCount);
+  //*out << Verbose(1) << "Back edge list - ";
+  //BackEdgeStack->Output(out);
   *out << Verbose(1) << "Analysing cycles ... " << endl;
 …
     BackEdge = BackEdgeStack->PopFirst();
     // this is the target
     Root = BackEdge->leftatom;
+    BFS.Root = BackEdge->leftatom;
     // this is the source point
     Walker = BackEdge->rightatom;
+    ShortestPathList[Walker->nr] = 0;
+    BFSStack->ClearStack();  // start with empty BFS stack
+    BFSStack->Push(Walker);
+    TouchedStack->Push(Walker);
+    ResetBFSAccounting(out, Walker, BFS);
     *out << Verbose(1) << "---------------------------------------------------------------------------------------------------------" << endl;
     OtherAtom = NULL;
+    do {  // look for Root
+      Walker = BFSStack->PopFirst();
+      *out << Verbose(2) << "Current Walker is " << *Walker << ", we look for SP to Root " << *Root << "." << endl;
+      for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) {
+        Binder = ListOfBondsPerAtom[Walker->nr][i];
+        if (Binder != BackEdge) { // only walk along DFS spanning tree (otherwise we always find SP of one being backedge Binder)
+          OtherAtom = Binder->GetOtherAtom(Walker);
+#ifdef ADDHYDROGEN
+          if (OtherAtom->type->Z != 1) {
+#endif
+            *out << Verbose(2) << "Current OtherAtom is: " << OtherAtom->Name << " for bond " << *Binder << "." << endl;
+            if (ColorList[OtherAtom->nr] == white) {
+              TouchedStack->Push(OtherAtom);
+              ColorList[OtherAtom->nr] = lightgray;
+              PredecessorList[OtherAtom->nr] = Walker;  // Walker is the predecessor
+              ShortestPathList[OtherAtom->nr] = ShortestPathList[Walker->nr]+1;
+              *out << Verbose(2) << "Coloring OtherAtom " << OtherAtom->Name << " lightgray, its predecessor is " << Walker->Name << " and its Shortest Path is " << ShortestPathList[OtherAtom->nr] << " egde(s) long." << endl;
+              //if (ShortestPathList[OtherAtom->nr] < MinimumRingSize[Walker->GetTrueFather()->nr]) { // Check for maximum distance
+                *out << Verbose(3) << "Putting OtherAtom into queue." << endl;
+                BFSStack->Push(OtherAtom);
+              //}
+            } else {
+              *out << Verbose(3) << "Not Adding, has already been visited." << endl;
+            }
+            if (OtherAtom == Root)
+              break;
+#ifdef ADDHYDROGEN
+          } else {
+            *out << Verbose(2) << "Skipping hydrogen atom " << *OtherAtom << "." << endl;
+            ColorList[OtherAtom->nr] = black;
+          }
+#endif
+        } else {
+          *out << Verbose(2) << "Bond " << *Binder << " not Visiting, is the back edge." << endl;
+        }
+      }
+      ColorList[Walker->nr] = black;
+      *out << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl;
+      if (OtherAtom == Root) { // if we have found the root, check whether this cycle wasn't already found beforehand
+        // step through predecessor list
+        while (OtherAtom != BackEdge->rightatom) {
+          if (!OtherAtom->GetTrueFather()->IsCyclic)  // if one bond in the loop is not marked as cyclic, we haven't found this cycle yet
+            break;
+          else
+            OtherAtom = PredecessorList[OtherAtom->nr];
+        }
+        if (OtherAtom == BackEdge->rightatom) { // if each atom in found cycle is cyclic, loop's been found before already
+          *out << Verbose(3) << "This cycle was already found before, skipping and removing seeker from search." << endl;\
+          do {
+            OtherAtom = TouchedStack->PopLast();
+            if (PredecessorList[OtherAtom->nr] == Walker) {
+              *out << Verbose(4) << "Removing " << *OtherAtom << " from lists and stacks." << endl;
+              PredecessorList[OtherAtom->nr] = NULL;
+              ShortestPathList[OtherAtom->nr] = -1;
+              ColorList[OtherAtom->nr] = white;
+              BFSStack->RemoveItem(OtherAtom);
+            }
+          } while ((!TouchedStack->IsEmpty()) && (PredecessorList[OtherAtom->nr] == NULL));
+          TouchedStack->Push(OtherAtom);  // last was wrongly popped
+          OtherAtom = BackEdge->rightatom; // set to not Root
+        } else
+          OtherAtom = Root;
+      }
+    } while ((!BFSStack->IsEmpty()) && (OtherAtom != Root) && (OtherAtom != NULL)); // || (ShortestPathList[OtherAtom->nr] < MinimumRingSize[Walker->GetTrueFather()->nr])));
+    if (OtherAtom == Root) {
+      // now climb back the predecessor list and thus find the cycle members
+      NumCycles++;
+      RingSize = 1;
+      Root->GetTrueFather()->IsCyclic = true;
+      *out << Verbose(1) << "Found ring contains: ";
+      Walker = Root;
+      while (Walker != BackEdge->rightatom) {
+        *out << Walker->Name << " <-> ";
+        Walker = PredecessorList[Walker->nr];
+        Walker->GetTrueFather()->IsCyclic = true;
+        RingSize++;
+      }
+      *out << Walker->Name << "  with a length of " << RingSize << "." << endl << endl;
+      // walk through all and set MinimumRingSize
+      Walker = Root;
+      MinimumRingSize[Walker->GetTrueFather()->nr] = RingSize;
+      while (Walker != BackEdge->rightatom) {
+        Walker = PredecessorList[Walker->nr];
+        if (RingSize < MinimumRingSize[Walker->GetTrueFather()->nr])
+          MinimumRingSize[Walker->GetTrueFather()->nr] = RingSize;
+      }
+      if ((RingSize < MinRingSize) || (MinRingSize == -1))
+        MinRingSize = RingSize;
+    } else {
+      *out << Verbose(1) << "No ring containing " << *Root << " with length equal to or smaller than " << MinimumRingSize[Walker->GetTrueFather()->nr] << " found." << endl;
+    }
+    // now clean the lists
+    while (!TouchedStack->IsEmpty()){
+      Walker = TouchedStack->PopFirst();
+      PredecessorList[Walker->nr] = NULL;
+      ShortestPathList[Walker->nr] = -1;
+      ColorList[Walker->nr] = white;
+    }
+  }
+  if (MinRingSize != -1) {
+    // go over all atoms
+    Root = start;
+    while(Root->next != end) {
+      Root = Root->next;
+      if (MinimumRingSize[Root->GetTrueFather()->nr] == AtomCount) { // check whether MinimumRingSize is set, if not BFS to next where it is
+        Walker = Root;
+        ShortestPathList[Walker->nr] = 0;
+        BFSStack->ClearStack();  // start with empty BFS stack
+        BFSStack->Push(Walker);
+        TouchedStack->Push(Walker);
+        //*out << Verbose(1) << "---------------------------------------------------------------------------------------------------------" << endl;
+        OtherAtom = Walker;
+        while (OtherAtom != NULL) {  // look for Root
+          Walker = BFSStack->PopFirst();
+          //*out << Verbose(2) << "Current Walker is " << *Walker << ", we look for SP to Root " << *Root << "." << endl;
+          for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) {
+            Binder = ListOfBondsPerAtom[Walker->nr][i];
+            if ((Binder != BackEdge) || (NumberOfBondsPerAtom[Walker->nr] == 1)) { // only walk along DFS spanning tree (otherwise we always find SP of 1 being backedge Binder), but terminal hydrogens may be connected via backedge, hence extra check
+              OtherAtom = Binder->GetOtherAtom(Walker);
+              //*out << Verbose(2) << "Current OtherAtom is: " << OtherAtom->Name << " for bond " << *Binder << "." << endl;
+              if (ColorList[OtherAtom->nr] == white) {
+                TouchedStack->Push(OtherAtom);
+                ColorList[OtherAtom->nr] = lightgray;
+                PredecessorList[OtherAtom->nr] = Walker;  // Walker is the predecessor
+                ShortestPathList[OtherAtom->nr] = ShortestPathList[Walker->nr]+1;
+                //*out << Verbose(2) << "Coloring OtherAtom " << OtherAtom->Name << " lightgray, its predecessor is " << Walker->Name << " and its Shortest Path is " << ShortestPathList[OtherAtom->nr] << " egde(s) long." << endl;
+                if (OtherAtom->GetTrueFather()->IsCyclic) { // if the other atom is connected to a ring
+                  MinimumRingSize[Root->GetTrueFather()->nr] = ShortestPathList[OtherAtom->nr]+MinimumRingSize[OtherAtom->GetTrueFather()->nr];
+                  OtherAtom = NULL; //break;
+                  break;
+                } else
+                  BFSStack->Push(OtherAtom);
+              } else {
+                //*out << Verbose(3) << "Not Adding, has already been visited." << endl;
+              }
+            } else {
+              //*out << Verbose(3) << "Not Visiting, is a back edge." << endl;
+            }
+          }
+          ColorList[Walker->nr] = black;
+          //*out << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl;
+        }
+        // now clean the lists
+        while (!TouchedStack->IsEmpty()){
+          Walker = TouchedStack->PopFirst();
+          PredecessorList[Walker->nr] = NULL;
+          ShortestPathList[Walker->nr] = -1;
+          ColorList[Walker->nr] = white;
+        }
+      }
+      *out << Verbose(1) << "Minimum ring size of " << *Root << " is " << MinimumRingSize[Root->GetTrueFather()->nr] << "." << endl;
+    }
+    *out << Verbose(1) << "Minimum ring size is " << MinRingSize << ", over " << NumCycles << " cycles total." << endl;
+  } else
+    *out << Verbose(1) << "No rings were detected in the molecular structure." << endl;
+  Free(&PredecessorList);
+  Free(&ShortestPathList);
+  Free(&ColorList);
+  delete(BFSStack);
+    CyclicStructureAnalysis_CyclicBFSFromRootToRoot(out, BackEdge, BFS);
+    CyclicStructureAnalysis_RetrieveCycleMembers(out, OtherAtom, BackEdge, BFS, MinimumRingSize, MinRingSize);
+    CleanBFSAccounting(out, BFS);
+  }
+  FinalizeBFSAccounting(out, BFS);
+  CyclicStructureAnalysis_AssignRingSizetoNonCycleMembers(out, MinimumRingSize, MinRingSize, NumCycles, this);
 };
 …
  * \param nr number to use
  */
 void molecule::SetNextComponentNumber(atom *vertex, int nr)
+{
   int i=0;
+void molecule::SetNextComponentNumber(atom *vertex, int nr) const
+{
+  size_t i = 0;
   if (vertex != NULL) {
     for(;i<NumberOfBondsPerAtom[vertex->nr];i++) {
       if (vertex->ComponentNr[i] == -1) {   // check if not yet used
+    for (; i < vertex->ListOfBonds.size(); i++) {
+      if (vertex->ComponentNr[i] == -1) { // check if not yet used
         vertex->ComponentNr[i] = nr;
         break;
+      }
+      else if (vertex->ComponentNr[i] == nr) // if number is already present, don't add another time
+        break;  // breaking here will not cause error!
+    }
+    if (i == NumberOfBondsPerAtom[vertex->nr])
+      } else if (vertex->ComponentNr[i] == nr) // if number is already present, don't add another time
+        break; // breaking here will not cause error!
+    }
+    if (i == vertex->ListOfBonds.size())
       cerr << "Error: All Component entries are already occupied!" << endl;
   } else
+      cerr << "Error: Given vertex is NULL!" << endl;
+};
+/** Output a list of flags, stating whether the bond was visited or not.
+ * \param *out output stream for debugging
+ */
+void molecule::OutputComponentNumber(ofstream *out, atom *vertex)
+{
+  for(int i=0;i<NumberOfBondsPerAtom[vertex->nr];i++)
+    *out << vertex->ComponentNr[i] << "  ";
+};
+/** Allocates memory for all atom::*ComponentNr in this molecule and sets each entry to -1.
+ */
+void molecule::InitComponentNumbers()
+{
+  atom *Walker = start;
+  while(Walker->next != end) {
+    Walker = Walker->next;
+    if (Walker->ComponentNr != NULL)
+      Free(&Walker->ComponentNr);
+    Walker->ComponentNr = Malloc<int>(NumberOfBondsPerAtom[Walker->nr], "molecule::InitComponentNumbers: *Walker->ComponentNr");
+    for (int i=NumberOfBondsPerAtom[Walker->nr];i--;)
+      Walker->ComponentNr[i] = -1;
+  }
+};
+    cerr << "Error: Given vertex is NULL!" << endl;
+}
+;
 /** Returns next unused bond for this atom \a *vertex or NULL of none exists.
 …
  * \return bond class or NULL
  */
 bond * molecule::FindNextUnused(atom *vertex)
+{
   for(int i=0;i<NumberOfBondsPerAtom[vertex->nr];i++)
     if (ListOfBondsPerAtom[vertex->nr][i]->IsUsed() == white)
       return(ListOfBondsPerAtom[vertex->nr][i]);
+bond * molecule::FindNextUnused(atom *vertex) const
+{
+  for (BondList::const_iterator Runner = vertex->ListOfBonds.begin(); Runner != vertex->ListOfBonds.end(); (++Runner))
+    if ((*Runner)->IsUsed() == white)
+      return ((*Runner));
   return NULL;
+};
+}
+;
 /** Resets bond::Used flag of all bonds in this molecule.
  * \return true - success, false - -failure
  */
 void molecule::ResetAllBondsToUnused()
+void molecule::ResetAllBondsToUnused() const
+{
   bond *Binder = first;
 …
     Binder->ResetUsed();
+  }
+};
+/** Resets atom::nr to -1 of all atoms in this molecule.
+ */
+void molecule::ResetAllAtomNumbers()
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    Walker->GraphNr  = -1;
+  }
+};
+}
+;
 /** Output a list of flags, stating whether the bond was visited or not.
 …
+{
   *out << Verbose(4) << "Already Visited Bonds:\t";
+  for(int i=1;i<=list[0];i++) *out << Verbose(0) << list[i] << "  ";
+  for (int i = 1; i <= list[0]; i++)
+    *out << Verbose(0) << list[i] << "  ";
   *out << endl;
 };
+}
+;
 /** Storing the bond structure of a molecule to file.
 …
+{
   ofstream AdjacencyFile;
-  atom *Walker = NULL;
   stringstream line;
   bool status = true;
 …
   *out << Verbose(1) << "Saving adjacency list ... ";
   if (AdjacencyFile != NULL) {
+    Walker = start;
+    while(Walker->next != end) {
+      Walker = Walker->next;
+      AdjacencyFile << Walker->nr << "\t";
+      for (int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++)
+        AdjacencyFile << ListOfBondsPerAtom[Walker->nr][i]->GetOtherAtom(Walker)->nr << "\t";
+      AdjacencyFile << endl;
+    }
+    ActOnAllAtoms(&atom::OutputAdjacency, &AdjacencyFile);
     AdjacencyFile.close();
     *out << Verbose(1) << "done." << endl;
 …
   return status;
+};
+}
+;
+bool CheckAdjacencyFileAgainstMolecule_Init(ofstream *out, char *path, ifstream &File, int *&CurrentBonds)
+{
+  stringstream filename;
+  filename << path << "/" << FRAGMENTPREFIX << ADJACENCYFILE;
+  File.open(filename.str().c_str(), ios::out);
+  *out << Verbose(1) << "Looking at bond structure stored in adjacency file and comparing to present one ... ";
+  if (File == NULL)
+    return false;
+  // allocate storage structure
+  CurrentBonds = Calloc<int> (8, "molecule::CheckAdjacencyFileAgainstMolecule - CurrentBonds"); // contains parsed bonds of current atom
+  return true;
+}
+;
+void CheckAdjacencyFileAgainstMolecule_Finalize(ofstream *out, ifstream &File, int *&CurrentBonds)
+{
+  File.close();
+  File.clear();
+  Free(&CurrentBonds);
+}
+;
+void CheckAdjacencyFileAgainstMolecule_CompareBonds(ofstream *out, bool &status, int &NonMatchNumber, atom *&Walker, size_t &CurrentBondsOfAtom, int AtomNr, int *&CurrentBonds, atom **ListOfAtoms)
+{
+  size_t j = 0;
+  int id = -1;
+  //*out << Verbose(2) << "Walker is " << *Walker << ", bond partners: ";
+  if (CurrentBondsOfAtom == Walker->ListOfBonds.size()) {
+    for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
+      id = (*Runner)->GetOtherAtom(Walker)->nr;
+      j = 0;
+      for (; (j < CurrentBondsOfAtom) && (CurrentBonds[j++] != id);)
+        ; // check against all parsed bonds
+      if (CurrentBonds[j - 1] != id) { // no match ? Then mark in ListOfAtoms
+        ListOfAtoms[AtomNr] = NULL;
+        NonMatchNumber++;
+        status = false;
+        //*out << "[" << id << "]\t";
+      } else {
+        //*out << id << "\t";
+      }
+    }
+    //*out << endl;
+  } else {
+    *out << "Number of bonds for Atom " << *Walker << " does not match, parsed " << CurrentBondsOfAtom << " against " << Walker->ListOfBonds.size() << "." << endl;
+    status = false;
+  }
+}
+;
 /** Checks contents of adjacency file against bond structure in structure molecule.
 …
+{
   ifstream File;
-  stringstream filename;
   bool status = true;
+  char *buffer = Malloc<char>(MAXSTRINGSIZE, "molecule::CheckAdjacencyFileAgainstMolecule: *buffer");
+  filename << path << "/" << FRAGMENTPREFIX << ADJACENCYFILE;
+  File.open(filename.str().c_str(), ios::out);
+  *out << Verbose(1) << "Looking at bond structure stored in adjacency file and comparing to present one ... ";
+  if (File != NULL) {
+    // allocate storage structure
+    int NonMatchNumber = 0;   // will number of atoms with differing bond structure
+    int *CurrentBonds = Malloc<int>(8, "molecule::CheckAdjacencyFileAgainstMolecule - CurrentBonds"); // contains parsed bonds of current atom
+    int CurrentBondsOfAtom;
+    // Parse the file line by line and count the bonds
+    while (!File.eof()) {
+      File.getline(buffer, MAXSTRINGSIZE);
+      stringstream line;
+      line.str(buffer);
+      int AtomNr = -1;
+      line >> AtomNr;
+      CurrentBondsOfAtom = -1; // we count one too far due to line end
+      // parse into structure
+      if ((AtomNr >= 0) && (AtomNr < AtomCount)) {
+        while (!line.eof())
+          line >> CurrentBonds[ ++CurrentBondsOfAtom ];
+        // compare against present bonds
+        //cout << Verbose(2) << "Walker is " << *Walker << ", bond partners: ";
+        if (CurrentBondsOfAtom == NumberOfBondsPerAtom[AtomNr]) {
+          for(int i=0;i<NumberOfBondsPerAtom[AtomNr];i++) {
+            int id = ListOfBondsPerAtom[AtomNr][i]->GetOtherAtom(ListOfAtoms[AtomNr])->nr;
+            int j = 0;
+            for (;(j<CurrentBondsOfAtom) && (CurrentBonds[j++] != id);); // check against all parsed bonds
+            if (CurrentBonds[j-1] != id) { // no match ? Then mark in ListOfAtoms
+              ListOfAtoms[AtomNr] = NULL;
+              NonMatchNumber++;
+              status = false;
+              //out << "[" << id << "]\t";
+            } else {
+              //out << id << "\t";
+            }
+          }
+          //out << endl;
+        } else {
+          *out << "Number of bonds for Atom " << *ListOfAtoms[AtomNr] << " does not match, parsed " << CurrentBondsOfAtom << " against " << NumberOfBondsPerAtom[AtomNr] << "." << endl;
+          status = false;
+        }
+      }
+    }
+    File.close();
+    File.clear();
+    if (status) { // if equal we parse the KeySetFile
+      *out << Verbose(1) << "done: Equal." << endl;
+      status = true;
+    } else
+      *out << Verbose(1) << "done: Not equal by " << NonMatchNumber << " atoms." << endl;
+    Free(&CurrentBonds);
+  } else {
+  atom *Walker = NULL;
+  char *buffer = NULL;
+  int *CurrentBonds = NULL;
+  int NonMatchNumber = 0; // will number of atoms with differing bond structure
+  size_t CurrentBondsOfAtom = -1;
+  if (!CheckAdjacencyFileAgainstMolecule_Init(out, path, File, CurrentBonds)) {
     *out << Verbose(1) << "Adjacency file not found." << endl;
+    status = false;
+  }
+  *out << endl;
+    return true;
+  }
+  buffer = Malloc<char> (MAXSTRINGSIZE, "molecule::CheckAdjacencyFileAgainstMolecule: *buffer");
+  // Parse the file line by line and count the bonds
+  while (!File.eof()) {
+    File.getline(buffer, MAXSTRINGSIZE);
+    stringstream line;
+    line.str(buffer);
+    int AtomNr = -1;
+    line >> AtomNr;
+    CurrentBondsOfAtom = -1; // we count one too far due to line end
+    // parse into structure
+    if ((AtomNr >= 0) && (AtomNr < AtomCount)) {
+      Walker = ListOfAtoms[AtomNr];
+      while (!line.eof())
+        line >> CurrentBonds[++CurrentBondsOfAtom];
+      // compare against present bonds
+      CheckAdjacencyFileAgainstMolecule_CompareBonds(out, status, NonMatchNumber, Walker, CurrentBondsOfAtom, AtomNr, CurrentBonds, ListOfAtoms);
+    }
+  }
   Free(&buffer);
+  CheckAdjacencyFileAgainstMolecule_Finalize(out, File, CurrentBonds);
+  if (status) { // if equal we parse the KeySetFile
+    *out << Verbose(1) << "done: Equal." << endl;
+  } else
+    *out << Verbose(1) << "done: Not equal by " << NonMatchNumber << " atoms." << endl;
   return status;
 };
+}
+;
 /** Picks from a global stack with all back edges the ones in the fragment.
 …
  * \return true - everything ok, false - ReferenceStack was empty
  */
 bool molecule::PickLocalBackEdges(ofstream *out, atom **ListOfLocalAtoms, class StackClass<bond *> *&ReferenceStack, class StackClass<bond *> *&LocalStack)
+bool molecule::PickLocalBackEdges(ofstream *out, atom **ListOfLocalAtoms, class StackClass<bond *> *&ReferenceStack, class StackClass<bond *> *&LocalStack) const
+{
   bool status = true;
 …
+  }
   bond *Binder = ReferenceStack->PopFirst();
   bond *FirstBond = Binder;   // mark the first bond, so that we don't loop through the stack indefinitely
+  bond *FirstBond = Binder; // mark the first bond, so that we don't loop through the stack indefinitely
   atom *Walker = NULL, *OtherAtom = NULL;
   ReferenceStack->Push(Binder);
   do {  // go through all bonds and push local ones
     Walker = ListOfLocalAtoms[Binder->leftatom->nr];  // get one atom in the reference molecule
+  do { // go through all bonds and push local ones
+    Walker = ListOfLocalAtoms[Binder->leftatom->nr]; // get one atom in the reference molecule
     if (Walker != NULL) // if this Walker exists in the subgraph ...
       for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) {    // go through the local list of bonds
         OtherAtom = ListOfBondsPerAtom[Walker->nr][i]->GetOtherAtom(Walker);
         if (OtherAtom == ListOfLocalAtoms[Binder->rightatom->nr]) { // found the bond
           LocalStack->Push(ListOfBondsPerAtom[Walker->nr][i]);
           *out << Verbose(3) << "Found local edge " << *(ListOfBondsPerAtom[Walker->nr][i]) << "." << endl;
+      for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
+        OtherAtom = (*Runner)->GetOtherAtom(Walker);
+        if (OtherAtom == ListOfLocalAtoms[(*Runner)->rightatom->nr]) { // found the bond
+          LocalStack->Push((*Runner));
+          *out << Verbose(3) << "Found local edge " << *(*Runner) << "." << endl;
           break;
+        }
+      }
     Binder = ReferenceStack->PopFirst();  // loop the stack for next item
+    Binder = ReferenceStack->PopFirst(); // loop the stack for next item
     *out << Verbose(3) << "Current candidate edge " << Binder << "." << endl;
     ReferenceStack->Push(Binder);
 …
   return status;
+};
+}
+;
+void BreadthFirstSearchAdd_Init(struct BFSAccounting &BFS, atom *&Root, int AtomCount, int BondOrder, atom **AddedAtomList = NULL)
+{
+  BFS.AtomCount = AtomCount;
+  BFS.BondOrder = BondOrder;
+  BFS.PredecessorList = Calloc<atom*> (AtomCount, "molecule::BreadthFirstSearchAdd_Init: **PredecessorList");
+  BFS.ShortestPathList = Calloc<int> (AtomCount, "molecule::BreadthFirstSearchAdd_Init: *ShortestPathList");
+  BFS.ColorList = Malloc<enum Shading> (AtomCount, "molecule::BreadthFirstSearchAdd_Init: *ColorList");
+  BFS.BFSStack = new StackClass<atom *> (AtomCount);
+  BFS.Root = Root;
+  BFS.BFSStack->ClearStack();
+  BFS.BFSStack->Push(Root);
+  // initialise each vertex as white with no predecessor, empty queue, color Root lightgray
+  for (int i = AtomCount; i--;) {
+    BFS.ShortestPathList[i] = -1;
+    if ((AddedAtomList != NULL) && (AddedAtomList[i] != NULL)) // mark already present atoms (i.e. Root and maybe others) as visited
+      BFS.ColorList[i] = lightgray;
+    else
+      BFS.ColorList[i] = white;
+  }
+  //BFS.ShortestPathList[Root->nr] = 0; //is set due to Calloc()
+}
+;
+void BreadthFirstSearchAdd_Free(struct BFSAccounting &BFS)
+{
+  Free(&BFS.PredecessorList);
+  Free(&BFS.ShortestPathList);
+  Free(&BFS.ColorList);
+  delete (BFS.BFSStack);
+  BFS.AtomCount = 0;
+}
+;
+void BreadthFirstSearchAdd_UnvisitedNode(ofstream *out, molecule *Mol, struct BFSAccounting &BFS, atom *&Walker, atom *&OtherAtom, bond *&Binder, bond *&Bond, atom **&AddedAtomList, bond **&AddedBondList, bool IsAngstroem)
+{
+  if (Binder != Bond) // let other atom white if it's via Root bond. In case it's cyclic it has to be reached again (yet Root is from OtherAtom already black, thus no problem)
+    BFS.ColorList[OtherAtom->nr] = lightgray;
+  BFS.PredecessorList[OtherAtom->nr] = Walker; // Walker is the predecessor
+  BFS.ShortestPathList[OtherAtom->nr] = BFS.ShortestPathList[Walker->nr] + 1;
+  *out << Verbose(2) << "Coloring OtherAtom " << OtherAtom->Name << " " << ((BFS.ColorList[OtherAtom->nr] == white) ? "white" : "lightgray") << ", its predecessor is " << Walker->Name << " and its Shortest Path is " << BFS.ShortestPathList[OtherAtom->nr] << " egde(s) long." << endl;
+  if ((((BFS.ShortestPathList[OtherAtom->nr] < BFS.BondOrder) && (Binder != Bond)))) { // Check for maximum distance
+    *out << Verbose(3);
+    if (AddedAtomList[OtherAtom->nr] == NULL) { // add if it's not been so far
+      AddedAtomList[OtherAtom->nr] = Mol->AddCopyAtom(OtherAtom);
+      *out << "Added OtherAtom " << OtherAtom->Name;
+      AddedBondList[Binder->nr] = Mol->CopyBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder);
+      *out << " and bond " << *(AddedBondList[Binder->nr]) << ", ";
+    } else { // this code should actually never come into play (all white atoms are not yet present in BondMolecule, that's why they are white in the first place)
+      *out << "Not adding OtherAtom " << OtherAtom->Name;
+      if (AddedBondList[Binder->nr] == NULL) {
+        AddedBondList[Binder->nr] = Mol->CopyBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder);
+        *out << ", added Bond " << *(AddedBondList[Binder->nr]);
+      } else
+        *out << ", not added Bond ";
+    }
+    *out << ", putting OtherAtom into queue." << endl;
+    BFS.BFSStack->Push(OtherAtom);
+  } else { // out of bond order, then replace
+    if ((AddedAtomList[OtherAtom->nr] == NULL) && (Binder->Cyclic))
+      BFS.ColorList[OtherAtom->nr] = white; // unmark if it has not been queued/added, to make it available via its other bonds (cyclic)
+    if (Binder == Bond)
+      *out << Verbose(3) << "Not Queueing, is the Root bond";
+    else if (BFS.ShortestPathList[OtherAtom->nr] >= BFS.BondOrder)
+      *out << Verbose(3) << "Not Queueing, is out of Bond Count of " << BFS.BondOrder;
+    if (!Binder->Cyclic)
+      *out << ", is not part of a cyclic bond, saturating bond with Hydrogen." << endl;
+    if (AddedBondList[Binder->nr] == NULL) {
+      if ((AddedAtomList[OtherAtom->nr] != NULL)) { // .. whether we add or saturate
+        AddedBondList[Binder->nr] = Mol->CopyBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder);
+      } else {
+#ifdef ADDHYDROGEN
+        if (!Mol->AddHydrogenReplacementAtom(out, Binder, AddedAtomList[Walker->nr], Walker, OtherAtom, IsAngstroem))
+        exit(1);
+#endif
+      }
+    }
+  }
+}
+;
+void BreadthFirstSearchAdd_VisitedNode(ofstream *out, molecule *Mol, struct BFSAccounting &BFS, atom *&Walker, atom *&OtherAtom, bond *&Binder, bond *&Bond, atom **&AddedAtomList, bond **&AddedBondList, bool IsAngstroem)
+{
+  *out << Verbose(3) << "Not Adding, has already been visited." << endl;
+  // This has to be a cyclic bond, check whether it's present ...
+  if (AddedBondList[Binder->nr] == NULL) {
+    if ((Binder != Bond) && (Binder->Cyclic) && (((BFS.ShortestPathList[Walker->nr] + 1) < BFS.BondOrder))) {
+      AddedBondList[Binder->nr] = Mol->CopyBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder);
+    } else { // if it's root bond it has to broken (otherwise we would not create the fragments)
+#ifdef ADDHYDROGEN
+      if(!Mol->AddHydrogenReplacementAtom(out, Binder, AddedAtomList[Walker->nr], Walker, OtherAtom, IsAngstroem))
+      exit(1);
+#endif
+    }
+  }
+}
+;
 /** Adds atoms up to \a BondCount distance from \a *Root and notes them down in \a **AddedAtomList.
 …
 void molecule::BreadthFirstSearchAdd(ofstream *out, molecule *Mol, atom **&AddedAtomList, bond **&AddedBondList, atom *Root, bond *Bond, int BondOrder, bool IsAngstroem)
+{
+  atom **PredecessorList = Malloc<atom*>(AtomCount, "molecule::BreadthFirstSearchAdd: **PredecessorList");
+  int *ShortestPathList = Malloc<int>(AtomCount, "molecule::BreadthFirstSearchAdd: *ShortestPathList");
+  enum Shading *ColorList = Malloc<enum Shading>(AtomCount, "molecule::BreadthFirstSearchAdd: *ColorList");
+  class StackClass<atom *> *AtomStack = new StackClass<atom *>(AtomCount);
+  struct BFSAccounting BFS;
   atom *Walker = NULL, *OtherAtom = NULL;
   bond *Binder = NULL;
   // add Root if not done yet
+  AtomStack->ClearStack();
+  if (AddedAtomList[Root->nr] == NULL)  // add Root if not yet present
+  if (AddedAtomList[Root->nr] == NULL) // add Root if not yet present
     AddedAtomList[Root->nr] = Mol->AddCopyAtom(Root);
+  AtomStack->Push(Root);
+  // initialise each vertex as white with no predecessor, empty queue, color Root lightgray
+  for (int i=AtomCount;i--;) {
+    PredecessorList[i] = NULL;
+    ShortestPathList[i] = -1;
+    if (AddedAtomList[i] != NULL) // mark already present atoms (i.e. Root and maybe others) as visited
+      ColorList[i] = lightgray;
+    else
+      ColorList[i] = white;
+  }
+  ShortestPathList[Root->nr] = 0;
+  BreadthFirstSearchAdd_Init(BFS, Root, BondOrder, AtomCount, AddedAtomList);
   // and go on ... Queue always contains all lightgray vertices
   while (!AtomStack->IsEmpty()) {
+  while (!BFS.BFSStack->IsEmpty()) {
     // we have to pop the oldest atom from stack. This keeps the atoms on the stack always of the same ShortestPath distance.
     // e.g. if current atom is 2, push to end of stack are of length 3, but first all of length 2 would be popped. They again
     // append length of 3 (their neighbours). Thus on stack we have always atoms of a certain length n at bottom of stack and
     // followed by n+1 till top of stack.
+    Walker = AtomStack->PopFirst(); // pop oldest added
+    *out << Verbose(1) << "Current Walker is: " << Walker->Name << ", and has " << NumberOfBondsPerAtom[Walker->nr] << " bonds." << endl;
+    for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) {
+      Binder = ListOfBondsPerAtom[Walker->nr][i];
+      if (Binder != NULL) { // don't look at bond equal NULL
+        OtherAtom = Binder->GetOtherAtom(Walker);
+        *out << Verbose(2) << "Current OtherAtom is: " << OtherAtom->Name << " for bond " << *Binder << "." << endl;
+        if (ColorList[OtherAtom->nr] == white) {
+          if (Binder != Bond) // let other atom white if it's via Root bond. In case it's cyclic it has to be reached again (yet Root is from OtherAtom already black, thus no problem)
+            ColorList[OtherAtom->nr] = lightgray;
+          PredecessorList[OtherAtom->nr] = Walker;  // Walker is the predecessor
+          ShortestPathList[OtherAtom->nr] = ShortestPathList[Walker->nr]+1;
+          *out << Verbose(2) << "Coloring OtherAtom " << OtherAtom->Name << " " << ((ColorList[OtherAtom->nr] == white) ? "white" : "lightgray") << ", its predecessor is " << Walker->Name << " and its Shortest Path is " << ShortestPathList[OtherAtom->nr] << " egde(s) long." << endl;
+          if ((((ShortestPathList[OtherAtom->nr] < BondOrder) && (Binder != Bond))) ) { // Check for maximum distance
+            *out << Verbose(3);
+            if (AddedAtomList[OtherAtom->nr] == NULL) { // add if it's not been so far
+              AddedAtomList[OtherAtom->nr] = Mol->AddCopyAtom(OtherAtom);
+              *out << "Added OtherAtom " << OtherAtom->Name;
+              AddedBondList[Binder->nr] = Mol->AddBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder->BondDegree);
+              AddedBondList[Binder->nr]->Cyclic = Binder->Cyclic;
+              AddedBondList[Binder->nr]->Type = Binder->Type;
+              *out << " and bond " << *(AddedBondList[Binder->nr]) << ", ";
+            } else {  // this code should actually never come into play (all white atoms are not yet present in BondMolecule, that's why they are white in the first place)
+              *out << "Not adding OtherAtom " << OtherAtom->Name;
+              if (AddedBondList[Binder->nr] == NULL) {
+                AddedBondList[Binder->nr] = Mol->AddBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder->BondDegree);
+                AddedBondList[Binder->nr]->Cyclic = Binder->Cyclic;
+                AddedBondList[Binder->nr]->Type = Binder->Type;
+                *out << ", added Bond " << *(AddedBondList[Binder->nr]);
+              } else
+                *out << ", not added Bond ";
+            }
+            *out << ", putting OtherAtom into queue." << endl;
+            AtomStack->Push(OtherAtom);
+          } else { // out of bond order, then replace
+            if ((AddedAtomList[OtherAtom->nr] == NULL) && (Binder->Cyclic))
+              ColorList[OtherAtom->nr] = white; // unmark if it has not been queued/added, to make it available via its other bonds (cyclic)
+            if (Binder == Bond)
+              *out << Verbose(3) << "Not Queueing, is the Root bond";
+            else if (ShortestPathList[OtherAtom->nr] >= BondOrder)
+              *out << Verbose(3) << "Not Queueing, is out of Bond Count of " << BondOrder;
+            if (!Binder->Cyclic)
+              *out << ", is not part of a cyclic bond, saturating bond with Hydrogen." << endl;
+            if (AddedBondList[Binder->nr] == NULL) {
+              if ((AddedAtomList[OtherAtom->nr] != NULL)) { // .. whether we add or saturate
+                AddedBondList[Binder->nr] = Mol->AddBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder->BondDegree);
+                AddedBondList[Binder->nr]->Cyclic = Binder->Cyclic;
+                AddedBondList[Binder->nr]->Type = Binder->Type;
+              } else {
+#ifdef ADDHYDROGEN
+                if (!Mol->AddHydrogenReplacementAtom(out, Binder, AddedAtomList[Walker->nr], Walker, OtherAtom, ListOfBondsPerAtom[Walker->nr], NumberOfBondsPerAtom[Walker->nr], IsAngstroem))
+                  exit(1);
+#endif
+              }
+            }
+          }
+    Walker = BFS.BFSStack->PopFirst(); // pop oldest added
+    *out << Verbose(1) << "Current Walker is: " << Walker->Name << ", and has " << Walker->ListOfBonds.size() << " bonds." << endl;
+    for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
+      if ((*Runner) != NULL) { // don't look at bond equal NULL
+        Binder = (*Runner);
+        OtherAtom = (*Runner)->GetOtherAtom(Walker);
+        *out << Verbose(2) << "Current OtherAtom is: " << OtherAtom->Name << " for bond " << *(*Runner) << "." << endl;
+        if (BFS.ColorList[OtherAtom->nr] == white) {
+          BreadthFirstSearchAdd_UnvisitedNode(out, Mol, BFS, Walker, OtherAtom, Binder, Bond, AddedAtomList, AddedBondList, IsAngstroem);
         } else {
+          *out << Verbose(3) << "Not Adding, has already been visited." << endl;
+          // This has to be a cyclic bond, check whether it's present ...
+          if (AddedBondList[Binder->nr] == NULL) {
+            if ((Binder != Bond) && (Binder->Cyclic) && (((ShortestPathList[Walker->nr]+1) < BondOrder))) {
+              AddedBondList[Binder->nr] = Mol->AddBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder->BondDegree);
+              AddedBondList[Binder->nr]->Cyclic = Binder->Cyclic;
+              AddedBondList[Binder->nr]->Type = Binder->Type;
+            } else { // if it's root bond it has to broken (otherwise we would not create the fragments)
+#ifdef ADDHYDROGEN
+              if(!Mol->AddHydrogenReplacementAtom(out, Binder, AddedAtomList[Walker->nr], Walker, OtherAtom, ListOfBondsPerAtom[Walker->nr], NumberOfBondsPerAtom[Walker->nr], IsAngstroem))
+                exit(1);
+#endif
+            }
+          }
+          BreadthFirstSearchAdd_VisitedNode(out, Mol, BFS, Walker, OtherAtom, Binder, Bond, AddedAtomList, AddedBondList, IsAngstroem);
+        }
+      }
+    }
     ColorList[Walker->nr] = black;
+    BFS.ColorList[Walker->nr] = black;
     *out << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl;
+  }
+  Free(&PredecessorList);
+  Free(&ShortestPathList);
+  Free(&ColorList);
+  delete(AtomStack);
+};
+/** Adds bond structure to this molecule from \a Father molecule.
+ * This basically causes this molecule to become an induced subgraph of the \a Father, i.e. for every bond in Father
+ * with end points present in this molecule, bond is created in this molecule.
+ * Special care was taken to ensure that this is of complexity O(N), where N is the \a Father's molecule::AtomCount.
+ * \param *out output stream for debugging
+ * \param *Father father molecule
+ * \return true - is induced subgraph, false - there are atoms with fathers not in \a Father
+ * \todo not checked, not fully working probably
+ */
+bool molecule::BuildInducedSubgraph(ofstream *out, const molecule *Father)
+{
+  atom *Walker = NULL, *OtherAtom = NULL;
+  bool status = true;
+  atom **ParentList = Malloc<atom*>(Father->AtomCount, "molecule::BuildInducedSubgraph: **ParentList");
+  *out << Verbose(2) << "Begin of BuildInducedSubgraph." << endl;
+  BreadthFirstSearchAdd_Free(BFS);
+}
+;
+/** Adds a bond as a copy to a given one
+ * \param *left leftatom of new bond
+ * \param *right rightatom of new bond
+ * \param *CopyBond rest of fields in bond are copied from this
+ * \return pointer to new bond
+ */
+bond * molecule::CopyBond(atom *left, atom *right, bond *CopyBond)
+{
+  bond *Binder = AddBond(left, right, CopyBond->BondDegree);
+  Binder->Cyclic = CopyBond->Cyclic;
+  Binder->Type = CopyBond->Type;
+  return Binder;
+}
+;
+void BuildInducedSubgraph_Init(ofstream *out, atom **&ParentList, int AtomCount)
+{
   // reset parent list
+  ParentList = Calloc<atom*> (AtomCount, "molecule::BuildInducedSubgraph_Init: **ParentList");
   *out << Verbose(3) << "Resetting ParentList." << endl;
+  for (int i=Father->AtomCount;i--;)
+    ParentList[i] = NULL;
+}
+;
+void BuildInducedSubgraph_FillParentList(ofstream *out, const molecule *mol, const molecule *Father, atom **&ParentList)
+{
   // fill parent list with sons
   *out << Verbose(3) << "Filling Parent List." << endl;
   Walker = start;
   while (Walker->next != end) {
+  atom *Walker = mol->start;
+  while (Walker->next != mol->end) {
     Walker = Walker->next;
     ParentList[Walker->father->nr] = Walker;
     // Outputting List for debugging
+    *out << Verbose(4) << "Son["<< Walker->father->nr <<"] of " << Walker->father <<  " is " << ParentList[Walker->father->nr] << "." << endl;
+  }
+    *out << Verbose(4) << "Son[" << Walker->father->nr << "] of " << Walker->father << " is " << ParentList[Walker->father->nr] << "." << endl;
+  }
+}
+;
+void BuildInducedSubgraph_Finalize(ofstream *out, atom **&ParentList)
+{
+  Free(&ParentList);
+}
+;
+bool BuildInducedSubgraph_CreateBondsFromParent(ofstream *out, molecule *mol, const molecule *Father, atom **&ParentList)
+{
+  bool status = true;
+  atom *Walker = NULL;
+  atom *OtherAtom = NULL;
   // check each entry of parent list and if ok (one-to-and-onto matching) create bonds
   *out << Verbose(3) << "Creating bonds." << endl;
 …
         status = false;
       } else {
         for (int i=0;i<Father->NumberOfBondsPerAtom[Walker->nr];i++) {
           OtherAtom = Father->ListOfBondsPerAtom[Walker->nr][i]->GetOtherAtom(Walker);
+        for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
+          OtherAtom = (*Runner)->GetOtherAtom(Walker);
           if (ParentList[OtherAtom->nr] != NULL) { // if otheratom is also a father of an atom on this molecule, create the bond
             *out << Verbose(4) << "Endpoints of Bond " << Father->ListOfBondsPerAtom[Walker->nr][i] << " are both present: " << ParentList[Walker->nr]->Name << " and " << ParentList[OtherAtom->nr]->Name << "." << endl;
             AddBond(ParentList[Walker->nr], ParentList[OtherAtom->nr], Father->ListOfBondsPerAtom[Walker->nr][i]->BondDegree);
+            *out << Verbose(4) << "Endpoints of Bond " << (*Runner) << " are both present: " << ParentList[Walker->nr]->Name << " and " << ParentList[OtherAtom->nr]->Name << "." << endl;
+            mol->AddBond(ParentList[Walker->nr], ParentList[OtherAtom->nr], (*Runner)->BondDegree);
+          }
+        }
 …
+    }
+  }
+  Free(&ParentList);
+  return status;
+}
+;
+/** Adds bond structure to this molecule from \a Father molecule.
+ * This basically causes this molecule to become an induced subgraph of the \a Father, i.e. for every bond in Father
+ * with end points present in this molecule, bond is created in this molecule.
+ * Special care was taken to ensure that this is of complexity O(N), where N is the \a Father's molecule::AtomCount.
+ * \param *out output stream for debugging
+ * \param *Father father molecule
+ * \return true - is induced subgraph, false - there are atoms with fathers not in \a Father
+ * \todo not checked, not fully working probably
+ */
+bool molecule::BuildInducedSubgraph(ofstream *out, const molecule *Father)
+{
+  bool status = true;
+  atom **ParentList = NULL;
+  *out << Verbose(2) << "Begin of BuildInducedSubgraph." << endl;
+  BuildInducedSubgraph_Init(out, ParentList, Father->AtomCount);
+  BuildInducedSubgraph_FillParentList(out, this, Father, ParentList);
+  status = BuildInducedSubgraph_CreateBondsFromParent(out, this, Father, ParentList);
+  BuildInducedSubgraph_Finalize(out, ParentList);
   *out << Verbose(2) << "End of BuildInducedSubgraph." << endl;
   return status;
 };
+}
+;
 /** For a given keyset \a *Fragment, checks whether it is connected in the current molecule.
 …
   // count number of atoms in graph
   size = 0;
   for(KeySet::iterator runner = Fragment->begin(); runner != Fragment->end(); runner++)
+  for (KeySet::iterator runner = Fragment->begin(); runner != Fragment->end(); runner++)
     size++;
   if (size > 1)
     for(KeySet::iterator runner = Fragment->begin(); runner != Fragment->end(); runner++) {
+    for (KeySet::iterator runner = Fragment->begin(); runner != Fragment->end(); runner++) {
       Walker = FindAtom(*runner);
       BondStatus = false;
       for(KeySet::iterator runners = Fragment->begin(); runners != Fragment->end(); runners++) {
+      for (KeySet::iterator runners = Fragment->begin(); runners != Fragment->end(); runners++) {
         Walker2 = FindAtom(*runners);
         for (int i=0;i<NumberOfBondsPerAtom[Walker->nr]; i++) {
           if (ListOfBondsPerAtom[Walker->nr][i]->GetOtherAtom(Walker) == Walker2) {
+        for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
+          if ((*Runner)->GetOtherAtom(Walker) == Walker2) {
             BondStatus = true;
             break;

src/molecule_pointcloud.cpp

-              r06c7a3
+              r7326b2
  * \return pointer to allocated with central coordinates
  */
 Vector *molecule::GetCenter(ofstream *out)
+Vector *molecule::GetCenter(ofstream *out) const
+{
   Vector *center = DetermineCenterOfAll(out);
 …
  * \return pointer to atom or NULL if none present
  */
 TesselPoint *molecule::GetPoint()
+TesselPoint *molecule::GetPoint() const
+{
   if ((InternalPointer != start) && (InternalPointer != end))
 …
  * \return pointer to end marker
  */
 TesselPoint *molecule::GetTerminalPoint()
+TesselPoint *molecule::GetTerminalPoint() const
+{
   return end;
 …
  * Stops at last one.
  */
 void molecule::GoToNext()
+void molecule::GoToNext() const
+{
   if (InternalPointer != end)
 …
  * Stops at first one.
  */
 void molecule::GoToPrevious()
+void molecule::GoToPrevious() const
+{
   if (InternalPointer->previous != start)
 …
 /** Goes to first atom.
  */
 void molecule::GoToFirst()
+void molecule::GoToFirst() const
+{
   InternalPointer = start->next;
 …
 /** Goes to last atom.
  */
 void molecule::GoToLast()
+void molecule::GoToLast() const
+{
   InternalPointer = end->previous;
 …
  * \return true - no atoms, false - not empty
  */
 bool molecule::IsEmpty()
+bool molecule::IsEmpty() const
+{
   return (start->next == end);
 …
  * \return true - current atom is last one, false - is not last one
  */
 bool molecule::IsEnd()
+bool molecule::IsEnd() const
+{
   return (InternalPointer == end);

src/molecule_template.hpp

-              r06c7a3
+              r7326b2
 // zero arguments
-template <typename res> void molecule::ActOnAllVectors( res (Vector::*f)() )
+{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    ((Walker->node)->*f)();
+  }
-};
-template <typename res> void molecule::ActOnAllVectors( res (Vector::*f)() const )
+{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    ((Walker->node)->*f)();
+  }
-};
 template <typename res> void molecule::ActOnAllVectors( res (Vector::*f)() ) const
+    {
 …
 };
 // one argument
 template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T), T t )
+template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T), T t ) const
+{
   atom *Walker = start;
 …
+  }
 };
 template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T) const, T t )
+template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T) const, T t ) const
+{
   atom *Walker = start;
 …
+  }
 };
-template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T), T t ) const
+{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    ((Walker->node)->*f)(t);
+  }
-};
-template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T) const, T t ) const
+{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    ((Walker->node)->*f)(t);
+  }
-};
 // two arguments
 template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U), T t, U u )
+template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U), T t, U u ) const
+{
   atom *Walker = start;
 …
+  }
 };
 template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U) const, T t, U u )
+template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U) const, T t, U u ) const
+{
   atom *Walker = start;
 …
+  }
 };
-template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U), T t, U u ) const
+{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    ((Walker->node)->*f)(t, u);
+  }
-};
-template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U) const, T t, U u ) const
+{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    ((Walker->node)->*f)(t, u);
+  }
-};
 // three arguments
 template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V), T t, U u, V v)
+template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V), T t, U u, V v) const
+{
   atom *Walker = start;
 …
+  }
 };
 template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V) const, T t, U u, V v)
+template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V) const, T t, U u, V v) const
+{
   atom *Walker = start;
 …
+  }
 };
+template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V), T t, U u, V v) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)(t, u, v);
+  }
+};
+template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V) const, T t, U u, V v) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)(t, u, v);
+  }
+};
+// ========================= Summing over each Atoms =================================== //
+// zero arguments
+template <typename res, typename typ> res molecule::SumPerAtom(res (typ::*f)() ) const
+{
+  res result = 0;
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    result += (Walker->*f)();
+  }
+  return result;
+};
+template <typename res, typename typ> res molecule::SumPerAtom(res (typ::*f)() const ) const
+{
+  res result = 0;
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    result += (Walker->*f)();
+  }
+  return result;
+};
+// one argument
+template <typename res, typename typ, typename T> res molecule::SumPerAtom(res (typ::*f)(T), T t ) const
+{
+  res result = 0;
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    result += (Walker->*f)(t);
+  }
+  return result;
+};
+template <typename res, typename typ, typename T> res molecule::SumPerAtom(res (typ::*f)(T) const, T t ) const
+{
+  res result = 0;
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    result += (Walker->*f)(t);
+  }
+  return result;
+};
 // ================== Acting with each Atoms on same molecule ========================== //
 // zero arguments
 template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *))
+template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *)) const
+{
   atom *Walker = start;
 …
+  }
 };
 template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *) const)
+template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *) const) const
+{
   atom *Walker = start;
 …
+  }
 };
-template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *)) const
+{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (*f)(Walker);
+  }
-};
-template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *) const) const
+{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (*f)(Walker);
+  }
-};
 // ================== Acting with each Atoms on copy molecule ========================== //
 // zero arguments
 template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) , molecule *copy)
+template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) , molecule *copy) const
+{
   atom *Walker = start;
 …
+  }
 };
 template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) const , molecule *copy)
+template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) const, molecule *copy) const
+{
   atom *Walker = start;
 …
+  }
 };
-template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) , molecule *copy) const
+{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (copy->*f)(Walker);
+  }
-};
-template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) const, molecule *copy) const
+{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (copy->*f)(Walker);
+  }
-};
 // ================== Acting with each Atoms on copy molecule if true ========================== //
 // zero arguments
 template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () )
+template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () ) const
+{
   atom *Walker = start;
 …
+  }
 };
+template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () const ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)())
+      (copy->*f)(Walker);
+  }
+};
+template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) () ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)())
+      (copy->*f)(Walker);
+  }
+};
+template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) () const ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)())
+      (copy->*f)(Walker);
+  }
+};
 // one argument
 template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T), T t )
+template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T), T t ) const
+{
   atom *Walker = start;
 …
+  }
 };
+template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T) const, T t ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t))
+      (copy->*f)(Walker);
+  }
+};
+template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T), T t ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t))
+      (copy->*f)(Walker);
+  }
+};
+template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T) const, T t ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t))
+      (copy->*f)(Walker);
+  }
+};
 // two arguments
 template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U), T t, U u )
+template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U), T t, U u ) const
+{
   atom *Walker = start;
 …
+  }
 };
+template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U) const, T t, U u ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t,u))
+      (copy->*f)(Walker);
+  }
+};
+template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T, U), T t, U u ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t,u))
+      (copy->*f)(Walker);
+  }
+};
+template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T, U) const, T t, U u ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t,u))
+      (copy->*f)(Walker);
+  }
+};
 // three arguments
 template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U, V), T t, U u, V v )
+template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U, V), T t, U u, V v ) const
+{
   atom *Walker = start;
 …
+  }
 };
+template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U, V) const, T t, U u, V v ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t,u,v))
+      (copy->*f)(Walker);
+  }
+};
+template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T, U, V), T t, U u, V v ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t,u,v))
+      (copy->*f)(Walker);
+  }
+};
+template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T, U, V) const, T t, U u, V v ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t,u,v))
+      (copy->*f)(Walker);
+  }
+};
 // ================== Acting on all Atoms ========================== //
 // zero arguments
 template <typename res> void molecule::ActOnAllAtoms( res (atom::*f)())
+template <typename res, typename typ> void molecule::ActOnAllAtoms( res (typ::*f)()) const
+{
   atom *Walker = start;
 …
+  }
 };
 template <typename res> void molecule::ActOnAllAtoms( res (atom::*f)() const)
+template <typename res, typename typ> void molecule::ActOnAllAtoms( res (typ::*f)() const) const
+{
   atom *Walker = start;
 …
+  }
 };
-template <typename res> void molecule::ActOnAllAtoms( res (atom::*f)()) const
+{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (Walker->*f)();
+  }
-};
-template <typename res> void molecule::ActOnAllAtoms( res (atom::*f)() const) const
+{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (Walker->*f)();
+  }
-};
 // one argument
 template <typename res, typename T> void molecule::ActOnAllAtoms( res (atom::*f)(T), T t )
+template <typename res, typename typ, typename T> void molecule::ActOnAllAtoms( res (typ::*f)(T), T t ) const
+{
   atom *Walker = start;
 …
+  }
 };
 template <typename res, typename T> void molecule::ActOnAllAtoms( res (atom::*f)(T) const, T t )
+template <typename res, typename typ, typename T> void molecule::ActOnAllAtoms( res (typ::*f)(T) const, T t ) const
+{
   atom *Walker = start;
 …
+  }
 };
-template <typename res, typename T> void molecule::ActOnAllAtoms( res (atom::*f)(T), T t ) const
+{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (Walker->*f)(t);
+  }
-};
-template <typename res, typename T> void molecule::ActOnAllAtoms( res (atom::*f)(T) const, T t ) const
+{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (Walker->*f)(t);
+  }
-};
 // two argument
 template <typename res, typename T, typename U> void molecule::ActOnAllAtoms( res (atom::*f)(T, U), T t, U u )
+template <typename res, typename typ, typename T, typename U> void molecule::ActOnAllAtoms( res (typ::*f)(T, U), T t, U u ) const
+{
   atom *Walker = start;
 …
+  }
 };
 template <typename res, typename T, typename U> void molecule::ActOnAllAtoms( res (atom::*f)(T, U) const, T t, U u )
+template <typename res, typename typ, typename T, typename U> void molecule::ActOnAllAtoms( res (typ::*f)(T, U) const, T t, U u ) const
+{
   atom *Walker = start;
 …
+  }
 };
-template <typename res, typename T, typename U> void molecule::ActOnAllAtoms( res (atom::*f)(T, U), T t, U u ) const
+{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (Walker->*f)(t, u);
+  }
-};
-template <typename res, typename T, typename U> void molecule::ActOnAllAtoms( res (atom::*f)(T, U) const, T t, U u ) const
+{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (Walker->*f)(t, u);
+  }
-};
 // three argument
 template <typename res, typename T, typename U, typename V> void molecule::ActOnAllAtoms( res (atom::*f)(T, U, V), T t, U u, V v)
+template <typename res, typename typ, typename T, typename U, typename V> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V), T t, U u, V v) const
+{
   atom *Walker = start;
 …
+  }
 };
 template <typename res, typename T, typename U, typename V> void molecule::ActOnAllAtoms( res (atom::*f)(T, U, V) const, T t, U u, V v)
+template <typename res, typename typ, typename T, typename U, typename V> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V) const, T t, U u, V v) const
+{
   atom *Walker = start;
 …
+  }
 };
-template <typename res, typename T, typename U, typename V> void molecule::ActOnAllAtoms( res (atom::*f)(T, U, V), T t, U u, V v) const
+{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (Walker->*f)(t, u, v);
+  }
-};
-template <typename res, typename T, typename U, typename V> void molecule::ActOnAllAtoms( res (atom::*f)(T, U, V) const, T t, U u, V v) const
+{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (Walker->*f)(t, u, v);
+  }
-};
 // four arguments
 template <typename res, typename T, typename U, typename V, typename W> void molecule::ActOnAllAtoms( res (atom::*f)(T, U, V, W), T t, U u, V v, W w)
+template <typename res, typename typ, typename T, typename U, typename V, typename W> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V, W), T t, U u, V v, W w) const
+{
   atom *Walker = start;
 …
+  }
 };
 template <typename res, typename T, typename U, typename V, typename W> void molecule::ActOnAllAtoms( res (atom::*f)(T, U, V, W) const, T t, U u, V v, W w)
+template <typename res, typename typ, typename T, typename U, typename V, typename W> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V, W) const, T t, U u, V v, W w) const
+{
   atom *Walker = start;
 …
+  }
 };
-template <typename res, typename T, typename U, typename V, typename W> void molecule::ActOnAllAtoms( res (atom::*f)(T, U, V, W), T t, U u, V v, W w) const
+{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (Walker->*f)(t, u, v, w);
+  }
-};
-template <typename res, typename T, typename U, typename V, typename W> void molecule::ActOnAllAtoms( res (atom::*f)(T, U, V, W) const, T t, U u, V v, W w) const
+{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (Walker->*f)(t, u, v, w);
+  }
-};
 // ===================== Accessing arrays indexed by some integer for each atom ======================
 // for atom ints
 template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int TesselPoint::*index, void (*Setor)(T *, T *) )
+template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *) ) const
+{
   atom *Walker = start;
 …
+  }
 };
 template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int TesselPoint::*index, void (*Setor)(T *, T *), T value )
+template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *), T value ) const
+{
   atom *Walker = start;
 …
+  }
 };
 template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int TesselPoint::*index, void (*Setor)(T *, T *), T *value )
+template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *), T *value ) const
+{
   atom *Walker = start;
 …
+  }
 };
 // for element ints inside atom class
 template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *) )
+// for element ints
+template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *) ) const
+{
   atom *Walker = start;
 …
+  }
 };
 template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *), T value )
+template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *), T value ) const
+{
   atom *Walker = start;
 …
+  }
 };
 template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *), T *value )
+template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *), T *value ) const
+{
   atom *Walker = start;
 …
+  }
 };
+template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int TesselPoint::*index, T (atom::*Setor)(Vector &), Vector atom::*value )
+template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &), typ atom::*value ) const
+{
   atom *Walker = start;
 …
+  }
 };
+template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int TesselPoint::*index, T (atom::*Setor)(Vector &), Vector &vect )
+template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &) const, typ atom::*value ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    array[(Walker->*index)] = (Walker->*Setor) (Walker->*value);
+  }
+};
+template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &), typ &vect ) const
+{
   atom *Walker = start;
 …
+  }
 };
+template <typename T> void molecule::SetAtomValueToIndexedArray ( T *array, int TesselPoint::*index, T atom::*value )
+template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &) const, typ &vect ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    array[(Walker->*index)] = (Walker->*Setor) (vect);
+  }
+};
+template <typename T, typename typ, typename typ2> void molecule::SetAtomValueToIndexedArray ( T *array, int typ::*index, T typ2::*value ) const
+{
   atom *Walker = start;
 …
 };
+template <typename T> void molecule::SetAtomValueToIndexedArray ( T *array, int element::*index, T atom::*value )
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    Walker->*value = array[(Walker->type->*index)];
+    //cout << Verbose(2) << *Walker << " gets " << (Walker->*value) << endl;
+  }
+};
+template <typename T, typename typ> void molecule::SetAtomValueToValue ( T value, T typ::*ptr ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    Walker->*ptr = value;
+    //cout << Verbose(2) << *Walker << " gets " << (Walker->*ptr) << endl;
+  }
+};
 #endif /* MOLECULE_TEMPLATE_HPP_ */

src/moleculelist.cpp

-              r06c7a3
+              r7326b2
 #include "helpers.hpp"
 #include "linkedcell.hpp"
+#include "lists.hpp"
 #include "molecule.hpp"
 #include "memoryallocator.hpp"
 …
 bool MoleculeListClass::EmbedMerge(molecule *mol, molecule *srcmol)
+{
+  LinkedCell *LCList = NULL;
+  Tesselation *TesselStruct = NULL;
   if ((srcmol == NULL) || (mol == NULL)) {
     cout << Verbose(1) << "ERROR: Either fixed or variable molecule is given as NULL." << endl;
 …
   // calculate envelope for *mol
   LinkedCell *LCList = new LinkedCell(mol, 8.);
   FindNonConvexBorder((ofstream *)&cout, mol, LCList, 4., NULL);
   if (mol->TesselStruct == NULL) {
+  LCList = new LinkedCell(mol, 8.);
+  FindNonConvexBorder((ofstream *)&cout, mol, TesselStruct, (const LinkedCell *&)LCList, 4., NULL);
+  if (TesselStruct == NULL) {
     cout << Verbose(1) << "ERROR: Could not tesselate the fixed molecule." << endl;
     return false;
+  }
   delete(LCList);
   LCList = new LinkedCell(mol->TesselStruct, 8.);  // re-create with boundary points only!
+  LCList = new LinkedCell(TesselStruct, 8.);  // re-create with boundary points only!
   // prepare index list for bonds
 …
     Walker = Walker->next;
     cout << Verbose(2) << "INFO: Current Walker is " << *Walker << "." << endl;
     if (!mol->TesselStruct->IsInnerPoint((ofstream *)&cout, Walker->x, LCList)) {
+    if (!TesselStruct->IsInnerPoint((ofstream *)&cout, Walker->x, LCList)) {
       CopyAtoms[Walker->nr] = new atom(Walker);
       mol->AddAtom(CopyAtoms[Walker->nr]);
 …
   atom *Walker = NULL;
   atom *Runner = NULL;
+  bond *Binder = NULL;
   double ***FitConstant = NULL, **correction = NULL;
   int a, b;
 …
   // 0b. allocate memory for constants
   FitConstant = Malloc<double**>(3, "MoleculeListClass::AddHydrogenCorrection: ***FitConstant");
+  FitConstant = Calloc<double**>(3, "MoleculeListClass::AddHydrogenCorrection: ***FitConstant");
   for (int k = 0; k < 3; k++) {
     FitConstant[k] = Malloc<double*>(a, "MoleculeListClass::AddHydrogenCorrection: **FitConstant[]");
+    FitConstant[k] = Calloc<double*>(a, "MoleculeListClass::AddHydrogenCorrection: **FitConstant[]");
     for (int i = a; i--;) {
       FitConstant[k][i] = Malloc<double>(b, "MoleculeListClass::AddHydrogenCorrection: *FitConstant[][]");
+      FitConstant[k][i] = Calloc<double>(b, "MoleculeListClass::AddHydrogenCorrection: *FitConstant[][]");
+    }
+  }
 …
   // 0d. allocate final correction matrix
   correction = Malloc<double*>(a, "MoleculeListClass::AddHydrogenCorrection: **correction");
+  correction = Calloc<double*>(a, "MoleculeListClass::AddHydrogenCorrection: **correction");
   for (int i = a; i--;)
     correction[i] = Malloc<double>(b, "MoleculeListClass::AddHydrogenCorrection: *correction[]");
+    correction[i] = Calloc<double>(b, "MoleculeListClass::AddHydrogenCorrection: *correction[]");
   // 1a. go through every molecule in the list
 …
     while (Walker->next != (*ListRunner)->end) {
       Walker = Walker->next;
       //cout << Verbose(1) << "Walker: " << *Walker << " with first bond " << *(*Runner)->ListOfBondsPerAtom[Walker->nr][0] << "." << endl;
+      //cout << Verbose(1) << "Walker: " << *Walker << " with first bond " << *(Walker->ListOfBonds.begin()) << "." << endl;
       if ((Walker->type->Z == 1) && ((Walker->father == NULL)
           || (Walker->father->type->Z != 1))) { // if it's a hydrogen
 …
         while (Runner->next != (*ListRunner)->end) {
           Runner = Runner->next;
           //cout << Verbose(2) << "Runner: " << *Runner << " with first bond " << *(*Runner)->ListOfBondsPerAtom[Runner->nr][0] << "." << endl;
+          //cout << Verbose(2) << "Runner: " << *Runner << " with first bond " << *(Walker->ListOfBonds.begin()) << "." << 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) && ((*ListRunner)->ListOfBondsPerAtom[Runner->nr][0]->GetOtherAtom(Runner) != (*ListRunner)->ListOfBondsPerAtom[Walker->nr][0]->GetOtherAtom(Walker))) { // (hydrogens have only one bonding partner!)
+          Binder = *(Runner->ListOfBonds.begin());
+          if ((Runner->type->Z == 1) && (Runner->nr > Walker->nr) && (Binder->GetOtherAtom(Runner) != Binder->GetOtherAtom(Walker))) { // (hydrogens have only one bonding partner!)
             // 4. evaluate the morse potential for each matrix component and add up
             distance = Runner->x.Distance(&Walker->x);
 …
   output.close();
   // 6. free memory of parsed matrices
-  FitConstant = Malloc<double**>(a, "MoleculeListClass::AddHydrogenCorrection: ***FitConstant");
   for (int k = 0; k < 3; k++) {
-    FitConstant[k] = Malloc<double*>(a, "MoleculeListClass::AddHydrogenCorrection: **FitConstant[]");
     for (int i = a; i--;) {
+      FitConstant[k][i] = Malloc<double>(b, "MoleculeListClass::AddHydrogenCorrection: *FitConstant[][]");
+    }
+  }
+      Free(&FitConstant[k][i]);
+    }
+    Free(&FitConstant[k]);
+  }
+  Free(&FitConstant);
   cout << "done." << endl;
   return true;
 …
     //outputFragment.close();
     //outputFragment.clear();
+    delete (FragmentNumber);
+    //Free(&FragmentNumber);
+    Free(&FragmentNumber);
+  }
   cout << " done." << endl;
 …
 };
+/** Dissects given \a *mol into connected subgraphs and inserts them as new molecules but with old atoms into \a this.
+ * \param *out output stream for debugging
+ * \param *mol molecule with atoms to dissect
+ * \param *configuration config with BondGraph
+ */
+void MoleculeListClass::DissectMoleculeIntoConnectedSubgraphs(ofstream * const out, molecule * const mol, config * const configuration)
+{
+  // 1. dissect the molecule into connected subgraphs
+  configuration ->BG->ConstructBondGraph(out, mol);
+  // 2. scan for connected subgraphs
+  MoleculeLeafClass *Subgraphs = NULL;      // list of subgraphs from DFS analysis
+  class StackClass<bond *> *BackEdgeStack = NULL;
+  Subgraphs = mol->DepthFirstSearchAnalysis(out, BackEdgeStack);
+  delete(BackEdgeStack);
+  // 3. dissect (the following construct is needed to have the atoms not in the order of the DFS, but in
+  // the original one as parsed in)
+  // TODO: Optimize this, when molecules just contain pointer list of global atoms!
+  // 4a. create array of molecules to fill
+  const int MolCount = Subgraphs->next->Count();
+  molecule **molecules = Malloc<molecule *>(MolCount, "config::Load() - **molecules");
+  for (int i=0;i<MolCount;i++) {
+    molecules[i] = (molecule*) new molecule(mol->elemente);
+    molecules[i]->ActiveFlag = true;
+    insert(molecules[i]);
+  }
+  // 4b. create and fill map of which atom is associated to which connected molecule (note, counting starts at 1)
+  int FragmentCounter = 0;
+  int *MolMap = Calloc<int>(mol->AtomCount, "config::Load() - *MolMap");
+  MoleculeLeafClass *MolecularWalker = Subgraphs;
+  atom *Walker = NULL;
+  while (MolecularWalker->next != NULL) {
+    MolecularWalker = MolecularWalker->next;
+    Walker = MolecularWalker->Leaf->start;
+    while (Walker->next != MolecularWalker->Leaf->end) {
+      Walker = Walker->next;
+      MolMap[Walker->GetTrueFather()->nr] = FragmentCounter+1;
+    }
+    FragmentCounter++;
+  }
+  // 4c. relocate atoms to new molecules and remove from Leafs
+  Walker = mol->start;
+  while (mol->start->next != mol->end) {
+    Walker = mol->start->next;
+    if ((Walker->nr <0) || (Walker->nr >= mol->AtomCount)) {
+      cerr << "Index of atom " << *Walker << " is invalid!" << endl;
+      performCriticalExit();
+    }
+    FragmentCounter = MolMap[Walker->nr];
+    if (FragmentCounter != 0) {
+      cout << Verbose(3) << "Re-linking " << *Walker << "..." << endl;
+      unlink(Walker);
+      molecules[FragmentCounter-1]->AddAtom(Walker);    // counting starts at 1
+    } else {
+      cerr << "Atom " << *Walker << " not associated to molecule!" << endl;
+      performCriticalExit();
+    }
+  }
+  // 4d. we don't need to redo bonds, as they are connected subgraphs and still maintained their ListOfBonds
+  // 4e. free Leafs
+  MolecularWalker = Subgraphs;
+  while (MolecularWalker->next != NULL) {
+    MolecularWalker = MolecularWalker->next;
+    delete(MolecularWalker->previous);
+  }
+  delete(MolecularWalker);
+  Free(&MolMap);
+  Free(&molecules);
+  cout << Verbose(1) << "I scanned " << FragmentCounter << " molecules." << endl;
+};
 /******************************************* Class MoleculeLeafClass ************************************************/
 …
  * \return true - success, false - faoilure
  */
+bool MoleculeLeafClass::FillBondStructureFromReference(ofstream *out, molecule *reference, int &FragmentCounter, atom ***&ListOfLocalAtoms, bool FreeList)
+{
+  atom *Walker = NULL, *OtherWalker = NULL;
+  bond *Binder = NULL;
+bool MoleculeLeafClass::FillBondStructureFromReference(ofstream *out, const molecule * const reference, int &FragmentCounter, atom ***&ListOfLocalAtoms, bool FreeList)
+{
+  atom *Walker = NULL;
+  atom *OtherWalker = NULL;
+  atom *Father = NULL;
   bool status = true;
   int AtomNo;
 …
   if (status) {
+    *out << Verbose(1) << "Creating adjacency list for subgraph " << this
+        << "." << endl;
+    *out << Verbose(1) << "Creating adjacency list for subgraph " << Leaf << "." << endl;
+    // remove every bond from the list
+    bond *Binder = NULL;
+    while (Leaf->last->previous != Leaf->first) {
+      Binder = Leaf->last->previous;
+      Binder->leftatom->UnregisterBond(Binder);
+      Binder->rightatom->UnregisterBond(Binder);
+      removewithoutcheck(Binder);
+    }
     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
         Binder = reference->ListOfBondsPerAtom[AtomNo][i];
         OtherWalker = ListOfLocalAtoms[FragmentCounter][Binder->GetOtherAtom(Walker->GetTrueFather())->nr]; // local copy of current bond partner of walker
+      Father = Walker->GetTrueFather();
+      AtomNo = Father->nr; // global id of the current walker
+      for (BondList::const_iterator Runner = Father->ListOfBonds.begin(); Runner != Father->ListOfBonds.end(); (++Runner)) {
+        OtherWalker = ListOfLocalAtoms[FragmentCounter][(*Runner)->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, (*Runner)->BondDegree);
         } else {
           *out << Verbose(1) << "OtherWalker = ListOfLocalAtoms[" << FragmentCounter << "][" << Binder->GetOtherAtom(Walker->GetTrueFather())->nr << "] is NULL!" << endl;
+          *out << Verbose(1) << "OtherWalker = ListOfLocalAtoms[" << FragmentCounter << "][" << (*Runner)->GetOtherAtom(Walker->GetTrueFather())->nr << "] is NULL!" << endl;
           status = false;
+        }
+      }
+    }
-    Leaf->CreateListOfBondsPerAtom(out);
-    FragmentCounter++;
-    if (next != NULL)
-      status = next->FillBondStructureFromReference(out, reference, FragmentCounter, ListOfLocalAtoms);
-    FragmentCounter--;
+  }
 …
       Free(&ListOfLocalAtoms);
+  }
-  FragmentCounter--;
   *out << Verbose(1) << "End of FillBondStructureFromReference." << endl;
   return status;
 …
 /** Fills a lookup list of father's Atom::nr -> atom for each subgraph.
  * \param *out output stream fro debugging
+ * \param *out output stream from debugging
  * \param ***ListOfLocalAtoms Lookup table for each subgraph and index of each atom in global molecule, may be NULL on start, then it is filled
  * \param FragmentCounter counts the fragments as we move along the list
  * \param GlobalAtomCount number of atoms in the complete molecule
  * \param &FreeList true - ***ListOfLocalAtoms is free'd before return, false - it is not
  * \return true - succes, false - failure
+ * \return true - success, false - failure
  */
 bool MoleculeLeafClass::FillListOfLocalAtoms(ofstream *out, atom ***&ListOfLocalAtoms, const int FragmentCounter, const int GlobalAtomCount, bool &FreeList)
 …
   bool status = true;
-  int Counter = Count();
   if (ListOfLocalAtoms == NULL) { // allocated initial pointer
     // allocate and set each field to NULL
+    ListOfLocalAtoms = Malloc<atom**>(Counter, "MoleculeLeafClass::FillBondStructureFromReference - ***ListOfLocalAtoms");
+    if (ListOfLocalAtoms != NULL) {
+      for (int i = Counter; i--;)
+        ListOfLocalAtoms[i] = NULL;
+      FreeList = FreeList && true;
+    } else
+    const int Counter = Count();
+    ListOfLocalAtoms = Calloc<atom**>(Counter, "MoleculeLeafClass::FillListOfLocalAtoms - ***ListOfLocalAtoms");
+    if (ListOfLocalAtoms == NULL) {
+      FreeList = FreeList && false;
       status = false;
+    }
+  }
 …
   if (FragmentList == NULL) {
     KeySetCounter = Count();
+    FragmentList = Malloc<Graph*>(KeySetCounter, "MoleculeLeafClass::AssignKeySetsToFragment - **FragmentList");
+    for (int i = KeySetCounter; i--;)
+      FragmentList[i] = NULL;
+    FragmentList = Calloc<Graph*>(KeySetCounter, "MoleculeLeafClass::AssignKeySetsToFragment - **FragmentList");
     KeySetCounter = 0;
+  }

src/periodentafel.cpp

-              r06c7a3
+              r7326b2
  * Initialises start and end of list and resets periodentafel::checkliste to false.
  */
+periodentafel::periodentafel()
+{
+  start = new element;
+  end = new element;
+periodentafel::periodentafel() : start(new element), end(new element)
+{
   start->previous = NULL;
   start->next = end;
 …
  * \return true - succeeded, false - does not occur
  */
 bool periodentafel::AddElement(element *pointer)
+bool periodentafel::AddElement(element * const pointer)
+{
   pointer->sort = &pointer->Z;
 …
  * \return true - succeeded, false - element not found
  */
 bool periodentafel::RemoveElement(element *pointer)
+bool periodentafel::RemoveElement(element * const pointer)
+{
   return remove(pointer, start, end);
 …
 /** Finds an element by its atomic number.
  * If element is not yet in list, datas are asked and stored in database.
+ * If element is not yet in list, returns NULL.
  * \param Z atomic number
  * \return pointer to element
  */
 element * periodentafel::FindElement(int Z)
+ * \return pointer to element or NULL if not found
+ */
+element * const periodentafel::FindElement(const int Z) const
+{
   element *walker = find(&Z, start,end);
-  if (walker == NULL) { // not found: enter and put into db
-    cout << Verbose(0) << "Element not found in database, please enter." << endl;
-    walker = new element;
-    cout << Verbose(0) << "Mass: " << endl;
-    cin >> walker->mass;
-    walker->Z = Z;
-    cout << Verbose(0) << "Atomic number: " << walker->Z << endl;
-    cout << Verbose(0) << "Name [max 64 chars]: " << endl;
-    cin >> walker->name;
-    cout << Verbose(0) << "Short form [max 3 chars]: " << endl;
-    cin >> walker->symbol;
-    periodentafel::AddElement(walker);
+  }
   return(walker);
 };
 …
  * \return pointer to element
  */
 element * periodentafel::FindElement(const char *shorthand) const
+element * const periodentafel::FindElement(const char * const shorthand) const
+{
   element *walker =  periodentafel::start;
 …
 /** Asks for element number and returns pointer to element
  */
 element * periodentafel::AskElement()
+element * const periodentafel::AskElement() const
+{
   element *walker = NULL;
 …
 };
+/** Asks for element and if not found, presents mask to enter info.
+ * \return pointer to either present or newly created element
+ */
+element * const periodentafel::EnterElement()
+{
+  element *walker = NULL;
+  int Z = -1;
+  cout << Verbose(0) << "Atomic number: " << Z << endl;
+  cin >> Z;
+  walker = FindElement(Z);
+  if (walker == NULL) {
+    cout << Verbose(0) << "Element not found in database, please enter." << endl;
+    walker = new element;
+    walker->Z = Z;
+    cout << Verbose(0) << "Mass: " << endl;
+    cin >> walker->mass;
+    cout << Verbose(0) << "Name [max 64 chars]: " << endl;
+    cin >> walker->name;
+    cout << Verbose(0) << "Short form [max 3 chars]: " << endl;
+    cin >> walker->symbol;
+    periodentafel::AddElement(walker);
+  }
+  return(walker);
+};
 /** Prints period table to given stream.
  * \param output stream
  */
 bool periodentafel::Output(ofstream *output) const
+bool periodentafel::Output(ofstream * const output) const
+{
   bool result = true;
 …
  * \param *checkliste elements table for this molecule
  */
 bool periodentafel::Checkout(ofstream *output, const int *checkliste) const
+bool periodentafel::Checkout(ofstream * const output, const int * const checkliste) const
+{
   element *walker = start;
 …
         cout << "Could not parse element: ";
         neues->Output((ofstream *)&cout);
+        delete(neues);
+      }
+    }

src/periodentafel.hpp

-              r06c7a3
+              r7326b2
   ~periodentafel();
   bool AddElement(element *pointer);
   bool RemoveElement(element *pointer);
+  bool AddElement(element * const pointer);
+  bool RemoveElement(element * const pointer);
   bool CleanupPeriodtable();
+  element * FindElement(int Z);
+  element * FindElement(const char *shorthand) const;
+  element * AskElement();
+  bool Output(ofstream *output) const;
+  bool Checkout(ofstream *output, const int *checkliste) const;
+  bool LoadPeriodentafel(const char *path);
+  bool StorePeriodentafel(const char *path) const;
+  element * const FindElement(const int Z) const;
+  element * const FindElement(const char * const shorthand) const;
+  element * const AskElement() const;
+  element * const EnterElement();
+  bool Output(ofstream * const output) const;
+  bool Checkout(ofstream * const output, const int * const checkliste) const;
+  bool LoadPeriodentafel(const char * const path);
+  bool StorePeriodentafel(const char * const path) const;
   private:

src/stackclass.hpp

-              r06c7a3
+              r7326b2
   bool RemoveItem(T ptr);
   void ClearStack();
+  bool IsEmpty();
+  bool IsFull();
+  int ItemCount();
+  void Output(ofstream *out) const;
+  void TestImplementation(ofstream *out, T test);
+  bool IsEmpty() const;
+  bool IsFull() const;
+  int ItemCount() const;
+  void Output(ofstream * const out) const;
   private:
 …
 /** Constructor of class StackClass.
  */
+template <typename T> StackClass<T>::StackClass(int dimension)
+{
+  CurrentLastEntry = 0;
+  CurrentFirstEntry = 0;
+  NextFreeField = 0;
+  EntryCount = dimension;
+  StackList = Malloc<T>(EntryCount, "StackClass::StackClass: **StackList");
+template <typename T> StackClass<T>::StackClass(int dimension) : StackList(NULL), EntryCount(dimension), CurrentLastEntry(0), CurrentFirstEntry(0), NextFreeField(0)
+{
+  StackList = Calloc<T>(EntryCount, "StackClass::StackClass: **StackList");
 };
 …
 };
-/** Test the functionality of the stack.
- * \param *out ofstream for debugging
- * \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;
-};
 /** Puts contents of stack into ofstream \a *out.
  * \param *out ofstream for output
  */
 template <typename T> void StackClass<T>::Output(ofstream *out) const
+template <typename T> void StackClass<T>::Output(ofstream * const out) const
+{
   *out << "Contents of Stack: ";
 …
  * \return true - empty, false - not
  */
 template <typename T> bool StackClass<T>::IsEmpty()
+template <typename T> bool StackClass<T>::IsEmpty() const
+{
   return((NextFreeField == CurrentFirstEntry) && (CurrentLastEntry == CurrentFirstEntry));
 …
  * \return true - full, false - not
  */
 template <typename T> bool StackClass<T>::IsFull()
+template <typename T> bool StackClass<T>::IsFull() const
+{
   return((NextFreeField == CurrentFirstEntry) && (CurrentLastEntry != CurrentFirstEntry));
 …
  * \warning will never return correct item count if stack is full, i.e. count would be StackClass::EntryCount.
  */
 template <typename T> int StackClass<T>::ItemCount()
+template <typename T> int StackClass<T>::ItemCount() const
+{
   //cout << "Stack: CurrentLastEntry " << CurrentLastEntry<< "\tCurrentFirstEntry " << CurrentFirstEntry << "\tEntryCount " << EntryCount << "." << endl;

src/tesselation.cpp

-              r06c7a3
+              r7326b2
 #include <fstream>
+#include "helpers.hpp"
 #include "linkedcell.hpp"
 #include "tesselation.hpp"
 …
  * \param *Walker TesselPoint this boundary point represents
  */
 BoundaryPointSet::BoundaryPointSet(TesselPoint *Walker)
+BoundaryPointSet::BoundaryPointSet(TesselPoint * Walker)
+{
   node = Walker;
 …
  * \param &a boundary point
  */
 ostream & operator <<(ostream &ost, BoundaryPointSet &a)
+ostream & operator <<(ostream &ost, const BoundaryPointSet &a)
+{
   ost << "[" << a.Nr << "|" << a.node->Name << " at " << *a.node->node << "]";
 …
  * \param number number of the list
  */
 BoundaryLineSet::BoundaryLineSet(class BoundaryPointSet *Point[2], int number)
+BoundaryLineSet::BoundaryLineSet(class BoundaryPointSet *Point[2], const int number)
+{
   // set number
 …
  * \param &a boundary line
  */
 ostream & operator <<(ostream &ost, BoundaryLineSet &a)
+ostream & operator <<(ostream &ost, const  BoundaryLineSet &a)
+{
   ost << "[" << a.Nr << "|" << a.endpoints[0]->node->Name << " at " << *a.endpoints[0]->node->node << "," << a.endpoints[1]->node->Name << " at " << *a.endpoints[1]->node->node << "]";
 …
  * \param &a boundary triangle
  */
 ostream &operator <<(ostream &ost, BoundaryTriangleSet &a)
+ostream &operator <<(ostream &ost, const BoundaryTriangleSet &a)
+{
   ost << "[" << a.Nr << "|" << a.endpoints[0]->node->Name << " at " << *a.endpoints[0]->node->node << ","
 …
  * Uses PointsOnBoundary and STL stuff.
  */
 Vector * Tesselation::GetCenter(ofstream *out)
+Vector * Tesselation::GetCenter(ofstream *out) const
+{
   Vector *Center = new Vector(0.,0.,0.);
 …
  * Uses PointsOnBoundary and STL stuff.
  */
 TesselPoint * Tesselation::GetPoint()
+TesselPoint * Tesselation::GetPoint() const
+{
   return (InternalPointer->second->node);
 …
  * Uses PointsOnBoundary and STL stuff.
  */
 TesselPoint * Tesselation::GetTerminalPoint()
+{
   PointMap::iterator Runner = PointsOnBoundary.end();
+TesselPoint * Tesselation::GetTerminalPoint() const
+{
+  PointMap::const_iterator Runner = PointsOnBoundary.end();
   Runner--;
   return (Runner->second->node);
 …
  * Uses PointsOnBoundary and STL stuff.
  */
 void Tesselation::GoToNext()
+void Tesselation::GoToNext() const
+{
   if (InternalPointer != PointsOnBoundary.end())
 …
  * Uses PointsOnBoundary and STL stuff.
  */
 void Tesselation::GoToPrevious()
+void Tesselation::GoToPrevious() const
+{
   if (InternalPointer != PointsOnBoundary.begin())
 …
  * Uses PointsOnBoundary and STL stuff.
  */
 void Tesselation::GoToFirst()
+void Tesselation::GoToFirst() const
+{
   InternalPointer = PointsOnBoundary.begin();
 …
 /** PointCloud implementation of GoToLast.
  * Uses PointsOnBoundary and STL stuff.
  */
 void Tesselation::GoToLast()
+ */
+void Tesselation::GoToLast() const
+{
   InternalPointer = PointsOnBoundary.end();
 …
  * Uses PointsOnBoundary and STL stuff.
  */
 bool Tesselation::IsEmpty()
+bool Tesselation::IsEmpty() const
+{
   return (PointsOnBoundary.empty());
 …
  * Uses PointsOnBoundary and STL stuff.
  */
 bool Tesselation::IsEnd()
+bool Tesselation::IsEnd() const
+{
   return (InternalPointer == PointsOnBoundary.end());
 …
  * \param *cloud cluster of points
  */
 void Tesselation::TesselateOnBoundary(ofstream *out, PointCloud *cloud)
+void Tesselation::TesselateOnBoundary(ofstream *out, const PointCloud * const cloud)
+{
   bool flag;
 …
  * \return true - all straddling points insert, false - something went wrong
  */
 bool Tesselation::InsertStraddlingPoints(ofstream *out, PointCloud *cloud, LinkedCell *LC)
+bool Tesselation::InsertStraddlingPoints(ofstream *out, const PointCloud *cloud, const LinkedCell *LC)
+{
   Vector Intersection, Normal;
 …
  * \return true - new point was added, false - point already present
  */
+bool
+Tesselation::AddBoundaryPoint(TesselPoint *Walker, int n)
+bool Tesselation::AddBoundaryPoint(TesselPoint * Walker, const int n)
+{
   PointTestPair InsertUnique;
 …
  * @param n index for this point in Tesselation::TPS array
  */
+void
+Tesselation::AddTesselationPoint(TesselPoint* Candidate, int n)
+void Tesselation::AddTesselationPoint(TesselPoint* Candidate, const int n)
+{
   PointTestPair InsertUnique;
 …
  * @param n index of Tesselation::BLS giving the line with both endpoints
  */
 void Tesselation::AddTesselationLine(class BoundaryPointSet *a, class BoundaryPointSet *b, int n) {
+void Tesselation::AddTesselationLine(class BoundaryPointSet *a, class BoundaryPointSet *b, const int n) {
   bool insertNewLine = true;
 …
  * @param n index of Tesselation::BLS giving the line with both endpoints
  */
 void Tesselation::AlwaysAddTesselationTriangleLine(class BoundaryPointSet *a, class BoundaryPointSet *b, int n)
+void Tesselation::AlwaysAddTesselationTriangleLine(class BoundaryPointSet *a, class BoundaryPointSet *b, const int n)
+{
   cout << Verbose(4) << "Adding line [" << LinesOnBoundaryCount << "|" << *(a->node) << " and " << *(b->node) << "." << endl;
 …
  * \param nr triangle number
  */
 void Tesselation::AddTesselationTriangle(int nr)
+void Tesselation::AddTesselationTriangle(const int nr)
+{
   cout << Verbose(1) << "Adding triangle to global TrianglesOnBoundary map." << endl;
 …
  * \param *LC LinkedCell structure with neighbouring TesselPoint's
  */
 void Tesselation::FindStartingTriangle(ofstream *out, const double RADIUS, LinkedCell *LC)
+void Tesselation::FindStartingTriangle(ofstream *out, const double RADIUS, const LinkedCell *LC)
+{
   cout << Verbose(1) << "Begin of FindStartingTriangle\n";
   int i = 0;
-  LinkedNodes *List = NULL;
   TesselPoint* FirstPoint = NULL;
   TesselPoint* SecondPoint = NULL;
 …
     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();
+        const LinkedNodes *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 (LinkedNodes::iterator Runner = List->begin();Runner != List->end();Runner++) {
+          for (LinkedNodes::const_iterator Runner = List->begin();Runner != List->end();Runner++) {
             if ((*Runner)->node->x[i] > maxCoordinate[i]) {
               cout << Verbose(2) << "New maximal for axis " << i << " node is " << *(*Runner) << " at " << *(*Runner)->node << "." << endl;
 …
     //cout << Verbose(2) << "INFO: OldSphereCenter is at " << helper << ".\n";
+    FindThirdPointForTesselation(
+      Oben, SearchDirection, helper, BLS[0], NULL, *&OptCandidates, &ShortestAngle, RADIUS, LC
+    );
+    FindThirdPointForTesselation(Oben, SearchDirection, helper, BLS[0], NULL, *&OptCandidates, &ShortestAngle, RADIUS, LC);
     cout << Verbose(1) << "List of third Points is ";
     for (CandidateList::iterator it = OptCandidates->begin(); it != OptCandidates->end(); ++it) {
 …
  * @param *LC LinkedCell structure with neighbouring points
  */
 bool Tesselation::FindNextSuitableTriangle(ofstream *out, BoundaryLineSet &Line, BoundaryTriangleSet &T, const double& RADIUS, LinkedCell *LC)
+bool Tesselation::FindNextSuitableTriangle(ofstream *out, BoundaryLineSet &Line, BoundaryTriangleSet &T, const double& RADIUS, const LinkedCell *LC)
+{
   cout << Verbose(0) << "Begin of FindNextSuitableTriangle\n";
 …
     // construct old center
     GetCenterofCircumcircle(&OldSphereCenter, T.endpoints[0]->node->node, T.endpoints[1]->node->node, T.endpoints[2]->node->node);
+    GetCenterofCircumcircle(&OldSphereCenter, *T.endpoints[0]->node->node, *T.endpoints[1]->node->node, *T.endpoints[2]->node->node);
     helper.CopyVector(&T.NormalVector);  // normal vector ensures that this is correct center of the two possible ones
     radius = Line.endpoints[0]->node->node->DistanceSquared(&OldSphereCenter);
 …
     // add third point
+    FindThirdPointForTesselation(
+      T.NormalVector, SearchDirection, OldSphereCenter, &Line, ThirdNode, OptCandidates,
+      &ShortestAngle, RADIUS, LC
+    );
+    FindThirdPointForTesselation(T.NormalVector, SearchDirection, OldSphereCenter, &Line, ThirdNode, OptCandidates, &ShortestAngle, RADIUS, LC);
   } else {
 …
       AddTesselationPoint(BaseRay->endpoints[1]->node, 2);
       if (CheckLineCriteriaForDegeneratedTriangle(TPS)) {
+      if (CheckLineCriteriaForDegeneratedTriangle((const BoundaryPointSet ** const )TPS)) {
         AddTesselationLine(TPS[0], TPS[1], 0);
         AddTesselationLine(TPS[0], TPS[2], 1);
 …
         // We demand that at most one new degenerate line is created and that this line also already exists (which has to be the case due to existentTrianglesCount == 1)
         // i.e. at least one of the three lines must be present with TriangleCount <= 1
         if (CheckLineCriteriaForDegeneratedTriangle(TPS)) {
+        if (CheckLineCriteriaForDegeneratedTriangle((const BoundaryPointSet ** const)TPS)) {
           AddTesselationLine(TPS[0], TPS[1], 0);
           AddTesselationLine(TPS[0], TPS[2], 1);
 …
 };
 void Tesselation::PrintAllBoundaryPoints(ofstream *out)
+void Tesselation::PrintAllBoundaryPoints(ofstream *out) const
+{
   // print all lines
   *out << Verbose(1) << "Printing all boundary points for debugging:" << endl;
   for (PointMap::iterator PointRunner = PointsOnBoundary.begin();PointRunner != PointsOnBoundary.end(); PointRunner++)
+  for (PointMap::const_iterator PointRunner = PointsOnBoundary.begin();PointRunner != PointsOnBoundary.end(); PointRunner++)
     *out << Verbose(2) << *(PointRunner->second) << endl;
 };
 void Tesselation::PrintAllBoundaryLines(ofstream *out)
+void Tesselation::PrintAllBoundaryLines(ofstream *out) const
+{
   // print all lines
   *out << Verbose(1) << "Printing all boundary lines for debugging:" << endl;
   for (LineMap::iterator LineRunner = LinesOnBoundary.begin(); LineRunner != LinesOnBoundary.end(); LineRunner++)
+  for (LineMap::const_iterator LineRunner = LinesOnBoundary.begin(); LineRunner != LinesOnBoundary.end(); LineRunner++)
     *out << Verbose(2) << *(LineRunner->second) << endl;
 };
 void Tesselation::PrintAllBoundaryTriangles(ofstream *out)
+void Tesselation::PrintAllBoundaryTriangles(ofstream *out) const
+{
   // print all triangles
   *out << Verbose(1) << "Printing all boundary triangles for debugging:" << endl;
   for (TriangleMap::iterator TriangleRunner = TrianglesOnBoundary.begin(); TriangleRunner != TrianglesOnBoundary.end(); TriangleRunner++)
+  for (TriangleMap::const_iterator TriangleRunner = TrianglesOnBoundary.begin(); TriangleRunner != TrianglesOnBoundary.end(); TriangleRunner++)
     *out << Verbose(2) << *(TriangleRunner->second) << endl;
 };
 …
   // calculate volume
   volume = CalculateVolumeofGeneralTetraeder(Base->endpoints[1]->node->node, OtherBase->endpoints[0]->node->node, OtherBase->endpoints[1]->node->node, Base->endpoints[0]->node->node);
+  volume = CalculateVolumeofGeneralTetraeder(*Base->endpoints[1]->node->node, *OtherBase->endpoints[0]->node->node, *OtherBase->endpoints[1]->node->node, *Base->endpoints[0]->node->node);
   // delete the temporary other base line and the closest points
 …
  * \param *LC LinkedCell structure with neighbouring points
  */
 void Tesselation::FindSecondPointForTesselation(TesselPoint* a, Vector Oben, TesselPoint*& OptCandidate, double Storage[3], double RADIUS, LinkedCell *LC)
+void Tesselation::FindSecondPointForTesselation(TesselPoint* a, Vector Oben, TesselPoint*& OptCandidate, double Storage[3], double RADIUS, const LinkedCell *LC)
+{
   cout << Verbose(2) << "Begin of FindSecondPointForTesselation" << endl;
   Vector AngleCheck;
   class TesselPoint* Candidate = NULL;
+  double norm = -1., angle;
+  LinkedNodes *List = NULL;
+  int N[NDIM], Nlower[NDIM], Nupper[NDIM];
+  double norm = -1.;
+  double angle = 0.;
+  int N[NDIM];
+  int Nlower[NDIM];
+  int Nupper[NDIM];
   if (LC->SetIndexToNode(a)) {  // get cell for the starting point
 …
     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();
+        const LinkedNodes *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 (LinkedNodes::iterator Runner = List->begin(); Runner != List->end(); Runner++) {
+          for (LinkedNodes::const_iterator Runner = List->begin(); Runner != List->end(); Runner++) {
             Candidate = (*Runner);
             // check if we only have one unique point yet ...
 …
  * @param *LC LinkedCell structure with neighbouring points
  */
 void Tesselation::FindThirdPointForTesselation(Vector NormalVector, Vector SearchDirection, Vector OldSphereCenter, class BoundaryLineSet *BaseLine, class TesselPoint  *ThirdNode, CandidateList* &candidates, double *ShortestAngle, const double RADIUS, LinkedCell *LC)
+void Tesselation::FindThirdPointForTesselation(Vector NormalVector, Vector SearchDirection, Vector OldSphereCenter, class BoundaryLineSet *BaseLine, class TesselPoint  *ThirdNode, CandidateList* &candidates, double *ShortestAngle, const double RADIUS, const LinkedCell *LC)
+{
   Vector CircleCenter;  // center of the circle, i.e. of the band of sphere's centers
 …
   Vector NewNormalVector;   // normal vector of the Candidate's triangle
   Vector helper, OptCandidateCenter, OtherOptCandidateCenter;
-  LinkedNodes *List = NULL;
   double CircleRadius; // radius of this circle
   double radius;
 …
         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();
+            const LinkedNodes *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 (LinkedNodes::iterator Runner = List->begin(); Runner != List->end(); Runner++) {
+              for (LinkedNodes::const_iterator Runner = List->begin(); Runner != List->end(); Runner++) {
                 Candidate = (*Runner);
 …
                   // construct both new centers
                   GetCenterofCircumcircle(&NewSphereCenter, BaseLine->endpoints[0]->node->node, BaseLine->endpoints[1]->node->node, Candidate->node);
+                  GetCenterofCircumcircle(&NewSphereCenter, *BaseLine->endpoints[0]->node->node, *BaseLine->endpoints[1]->node->node, *Candidate->node);
                   OtherNewSphereCenter.CopyVector(&NewSphereCenter);
 …
  * \return point which is shared or NULL if none
  */
+class BoundaryPointSet *Tesselation::GetCommonEndpoint(class BoundaryLineSet * line1, class BoundaryLineSet * line2)
+{
+  class BoundaryLineSet * lines[2] =
+    { line1, line2 };
+class BoundaryPointSet *Tesselation::GetCommonEndpoint(const BoundaryLineSet * line1, const BoundaryLineSet * line2) const
+{
+  const BoundaryLineSet * lines[2] = { line1, line2 };
   class BoundaryPointSet *node = NULL;
   map<int, class BoundaryPointSet *> OrderMap;
 …
  * \return list of BoundaryTriangleSet of nearest triangles or NULL in degenerate case.
  */
 list<BoundaryTriangleSet*> * Tesselation::FindClosestTrianglesToPoint(ofstream *out, Vector *x, LinkedCell* LC)
+list<BoundaryTriangleSet*> * Tesselation::FindClosestTrianglesToPoint(ofstream *out, const Vector *x, const LinkedCell* LC) const
+{
   TesselPoint *trianglePoints[3];
 …
     return NULL;
+  }
+  *out << Verbose(1) << "Finding closest Tesselpoint to " << *x << " ... " << endl;
   trianglePoints[0] = FindClosestPoint(x, SecondPoint, LC);
 …
   if (trianglePoints[0]->node->DistanceSquared(x) < MYEPSILON) {
     *out << Verbose(3) << "Point is right on a tesselation point, no nearest triangle." << endl;
     PointMap::iterator PointRunner = PointsOnBoundary.find(trianglePoints[0]->nr);
+    PointMap::const_iterator PointRunner = PointsOnBoundary.find(trianglePoints[0]->nr);
     triangles = new list<BoundaryTriangleSet*>;
     if (PointRunner != PointsOnBoundary.end()) {
 …
   } else {
     list<TesselPoint*> *connectedClosestPoints = GetCircleOfConnectedPoints(out, trianglePoints[0], x);
+    trianglePoints[1] = connectedClosestPoints->front();
+    trianglePoints[2] = connectedClosestPoints->back();
+    for (int i=0;i<3;i++) {
+      if (trianglePoints[i] == NULL) {
+        *out << Verbose(1) << "ERROR: IsInnerPoint encounters serious error, point " << i << " not found." << endl;
+    if (connectedClosestPoints != NULL) {
+      trianglePoints[1] = connectedClosestPoints->front();
+      trianglePoints[2] = connectedClosestPoints->back();
+      for (int i=0;i<3;i++) {
+        if (trianglePoints[i] == NULL) {
+          *out << Verbose(1) << "ERROR: IsInnerPoint encounters serious error, point " << i << " not found." << endl;
+        }
+        //*out << Verbose(2) << "List of triangle points:" << endl;
+        //*out << Verbose(3) << *trianglePoints[i] << endl;
+      }
+      //*out << Verbose(2) << "List of triangle points:" << endl;
+      //*out << Verbose(3) << *trianglePoints[i] << endl;
+    }
+    triangles = FindTriangles(trianglePoints);
+    *out << Verbose(2) << "List of possible triangles:" << endl;
+    for(list<BoundaryTriangleSet*>::iterator Runner = triangles->begin(); Runner != triangles->end(); Runner++)
+      *out << Verbose(3) << **Runner << endl;
+    delete(connectedClosestPoints);
+      triangles = FindTriangles(trianglePoints);
+      *out << Verbose(2) << "List of possible triangles:" << endl;
+      for(list<BoundaryTriangleSet*>::iterator Runner = triangles->begin(); Runner != triangles->end(); Runner++)
+        *out << Verbose(3) << **Runner << endl;
+      delete(connectedClosestPoints);
+    } else {
+      triangles = NULL;
+      *out << Verbose(1) << "There is no circle of connected points!" << endl;
+    }
+  }
   if (triangles->empty()) {
+  if ((triangles == NULL) || (triangles->empty())) {
     *out << Verbose(0) << "ERROR: There is no nearest triangle. Please check the tesselation structure.";
     delete(triangles);
 …
  * \return list of BoundaryTriangleSet of nearest triangles or NULL.
  */
 class BoundaryTriangleSet * Tesselation::FindClosestTriangleToPoint(ofstream *out, Vector *x, LinkedCell* LC)
+class BoundaryTriangleSet * Tesselation::FindClosestTriangleToPoint(ofstream *out, const Vector *x, const LinkedCell* LC) const
+{
   class BoundaryTriangleSet *result = NULL;
 …
  * @return true if the point is inside the tesselation structure, false otherwise
  */
 bool Tesselation::IsInnerPoint(ofstream *out, Vector Point, LinkedCell* LC)
+bool Tesselation::IsInnerPoint(ofstream *out, const Vector &Point, const LinkedCell* const LC) const
+{
   class BoundaryTriangleSet *result = FindClosestTriangleToPoint(out, &Point, LC);
 …
  * @return true if the point is inside the tesselation structure, false otherwise
  */
 bool Tesselation::IsInnerPoint(ofstream *out, TesselPoint *Point, LinkedCell* LC)
+bool Tesselation::IsInnerPoint(ofstream *out, const TesselPoint * const Point, const LinkedCell* const LC) const
+{
   return IsInnerPoint(out, *(Point->node), LC);
 …
  * @return set of the all points linked to the provided one
  */
 set<TesselPoint*> * Tesselation::GetAllConnectedPoints(ofstream *out, TesselPoint* Point)
+set<TesselPoint*> * Tesselation::GetAllConnectedPoints(ofstream *out, const TesselPoint* const Point) const
+{
   set<TesselPoint*> *connectedPoints = new set<TesselPoint*>;
 …
   bool takePoint = false;
+  *out << Verbose(3) << "Begin of GetAllConnectedPoints" << endl;
   // find the respective boundary point
   PointMap::iterator PointRunner = PointsOnBoundary.find(Point->nr);
+  PointMap::const_iterator PointRunner = PointsOnBoundary.find(Point->nr);
   if (PointRunner != PointsOnBoundary.end()) {
     ReferencePoint = PointRunner->second;
 …
   // little trick so that we look just through lines connect to the BoundaryPoint
   // OR fall-back to look through all lines if there is no such BoundaryPoint
   LineMap *Lines = &LinesOnBoundary;
+  const LineMap *Lines;;
   if (ReferencePoint != NULL)
     Lines = &(ReferencePoint->lines);
+  LineMap::iterator findLines = Lines->begin();
+  else
+    Lines = &LinesOnBoundary;
+  LineMap::const_iterator findLines = Lines->begin();
   while (findLines != Lines->end()) {
    takePoint = false;
 …
+  }
+  *out << Verbose(3) << "End of GetAllConnectedPoints" << endl;
   return connectedPoints;
 };
 …
  * @return list of the all points linked to the provided one
  */
 list<TesselPoint*> * Tesselation::GetCircleOfConnectedPoints(ofstream *out, TesselPoint* Point, Vector *Reference)
+list<TesselPoint*> * Tesselation::GetCircleOfConnectedPoints(ofstream *out, const TesselPoint* const Point, const Vector * const Reference) const
+{
   map<double, TesselPoint*> anglesOfPoints;
 …
   Vector helper;
+  if (connectedPoints == NULL) {
+    *out << Verbose(2) << "Could not find any connected points!" << endl;
+    delete(connectedCircle);
+    return NULL;
+  }
+  *out << Verbose(2) << "Begin of GetCircleOfConnectedPoints" << endl;
   // calculate central point
   for (set<TesselPoint*>::iterator TesselRunner = connectedPoints->begin(); TesselRunner != connectedPoints->end(); TesselRunner++)
+  for (set<TesselPoint*>::const_iterator TesselRunner = connectedPoints->begin(); TesselRunner != connectedPoints->end(); TesselRunner++)
     center.AddVector((*TesselRunner)->node);
   //*out << "Summed vectors " << center << "; number of points " << connectedPoints.size()
 …
   // construct one orthogonal vector
   if (Reference != NULL)
+  if (Reference != NULL) {
     AngleZero.CopyVector(Reference);
+    AngleZero.SubtractVector(Point->node);
+    AngleZero.ProjectOntoPlane(&PlaneNormal);
+  }
+  if ((Reference == NULL) || (AngleZero.NormSquared() < MYEPSILON )) {
+    *out << Verbose(4) << "Using alternatively " << *(*connectedPoints->begin())->node << " as angle 0 referencer." << endl;
+    AngleZero.CopyVector((*connectedPoints->begin())->node);
+    AngleZero.SubtractVector(Point->node);
+    AngleZero.ProjectOntoPlane(&PlaneNormal);
+    if (AngleZero.NormSquared() < MYEPSILON) {
+      cerr << Verbose(0) << "CRITIAL: AngleZero is 0 even with alternative reference. The algorithm has to be changed here!" << endl;
+      performCriticalExit();
+    }
+  }
+  *out << Verbose(4) << "INFO: Reference vector on this plane representing angle 0 is " << AngleZero << "." << endl;
+  if (AngleZero.NormSquared() > MYEPSILON)
+    OrthogonalVector.MakeNormalVector(&PlaneNormal, &AngleZero);
   else
+    AngleZero.CopyVector((*connectedPoints->begin())->node);
+  AngleZero.SubtractVector(Point->node);
+  AngleZero.ProjectOntoPlane(&PlaneNormal);
+  *out << Verbose(4) << "INFO: Reference vector on this plane representing angle 0 is " << AngleZero << "." << endl;
+  OrthogonalVector.MakeNormalVector(&PlaneNormal, &AngleZero);
+    OrthogonalVector.MakeNormalVector(&PlaneNormal);
   *out << Verbose(4) << "INFO: OrthogonalVector on plane is " << OrthogonalVector << "." << endl;
 …
   delete(connectedPoints);
+  *out << Verbose(2) << "End of GetCircleOfConnectedPoints" << endl;
   return connectedCircle;
+}
 …
  * @return list of the all points linked to the provided one
  */
 list<list<TesselPoint*> *> * Tesselation::GetPathsOfConnectedPoints(ofstream *out, TesselPoint* Point)
+list<list<TesselPoint*> *> * Tesselation::GetPathsOfConnectedPoints(ofstream *out, const TesselPoint* const Point) const
+{
   map<double, TesselPoint*> anglesOfPoints;
 …
   // find the respective boundary point
   PointMap::iterator PointRunner = PointsOnBoundary.find(Point->nr);
+  PointMap::const_iterator PointRunner = PointsOnBoundary.find(Point->nr);
   if (PointRunner != PointsOnBoundary.end()) {
     ReferencePoint = PointRunner->second;
 …
  * @return list of the closed paths
  */
 list<list<TesselPoint*> *> * Tesselation::GetClosedPathsOfConnectedPoints(ofstream *out, TesselPoint* Point)
+list<list<TesselPoint*> *> * Tesselation::GetClosedPathsOfConnectedPoints(ofstream *out, const TesselPoint* const Point) const
+{
   list<list<TesselPoint*> *> *ListofPaths = GetPathsOfConnectedPoints(out, Point);
 …
  * \return pointer to allocated list of triangles
  */
 set<BoundaryTriangleSet*> *Tesselation::GetAllTriangles(ofstream *out, class BoundaryPointSet *Point)
+set<BoundaryTriangleSet*> *Tesselation::GetAllTriangles(ofstream *out, const BoundaryPointSet * const Point) const
+{
   set<BoundaryTriangleSet*> *connectedTriangles = new set<BoundaryTriangleSet*>;
 …
   } else {
     // go through its lines and insert all triangles
     for (LineMap::iterator LineRunner = Point->lines.begin(); LineRunner != Point->lines.end(); LineRunner++)
+    for (LineMap::const_iterator LineRunner = Point->lines.begin(); LineRunner != Point->lines.end(); LineRunner++)
       for (TriangleMap::iterator TriangleRunner = (LineRunner->second)->triangles.begin(); TriangleRunner != (LineRunner->second)->triangles.end(); TriangleRunner++) {
       connectedTriangles->insert(TriangleRunner->second);
 …
         AddTesselationTriangle();
         // calculate volume summand as a general tetraeder
         volume += CalculateVolumeofGeneralTetraeder(TPS[0]->node->node, TPS[1]->node->node, TPS[2]->node->node, &OldPoint);
+        volume += CalculateVolumeofGeneralTetraeder(*TPS[0]->node->node, *TPS[1]->node->node, *TPS[2]->node->node, OldPoint);
         // advance number
         count++;
 …
  *         will usually be one, in case of degeneration, there will be two
  */
 list<BoundaryTriangleSet*> *Tesselation::FindTriangles(TesselPoint* Points[3])
+list<BoundaryTriangleSet*> *Tesselation::FindTriangles(const TesselPoint* const Points[3]) const
+{
   list<BoundaryTriangleSet*> *result = new list<BoundaryTriangleSet*>;
+  LineMap::iterator FindLine;
+  PointMap::iterator FindPoint;
+  TriangleMap::iterator FindTriangle;
+  LineMap::const_iterator FindLine;
+  TriangleMap::const_iterator FindTriangle;
   class BoundaryPointSet *TrianglePoints[3];
   for (int i = 0; i < 3; i++) {
     FindPoint = PointsOnBoundary.find(Points[i]->nr);
+    PointMap::const_iterator FindPoint = PointsOnBoundary.find(Points[i]->nr);
     if (FindPoint != PointsOnBoundary.end()) {
       TrianglePoints[i] = FindPoint->second;
 …
   for (int i = 0; i < 3; i++) {
     if (TrianglePoints[i] != NULL) {
       for (int j = i; j < 3; j++) {
+      for (int j = i+1; j < 3; j++) {
         if (TrianglePoints[j] != NULL) {
           FindLine = TrianglePoints[i]->lines.find(TrianglePoints[j]->node->nr);
           if (FindLine != TrianglePoints[i]->lines.end()) {
             for (; FindLine->first == TrianglePoints[j]->node->nr; FindLine++) {
               FindTriangle = FindLine->second->triangles.begin();
               for (; FindTriangle != FindLine->second->triangles.end(); FindTriangle++) {
                 if (FindTriangle->second->IsPresentTupel(TrianglePoints)) {
                   result->push_back(FindTriangle->second);
+                }
+          for (FindLine = TrianglePoints[i]->lines.find(TrianglePoints[j]->node->nr); // is a multimap!
+              (FindLine != TrianglePoints[i]->lines.end()) && (FindLine->first == TrianglePoints[j]->node->nr);
+              FindLine++) {
+            for (FindTriangle = FindLine->second->triangles.begin();
+                FindTriangle != FindLine->second->triangles.end();
+                FindTriangle++) {
+              if (FindTriangle->second->IsPresentTupel(TrianglePoints)) {
+                result->push_back(FindTriangle->second);
+              }
+            }
-            // Is it sufficient to consider one of the triangle lines for this.
-            return result;
+          }
+          // Is it sufficient to consider one of the triangle lines for this.
+          return result;
+        }
+      }
 …
  * \param *cloud PointCloud structure with all nodes
  */
 void Tesselation::Output(ofstream *out, const char *filename, PointCloud *cloud)
+void Tesselation::Output(ofstream *out, const char *filename, const PointCloud * const cloud)
+{
   ofstream *tempstream = NULL;

src/tesselation.hpp

-              r06c7a3
+              r7326b2
 #include <set>
+#include "atom_particleinfo.hpp"
+#include "helpers.hpp"
 #include "vector.hpp"
 …
   public:
     BoundaryPointSet();
     BoundaryPointSet(TesselPoint *Walker);
+    BoundaryPointSet(TesselPoint * Walker);
     ~BoundaryPointSet();
 …
 };
 ostream & operator << (ostream &ost, BoundaryPointSet &a);
+ostream & operator << (ostream &ost, const BoundaryPointSet &a);
 // ======================================================== class BoundaryLineSet ==========================================
 …
   public:
     BoundaryLineSet();
     BoundaryLineSet(class BoundaryPointSet *Point[2], int number);
+    BoundaryLineSet(class BoundaryPointSet *Point[2], const int number);
     ~BoundaryLineSet();
 …
 };
 ostream & operator << (ostream &ost, BoundaryLineSet &a);
+ostream & operator << (ostream &ost, const BoundaryLineSet &a);
 // ======================================================== class BoundaryTriangleSet =======================================
 …
 };
 ostream & operator << (ostream &ost, BoundaryTriangleSet &a);
+ostream & operator << (ostream &ost, const BoundaryTriangleSet &a);
 // =========================================================== class TESSELPOINT ===========================================
 …
 /** Is a single point of the set of Vectors, also a super-class to be inherited and and its functions to be implemented.
  */
 class TesselPoint {
+class TesselPoint : virtual public ParticleInfo {
 public:
   TesselPoint();
 …
   Vector *node;   // pointer to position of the dot in space
-  int nr;       // index to easierly identify
-  char *Name;   // some name to reference to on output
   virtual ostream & operator << (ostream &ost);
 …
   virtual ~PointCloud();
   virtual Vector *GetCenter(ofstream *out) { return NULL; };
   virtual TesselPoint *GetPoint() { return NULL; };
   virtual TesselPoint *GetTerminalPoint() { return NULL; };
   virtual void GoToNext() {};
   virtual void GoToPrevious() {};
   virtual void GoToFirst() {};
   virtual void GoToLast() {};
   virtual bool IsEmpty() { return false; };
   virtual bool IsEnd() { return false; };
+  virtual Vector *GetCenter(ofstream *out) const { return NULL; };
+  virtual TesselPoint *GetPoint() const { return NULL; };
+  virtual TesselPoint *GetTerminalPoint() const { return NULL; };
+  virtual void GoToNext() const {};
+  virtual void GoToPrevious() const {};
+  virtual void GoToFirst() const {};
+  virtual void GoToLast() const {};
+  virtual bool IsEmpty() const { return false; };
+  virtual bool IsEnd() const { return false; };
 };
 …
     virtual ~Tesselation();
     void AddTesselationPoint(TesselPoint* Candidate, int n);
     void AddTesselationLine(class BoundaryPointSet *a, class BoundaryPointSet *b, int n);
     void AlwaysAddTesselationTriangleLine(class BoundaryPointSet *a, class BoundaryPointSet *b, int n);
+    void AddTesselationPoint(TesselPoint* Candidate, const int n);
+    void AddTesselationLine(class BoundaryPointSet *a, class BoundaryPointSet *b, const int n);
+    void AlwaysAddTesselationTriangleLine(class BoundaryPointSet *a, class BoundaryPointSet *b, const int n);
     void AddTesselationTriangle();
     void AddTesselationTriangle(int nr);
+    void AddTesselationTriangle(const int nr);
     void RemoveTesselationTriangle(class BoundaryTriangleSet *triangle);
     void RemoveTesselationLine(class BoundaryLineSet *line);
     void RemoveTesselationPoint(class BoundaryPointSet *point);
-    class BoundaryPointSet *GetCommonEndpoint(class BoundaryLineSet * line1, class BoundaryLineSet * line2);
     // concave envelope
     void FindStartingTriangle(ofstream *out, const double RADIUS, class LinkedCell *LC);
     void FindSecondPointForTesselation(class TesselPoint* a, Vector Oben, class TesselPoint*& OptCandidate, double Storage[3], double RADIUS, class LinkedCell *LC);
     void FindThirdPointForTesselation(Vector NormalVector, Vector SearchDirection, Vector OldSphereCenter, class BoundaryLineSet *BaseLine, class TesselPoint *ThirdNode, CandidateList* &candidates, double *ShortestAngle, const double RADIUS, class LinkedCell *LC);
     bool FindNextSuitableTriangle(ofstream *out, BoundaryLineSet &Line, BoundaryTriangleSet &T, const double& RADIUS, LinkedCell *LC);
+    void FindStartingTriangle(ofstream *out, const double RADIUS, const LinkedCell *LC);
+    void FindSecondPointForTesselation(class TesselPoint* a, Vector Oben, class TesselPoint*& OptCandidate, double Storage[3], double RADIUS, const LinkedCell *LC);
+    void FindThirdPointForTesselation(Vector NormalVector, Vector SearchDirection, Vector OldSphereCenter, class BoundaryLineSet *BaseLine, class TesselPoint *ThirdNode, CandidateList* &candidates, double *ShortestAngle, const double RADIUS, const LinkedCell *LC);
+    bool FindNextSuitableTriangle(ofstream *out, BoundaryLineSet &Line, BoundaryTriangleSet &T, const double& RADIUS, const LinkedCell *LC);
     int CheckPresenceOfTriangle(ofstream *out, class TesselPoint *Candidates[3]);
     class BoundaryTriangleSet * GetPresentTriangle(ofstream *out, TesselPoint *Candidates[3]);
     // convex envelope
     void TesselateOnBoundary(ofstream *out, PointCloud *cloud);
+    void TesselateOnBoundary(ofstream *out, const PointCloud * const cloud);
     void GuessStartingTriangle(ofstream *out);
     bool InsertStraddlingPoints(ofstream *out, PointCloud *cloud, LinkedCell *LC);
+    bool InsertStraddlingPoints(ofstream *out, const PointCloud *cloud, const LinkedCell *LC);
     double RemovePointFromTesselatedSurface(ofstream *out, class BoundaryPointSet *point);
     class BoundaryLineSet * FlipBaseline(ofstream *out, class BoundaryLineSet *Base);
 …
     void AddBoundaryPointByDegeneratedTriangle(ofstream *out, class TesselPoint *point, LinkedCell *LC);
+    set<TesselPoint*> * GetAllConnectedPoints(ofstream *out, TesselPoint* Point);
+    set<BoundaryTriangleSet*> *GetAllTriangles(ofstream *out, class BoundaryPointSet *Point);
+    list<list<TesselPoint*> *> * GetPathsOfConnectedPoints(ofstream *out, TesselPoint* Point);
+    list<list<TesselPoint*> *> * GetClosedPathsOfConnectedPoints(ofstream *out, TesselPoint* Point);
+    list<TesselPoint*> * GetCircleOfConnectedPoints(ofstream *out, TesselPoint* Point, Vector *Reference = NULL);
+    list<BoundaryTriangleSet*> *FindTriangles(TesselPoint* Points[3]);
+    list<BoundaryTriangleSet*> * FindClosestTrianglesToPoint(ofstream *out, Vector *x, LinkedCell* LC);
+    class BoundaryTriangleSet * FindClosestTriangleToPoint(ofstream *out, Vector *x, LinkedCell* LC);
+    bool IsInnerPoint(ofstream *out, Vector Point, LinkedCell* LC);
+    bool IsInnerPoint(ofstream *out, TesselPoint *Point, LinkedCell* LC);
+    bool AddBoundaryPoint(TesselPoint *Walker, int n);
+    set<TesselPoint*> * GetAllConnectedPoints(ofstream *out, const TesselPoint* const Point) const;
+    set<BoundaryTriangleSet*> *GetAllTriangles(ofstream *out, const BoundaryPointSet * const Point) const;
+    list<list<TesselPoint*> *> * GetPathsOfConnectedPoints(ofstream *out, const TesselPoint* const Point) const;
+    list<list<TesselPoint*> *> * GetClosedPathsOfConnectedPoints(ofstream *out, const TesselPoint* const Point) const;
+    list<TesselPoint*> * GetCircleOfConnectedPoints(ofstream *out, const TesselPoint* const Point, const Vector * const Reference = NULL) const;
+    class BoundaryPointSet *GetCommonEndpoint(const BoundaryLineSet * line1, const BoundaryLineSet * line2) const;
+    list<BoundaryTriangleSet*> *FindTriangles(const TesselPoint* const Points[3]) const;
+    list<BoundaryTriangleSet*> * FindClosestTrianglesToPoint(ofstream *out, const Vector *x, const LinkedCell* LC) const;
+    class BoundaryTriangleSet * FindClosestTriangleToPoint(ofstream *out, const Vector *x, const LinkedCell* LC) const;
+    bool IsInnerPoint(ofstream *out, const Vector &Point, const LinkedCell* const LC) const;
+    bool IsInnerPoint(ofstream *out, const TesselPoint * const Point, const LinkedCell* const LC) const;
+    bool AddBoundaryPoint(TesselPoint * Walker, const int n);
     // print for debugging
     void PrintAllBoundaryPoints(ofstream *out);
     void PrintAllBoundaryLines(ofstream *out);
     void PrintAllBoundaryTriangles(ofstream *out);
+    void PrintAllBoundaryPoints(ofstream *out) const;
+    void PrintAllBoundaryLines(ofstream *out) const;
+    void PrintAllBoundaryTriangles(ofstream *out) const;
     // store envelope in file
     void Output(ofstream *out, const char *filename, PointCloud *cloud);
+    void Output(ofstream *out, const char *filename, const PointCloud * const cloud);
     PointMap PointsOnBoundary;
 …
     // PointCloud implementation for PointsOnBoundary
     virtual Vector *GetCenter(ofstream *out);
     virtual TesselPoint *GetPoint();
     virtual TesselPoint *GetTerminalPoint();
     virtual void GoToNext();
     virtual void GoToPrevious();
     virtual void GoToFirst();
     virtual void GoToLast();
     virtual bool IsEmpty();
     virtual bool IsEnd();
+    virtual Vector *GetCenter(ofstream *out) const;
+    virtual TesselPoint *GetPoint() const;
+    virtual TesselPoint *GetTerminalPoint() const;
+    virtual void GoToNext() const;
+    virtual void GoToPrevious() const;
+    virtual void GoToFirst() const;
+    virtual void GoToLast() const;
+    virtual bool IsEmpty() const;
+    virtual bool IsEnd() const;
     class BoundaryPointSet *BPS[2];
 …
     class BoundaryPointSet *TPS[3]; //this is a Storage for pointers to triangle points, this and BPS[2] needed due to AddLine restrictions
     PointMap::iterator InternalPointer;
+    mutable PointMap::const_iterator InternalPointer;
 };

src/tesselationhelpers.cpp

-              r06c7a3
+              r7326b2
 #include "verbose.hpp"
 double DetGet(gsl_matrix *A, int inPlace) {
+double DetGet(gsl_matrix * const A, const int inPlace) {
   /*
   inPlace = 1 => A is replaced with the LU decomposed copy.
 …
 };
 void GetSphere(Vector *center, Vector &a, Vector &b, Vector &c, double RADIUS)
+void GetSphere(Vector * const center, const Vector &a, const Vector &b, const Vector &c, const double RADIUS)
+{
   gsl_matrix *A = gsl_matrix_calloc(3,3);
 …
  * @param b vector second point of triangle
  * @param c vector third point of triangle
  * @param *Umkreismittelpunkt new cneter point of circumference
+ * @param *Umkreismittelpunkt new center point of circumference
  * @param Direction vector indicates up/down
  * @param AlternativeDirection vecotr, needed in case the triangles have 90 deg angle
+ * @param AlternativeDirection Vector, needed in case the triangles have 90 deg angle
  * @param Halfplaneindicator double indicates whether Direction is up or down
  * @param AlternativeIndicator doube indicates in case of orthogonal triangles which direction of AlternativeDirection is suitable
+ * @param AlternativeIndicator double indicates in case of orthogonal triangles which direction of AlternativeDirection is suitable
  * @param alpha double angle at a
  * @param beta double, angle at b
 …
  * @param Umkreisradius double radius of circumscribing circle
  */
 void GetCenterOfSphere(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)
+void GetCenterOfSphere(Vector* const & Center, const Vector &a, const Vector &b, const Vector &c, Vector * const NewUmkreismittelpunkt, const Vector* const Direction, const Vector* const AlternativeDirection,
+    const double HalfplaneIndicator, const double AlternativeIndicator, const double alpha, const double beta, const double gamma, const double RADIUS, const double Umkreisradius)
+{
   Vector TempNormal, helper;
 …
  * \param *c third point
  */
 void GetCenterofCircumcircle(Vector *Center, Vector *a, Vector *b, Vector *c)
+void GetCenterofCircumcircle(Vector * const Center, const Vector &a, const Vector &b, const Vector &c)
+{
   Vector helper;
 …
   Vector SideA, SideB, SideC;
   SideA.CopyVector(b);
   SideA.SubtractVector(c);
+  SideA.SubtractVector(&c);
   SideB.CopyVector(c);
   SideB.SubtractVector(a);
+  SideB.SubtractVector(&a);
   SideC.CopyVector(a);
   SideC.SubtractVector(b);
+  SideC.SubtractVector(&b);
   alpha = M_PI - SideB.Angle(&SideC);
   beta = M_PI - SideC.Angle(&SideA);
 …
  * \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)
+double GetPathLengthonCircumCircle(const Vector &CircleCenter, const Vector &CirclePlaneNormal, const double CircleRadius, const Vector &NewSphereCenter, const Vector &OldSphereCenter, const Vector &NormalVector, const Vector &SearchDirection)
+{
   Vector helper;
 …
  * @return true if there is an intersection between the given lines, false otherwise
  */
 bool existsIntersection(Vector point1, Vector point2, Vector point3, Vector point4)
+bool existsIntersection(const Vector &point1, const Vector &point2, const Vector &point3, const Vector &point4)
+{
   bool result;
 …
  * @return angle between point and reference
  */
 double GetAngle(const Vector &point, const Vector &reference, const Vector OrthogonalVector)
+double GetAngle(const Vector &point, const Vector &reference, const Vector &OrthogonalVector)
+{
   if (reference.IsZero())
 …
  * \return \f$ \frac{1}{6} \cdot ((a-d) \times (a-c) \cdot  (a-b)) \f$
  */
 double CalculateVolumeofGeneralTetraeder(Vector *a, Vector *b, Vector *c, Vector *d)
+double CalculateVolumeofGeneralTetraeder(const Vector &a, const Vector &b, const Vector &c, const Vector &d)
+{
   Vector Point, TetraederVector[3];
 …
   TetraederVector[2].CopyVector(c);
   for (int j=0;j<3;j++)
     TetraederVector[j].SubtractVector(d);
+    TetraederVector[j].SubtractVector(&d);
   Point.CopyVector(&TetraederVector[0]);
   Point.VectorProduct(&TetraederVector[1]);
 …
  * \return true - there is such a line (i.e. creation of degenerated triangle is valid), false - no such line (don't create)
  */
 bool CheckLineCriteriaForDegeneratedTriangle(class BoundaryPointSet *nodes[3])
+bool CheckLineCriteriaForDegeneratedTriangle(const BoundaryPointSet * const nodes[3])
+{
   bool result = false;
 …
     for (int j=i+1; j<3; j++) {
       if (nodes[i]->lines.find(nodes[j]->node->nr) != nodes[i]->lines.end()) {  // there already is a line
         LineMap::iterator FindLine;
         pair<LineMap::iterator,LineMap::iterator> FindPair;
+        LineMap::const_iterator FindLine;
+        pair<LineMap::const_iterator,LineMap::const_iterator> FindPair;
         FindPair = nodes[i]->lines.equal_range(nodes[j]->node->nr);
         for (FindLine = FindPair.first; FindLine != FindPair.second; ++FindLine) {
 …
 /** Sort function for the candidate list.
  */
 bool SortCandidates(CandidateForTesselation* candidate1, CandidateForTesselation* candidate2)
+bool SortCandidates(const CandidateForTesselation* candidate1, const CandidateForTesselation* candidate2)
+{
   Vector BaseLineVector, OrthogonalVector, helper;
 …
  * @return point which is second closest to the provided one
  */
+TesselPoint* FindSecondClosestPoint(const Vector* Point, LinkedCell* LC)
+{
+  LinkedNodes *List = NULL;
+TesselPoint* FindSecondClosestPoint(const Vector* Point, const LinkedCell* const LC)
+{
   TesselPoint* closestPoint = NULL;
   TesselPoint* secondClosestPoint = NULL;
 …
     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();
+        const LinkedNodes *List = LC->GetCurrentCell();
         //cout << Verbose(3) << "The current cell " << LC->n[0] << "," << LC->n[1] << "," << LC->n[2] << endl;
         if (List != NULL) {
           for (LinkedNodes::iterator Runner = List->begin(); Runner != List->end(); Runner++) {
+          for (LinkedNodes::const_iterator Runner = List->begin(); Runner != List->end(); Runner++) {
             helper.CopyVector(Point);
             helper.SubtractVector((*Runner)->node);
 …
  * @return point which is closest to the provided one, NULL if none found
  */
+TesselPoint* FindClosestPoint(const Vector* Point, TesselPoint *&SecondPoint, LinkedCell* LC)
+{
+  LinkedNodes *List = NULL;
+TesselPoint* FindClosestPoint(const Vector* Point, TesselPoint *&SecondPoint, const LinkedCell* const LC)
+{
   TesselPoint* closestPoint = NULL;
   SecondPoint = NULL;
 …
     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();
+        const LinkedNodes *List = LC->GetCurrentCell();
         //cout << Verbose(3) << "The current cell " << LC->n[0] << "," << LC->n[1] << "," << LC->n[2] << endl;
         if (List != NULL) {
           for (LinkedNodes::iterator Runner = List->begin(); Runner != List->end(); Runner++) {
+          for (LinkedNodes::const_iterator Runner = List->begin(); Runner != List->end(); Runner++) {
             helper.CopyVector(Point);
             helper.SubtractVector((*Runner)->node);
 …
+        }
+      }
+  // output
+  if (closestPoint != NULL) {
+    cout << Verbose(2) << "Closest point is " << *closestPoint;
+    if (SecondPoint != NULL)
+      cout << " and second closest is " << *SecondPoint;
+    cout << "." << endl;
+  }
   return closestPoint;
 };
 …
  * \return Vector on reference line that has closest distance
  */
 Vector * GetClosestPointBetweenLine(ofstream *out, class BoundaryLineSet *Base, class BoundaryLineSet *OtherBase)
+Vector * GetClosestPointBetweenLine(ofstream *out, const BoundaryLineSet * const Base, const BoundaryLineSet * const OtherBase)
+{
   // construct the plane of the two baselines (i.e. take both their directional vectors)
 …
  * \return distance between \a *x and plane defined by \a *triangle, -1 - if something went wrong
  */
 double DistanceToTrianglePlane(ofstream *out, Vector *x, BoundaryTriangleSet *triangle)
+double DistanceToTrianglePlane(ofstream * const out, const Vector *x, const BoundaryTriangleSet * const triangle)
+{
   double distance = 0.;
 …
  * \param *mol molecule structure with atom positions
  */
 void WriteVrmlFile(ofstream *out, ofstream *vrmlfile, class Tesselation *Tess, PointCloud *cloud)
+void WriteVrmlFile(ofstream * const out, ofstream * const vrmlfile, const Tesselation * const Tess, const PointCloud * const cloud)
+{
   TesselPoint *Walker = NULL;
 …
     *vrmlfile << "# All tesselation triangles" << endl;
     for (TriangleMap::iterator TriangleRunner = Tess->TrianglesOnBoundary.begin(); TriangleRunner != Tess->TrianglesOnBoundary.end(); TriangleRunner++) {
+    for (TriangleMap::const_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
 …
  * \param *mol molecule structure with atom positions
  */
 void IncludeSphereinRaster3D(ofstream *out, ofstream *rasterfile, class Tesselation *Tess, PointCloud *cloud)
+void IncludeSphereinRaster3D(ofstream * const out, ofstream * const rasterfile, const Tesselation * const Tess, const PointCloud * const cloud)
+{
   Vector helper;
 …
  * \param *mol molecule structure with atom positions
  */
 void WriteRaster3dFile(ofstream *out, ofstream *rasterfile, class Tesselation *Tess, PointCloud *cloud)
+void WriteRaster3dFile(ofstream * const out, ofstream * const rasterfile, const Tesselation * const Tess, const PointCloud * const cloud)
+{
   TesselPoint *Walker = NULL;
 …
     *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++) {
+    for (TriangleMap::const_iterator TriangleRunner = Tess->TrianglesOnBoundary.begin(); TriangleRunner != Tess->TrianglesOnBoundary.end(); TriangleRunner++) {
       *rasterfile << "1" << endl << "  ";  // 1 is triangle type
       for (i=0;i<3;i++) {  // print each node
 …
  * \param N arbitrary number to differentiate various zones in the tecplot format
  */
 void WriteTecplotFile(ofstream *out, ofstream *tecplot, class Tesselation *TesselStruct, PointCloud *cloud, int N)
+void WriteTecplotFile(ofstream * const out, ofstream * const tecplot, const Tesselation * const TesselStruct, const PointCloud * const cloud, const int N)
+{
   if ((tecplot != NULL) && (TesselStruct != NULL)) {
 …
     int Counter = 1;
     TesselPoint *Walker = NULL;
     for (PointMap::iterator target = TesselStruct->PointsOnBoundary.begin(); target != TesselStruct->PointsOnBoundary.end(); target++) {
+    for (PointMap::const_iterator target = TesselStruct->PointsOnBoundary.begin(); target != TesselStruct->PointsOnBoundary.end(); target++) {
       Walker = target->second->node;
       LookupList[Walker->nr] = Counter++;
 …
     *tecplot << endl;
     // print connectivity
     for (TriangleMap::iterator runner = TesselStruct->TrianglesOnBoundary.begin(); runner != TesselStruct->TrianglesOnBoundary.end(); runner++) {
+    for (TriangleMap::const_iterator runner = TesselStruct->TrianglesOnBoundary.begin(); runner != TesselStruct->TrianglesOnBoundary.end(); runner++) {
       *out << " " << runner->second->endpoints[0]->node->Name << "<->" << runner->second->endpoints[1]->node->Name << "<->" << runner->second->endpoints[2]->node->Name;
       *tecplot << LookupList[runner->second->endpoints[0]->node->nr] << " " << LookupList[runner->second->endpoints[1]->node->nr] << " " << LookupList[runner->second->endpoints[2]->node->nr] << endl;
 …
  * \param *TesselStruct pointer to Tesselation structure
  */
 void CalculateConcavityPerBoundaryPoint(ofstream *out, class Tesselation *TesselStruct)
+void CalculateConcavityPerBoundaryPoint(ofstream * const out, const Tesselation * const TesselStruct)
+{
   class BoundaryPointSet *point = NULL;
 …
   //*out << Verbose(2) << "Begin of CalculateConcavityPerBoundaryPoint" << endl;
   // calculate remaining concavity
   for (PointMap::iterator PointRunner = TesselStruct->PointsOnBoundary.begin(); PointRunner != TesselStruct->PointsOnBoundary.end(); PointRunner++) {
+  for (PointMap::const_iterator PointRunner = TesselStruct->PointsOnBoundary.begin(); PointRunner != TesselStruct->PointsOnBoundary.end(); PointRunner++) {
     point = PointRunner->second;
     *out << Verbose(1) << "INFO: Current point is " << *point << "." << endl;
 …
  * \return true - all have exactly two triangles, false - some not, list is printed to screen
  */
 bool CheckListOfBaselines(ofstream *out, Tesselation *TesselStruct)
+{
   LineMap::iterator testline;
+bool CheckListOfBaselines(ofstream * const out, const Tesselation * const TesselStruct)
+{
+  LineMap::const_iterator testline;
   bool result = false;
   int counter = 0;

src/tesselationhelpers.hpp

-              r06c7a3
+              r7326b2
 /********************************************** declarations *******************************/
 double DetGet(gsl_matrix *A, int inPlace);
 void GetSphere(Vector *center, Vector &a, Vector &b, Vector &c, double RADIUS);
 void GetCenterOfSphere(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);
 void GetCenterofCircumcircle(Vector *Center, Vector *a, Vector *b, Vector *c);
 double GetPathLengthonCircumCircle(Vector &CircleCenter, Vector &CirclePlaneNormal, double CircleRadius, Vector &NewSphereCenter, Vector &OldSphereCenter, Vector &NormalVector, Vector &SearchDirection);
+double DetGet(gsl_matrix * const A, const int inPlace);
+void GetSphere(Vector * const Center, const Vector &a, const Vector &b, const Vector &c, const double RADIUS);
+void GetCenterOfSphere(Vector* const Center, const Vector &a, const Vector &b, const Vector &c, Vector * const NewUmkreismittelpunkt, const Vector* const Direction, const Vector* const AlternativeDirection, const double HalfplaneIndicator, const double AlternativeIndicator, const double alpha, const double beta, const double gamma, const double RADIUS, const double Umkreisradius);
+void GetCenterofCircumcircle(Vector * const Center, const Vector &a, const Vector &b, const Vector &c);
+double GetPathLengthonCircumCircle(const Vector &CircleCenter, const Vector &CirclePlaneNormal, const double CircleRadius, const Vector &NewSphereCenter, const Vector &OldSphereCenter, const Vector &NormalVector, const Vector &SearchDirection);
 double MinIntersectDistance(const gsl_vector * x, void *params);
 bool existsIntersection(Vector point1, Vector point2, Vector point3, Vector point4);
 double CalculateVolumeofGeneralTetraeder(Vector *a, Vector *b, Vector *c, Vector *d);
 double GetAngle(const Vector &point, const Vector &reference, const Vector OrthogonalVector);
+bool existsIntersection(const Vector &point1, const Vector &point2, const Vector &point3, const Vector &point4);
+double CalculateVolumeofGeneralTetraeder(const Vector &a, const Vector &b, const Vector &c, const Vector &d);
+double GetAngle(const Vector &point, const Vector &reference, const Vector &OrthogonalVector);
 bool CheckLineCriteriaForDegeneratedTriangle(class BoundaryPointSet *nodes[3]);
 bool SortCandidates(class CandidateForTesselation* candidate1, class CandidateForTesselation* candidate2);
 TesselPoint* FindClosestPoint(const Vector* Point, TesselPoint *&SecondPoint, LinkedCell* LC);
 TesselPoint* FindSecondClosestPoint(const Vector*, LinkedCell*);
 Vector * GetClosestPointBetweenLine(ofstream *out, class BoundaryLineSet *Base, class BoundaryLineSet *OtherBase);
+bool CheckLineCriteriaForDegeneratedTriangle(const BoundaryPointSet * const nodes[3]);
+bool SortCandidates(const CandidateForTesselation* candidate1, const CandidateForTesselation *candidate2);
+TesselPoint* FindClosestPoint(const Vector* Point, TesselPoint *&SecondPoint, const LinkedCell* const LC);
+TesselPoint* FindSecondClosestPoint(const Vector*, const LinkedCell* const LC);
+Vector * GetClosestPointBetweenLine(ofstream *out, const BoundaryLineSet * const Base, const BoundaryLineSet * const OtherBase);
 void WriteTecplotFile(ofstream *out, ofstream *tecplot, class Tesselation *TesselStruct, PointCloud *cloud, int N);
 void WriteRaster3dFile(ofstream *out, ofstream *rasterfile, class Tesselation *Tess, PointCloud *cloud);
 void IncludeSphereinRaster3D(ofstream *out, ofstream *rasterfile, class Tesselation *Tess, PointCloud *cloud);
 void WriteVrmlFile(ofstream *out, ofstream *vrmlfile, class Tesselation *Tess, PointCloud *cloud);
 void CalculateConcavityPerBoundaryPoint(ofstream *out, class Tesselation *TesselStruct);
 double DistanceToTrianglePlane(ofstream *out, Vector *x, BoundaryTriangleSet *triangle);
+void WriteTecplotFile(ofstream * const out, ofstream * const tecplot, const Tesselation * const TesselStruct, const PointCloud * const cloud, const int N);
+void WriteRaster3dFile(ofstream * const out, ofstream * const rasterfile, const Tesselation * const Tess, const PointCloud * const cloud);
+void IncludeSphereinRaster3D(ofstream * const out, ofstream * const rasterfile, const Tesselation *Tess, const PointCloud *cloud);
+void WriteVrmlFile(ofstream * const out, ofstream * const vrmlfile, const Tesselation * const Tess, const PointCloud * const cloud);
+void CalculateConcavityPerBoundaryPoint(ofstream * const out, const Tesselation * const TesselStruct);
+double DistanceToTrianglePlane(ofstream * const out, const Vector *x, const BoundaryTriangleSet * const triangle);
 bool CheckListOfBaselines(ofstream *out, Tesselation *TesselStruct);
+bool CheckListOfBaselines(ofstream * const out, const Tesselation * const TesselStruct);

src/unittests/ActOnAllUnitTest.cpp

-              r06c7a3
+              r7326b2
 #include <cppunit/ui/text/TestRunner.h>
 #include "ActOnAlltest.hpp"
+#include "../test/ActOnAlltest.hpp"
 #include "ActOnAllUnitTest.hpp"
 #include "memoryallocator.hpp"
 …
   // scaling by value
   VL.ActOnAll( (void (Vector::*)(double)) &Vector::Scale, 2. );
+  VL.ActOnAll( (void (Vector::*)(const double)) &Vector::Scale, 2. );
   CPPUNIT_ASSERT_EQUAL( VL == Ref , false );
   VL.ActOnAll( (void (Vector::*)(double)) &Vector::Scale, 0.5 );
+  VL.ActOnAll( (void (Vector::*)(const double)) &Vector::Scale, 0.5 );
   CPPUNIT_ASSERT_EQUAL( VL == Ref , true );
   // scaling by ref
   VL.ActOnAll( (void (Vector::*)(double *)) &Vector::Scale, &factor );
+  VL.ActOnAll( (void (Vector::*)(const double * const)) &Vector::Scale, (const double * const)&factor );
   CPPUNIT_ASSERT_EQUAL( VL == Ref , false );
   VL.ActOnAll( (void (Vector::*)(double *)) &Vector::Scale, &inverse );
+  VL.ActOnAll( (void (Vector::*)(const double * const)) &Vector::Scale, (const double * const)&inverse );
   CPPUNIT_ASSERT_EQUAL( VL == Ref , true );
 …
     inverses[i] = 1./factors[i];
+  }
   VL.ActOnAll( (void (Vector::*)(double **)) &Vector::Scale, &factors );
+  VL.ActOnAll( (void (Vector::*)(const double ** const)) &Vector::Scale, (const double ** const)&factors );
   CPPUNIT_ASSERT_EQUAL( VL == Ref , false );
   VL.ActOnAll( (void (Vector::*)(double **)) &Vector::Scale, &inverses );
+  VL.ActOnAll( (void (Vector::*)(const double ** const)) &Vector::Scale, (const double ** const)&inverses );
   CPPUNIT_ASSERT_EQUAL( VL == Ref , true );
 };

src/unittests/ActOnAllUnitTest.hpp

r06c7a3	r7326b2
11	11	#include <cppunit/extensions/HelperMacros.h>
12	12
13		#include "ActOnAlltest.hpp"
	13	#include "../test/ActOnAlltest.hpp"
14	14
15	15	/******************************************** Test classes ************************************/

src/unittests/AnalysisCorrelationToPointUnitTest.cpp

-              r06c7a3
+              r7326b2
   // init private all pointers to zero
+  TestList = NULL;
   TestMolecule = NULL;
   hydrogen = NULL;
 …
   hydrogen->Z = 1;
   strcpy(hydrogen->name, "hydrogen");
+  hydrogen->symbol[0] = 'H';
+  strcpy(hydrogen->symbol, "H");
   // construct periodentafel
 …
   CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
+  TestList = new MoleculeListClass;
+  TestMolecule->ActiveFlag = true;
+  TestList->insert(TestMolecule);
   // init point
   point = new Vector(1.,1.,1.);
   // init maps
   pointmap = CorrelationToPoint( (ofstream *)&cout, TestMolecule, hydrogen, point );
+  pointmap = CorrelationToPoint( (ofstream *)&cout, (MoleculeListClass * const)TestList, (const element * const)hydrogen, (const Vector *)point );
   binmap = NULL;
 …
   // remove
   delete(TestMolecule);
+  delete(TestList);
   // note that all the atoms are cleaned by TestMolecule
   delete(point);

src/unittests/AnalysisCorrelationToPointUnitTest.hpp

-              r06c7a3
+              r7326b2
 class element;
+class LinkedCell;
 class molecule;
 class LinkedCell;
+class MoleculeListClass;
 class periodentafel;
 class Tesselation;
 …
 private:
+      MoleculeListClass *TestList;
       molecule *TestMolecule;
       element *hydrogen;

src/unittests/AnalysisCorrelationToSurfaceUnitTest.cpp

-              r06c7a3
+              r7326b2
   // init private all pointers to zero
+  TestList = NULL;
   TestMolecule = NULL;
   hydrogen = NULL;
 …
   LC = NULL;
   // construct element
   hydrogen = new element;
   hydrogen->Z = 1;
   strcpy(hydrogen->name, "hydrogen");
+  hydrogen->symbol[0] = 'H';
+  strcpy(hydrogen->symbol, "H");
+  carbon = new element;
+  carbon->Z = 6;
+  strcpy(carbon->name, "carbon");
+  strcpy(carbon->symbol, "C");
   // construct periodentafel
   tafel = new periodentafel;
   tafel->AddElement(hydrogen);
+  // construct molecule (tetraeder of hydrogens)
+  tafel->AddElement(carbon);
+  // construct molecule (tetraeder of hydrogens) base
   TestMolecule = new molecule(tafel);
   Walker = new atom();
 …
   CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
+  TestList = new MoleculeListClass;
+  TestMolecule->ActiveFlag = true;
+  TestList->insert(TestMolecule);
   // init tesselation and linked cell
   Surface = new Tesselation;
+  TestMolecule->TesselStruct = Surface;
+  FindNonConvexBorder((ofstream *)&cout, TestMolecule, LC, 2.5, NULL);
+  FindNonConvexBorder((ofstream *)&cerr, TestMolecule, Surface, (const LinkedCell *&)LC, 2.5, NULL);
   LC = new LinkedCell(TestMolecule, 5.);
   CPPUNIT_ASSERT_EQUAL( (size_t)4, Surface->PointsOnBoundary.size() );
 …
   CPPUNIT_ASSERT_EQUAL( (size_t)4, Surface->TrianglesOnBoundary.size() );
+  // add outer atoms
+  Walker = new atom();
+  Walker->type = carbon;
+  Walker->node->Init(4., 0., 4. );
+  TestMolecule->AddAtom(Walker);
+  Walker = new atom();
+  Walker->type = carbon;
+  Walker->node->Init(0., 4., 4. );
+  TestMolecule->AddAtom(Walker);
+  Walker = new atom();
+  Walker->type = carbon;
+  Walker->node->Init(4., 4., 0. );
+  TestMolecule->AddAtom(Walker);
+  // add inner atoms
+  Walker = new atom();
+  Walker->type = carbon;
+  Walker->node->Init(0.5, 0.5, 0.5 );
+  TestMolecule->AddAtom(Walker);
   // init maps
   surfacemap = CorrelationToSurface( (ofstream *)&cout, TestMolecule, hydrogen, Surface, LC );
+  surfacemap = NULL;
   binmap = NULL;
 …
   // remove
+  delete(TestMolecule);
+  // note that Surface and all the atoms are cleaned by TestMolecule
+  delete(TestList);
+  delete(Surface);
+  // note that all the atoms are cleaned by TestMolecule
   delete(LC);
   delete(tafel);
 …
+{
   // do the pair correlation
+  surfacemap = CorrelationToSurface( (ofstream *)&cout, TestList, hydrogen, Surface, LC );
   CPPUNIT_ASSERT( surfacemap != NULL );
   CPPUNIT_ASSERT_EQUAL( (size_t)4, surfacemap->size() );
 };
+void AnalysisCorrelationToSurfaceUnitTest::CorrelationToSurfaceBinNoRangeTest()
+{
+  BinPairMap::iterator tester;
+void AnalysisCorrelationToSurfaceUnitTest::CorrelationToSurfaceHydrogenBinNoRangeTest()
+{
+  BinPairMap::iterator tester;
+  surfacemap = CorrelationToSurface( (ofstream *)&cout, TestList, hydrogen, Surface, LC );
   // put pair correlation into bins and check with no range
   binmap = BinData( (ofstream *)&cout, surfacemap, 0.5, 0., 0. );
 …
 };
+void AnalysisCorrelationToSurfaceUnitTest::CorrelationToSurfaceBinRangeTest()
+{
+  BinPairMap::iterator tester;
+void AnalysisCorrelationToSurfaceUnitTest::CorrelationToSurfaceHydrogenBinRangeTest()
+{
+  BinPairMap::iterator tester;
+  surfacemap = CorrelationToSurface( (ofstream *)&cout, TestList, hydrogen, Surface, LC );
   // ... and check with [0., 2.] range
   binmap = BinData( (ofstream *)&cout, surfacemap, 0.5, 0., 2. );
 …
 };
+void AnalysisCorrelationToSurfaceUnitTest::CorrelationToSurfaceCarbonBinNoRangeTest()
+{
+  BinPairMap::iterator tester;
+  surfacemap = CorrelationToSurface( (ofstream *)&cout, TestList, carbon, Surface, LC );
+  // put pair correlation into bins and check with no range
+  binmap = BinData( (ofstream *)&cout, surfacemap, 0.5, 0., 0. );
+  CPPUNIT_ASSERT_EQUAL( (size_t)2, binmap->size() );
+  OutputCorrelation ( (ofstream *)&cout, binmap );
+  // inside point is first and must have negative value
+  tester = binmap->lower_bound(2.95); // start depends on the min value and
+  CPPUNIT_ASSERT( tester != binmap->end() );
+  CPPUNIT_ASSERT_EQUAL( 3, tester->second );
+  // inner point
+  tester = binmap->lower_bound(-0.5);
+  CPPUNIT_ASSERT( tester != binmap->end() );
+  CPPUNIT_ASSERT_EQUAL( 1, tester->second );
+};
+void AnalysisCorrelationToSurfaceUnitTest::CorrelationToSurfaceCarbonBinRangeTest()
+{
+  BinPairMap::iterator tester;
+  surfacemap = CorrelationToSurface( (ofstream *)&cout, TestList, carbon, Surface, LC );
+  // ... and check with [0., 2.] range
+  binmap = BinData( (ofstream *)&cout, surfacemap, 0.5, -2., 4. );
+  CPPUNIT_ASSERT_EQUAL( (size_t)13, binmap->size() );
+  OutputCorrelation ( (ofstream *)&cout, binmap );
+  // three outside points
+  tester = binmap->lower_bound(3.);
+  CPPUNIT_ASSERT( tester != binmap->end() );
+  CPPUNIT_ASSERT_EQUAL( 3, tester->second );
+  // inner point
+  tester = binmap->lower_bound(-0.5);
+  CPPUNIT_ASSERT( tester != binmap->end() );
+  CPPUNIT_ASSERT_EQUAL( 1, tester->second );
+};
 /********************************************** Main routine **************************************/

src/unittests/AnalysisCorrelationToSurfaceUnitTest.hpp

-              r06c7a3
+              r7326b2
 class element;
+class LinkedCell;
 class molecule;
 class LinkedCell;
+class MoleculeListClass;
 class periodentafel;
 class Tesselation;
 …
     CPPUNIT_TEST_SUITE( AnalysisCorrelationToSurfaceUnitTest ) ;
     CPPUNIT_TEST ( CorrelationToSurfaceTest );
+    CPPUNIT_TEST ( CorrelationToSurfaceBinNoRangeTest );
+    CPPUNIT_TEST ( CorrelationToSurfaceBinRangeTest );
+    CPPUNIT_TEST ( CorrelationToSurfaceHydrogenBinNoRangeTest );
+    CPPUNIT_TEST ( CorrelationToSurfaceHydrogenBinRangeTest );
+    CPPUNIT_TEST ( CorrelationToSurfaceCarbonBinNoRangeTest );
+    CPPUNIT_TEST ( CorrelationToSurfaceCarbonBinRangeTest );
     CPPUNIT_TEST_SUITE_END();
 …
       void tearDown();
       void CorrelationToSurfaceTest();
+      void CorrelationToSurfaceBinNoRangeTest();
+      void CorrelationToSurfaceBinRangeTest();
+      void CorrelationToSurfaceHydrogenBinNoRangeTest();
+      void CorrelationToSurfaceHydrogenBinRangeTest();
+      void CorrelationToSurfaceCarbonBinNoRangeTest();
+      void CorrelationToSurfaceCarbonBinRangeTest();
 private:
+      MoleculeListClass *TestList;
       molecule *TestMolecule;
       element *hydrogen;
+      element *carbon;
       periodentafel *tafel;

src/unittests/AnalysisPairCorrelationUnitTest.cpp

-              r06c7a3
+              r7326b2
   // init private all pointers to zero
+  TestList = NULL;
   TestMolecule = NULL;
   hydrogen = NULL;
 …
   hydrogen->Z = 1;
   strcpy(hydrogen->name, "hydrogen");
   hydrogen->symbol[0] = 'H';
+  strcpy(hydrogen->symbol, "H");
   // construct periodentafel
 …
   CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
+  TestList = new MoleculeListClass;
+  TestMolecule->ActiveFlag = true;
+  TestList->insert(TestMolecule);
   // init maps
   correlationmap = PairCorrelation( (ofstream *)&cout, TestMolecule, hydrogen, hydrogen );
+  correlationmap = PairCorrelation( (ofstream *)&cout, TestList, hydrogen, hydrogen );
   binmap = NULL;
 …
   // remove
   delete(TestMolecule);
+  delete(TestList);
   // note that all the atoms are cleaned by TestMolecule
   delete(tafel);

src/unittests/AnalysisPairCorrelationUnitTest.hpp

-              r06c7a3
+              r7326b2
 class element;
+class LinkedCell;
 class molecule;
 class LinkedCell;
+class MoleculeListClass;
 class periodentafel;
 class Tesselation;
 …
 private:
+      MoleculeListClass *TestList;
       molecule *TestMolecule;
       element *hydrogen;

src/unittests/Makefile.am

-              r06c7a3
+              r7326b2
 INCLUDES = -I$(top_srcdir)/src
+noinst_PROGRAMS =  ActOnAllUnitTest AnalysisCorrelationToPointUnitTest AnalysisCorrelationToSurfaceUnitTest AnalysisPairCorrelationUnitTest LogUnitTest MemoryAllocatorUnitTest MemoryUsageObserverUnitTest VectorUnitTest
+AM_LDFLAGS = $(CPPUNIT_LIBS) -ldl
+AM_CXXFLAGS = $(CPPUNIT_CFLAGS)
 TESTS = ActOnAllUnitTest AnalysisCorrelationToPointUnitTest AnalysisCorrelationToSurfaceUnitTest AnalysisPairCorrelationUnitTest MemoryUsageObserverUnitTest MemoryAllocatorUnitTest VectorUnitTest
+TESTS = ActOnAllUnitTest AnalysisCorrelationToPointUnitTest AnalysisCorrelationToSurfaceUnitTest AnalysisPairCorrelationUnitTest BondGraphUnitTest ListOfBondsUnitTest LogUnitTest MemoryUsageObserverUnitTest MemoryAllocatorUnitTest StackClassUnitTest VectorUnitTest
 check_PROGRAMS = $(TESTS)
+noinst_PROGRAMS = $(TESTS)
+ActOnAllUnitTest_SOURCES = ActOnAllTest.hpp ActOnAllUnitTest.cpp ActOnAllUnitTest.hpp memoryallocator.hpp
+ActOnAllUnitTest_CXXFLAGS = $(CPPUNIT_CFLAGS)
+ActOnAllUnitTest_LDFLAGS = $(CPPUNIT_LIBS) -ldl
+ActOnAllUnitTest_LDADD = ../libmolecuilder.a
+ActOnAllUnitTest_SOURCES = ../test/ActOnAllTest.hpp ActOnAllUnitTest.cpp ActOnAllUnitTest.hpp memoryallocator.hpp
 AnalysisCorrelationToPointUnitTest_SOURCES = analysis_correlation.hpp AnalysisCorrelationToPointUnitTest.cpp AnalysisCorrelationToPointUnitTest.hpp
-AnalysisCorrelationToPointUnitTest_CXXFLAGS = $(CPPUNIT_CFLAGS)
-AnalysisCorrelationToPointUnitTest_LDFLAGS = $(CPPUNIT_LIBS) -ldl
 AnalysisCorrelationToPointUnitTest_LDADD = ../libmolecuilder.a
 AnalysisCorrelationToSurfaceUnitTest_SOURCES = analysis_correlation.hpp AnalysisCorrelationToSurfaceUnitTest.cpp AnalysisCorrelationToSurfaceUnitTest.hpp
-AnalysisCorrelationToSurfaceUnitTest_CXXFLAGS = $(CPPUNIT_CFLAGS)
-AnalysisCorrelationToSurfaceUnitTest_LDFLAGS = $(CPPUNIT_LIBS) -ldl
 AnalysisCorrelationToSurfaceUnitTest_LDADD = ../libmolecuilder.a
 AnalysisPairCorrelationUnitTest_SOURCES = analysis_correlation.hpp AnalysisPairCorrelationUnitTest.cpp AnalysisPairCorrelationUnitTest.hpp
-AnalysisPairCorrelationUnitTest_CXXFLAGS = $(CPPUNIT_CFLAGS)
-AnalysisPairCorrelationUnitTest_LDFLAGS = $(CPPUNIT_LIBS) -ldl
 AnalysisPairCorrelationUnitTest_LDADD = ../libmolecuilder.a
+VectorUnitTest_SOURCES = defs.hpp helpers.hpp leastsquaremin.hpp memoryallocator.hpp memoryusageobserver.hpp vectorunittest.cpp vectorunittest.hpp vector.hpp verbose.hpp
+VectorUnitTest_CXXFLAGS = $(CPPUNIT_CFLAGS)
+VectorUnitTest_LDFLAGS = $(CPPUNIT_LIBS) -ldl
+VectorUnitTest_LDADD = ../libmolecuilder.a
+BondGraphUnitTest_SOURCES = bondgraphunittest.cpp bondgraphunittest.hpp
+BondGraphUnitTest_LDADD = ../libmolecuilder.a
+MemoryAllocatorUnitTest_SOURCES = defs.hpp helpers.hpp memoryallocatorunittest.cpp memoryallocatorunittest.hpp memoryallocator.hpp memoryusageobserver.hpp verbose.hpp
+MemoryAllocatorUnitTest_CXXFLAGS = $(CPPUNIT_CFLAGS) -I..
+MemoryAllocatorUnitTest_LDFLAGS = $(CPPUNIT_LIBS) -ldl
+MemoryAllocatorUnitTest_LDADD = ../libmolecuilder.a
+ListOfBondsUnitTest_SOURCES = listofbondsunittest.cpp listofbondsunittest.hpp
+ListOfBondsUnitTest_LDADD = ../libmolecuilder.a
+LogUnitTest_SOURCES = logunittest.cpp logunittest.hpp
+LogUnitTest_LDADD = ../libmolecuilder.a
+MemoryAllocatorUnitTest_SOURCES = defs.hpp ../helpers.cpp ../helpers.hpp memoryallocatorunittest.cpp memoryallocatorunittest.hpp memoryallocator.hpp ../memoryusageobserver.cpp memoryusageobserver.hpp ../verbose.cpp verbose.hpp
 MemoryUsageObserverUnitTest_SOURCES = defs.hpp helpers.hpp memoryusageobserverunittest.cpp memoryusageobserverunittest.hpp memoryusageobserver.hpp verbose.hpp
-MemoryUsageObserverUnitTest_CXXFLAGS = $(CPPUNIT_CFLAGS)
-MemoryUsageObserverUnitTest_LDFLAGS = $(CPPUNIT_LIBS) -ldl
-MemoryUsageObserverUnitTest_LDADD = ../libmolecuilder.a
+LogUnitTest_SOURCES = ../errorLogger.cpp ../errorLogger.hpp ../log.cpp ../log.hpp ../logger.cpp ../logger.hpp logunittest.cpp logunittest.hpp
+LogUnitTest_CXXFLAGS = $(CPPUNIT_CFLAGS)
+LogUnitTest_LDFLAGS = $(CPPUNIT_LIBS) -ldl
+LogUnitTest_LDADD = ../libmolecuilder.a
+StackClassUnitTest_SOURCES = memoryallocator.hpp stackclass.hpp stackclassunittest.cpp stackclassunittest.hpp
+VectorUnitTest_SOURCES = defs.hpp ../helpers.cpp helpers.hpp ../leastsquaremin.cpp leastsquaremin.hpp memoryallocator.hpp memoryusageobserver.hpp ../memoryusageobserver.cpp vectorunittest.cpp vectorunittest.hpp vector.hpp ../vector.cpp verbose.hpp ../verbose.cpp
+#AUTOMAKE_OPTIONS = parallel-tests

src/unittests/memoryallocatorunittest.cpp

-              r06c7a3
+              r7326b2
 void MemoryAllocatorTest::tearDown()
+{
+  MemoryUsageObserver::getInstance()->purgeInstance();
 };
 …
   char** buffer4 = NULL;
+  buffer4 = Malloc<char*>(1, "");
+  buffer4 = Malloc<char*>(10, "");
+  for (int i=0;i<10;i++)
+    buffer4[i] = NULL;
   Free(&buffer4);
 };
 …
+{
   int* buffer1 = NULL;
   buffer1 = Calloc<int>(1, "");
+  buffer1 = Calloc<int>(10, "");
   Free(&buffer1);
   long* buffer2 = NULL;
   buffer2 = Calloc<long>(1, "");
+  buffer2 = Calloc<long>(10, "");
   Free(&buffer2);
+  char* buffer3 = NULL;
+  buffer3 = Calloc<char>(1, "");
+  char** buffer3 = NULL;
+  buffer3 = Calloc<char *>(10, "");
+  for (int i=0;i<10;i++)
+    buffer3[i] = NULL;
   Free(&buffer3);
 };

src/vector.cpp

Property mode changed from 100755 to 100644

-              r06c7a3
+              r7326b2
 /** Constructor of class vector.
  */
 Vector::Vector(double x1, double x2, double x3) { x[0] = x1; x[1] = x2; x[2] = x3; };
+Vector::Vector(const double x1, const double x2, const double x3) { x[0] = x1; x[1] = x2; x[2] = x3; };
 /** Desctructor of class vector.
 …
  * \return \f$| x - y |^2\f$
  */
 double Vector::DistanceSquared(const Vector *y) const
+double Vector::DistanceSquared(const Vector * const y) const
+{
   double res = 0.;
 …
  * \return \f$| x - y |\f$
  */
 double Vector::Distance(const Vector *y) const
+double Vector::Distance(const Vector * const y) const
+{
   double res = 0.;
 …
  * \return \f$| x - y |\f$
  */
 double Vector::PeriodicDistance(const Vector *y, const double *cell_size) const
+double Vector::PeriodicDistance(const Vector * const y, const double * const cell_size) const
+{
   double res = Distance(y), tmp, matrix[NDIM*NDIM];
 …
  * \return \f$| x - y |^2\f$
  */
 double Vector::PeriodicDistanceSquared(const Vector *y, const double *cell_size) const
+double Vector::PeriodicDistanceSquared(const Vector * const y, const double * const cell_size) const
+{
   double res = DistanceSquared(y), tmp, matrix[NDIM*NDIM];
 …
  * Tries to translate a vector into each adjacent neighbouring cell.
  */
 void Vector::KeepPeriodic(ofstream *out, double *matrix)
+void Vector::KeepPeriodic(ofstream *out, const double * const matrix)
+{
 //  int N[NDIM];
 …
  * \return \f$\langle x, y \rangle\f$
  */
 double Vector::ScalarProduct(const Vector *y) const
+double Vector::ScalarProduct(const Vector * const y) const
+{
   double res = 0.;
 …
  *  \return \f$ x \times y \f&
  */
 void Vector::VectorProduct(const Vector *y)
+void Vector::VectorProduct(const Vector * const y)
+{
   Vector tmp;
 …
   tmp.x[2] = x[0]* (y->x[1]) - x[1]* (y->x[0]);
   this->CopyVector(&tmp);
 };
 …
  * \return \f$\langle x, y \rangle\f$
  */
 void Vector::ProjectOntoPlane(const Vector *y)
+void Vector::ProjectOntoPlane(const Vector * const y)
+{
   Vector tmp;
 …
  * \return true -  \a this contains intersection point on return, false - line is parallel to plane
  */
 bool Vector::GetIntersectionWithPlane(ofstream *out, Vector *PlaneNormal, Vector *PlaneOffset, Vector *Origin, Vector *LineVector)
+bool Vector::GetIntersectionWithPlane(ofstream *out, const Vector * const PlaneNormal, const Vector * const PlaneOffset, const Vector * const Origin, const Vector * const LineVector)
+{
   double factor;
 …
  * \return distance to plane
  */
 double Vector::DistanceToPlane(ofstream *out, Vector *PlaneNormal, Vector *PlaneOffset)
+double Vector::DistanceToPlane(ofstream *out, const Vector * const PlaneNormal, const Vector * const PlaneOffset) const
+{
   Vector temp;
 …
   temp.AddVector(this);
   temp.SubtractVector(PlaneOffset);
+  return temp.Norm();
+  double sign = temp.ScalarProduct(PlaneNormal);
+  if (fabs(sign) > MYEPSILON)
+    sign /= fabs(sign);
+  else
+    sign = 0.;
+  return (temp.Norm()*sign);
 };
 …
  * \return true - \a this will contain the intersection on return, false - lines are parallel
  */
 bool Vector::GetIntersectionOfTwoLinesOnPlane(ofstream *out, Vector *Line1a, Vector *Line1b, Vector *Line2a, Vector *Line2b, const Vector *PlaneNormal)
+bool Vector::GetIntersectionOfTwoLinesOnPlane(ofstream *out, const Vector * const Line1a, const Vector * const Line1b, const Vector * const Line2a, const Vector * const Line2b, const Vector *PlaneNormal)
+{
   bool result = true;
 …
  * \param *y array to second vector
  */
 void Vector::ProjectIt(const Vector *y)
+void Vector::ProjectIt(const Vector * const y)
+{
   Vector helper(*y);
 …
  * \return Vector
  */
 Vector Vector::Projection(const Vector *y) const
+Vector Vector::Projection(const Vector * const y) const
+{
   Vector helper(*y);
 …
 /** Zeros all components of this vector.
  */
 void Vector::One(double one)
+void Vector::One(const double one)
+{
   for (int i=NDIM;i--;)
 …
 /** Initialises all components of this vector.
  */
 void Vector::Init(double x1, double x2, double x3)
+void Vector::Init(const double x1, const double x2, const double x3)
+{
   x[0] = x1;
 …
  * @return true - vector is normalized, false - vector is not
  */
 bool Vector::IsNormalTo(const Vector *normal) const
+bool Vector::IsNormalTo(const Vector * const normal) const
+{
   if (ScalarProduct(normal) < MYEPSILON)
 …
  * \return \f$\acos\bigl(frac{\langle x, y \rangle}{|x||y|}\bigr)\f$
  */
 double Vector::Angle(const Vector *y) const
+double Vector::Angle(const Vector * const y) const
+{
   double norm1 = Norm(), norm2 = y->Norm();
 …
  * \param alpha rotation angle in radian
  */
 void Vector::RotateVector(const Vector *axis, const double alpha)
+void Vector::RotateVector(const Vector * const axis, const double alpha)
+{
   Vector a,y;
 …
  * \param *factor pointer to scaling factor
  */
 void Vector::Scale(double **factor)
+void Vector::Scale(const double ** const factor)
+{
   for (int i=NDIM;i--;)
 …
 };
 void Vector::Scale(double *factor)
+void Vector::Scale(const double * const factor)
+{
   for (int i=NDIM;i--;)
 …
 };
 void Vector::Scale(double factor)
+void Vector::Scale(const double factor)
+{
   for (int i=NDIM;i--;)
 …
  * \param trans[] translation vector.
  */
 void Vector::Translate(const Vector *trans)
+void Vector::Translate(const Vector * const trans)
+{
   for (int i=NDIM;i--;)
 …
  * \param *Minv inverse matrix
  */
 void Vector::WrapPeriodically(const double *M, const double *Minv)
+void Vector::WrapPeriodically(const double * const M, const double * const Minv)
+{
   MatrixMultiplication(Minv);
 …
  * \param *matrix NDIM_NDIM array
  */
 void Vector::MatrixMultiplication(const double *M)
+void Vector::MatrixMultiplication(const double * const M)
+{
   Vector C;
 …
 };
 /** Calculate the inverse of a 3x3 matrix.
+/** Do a matrix multiplication with the \a *A' inverse.
  * \param *matrix NDIM_NDIM array
  */
+double * Vector::InverseMatrix(double *A)
+{
+  double *B = Malloc<double>(NDIM * NDIM, "Vector::InverseMatrix: *B");
+void Vector::InverseMatrixMultiplication(const double * const A)
+{
+  Vector C;
+  double B[NDIM*NDIM];
   double detA = RDET3(A);
   double detAReci;
-  for (int i=0;i<NDIM*NDIM;++i)
-    B[i] = 0.;
   // calculate the inverse B
   if (fabs(detA) > MYEPSILON) {;  // RDET3(A) yields precisely zero if A irregular
 …
     B[7] = -detAReci*RDET2(A[0],A[1],A[6],A[7]);    // A_32
     B[8] =  detAReci*RDET2(A[0],A[1],A[3],A[4]);    // A_33
+  }
-  return B;
-};
-/** Do a matrix multiplication with the \a *A' inverse.
- * \param *matrix NDIM_NDIM array
- */
-void Vector::InverseMatrixMultiplication(const 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
 …
  * \param *factors three-component vector with the factor for each given vector
  */
 void Vector::LinearCombinationOfVectors(const Vector *x1, const Vector *x2, const Vector *x3, double *factors)
+void Vector::LinearCombinationOfVectors(const Vector * const x1, const Vector * const x2, const Vector * const x3, const double * const factors)
+{
   for(int i=NDIM;i--;)
 …
  * \param n[] normal vector of mirror plane.
  */
 void Vector::Mirror(const Vector *n)
+void Vector::Mirror(const Vector * const n)
+{
   double projection;
 …
  * \return true - success, vectors are linear independent, false - failure due to linear dependency
  */
 bool Vector::MakeNormalVector(const Vector *y1, const Vector *y2, const Vector *y3)
+bool Vector::MakeNormalVector(const Vector * const y1, const Vector * const y2, const Vector * const y3)
+{
   Vector x1, x2;
 …
  * \return true - success, vectors are linear independent, false - failure due to linear dependency
  */
 bool Vector::MakeNormalVector(const Vector *y1, const Vector *y2)
+bool Vector::MakeNormalVector(const Vector * const y1, const Vector * const y2)
+{
   Vector x1,x2;
 …
  * \return true - success, false - vector is zero
  */
 bool Vector::MakeNormalVector(const Vector *y1)
+bool Vector::MakeNormalVector(const Vector * const y1)
+{
   bool result = false;
 …
  * \return true - success, false - failure (null vector given)
  */
 bool Vector::GetOneNormalVector(const Vector *GivenVector)
+bool Vector::GetOneNormalVector(const Vector * const GivenVector)
+{
   int Components[NDIM]; // contains indices of non-zero components
 …
  * \return scaling parameter for this vector
  */
 double Vector::CutsPlaneAt(Vector *A, Vector *B, Vector *C)
+double Vector::CutsPlaneAt(const Vector * const A, const Vector * const B, const Vector * const C) const
+{
 //  cout << Verbose(3) << "For comparison: ";
 …
  * \return true if success, false if failed due to linear dependency
  */
 bool Vector::LSQdistance(Vector **vectors, int num)
+bool Vector::LSQdistance(const Vector **vectors, int num)
+{
   int j;
 …
  * \param *y vector
  */
 void Vector::AddVector(const Vector *y)
+void Vector::AddVector(const Vector * const y)
+{
   for (int i=NDIM;i--;)
 …
  * \param *y vector
  */
 void Vector::SubtractVector(const Vector *y)
+void Vector::SubtractVector(const Vector * const y)
+{
   for (int i=NDIM;i--;)
 …
  * \param *y vector
  */
 void Vector::CopyVector(const Vector *y)
+void Vector::CopyVector(const Vector * const y)
+{
   for (int i=NDIM;i--;)
 …
  * \param y vector
  */
 void Vector::CopyVector(const Vector y)
+void Vector::CopyVector(const Vector &y)
+{
   for (int i=NDIM;i--;)
 …
  * \param check whether bounds shall be checked (true) or not (false)
  */
 void Vector::AskPosition(double *cell_size, bool check)
+void Vector::AskPosition(const double * const cell_size, const bool check)
+{
   char coords[3] = {'x','y','z'};
 …
  * \bug this is not yet working properly
  */
 bool Vector::SolveSystem(Vector *x1, Vector *x2, Vector *y, double alpha, double beta, double c)
+bool Vector::SolveSystem(Vector * x1, Vector * x2, Vector * y, const double alpha, const double beta, const double c)
+{
   double D1,D2,D3,E1,E2,F1,F2,F3,p,q=0., A, B1, B2, C;
 …
       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]);
+      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]);
+      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;
+  }
 …
       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]);
+      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]);
+      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;
+  }
 …
  * @param three vectors forming the matrix that defines the shape of the parallelpiped
  */
 bool Vector::IsInParallelepiped(Vector offset, double *parallelepiped)
+bool Vector::IsInParallelepiped(const Vector &offset, const double * const parallelepiped) const
+{
   Vector a;

src/vector.hpp

-              r06c7a3
+              r7326b2
 #endif
+#include <iostream>
 #include <gsl/gsl_vector.h>
 #include <gsl/gsl_multimin.h>
 …
   Vector();
   Vector(double x1, double x2, double x3);
+  Vector(const double x1, const double x2, const double x3);
   ~Vector();
   double Distance(const Vector *y) const;
   double DistanceSquared(const Vector *y) const;
   double DistanceToPlane(ofstream *out, Vector *PlaneNormal, Vector *PlaneOffset);
   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 Distance(const Vector * const y) const;
+  double DistanceSquared(const Vector * const y) const;
+  double DistanceToPlane(ofstream *out, const Vector * const PlaneNormal, const Vector * const PlaneOffset) const;
+  double PeriodicDistance(const Vector * const y, const double * const cell_size) const;
+  double PeriodicDistanceSquared(const Vector * const y, const double * const cell_size) const;
+  double ScalarProduct(const Vector * const y) const;
   double Norm() const;
   double NormSquared() const;
   double Angle(const Vector *y) const;
+  double Angle(const Vector * const y) const;
   bool IsZero() const;
   bool IsOne() const;
   bool IsNormalTo(const Vector *normal) const;
+  bool IsNormalTo(const Vector * const normal) const;
   void AddVector(const Vector *y);
   void SubtractVector(const Vector *y);
   void CopyVector(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 ProjectIt(const Vector *y);
   Vector Projection(const Vector *y) const;
+  void AddVector(const Vector * const y);
+  void SubtractVector(const Vector * const y);
+  void CopyVector(const Vector * const y);
+  void CopyVector(const Vector &y);
+  void RotateVector(const Vector * const y, const double alpha);
+  void VectorProduct(const Vector * const y);
+  void ProjectOntoPlane(const Vector * const y);
+  void ProjectIt(const Vector * const y);
+  Vector Projection(const Vector * const y) const;
   void Zero();
   void One(double one);
   void Init(double x1, double x2, double x3);
+  void One(const double one);
+  void Init(const double x1, const double x2, const 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(const double *M);
+  double * InverseMatrix(double *A);
+  void InverseMatrixMultiplication(const 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 GetIntersectionWithPlane(ofstream *out, Vector *PlaneNormal, Vector *PlaneOffset, Vector *Origin, Vector *LineVector);
+  bool GetIntersectionOfTwoLinesOnPlane(ofstream *out, Vector *Line1a, Vector *Line1b, Vector *Line2a, Vector *Line2b, const Vector *Normal = NULL);
+  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);
+  void Translate(const Vector * const x);
+  void Mirror(const Vector * const x);
+  void Scale(const double ** const factor);
+  void Scale(const double * const factor);
+  void Scale(const double factor);
+  void MatrixMultiplication(const double * const M);
+  void InverseMatrixMultiplication(const double * const M);
+  void KeepPeriodic(ofstream *out, const double * const matrix);
+  void LinearCombinationOfVectors(const Vector * const x1, const Vector * const x2, const Vector * const x3, const double * const factors);
+  double CutsPlaneAt(const Vector * const A, const Vector * const B, const Vector * const C) const;
+  bool GetIntersectionWithPlane(ofstream *out, const Vector * const PlaneNormal, const Vector * const PlaneOffset, const Vector * const Origin, const Vector * const LineVector);
+  bool GetIntersectionOfTwoLinesOnPlane(ofstream *out, const Vector * const Line1a, const Vector * const Line1b, const Vector * const Line2a, const Vector * const Line2b, const Vector *Normal = NULL);
+  bool GetOneNormalVector(const Vector * const x1);
+  bool MakeNormalVector(const Vector * const y1);
+  bool MakeNormalVector(const Vector * const y1, const Vector * const y2);
+  bool MakeNormalVector(const Vector * const x1, const Vector * const x2, const Vector * const x3);
+  bool SolveSystem(Vector * x1, Vector * x2, Vector * y, const double alpha, const double beta, const double c);
+  bool LSQdistance(const Vector ** vectors, int dim);
+  void AskPosition(const double * const cell_size, const bool check);
   bool Output(ofstream *out) const;
   bool IsInParallelepiped(Vector offset, double *parallelepiped);
   void WrapPeriodically(const double *M, const double *Minv);
+  bool IsInParallelepiped(const Vector &offset, const double * const parallelepiped) const;
+  void WrapPeriodically(const double * const M, const double * const Minv);
 };
 …
 Vector& operator-(const Vector& a, const Vector& b);
-// some algebraic matrix stuff
-#define RDET3(a) ((a)[0]*(a)[4]*(a)[8] + (a)[3]*(a)[7]*(a)[2] + (a)[6]*(a)[1]*(a)[5] - (a)[2]*(a)[4]*(a)[6] - (a)[5]*(a)[7]*(a)[0] - (a)[8]*(a)[1]*(a)[3])  //!< hard-coded determinant of a 3x3 matrix
-#define RDET2(a0,a1,a2,a3) ((a0)*(a3)-(a1)*(a2))                      //!< hard-coded determinant of a 2x2 matrix
 #endif /*VECTOR_HPP_*/

Context Navigation

Changes in / [06c7a3:7326b2]

Legend:

Download in other formats: