Changes in / [42af9e:1024cb]

Files:

• src/Actions/FragmentationAction/DepthFirstSearchAction.cpp (modified) (1 diff)
• src/Actions/TesselationAction/NonConvexEnvelopeAction.cpp (modified) (1 diff)
• src/Actions/WorldAction/RepeatBoxAction.cpp (modified) (3 diffs)
• src/Helpers/Assert.cpp (modified) (2 diffs)
• src/Helpers/MemDebug.cpp (modified) (6 diffs)
• src/Helpers/MemDebug.hpp (modified) (2 diffs)
• src/Legacy/oldmenu.cpp (modified) (8 diffs)
• src/Makefile.am (modified) (4 diffs)
• src/Patterns/Cacheable.hpp (modified) (8 diffs)
• src/Patterns/ObservedIterator.hpp (added)
• src/Patterns/Observer.cpp (modified) (2 diffs)
• src/Patterns/Observer.hpp (modified) (4 diffs)
• src/Plane.cpp (modified) (1 diff)
• src/Plane.hpp (modified) (1 diff)
• src/analysis_bonds.cpp (modified) (9 diffs)
• src/analysis_correlation.cpp (modified) (10 diffs)
• src/atom.cpp (modified) (1 diff)
• src/bondgraph.cpp (modified) (2 diffs)
• src/boundary.cpp (modified) (17 diffs)
• src/builder.cpp (modified) (15 diffs)
• src/config.cpp (modified) (15 diffs)
• src/helpers.cpp (modified) (1 diff)
• src/helpers.hpp (modified) (1 diff)
• src/lists.cpp (deleted)
• src/lists.hpp (modified) (1 diff)
• src/memoryallocator.cpp (added)
• src/molecule.cpp (modified) (25 diffs)
• src/molecule.hpp (modified) (9 diffs)
• src/molecule_dynamics.cpp (modified) (22 diffs)
• src/molecule_fragmentation.cpp (modified) (25 diffs)
• src/molecule_geometry.cpp (modified) (20 diffs)
• src/molecule_graph.cpp (modified) (20 diffs)
• src/molecule_pointcloud.cpp (modified) (2 diffs)
• src/molecule_template.hpp (modified) (23 diffs)
• src/moleculelist.cpp (modified) (27 diffs)
• src/tesselation.cpp (modified) (12 diffs)
• src/tesselation.hpp (modified) (5 diffs)
• src/tesselationhelpers.cpp (modified) (3 diffs)
• src/unittests/AnalysisCorrelationToPointUnitTest.cpp (modified) (1 diff)
• src/unittests/AnalysisCorrelationToSurfaceUnitTest.cpp (modified) (7 diffs)
• src/unittests/AnalysisPairCorrelationUnitTest.cpp (modified) (1 diff)
• src/unittests/CountBondsUnitTest.cpp (modified) (1 diff)
• src/unittests/LinkedCellUnitTest.cpp (modified) (6 diffs)
• src/unittests/Makefile.am (modified) (3 diffs)
• src/unittests/ObserverTest.cpp (modified) (6 diffs)
• src/unittests/ObserverTest.hpp (modified) (4 diffs)
• src/unittests/analysisbondsunittest.cpp (modified) (2 diffs)
• src/unittests/bondgraphunittest.cpp (modified) (4 diffs)
• src/unittests/bondgraphunittest.hpp (modified) (2 diffs)
• src/unittests/listofbondsunittest.cpp (modified) (8 diffs)
• src/unittests/listofbondsunittest.hpp (modified) (2 diffs)
• src/vector.cpp (modified) (1 diff)
• src/vector.hpp (modified) (1 diff)
• tests/regression/Domain/5/post/test.conf (modified) (1 diff)
• tests/regression/Domain/5/pre/test.conf (modified) (1 diff)
• tests/regression/Domain/6/post/test-x.conf (deleted)
• tests/regression/Domain/6/post/test-x.conf.xyz (added)
• tests/regression/Domain/6/post/test-y.conf (deleted)
• tests/regression/Domain/6/post/test-y.conf.xyz (added)
• tests/regression/Domain/6/post/test-z.conf (deleted)
• tests/regression/Domain/6/post/test-z.conf.xyz (added)
• tests/regression/Domain/6/post/test.conf (deleted)
• tests/regression/Domain/6/pre/test.conf (modified) (1 diff)
• tests/regression/Simple_configuration/8/post/test.conf (deleted)
• tests/regression/Simple_configuration/8/post/test.conf.xyz (added)
• tests/regression/testsuite-domain.at (modified) (1 diff)
• tests/regression/testsuite-simple_configuration.at (modified) (1 diff)

src/Actions/FragmentationAction/DepthFirstSearchAction.cpp

@@ -46 +46 @@
     molecule * const mol = World::getInstance().getMolecule(MoleculeById(0));
     MoleculeLeafClass *Subgraphs = NULL;      // list of subgraphs from DFS analysis
-    int *MinimumRingSize = new int[mol->AtomCount];
+    int *MinimumRingSize = new int[mol->getAtomCount()];
     atom ***ListOfLocalAtoms = NULL;
     class StackClass<bond *> *BackEdgeStack = NULL;

src/Actions/TesselationAction/NonConvexEnvelopeAction.cpp

@@ -65 +65 @@
     DoLog(0) && (Log() << Verbose(0) << "Evaluating non-convex envelope of molecule." << Boundary->getId() << endl);
     DoLog(1) && (Log() << Verbose(1) << "Using rolling ball of radius " << SphereRadius << " and storing tecplot data in " << filename << "." << endl);
-    DoLog(1) && (Log() << Verbose(1) << "Specified molecule has " << Boundary->AtomCount << " atoms." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "Specified molecule has " << Boundary->getAtomCount() << " atoms." << endl);
     start = clock();
     LCList = new LinkedCell(Boundary, SphereRadius*2.);

src/Actions/WorldAction/RepeatBoxAction.cpp

@@ -40 +40 @@
   molecule *mol = NULL;
   int j = 0;
+  atom *Walker = NULL;
 
   dialog->queryVector(NAME, &Repeater, World::getInstance().getDomain(), false, MapOfActions::getInstance().getDescription(NAME));
@@ -54 +55 @@
         Repeater[axis] = 1;
       }
-      mol->CountAtoms();  // recount atoms
-      if (mol->AtomCount != 0) {  // if there is more than none
-        count = mol->AtomCount;   // is changed becausing of adding, thus has to be stored away beforehand
+      if (mol->getAtomCount() != 0) {  // if there is more than none
+        count = mol->getAtomCount();   // is changed becausing of adding, thus has to be stored away beforehand
         Elements = new const element *[count];
         vectors = new Vector *[count];
         j = 0;
-        atom *first = mol->start;
-        while (first->next != mol->end) {  // make a list of all atoms with coordinates and element
-          first = first->next;
-          Elements[j] = first->type;
-          vectors[j] = &first->x;
+        for(molecule::iterator AtomRunner = mol->begin(); AtomRunner != mol->end(); ++AtomRunner) {
+          Elements[j] = (*AtomRunner)->type;
+          vectors[j] = &(*AtomRunner)->x;
           j++;
         }
@@ -75 +73 @@
           x += y; // per factor one cell width further
           for (int k=count;k--;) { // go through every atom of the original cell
-            first = World::getInstance().createAtom(); // create a new body
-            first->x = (*vectors[k]) + x;
-            first->type = Elements[k];  // insert original element
-            mol->AddAtom(first);        // and add to the molecule (which increments ElementsInMolecule, AtomCount, ...)
+            Walker = World::getInstance().createAtom(); // create a new body
+            Walker->x = (*vectors[k]) + x;
+            Walker->type = Elements[k];  // insert original element
+            mol->AddAtom(Walker);        // and add to the molecule (which increments ElementsInMolecule, AtomCount, ...)
           }
         }

src/Helpers/Assert.cpp

@@ -54 +54 @@
 
 
-
 bool _my_assert::check(const bool res,
                        const char* condition,
@@ -63 +62 @@
 {
   if(!res){
-    cout << "Assertion " << condition << " failed in file " << filename << " at line " << line << endl;
+    cout << "Assertion \"" << condition << "\" failed in file " << filename << " at line " << line << endl;
     cout << "Assertion Message: " << message << std::endl;
     while(true){

src/Helpers/MemDebug.cpp

@@ -9 +9 @@
 #include <cstdlib>
 #include <cstring>
+#include <boost/thread.hpp>
 
 using namespace std;
+
+#ifndef NDBEGUG
+#ifndef NO_MEMDEBUG
 
 namespace Memory {
@@ -40 +44 @@
   };
 
+  boost::mutex memorylock;
+
   // start and end of the doubly-linked list
   entry_t *begin=0;
@@ -127 +133 @@
 
 void *operator new(size_t nbytes,const char* file, int line) throw(std::bad_alloc) {
+
+  // we need to lock, so that no one changes the linked list while we are here
+  boost::mutex::scoped_lock guard(Memory::memorylock);
 
   // to avoid allocations of 0 bytes if someone screws up
@@ -204 +213 @@
 
 void operator delete(void *ptr) throw() {
+  if(!ptr){
+    cerr << "Warning: Deleting NULL pointer" << endl;
+    return;
+  }
+
+  // we need to lock, so the linked list does not changed while we are in here
+  boost::mutex::scoped_lock guard(Memory::memorylock);
+
   // get the size for the entry, including alignment
   static const size_t entrySpace = Memory::doAlign(sizeof(Memory::entry_t));
@@ -212 +229 @@
   // let's see if the checksum is still matching
   if(Memory::calcChecksum(&entry->info)!=entry->checksum){
-    cout << "Possible memory corruption detected!" << endl;
-    cout << "Trying to recover allocation information..." << endl;
-    cout << "Memory was allocated at " << entry->info.file << ":" << entry->info.line << endl;
+    cerr << "Possible memory corruption detected!" << endl;
+    cerr << "Trying to recover allocation information..." << endl;
+    cerr << "Memory was allocated at " << entry->info.file << ":" << entry->info.line << endl;
     terminate();
   }
@@ -241 +258 @@
   operator delete(ptr);
 }
+#endif
+#endif

src/Helpers/MemDebug.hpp

@@ -21 +21 @@
  * your sourcefiles.
  */
+#ifndef NDEBUG
+#ifndef NO_MEMDEBUG
+
+#ifndef MEMDEBUG
+#define MEMDEBUG
+#endif
 
 namespace Memory {
@@ -56 +62 @@
 #define new new(__FILE__,__LINE__)
 
+#endif
+#endif
+
+
+#ifndef MEMDEBUG
+// memory debugging was disabled
+
+namespace Memory {
+  inline void getState(){}
+
+  template <typename T>
+  inline T *ignore(T* ptr){
+    return ptr;
+  }
+}
+
+#endif
 #endif /* MEMDEBUG_HPP_ */

src/Legacy/oldmenu.cpp

@@ -424 +424 @@
 void oldmenu::RemoveAtoms(molecule *mol)
 {
-  atom *first, *second;
+  atom *second;
   int axis;
   double tmp1, tmp2;
@@ -447 +447 @@
       break;
     case 'b':
-      second = mol->AskAtom("Enter number of atom as reference point: ");
-      Log() << Verbose(0) << "Enter radius: ";
-      cin >> tmp1;
-      first = mol->start;
-      second = first->next;
-      while(second != mol->end) {
-        first = second;
-        second = first->next;
-        if (first->x.DistanceSquared(second->x) > tmp1*tmp1) // distance to first above radius ...
-          mol->RemoveAtom(first);
+      {
+        second = mol->AskAtom("Enter number of atom as reference point: ");
+        Log() << Verbose(0) << "Enter radius: ";
+        cin >> tmp1;
+        molecule::iterator runner;
+        for (molecule::iterator iter = mol->begin(); iter != mol->end(); ) {
+          runner = iter++;
+          if ((*runner)->x.DistanceSquared((*runner)->x) > tmp1*tmp1) // distance to first above radius ...
+            mol->RemoveAtom((*runner));
+        }
       }
       break;
@@ -466 +466 @@
       Log() << Verbose(0) << "Upper boundary: ";
       cin >> tmp2;
-      first = mol->start;
-      second = first->next;
-      while(second != mol->end) {
-        first = second;
-        second = first->next;
-        if ((first->x[axis] < tmp1) || (first->x[axis] > tmp2)) {// out of boundary ...
-          //Log() << Verbose(0) << "Atom " << *first << " with " << first->x.x[axis] << " on axis " << axis << " is out of bounds [" << tmp1 << "," << tmp2 << "]." << endl;
-          mol->RemoveAtom(first);
+      molecule::iterator runner;
+      for (molecule::iterator iter = mol->begin(); iter != mol->end(); ) {
+        runner = iter++;
+        if (((*runner)->x[axis] < tmp1) || ((*runner)->x[axis] > tmp2)) {// out of boundary ...
+          //Log() << Verbose(0) << "Atom " << *(*runner) << " with " << (*runner)->x.x[axis] << " on axis " << axis << " is out of bounds [" << tmp1 << "," << tmp2 << "]." << endl;
+          mol->RemoveAtom((*runner));
         }
       }
@@ -516 +514 @@
         min[i] = 0.;
 
-      second = mol->start;
-      while ((second->next != mol->end)) {
-        second = second->next; // advance
-        Z = second->type->Z;
+      for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+        Z = (*iter)->type->Z;
         tmp1 = 0.;
-        if (first != second) {
-          x = first->x - second->x;
+        if (first != (*iter)) {
+          x = first->x - (*iter)->x;
           tmp1 = x.Norm();
         }
         if ((tmp1 != 0.) && ((min[Z] == 0.) || (tmp1 < min[Z]))) min[Z] = tmp1;
-        //Log() << Verbose(0) << "Bond length between Atom " << first->nr << " and " << second->nr << ": " << tmp1 << " a.u." << endl;
+        //Log() << Verbose(0) << "Bond length between Atom " << first->nr << " and " << ((*iter)->nr << ": " << tmp1 << " a.u." << endl;
       }
       for (int i=MAX_ELEMENTS;i--;)
@@ -755 +751 @@
     Log() << Verbose(0) << "State the factor: ";
     cin >> faktor;
-
-    mol->CountAtoms(); // recount atoms
-    if (mol->AtomCount != 0) {  // if there is more than none
-      count = mol->AtomCount;  // is changed becausing of adding, thus has to be stored away beforehand
+    if (mol->getAtomCount() != 0) {  // if there is more than none
+      count = mol->getAtomCount();  // is changed becausing of adding, thus has to be stored away beforehand
       Elements = new const element *[count];
       vectors = new Vector *[count];
       j = 0;
-      first = mol->start;
-      while (first->next != mol->end) { // make a list of all atoms with coordinates and element
-        first = first->next;
-        Elements[j] = first->type;
-        vectors[j] = &first->x;
+      for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+        Elements[j] = (*iter)->type;
+        vectors[j] = &(*iter)->x;
         j++;
       }
@@ -1025 +1017 @@
     return;
   }
-  atom *Walker = mol->start;
 
   // generate some KeySets
   Log() << Verbose(0) << "Generating KeySets." << endl;
-  KeySet TestSets[mol->AtomCount+1];
+  KeySet TestSets[mol->getAtomCount()+1];
   i=1;
-  while (Walker->next != mol->end) {
-    Walker = Walker->next;
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
     for (int j=0;j<i;j++) {
-      TestSets[j].insert(Walker->nr);
+      TestSets[j].insert((*iter)->nr);
     }
     i++;
@@ -1040 +1030 @@
   Log() << Verbose(0) << "Testing insertion of already present item in KeySets." << endl;
   KeySetTestPair test;
-  test = TestSets[mol->AtomCount-1].insert(Walker->nr);
-  if (test.second) {
-    Log() << Verbose(1) << "Insertion worked?!" << endl;
+  molecule::const_iterator iter = mol->begin();
+  if (iter != mol->end()) {
+    test = TestSets[mol->getAtomCount()-1].insert((*iter)->nr);
+    if (test.second) {
+      Log() << Verbose(1) << "Insertion worked?!" << endl;
+    } else {
+      Log() << Verbose(1) << "Insertion rejected: Present object is " << (*test.first) << "." << endl;
+    }
   } else {
-    Log() << Verbose(1) << "Insertion rejected: Present object is " << (*test.first) << "." << endl;
-  }
-  TestSets[mol->AtomCount].insert(mol->end->previous->nr);
-  TestSets[mol->AtomCount].insert(mol->end->previous->previous->previous->nr);
+    eLog() << Verbose(1) << "No atoms to test double insertion." << endl;
+  }
 
   // constructing Graph structure
@@ -1055 +1048 @@
   // insert KeySets into Subgraphs
   Log() << Verbose(0) << "Inserting KeySets into Subgraph class." << endl;
-  for (int j=0;j<mol->AtomCount;j++) {
+  for (int j=0;j<mol->getAtomCount();j++) {
     Subgraphs.insert(GraphPair (TestSets[j],pair<int, double>(counter++, 1.)));
   }
   Log() << Verbose(0) << "Testing insertion of already present item in Subgraph." << endl;
   GraphTestPair test2;
-  test2 = Subgraphs.insert(GraphPair (TestSets[mol->AtomCount],pair<int, double>(counter++, 1.)));
+  test2 = Subgraphs.insert(GraphPair (TestSets[mol->getAtomCount()],pair<int, double>(counter++, 1.)));
   if (test2.second) {
     Log() << Verbose(1) << "Insertion worked?!" << endl;

src/Makefile.am

@@ -115 +115 @@
   Descriptors/MoleculeIdDescriptor.cpp 
                                    
-                                   
+
 DESCRIPTORHEADER = Descriptors/AtomDescriptor.hpp \
   Descriptors/AtomIdDescriptor.hpp \
@@ -157 +157 @@
   Line.cpp \
   linkedcell.cpp \
-  lists.cpp \
   log.cpp \
   logger.cpp \
@@ -170 +169 @@
   periodentafel.cpp \
   Plane.cpp \
+  Space.cpp \
   tesselation.cpp \
   tesselationhelpers.cpp \
   triangleintersectionlist.cpp \
+  vector.cpp \
+  vector_ops.cpp \
   verbose.cpp \
-  vector_ops.cpp \
   World.cpp
 
@@ -220 +221 @@
 # the following files are no longer used:
 #  memoryallocator.hpp \
+#  memoryallocator.cpp \
 #  memoryusageobserver.hpp \
 #  memoryusageobserver.cpp

src/Patterns/Cacheable.hpp

@@ -28 +28 @@
         owner(_owner)
         {}
-      virtual T getValue()=0;
+      virtual T& getValue()=0;
       virtual void invalidate()=0;
       virtual bool isValid()=0;
@@ -46 +46 @@
         {}
 
-      virtual T getValue(){
+      virtual T& getValue(){
         // set the state to valid
         State::owner->switchState(State::owner->validState);
@@ -72 +72 @@
         {}
 
-      virtual T getValue(){
+      virtual T& getValue(){
         return content;
       }
@@ -100 +100 @@
         {}
 
-      virtual T getValue(){
+      virtual T& getValue(){
         ASSERT(0,"Cannot get a value from a Cacheable after it's Observable has died");
         // we have to return a grossly invalid reference, because no value can be produced anymore
@@ -134 +134 @@
     void subjectKilled(Observable *subject);
   private:
-
     void switchState(state_ptr newState);
 
@@ -144 +143 @@
 
     Observable *owner;
-
     boost::function<T()> recalcMethod;
 
@@ -221 +219 @@
 
     const bool isValid() const;
-    const T operator*() const;
+    const T& operator*() const;
 
     // methods implemented for base-class Observer
@@ -237 +235 @@
 
   template<typename T>
-  const T Cacheable<T>::operator*() const{
+  const T& Cacheable<T>::operator*() const{
     return recalcMethod();
   }

src/Patterns/Observer.cpp

@@ -82 +82 @@
 Observable::_Observable_protector::_Observable_protector(Observable *_protege) :
   protege(_protege)
+{
+  start_observer_internal(protege);
+}
+
+Observable::_Observable_protector::_Observable_protector(const _Observable_protector &dest) :
+    protege(dest.protege)
 {
   start_observer_internal(protege);
@@ -189 +195 @@
   ASSERT(callTable.count(this),"SignOff called for an Observable without Observers.");
   callees_t &callees = callTable[this];
+
   callees_t::iterator iter;
   callees_t::iterator deliter;

src/Patterns/Observer.hpp

@@ -36 +36 @@
 typedef Notification *const Notification_ptr;
 
+template<class _Set>
+class ObservedIterator;
+
 /**
  * An Observer is notified by all Observed objects, when anything changes.
@@ -53 +56 @@
   friend class Observable;
   friend class Notification;
+  template<class> friend class ObservedIterator;
+
 public:
   Observer();
@@ -152 +157 @@
   static std::set<Observable*> busyObservables;
 
-
   //! @cond
   // Structure for RAII-Style notification
@@ -164 +168 @@
   public:
     _Observable_protector(Observable *);
+    _Observable_protector(const _Observable_protector&);
     ~_Observable_protector();
   private:

src/Plane.cpp

@@ -91 +91 @@
   offset = normalVector->ScalarProduct(_offsetVector);
 }
+
+/**
+ * copy constructor
+ */
+Plane::Plane(const Plane& plane) :
+  normalVector(new Vector(*plane.normalVector)),
+  offset(plane.offset)
+{}
+
 
 Plane::~Plane()

src/Plane.hpp

@@ -26 +26 @@
   Plane(const Vector &_normalVector, double _offset)  throw(ZeroVectorException);
   Plane(const Vector &_normalVector, const Vector &_offsetVector) throw(ZeroVectorException);
+  Plane(const Plane& plane);
   virtual ~Plane();
 

src/analysis_bonds.cpp

@@ -26 +26 @@
   Mean = 0.;
 
-  atom *Walker = mol->start;
   int AtomCount = 0;
-  while (Walker->next != mol->end) {
-    Walker = Walker->next;
-    const int count = Walker->ListOfBonds.size();
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    const int count = (*iter)->ListOfBonds.size();
     if (Max < count)
       Max = count;
@@ -58 +56 @@
 
   int AtomNo = 0;
-  atom *Walker = mol->start;
-  while (Walker->next != mol->end) {
-    Walker = Walker->next;
-    if (Walker->type == type1)
-      for (BondList::const_iterator BondRunner = Walker->ListOfBonds.begin(); BondRunner != Walker->ListOfBonds.end(); BondRunner++)
-        if ((*BondRunner)->GetOtherAtom(Walker)->type == type2) {
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    if ((*iter)->type == type1)
+      for (BondList::const_iterator BondRunner = (*iter)->ListOfBonds.begin(); BondRunner != (*iter)->ListOfBonds.end(); BondRunner++)
+        if ((*BondRunner)->GetOtherAtom((*iter))->type == type2) {
           const double distance = (*BondRunner)->GetDistanceSquared();
           if (Min > distance)
@@ -126 +122 @@
 int CountHydrogenBridgeBonds(MoleculeListClass *molecules, const element * InterfaceElement = NULL)
 {
-  atom *Walker = NULL;
-  atom *Runner = NULL;
   int count = 0;
   int OtherHydrogens = 0;
@@ -133 +127 @@
   bool InterfaceFlag = false;
   bool OtherHydrogenFlag = true;
-  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin();MolWalker != molecules->ListOfMolecules.end(); MolWalker++) {
-    Walker = (*MolWalker)->start;
-    while (Walker->next != (*MolWalker)->end) {
-      Walker = Walker->next;
-      for (MoleculeList::const_iterator MolRunner = molecules->ListOfMolecules.begin();MolRunner != molecules->ListOfMolecules.end(); MolRunner++) {
-        Runner = (*MolRunner)->start;
-        while (Runner->next != (*MolRunner)->end) {
-          Runner = Runner->next;
-          if ((Walker->type->Z  == 8) && (Runner->type->Z  == 8)) {
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin();MolWalker != molecules->ListOfMolecules.end(); ++MolWalker) {
+    molecule::iterator Walker = (*MolWalker)->begin();
+    for(;Walker!=(*MolWalker)->end();++Walker){
+      for (MoleculeList::const_iterator MolRunner = molecules->ListOfMolecules.begin();MolRunner != molecules->ListOfMolecules.end(); ++MolRunner) {
+        molecule::iterator Runner = (*MolRunner)->begin();
+        for(;Runner!=(*MolRunner)->end();++Runner){
+          if (((*Walker)->type->Z  == 8) && ((*Runner)->type->Z  == 8)) {
             // check distance
-            const double distance = Runner->x.DistanceSquared(Walker->x);
+            const double distance = (*Runner)->x.DistanceSquared((*Walker)->x);
             if ((distance > MYEPSILON) && (distance < HBRIDGEDISTANCE*HBRIDGEDISTANCE)) { // distance >0 means  different atoms
               // on other atom(Runner) we check for bond to interface element and
@@ -151 +143 @@
               OtherHydrogens = 0;
               InterfaceFlag = (InterfaceElement == NULL);
-              for (BondList::const_iterator BondRunner = Runner->ListOfBonds.begin(); BondRunner != Runner->ListOfBonds.end(); BondRunner++) {
-                atom * const OtherAtom = (*BondRunner)->GetOtherAtom(Runner);
+              for (BondList::const_iterator BondRunner = (*Runner)->ListOfBonds.begin(); BondRunner != (*Runner)->ListOfBonds.end(); BondRunner++) {
+                atom * const OtherAtom = (*BondRunner)->GetOtherAtom(*Runner);
                 // if hydrogen, check angle to be greater(!) than 30 degrees
                 if (OtherAtom->type->Z == 1) {
-                  const double angle = CalculateAngle(&OtherAtom->x, &Runner->x, &Walker->x);
+                  const double angle = CalculateAngle(&OtherAtom->x, &(*Runner)->x, &(*Walker)->x);
                   OtherHydrogenFlag = OtherHydrogenFlag && (angle > M_PI*(30./180.) + MYEPSILON);
                   Otherangle += angle;
@@ -176 +168 @@
               if (InterfaceFlag && OtherHydrogenFlag) {
                 // on this element (Walker) we check for bond to hydrogen, i.e. part of water molecule
-                for (BondList::const_iterator BondRunner = Walker->ListOfBonds.begin(); BondRunner != Walker->ListOfBonds.end(); BondRunner++) {
-                  atom * const OtherAtom = (*BondRunner)->GetOtherAtom(Walker);
+                for (BondList::const_iterator BondRunner = (*Walker)->ListOfBonds.begin(); BondRunner != (*Walker)->ListOfBonds.end(); BondRunner++) {
+                  atom * const OtherAtom = (*BondRunner)->GetOtherAtom(*Walker);
                   if (OtherAtom->type->Z == 1) {
                     // check angle
-                    if (CheckHydrogenBridgeBondAngle(Walker, OtherAtom, Runner)) {
-                      DoLog(1) && (Log() << Verbose(1) << Walker->getName() << ", " << OtherAtom->getName() << " and " << Runner->getName() << " has a hydrogen bridge bond with distance " << sqrt(distance) << " and angle " << CalculateAngle(&OtherAtom->x, &Walker->x, &Runner->x)*(180./M_PI) << "." << endl);
+                    if (CheckHydrogenBridgeBondAngle(*Walker, OtherAtom, *Runner)) {
+                      DoLog(1) && (Log() << Verbose(1) << (*Walker)->getName() << ", " << OtherAtom->getName() << " and " << (*Runner)->getName() << " has a hydrogen bridge bond with distance " << sqrt(distance) << " and angle " << CalculateAngle(&OtherAtom->x, &(*Walker)->x, &(*Runner)->x)*(180./M_PI) << "." << endl);
                       count++;
                       break;
@@ -205 +197 @@
 int CountBondsOfTwo(MoleculeListClass * const molecules, const element * const first, const element * const second)
 {
-  atom *Walker = NULL;
   int count = 0;
 
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin();MolWalker != molecules->ListOfMolecules.end(); MolWalker++) {
-    Walker = (*MolWalker)->start;
-    while (Walker->next != (*MolWalker)->end) {
-      Walker = Walker->next;
-      if ((Walker->type == first) || (Walker->type == second)) {  // first element matches
-        for (BondList::const_iterator BondRunner = Walker->ListOfBonds.begin(); BondRunner != Walker->ListOfBonds.end(); BondRunner++) {
-          atom * const OtherAtom = (*BondRunner)->GetOtherAtom(Walker);
-          if (((OtherAtom->type == first) || (OtherAtom->type == second)) && (Walker->nr < OtherAtom->nr)) {
+    molecule::iterator Walker = (*MolWalker)->begin();
+    for(;Walker!=(*MolWalker)->end();++Walker){
+      atom * theAtom = *Walker;
+      if ((theAtom->type == first) || (theAtom->type == second)) {  // first element matches
+        for (BondList::const_iterator BondRunner = theAtom->ListOfBonds.begin(); BondRunner != theAtom->ListOfBonds.end(); BondRunner++) {
+          atom * const OtherAtom = (*BondRunner)->GetOtherAtom(theAtom);
+          if (((OtherAtom->type == first) || (OtherAtom->type == second)) && (theAtom->nr < OtherAtom->nr)) {
             count++;
             DoLog(1) && (Log() << Verbose(1) << first->name << "-" << second->name << " bond found between " << *Walker << " and " << *OtherAtom << "." << endl);
@@ -240 +231 @@
   bool MatchFlag[2];
   bool result = false;
-  atom *Walker = NULL;
   const element * ElementArray[2];
   ElementArray[0] = first;
@@ -246 +236 @@
 
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin();MolWalker != molecules->ListOfMolecules.end(); MolWalker++) {
-    Walker = (*MolWalker)->start;
-    while (Walker->next != (*MolWalker)->end) {
-      Walker = Walker->next;
-      if (Walker->type == second) {  // first element matches
+    molecule::iterator Walker = (*MolWalker)->begin();
+    for(;Walker!=(*MolWalker)->end();++Walker){
+      atom *theAtom = *Walker;
+      if (theAtom->type == second) {  // first element matches
         for (int i=0;i<2;i++)
           MatchFlag[i] = false;
-        for (BondList::const_iterator BondRunner = Walker->ListOfBonds.begin(); BondRunner != Walker->ListOfBonds.end(); BondRunner++) {
-          atom * const OtherAtom = (*BondRunner)->GetOtherAtom(Walker);
+        for (BondList::const_iterator BondRunner = theAtom->ListOfBonds.begin(); BondRunner != theAtom->ListOfBonds.end(); BondRunner++) {
+          atom * const OtherAtom = (*BondRunner)->GetOtherAtom(theAtom);
           for (int i=0;i<2;i++)
             if ((!MatchFlag[i]) && (OtherAtom->type == ElementArray[i])) {

src/analysis_correlation.cpp

@@ -40 +40 @@
   }
   outmap = new PairCorrelationMap;
-  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++){
     if ((*MolWalker)->ActiveFlag) {
       DoeLog(2) && (eLog()<< Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
-      atom *Walker = (*MolWalker)->start;
-      while (Walker->next != (*MolWalker)->end) {
-        Walker = Walker->next;
-        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << *Walker << "." << endl);
-        if ((type1 == NULL) || (Walker->type == type1)) {
-          for (MoleculeList::const_iterator MolOtherWalker = MolWalker; MolOtherWalker != molecules->ListOfMolecules.end(); MolOtherWalker++)
+      eLog() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl;
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+        if ((type1 == NULL) || ((*iter)->type == type1)) {
+          for (MoleculeList::const_iterator MolOtherWalker = MolWalker; MolOtherWalker != molecules->ListOfMolecules.end(); MolOtherWalker++){
             if ((*MolOtherWalker)->ActiveFlag) {
               DoLog(2) && (Log() << 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;
-                DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << *OtherWalker << "." << endl);
-                if (Walker->nr < OtherWalker->nr)
-                  if ((type2 == NULL) || (OtherWalker->type == type2)) {
-                    distance = Walker->node->PeriodicDistance(*OtherWalker->node, World::getInstance().getDomain());
-                    //Log() << Verbose(1) <<"Inserting " << *Walker << " and " << *OtherWalker << endl;
-                    outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> (Walker, OtherWalker) ) );
+              for (molecule::const_iterator runner = (*MolOtherWalker)->begin(); runner != (*MolOtherWalker)->end(); ++runner) {
+                DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << **runner << "." << endl);
+                if ((*iter)->getId() < (*runner)->getId()){
+                  if ((type2 == NULL) || ((*runner)->type == type2)) {
+                    distance = (*iter)->node->PeriodicDistance(*(*runner)->node,  World::getInstance().getDomain());
+                    //Log() << Verbose(1) <<"Inserting " << *(*iter) << " and " << *(*runner) << endl;
+                    outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> ((*iter), (*runner)) ) );
                   }
+                }
               }
+            }
           }
         }
       }
     }
-
+  }
   return outmap;
 };
@@ -101 +100 @@
       double * FullInverseMatrix = InverseMatrix(FullMatrix);
       DoeLog(2) && (eLog()<< Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
-      atom *Walker = (*MolWalker)->start;
-      while (Walker->next != (*MolWalker)->end) {
-        Walker = Walker->next;
-        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << *Walker << "." << endl);
-        if ((type1 == NULL) || (Walker->type == type1)) {
-          periodicX = *(Walker->node);
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+        if ((type1 == NULL) || ((*iter)->type == type1)) {
+          periodicX = *(*iter)->node;
           periodicX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
           // go through every range in xyz and get distance
@@ -117 +114 @@
                   if ((*MolOtherWalker)->ActiveFlag) {
                     DoLog(2) && (Log() << 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;
-                      DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << *OtherWalker << "." << endl);
-                      if (Walker->nr < OtherWalker->nr)
-                        if ((type2 == NULL) || (OtherWalker->type == type2)) {
-                          periodicOtherX = *(OtherWalker->node);
+                    for (molecule::const_iterator runner = (*MolOtherWalker)->begin(); runner != (*MolOtherWalker)->end(); ++runner) {
+                      DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << **runner << "." << endl);
+                      if ((*iter)->nr < (*runner)->nr)
+                        if ((type2 == NULL) || ((*runner)->type == type2)) {
+                          periodicOtherX = *(*runner)->node;
                           periodicOtherX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
                           // go through every range in xyz and get distance
@@ -132 +127 @@
                                 checkOtherX.MatrixMultiplication(FullMatrix);
                                 distance = checkX.distance(checkOtherX);
-                                //Log() << Verbose(1) <<"Inserting " << *Walker << " and " << *OtherWalker << endl;
-                                outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> (Walker, OtherWalker) ) );
+                                //Log() << Verbose(1) <<"Inserting " << *(*iter) << " and " << *(*runner) << endl;
+                                outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> ((*iter), (*runner)) ) );
                               }
                         }
@@ -169 +164 @@
     if ((*MolWalker)->ActiveFlag) {
       DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
-      atom *Walker = (*MolWalker)->start;
-      while (Walker->next != (*MolWalker)->end) {
-        Walker = Walker->next;
-        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << *Walker << "." << endl);
-        if ((type == NULL) || (Walker->type == type)) {
-          distance = Walker->node->PeriodicDistance(*point, World::getInstance().getDomain());
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+        if ((type == NULL) || ((*iter)->type == type)) {
+          distance = (*iter)->node->PeriodicDistance(*point, World::getInstance().getDomain());
           DoLog(4) && (Log() << Verbose(4) << "Current distance is " << distance << "." << endl);
-          outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> (Walker, point) ) );
+          outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> ((*iter), point) ) );
         }
       }
@@ -211 +204 @@
       double * FullInverseMatrix = InverseMatrix(FullMatrix);
       DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
-      atom *Walker = (*MolWalker)->start;
-      while (Walker->next != (*MolWalker)->end) {
-        Walker = Walker->next;
-        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << *Walker << "." << endl);
-        if ((type == NULL) || (Walker->type == type)) {
-          periodicX = *(Walker->node);
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+        if ((type == NULL) || ((*iter)->type == type)) {
+          periodicX = *(*iter)->node;
           periodicX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
           // go through every range in xyz and get distance
@@ -226 +217 @@
                 distance = checkX.distance(*point);
                 DoLog(4) && (Log() << Verbose(4) << "Current distance is " << distance << "." << endl);
-                outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> (Walker, point) ) );
+                outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> (*iter, point) ) );
               }
         }
@@ -261 +252 @@
     if ((*MolWalker)->ActiveFlag) {
       DoLog(1) && (Log() << Verbose(1) << "Current molecule is " << (*MolWalker)->name << "." << endl);
-      atom *Walker = (*MolWalker)->start;
-      while (Walker->next != (*MolWalker)->end) {
-        Walker = Walker->next;
-        //Log() << Verbose(1) << "Current atom is " << *Walker << "." << endl;
-        if ((type == NULL) || (Walker->type == type)) {
-          TriangleIntersectionList Intersections(Walker->node,Surface,LC);
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        //Log() << Verbose(3) << "Current atom is " << *(*iter) << "." << endl;
+        if ((type == NULL) || ((*iter)->type == type)) {
+          TriangleIntersectionList Intersections((*iter)->node,Surface,LC);
           distance = Intersections.GetSmallestDistance();
           triangle = Intersections.GetClosestTriangle();
-          outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(distance, pair<atom *, BoundaryTriangleSet*> (Walker, triangle) ) );
+          outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(distance, pair<atom *, BoundaryTriangleSet*> ((*iter), triangle) ) );
         }
       }
@@ -314 +303 @@
       double * FullInverseMatrix = InverseMatrix(FullMatrix);
       DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
-      atom *Walker = (*MolWalker)->start;
-      while (Walker->next != (*MolWalker)->end) {
-        Walker = Walker->next;
-        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << *Walker << "." << endl);
-        if ((type == NULL) || (Walker->type == type)) {
-          periodicX = *(Walker->node);
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+        if ((type == NULL) || ((*iter)->type == type)) {
+          periodicX = *(*iter)->node;
           periodicX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
           // go through every range in xyz and get distance
@@ -337 +324 @@
               }
           // insert
-          outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(ShortestDistance, pair<atom *, BoundaryTriangleSet*> (Walker, ShortestTriangle) ) );
+          outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(ShortestDistance, pair<atom *, BoundaryTriangleSet*> (*iter, ShortestTriangle) ) );
           //Log() << Verbose(1) << "INFO: Inserting " << Walker << " with distance " << ShortestDistance << " to " << *ShortestTriangle << "." << endl;
         }

src/atom.cpp

@@ -59 +59 @@
 atom::~atom()
 {
-  unlink(this);
 };
 

src/bondgraph.cpp

@@ -90 +90 @@
 bool status = true;
 
-  if (mol->start->next == mol->end) // only construct if molecule is not empty
+  if (mol->empty()) // only construct if molecule is not empty
     return false;
 
@@ -124 +124 @@
   max_distance = 0.;
 
-  atom *Runner = mol->start;
-  while (Runner->next != mol->end) {
-    Runner = Runner->next;
-    if (Runner->type->CovalentRadius > max_distance)
-      max_distance = Runner->type->CovalentRadius;
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    if ((*iter)->type->CovalentRadius > max_distance)
+      max_distance = (*iter)->type->CovalentRadius;
   }
   max_distance *= 2.;

src/boundary.cpp

@@ -139 +139 @@
 {
         Info FunctionInfo(__func__);
-  atom *Walker = NULL;
   PointMap PointsOnBoundary;
   LineMap LinesOnBoundary;
@@ -165 +164 @@
 
     // 3b. construct set of all points, transformed into cylindrical system and with left and right neighbours
-    Walker = mol->start;
-    while (Walker->next != mol->end) {
-      Walker = Walker->next;
-      ProjectedVector = Walker->x - (*MolCenter);
+    for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+      ProjectedVector = (*iter)->x - (*MolCenter);
       ProjectedVector.ProjectOntoPlane(AxisVector);
 
@@ -182 +179 @@
         angle = 2. * M_PI - angle;
       }
-      DoLog(1) && (Log() << Verbose(1) << "Inserting " << *Walker << ": (r, alpha) = (" << radius << "," << angle << "): " << ProjectedVector << endl);
-      BoundaryTestPair = BoundaryPoints[axis].insert(BoundariesPair(angle, DistancePair (radius, Walker)));
+    DoLog(1) && (Log() << Verbose(1) << "Inserting " << **iter << ": (r, alpha) = (" << radius << "," << angle << "): " << ProjectedVector << endl);
+      BoundaryTestPair = BoundaryPoints[axis].insert(BoundariesPair(angle, DistancePair (radius, (*iter))));
       if (!BoundaryTestPair.second) { // same point exists, check first r, then distance of original vectors to center of gravity
         DoLog(2) && (Log() << Verbose(2) << "Encountered two vectors whose projection onto axis " << axis << " is equal: " << endl);
         DoLog(2) && (Log() << Verbose(2) << "Present vector: " << *BoundaryTestPair.first->second.second << endl);
-        DoLog(2) && (Log() << Verbose(2) << "New vector: " << *Walker << endl);
+        DoLog(2) && (Log() << Verbose(2) << "New vector: " << **iter << endl);
         const double ProjectedVectorNorm = ProjectedVector.NormSquared();
         if ((ProjectedVectorNorm - BoundaryTestPair.first->second.first) > MYEPSILON) {
           BoundaryTestPair.first->second.first = ProjectedVectorNorm;
-          BoundaryTestPair.first->second.second = Walker;
+          BoundaryTestPair.first->second.second = (*iter);
           DoLog(2) && (Log() << Verbose(2) << "Keeping new vector due to larger projected distance " << ProjectedVectorNorm << "." << endl);
         } else if (fabs(ProjectedVectorNorm - BoundaryTestPair.first->second.first) < MYEPSILON) {
-          helper = Walker->x - (*MolCenter);
+          helper = (*iter)->x;
+          helper -= *MolCenter;
           const double oldhelperNorm = helper.NormSquared();
           helper = BoundaryTestPair.first->second.second->x - (*MolCenter);
           if (helper.NormSquared() < oldhelperNorm) {
-            BoundaryTestPair.first->second.second = Walker;
+            BoundaryTestPair.first->second.second = (*iter);
             DoLog(2) && (Log() << Verbose(2) << "Keeping new vector due to larger distance to molecule center " << helper.NormSquared() << "." << endl);
           } else {
@@ -620 +618 @@
   for (TriangleMap::iterator runner = TesselStruct->TrianglesOnBoundary.begin(); runner != TesselStruct->TrianglesOnBoundary.end(); runner++)
     { // go through every triangle, calculate volume of its pyramid with CoG as peak
-      x = (*runner->second->endpoints[0]->node->node) - (*runner->second->endpoints[1]->node->node);
-      y = (*runner->second->endpoints[0]->node->node) - (*runner->second->endpoints[2]->node->node);
-      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));
+      x = runner->second->getEndpoint(0) - runner->second->getEndpoint(1);
+      y = runner->second->getEndpoint(0) - runner->second->getEndpoint(2);
+      const double a = x.Norm();
+      const double b = y.Norm();
+      const double c = runner->second->getEndpoint(2).distance(runner->second->getEndpoint(1));
       const double G = sqrt(((a + b + c) * (a + b + c) - 2 * (a * a + b * b + c * c)) / 16.); // area of tesselated triangle
-      x = Plane(*(runner->second->endpoints[0]->node->node),
-                *(runner->second->endpoints[1]->node->node),
-                *(runner->second->endpoints[2]->node->node)).getNormal();
-      x.Scale(runner->second->endpoints[1]->node->node->ScalarProduct(x));
+      x = runner->second->getPlane().getNormal();
+      x.Scale(runner->second->getEndpoint(1).ScalarProduct(x));
       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)
@@ -697 +693 @@
   int repetition[NDIM] = { 1, 1, 1 };
   int TotalNoClusters = 1;
-  atom *Walker = NULL;
   double totalmass = 0.;
   double clustervolume = 0.;
@@ -721 +716 @@
 
   // sum up the atomic masses
-  Walker = mol->start;
-  while (Walker->next != mol->end) {
-      Walker = Walker->next;
-      totalmass += Walker->type->mass;
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+      totalmass += (*iter)->type->mass;
   }
   DoLog(0) && (Log() << Verbose(0) << "RESULT: The summed mass is " << setprecision(10) << totalmass << " atomicmassunit." << endl);
@@ -806 +799 @@
   Vector Inserter;
   double FillIt = false;
-  atom *Walker = NULL;
   bond *Binder = NULL;
   double phi[NDIM];
@@ -813 +805 @@
 
   for (MoleculeList::iterator ListRunner = List->ListOfMolecules.begin(); ListRunner != List->ListOfMolecules.end(); ListRunner++)
-    if ((*ListRunner)->AtomCount > 0) {
+    if ((*ListRunner)->getAtomCount() > 0) {
       DoLog(1) && (Log() << Verbose(1) << "Pre-creating linked cell lists for molecule " << *ListRunner << "." << endl);
       LCList[(*ListRunner)] = new LinkedCell((*ListRunner), 10.); // get linked cell list
@@ -831 +823 @@
   }
 
-  filler->CountAtoms();
-  atom * CopyAtoms[filler->AtomCount];
+  atom * CopyAtoms[filler->getAtomCount()];
 
   // calculate filler grid in [0,1]^3
@@ -857 +848 @@
 
         // go through all atoms
-        for (int i=0;i<filler->AtomCount;i++)
+        for (int i=0;i<filler->getAtomCount();i++)
           CopyAtoms[i] = NULL;
-        Walker = filler->start;
-        while (Walker->next != filler->end) {
-          Walker = Walker->next;
+        for(molecule::iterator iter = filler->begin(); iter !=filler->end();++filler){
 
           // create atomic random translation vector ...
@@ -885 +874 @@
 
           // ... and put at new position
-          Inserter = Walker->x;
+          Inserter = (*iter)->x;
           if (DoRandomRotation)
             Inserter.MatrixMultiplication(Rotations);
@@ -909 +898 @@
             DoLog(1) && (Log() << Verbose(1) << "INFO: Position at " << Inserter << " is outer point." << endl);
             // copy atom ...
-            CopyAtoms[Walker->nr] = Walker->clone();
-            CopyAtoms[Walker->nr]->x = Inserter;
-            Filling->AddAtom(CopyAtoms[Walker->nr]);
-            DoLog(4) && (Log() << Verbose(4) << "Filling atom " << *Walker << ", translated to " << AtomTranslations << ", at final position is " << (CopyAtoms[Walker->nr]->x) << "." << endl);
+            CopyAtoms[(*iter)->nr] = (*iter)->clone();
+            CopyAtoms[(*iter)->nr]->x = Inserter;
+            Filling->AddAtom(CopyAtoms[(*iter)->nr]);
+            DoLog(4) && (Log() << Verbose(4) << "Filling atom " << **iter << ", translated to " << AtomTranslations << ", at final position is " << (CopyAtoms[(*iter)->nr]->x) << "." << endl);
           } else {
             DoLog(1) && (Log() << Verbose(1) << "INFO: Position at " << Inserter << " is inner point, within boundary or outside of MaxDistance." << endl);
-            CopyAtoms[Walker->nr] = NULL;
+            CopyAtoms[(*iter)->nr] = NULL;
             continue;
           }
@@ -954 +943 @@
   bool TesselationFailFlag = false;
 
+  mol->getAtomCount();
+
   if (TesselStruct == NULL) {
     DoLog(1) && (Log() << Verbose(1) << "Allocating Tesselation struct ..." << endl);
@@ -1025 +1016 @@
 //  // look whether all points are inside of the convex envelope, otherwise add them via degenerated triangles
 //  //->InsertStraddlingPoints(mol, LCList);
-//  mol->GoToFirst();
+//  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
 //  class TesselPoint *Runner = NULL;
-//  while (!mol->IsEnd()) {
-//    Runner = mol->GetPoint();
+//    Runner = *iter;
 //    Log() << Verbose(1) << "Checking on " << Runner->Name << " ... " << endl;
 //    if (!->IsInnerPoint(Runner, LCList)) {
@@ -1036 +1026 @@
 //      Log() << Verbose(2) << Runner->Name << " is inside of or on envelope." << endl;
 //    }
-//    mol->GoToNext();
 //  }
 
@@ -1045 +1034 @@
   status = CheckListOfBaselines(TesselStruct);
 
+  cout << "before correction" << endl;
+
   // store before correction
-  StoreTrianglesinFile(mol, (const Tesselation *&)TesselStruct, filename, "");
+  StoreTrianglesinFile(mol, TesselStruct, filename, "");
 
 //  // correct degenerated polygons
@@ -1056 +1047 @@
   // write final envelope
   CalculateConcavityPerBoundaryPoint(TesselStruct);
-  StoreTrianglesinFile(mol, (const Tesselation *&)TesselStruct, filename, "");
+  cout << "after correction" << endl;
+  StoreTrianglesinFile(mol, TesselStruct, filename, "");
 
   if (freeLC)

src/builder.cpp

@@ -865 +865 @@
 
         mol->CountAtoms(); // recount atoms
-        if (mol->AtomCount != 0) {  // if there is more than none
-          count = mol->AtomCount;  // is changed becausing of adding, thus has to be stored away beforehand
+        if (mol->getAtomCount() != 0) {  // if there is more than none
+          count = mol->getAtomCount();  // is changed becausing of adding, thus has to be stored away beforehand
           Elements = new element *[count];
           vectors = new Vector *[count];
@@ -1296 +1296 @@
   // generate some KeySets
   DoLog(0) && (Log() << Verbose(0) << "Generating KeySets." << endl);
-  KeySet TestSets[mol->AtomCount+1];
+  KeySet TestSets[mol->getAtomCount()+1];
   i=1;
   while (Walker->next != mol->end) {
@@ -1307 +1307 @@
   DoLog(0) && (Log() << Verbose(0) << "Testing insertion of already present item in KeySets." << endl);
   KeySetTestPair test;
-  test = TestSets[mol->AtomCount-1].insert(Walker->nr);
+  test = TestSets[mol->getAtomCount()-1].insert(Walker->nr);
   if (test.second) {
     DoLog(1) && (Log() << Verbose(1) << "Insertion worked?!" << endl);
@@ -1313 +1313 @@
     DoLog(1) && (Log() << Verbose(1) << "Insertion rejected: Present object is " << (*test.first) << "." << endl);
   }
-  TestSets[mol->AtomCount].insert(mol->end->previous->nr);
-  TestSets[mol->AtomCount].insert(mol->end->previous->previous->previous->nr);
+  TestSets[mol->getAtomCount()].insert(mol->end->previous->nr);
+  TestSets[mol->getAtomCount()].insert(mol->end->previous->previous->previous->nr);
 
   // constructing Graph structure
@@ -1322 +1322 @@
   // insert KeySets into Subgraphs
   DoLog(0) && (Log() << Verbose(0) << "Inserting KeySets into Subgraph class." << endl);
-  for (int j=0;j<mol->AtomCount;j++) {
+  for (int j=0;j<mol->getAtomCount();j++) {
     Subgraphs.insert(GraphPair (TestSets[j],pair<int, double>(counter++, 1.)));
   }
   DoLog(0) && (Log() << Verbose(0) << "Testing insertion of already present item in Subgraph." << endl);
   GraphTestPair test2;
-  test2 = Subgraphs.insert(GraphPair (TestSets[mol->AtomCount],pair<int, double>(counter++, 1.)));
+  test2 = Subgraphs.insert(GraphPair (TestSets[mol->getAtomCount()],pair<int, double>(counter++, 1.)));
   if (test2.second) {
     DoLog(1) && (Log() << Verbose(1) << "Insertion worked?!" << endl);
@@ -1714 +1714 @@
                 if (first->type != NULL) {
                   mol->AddAtom(first);  // add to molecule
-                  if ((configPresent == empty) && (mol->AtomCount != 0))
+                  if ((configPresent == empty) && (mol->getAtomCount() != 0))
                     configPresent = present;
                 } else
@@ -1732 +1732 @@
                 DoLog(1) && (Log() << Verbose(1) << "Depth-First-Search Analysis." << endl);
                 MoleculeLeafClass *Subgraphs = NULL;      // list of subgraphs from DFS analysis
-                int *MinimumRingSize = new int[mol->AtomCount];
+                int *MinimumRingSize = new int[mol->getAtomCount()];
                 atom ***ListOfLocalAtoms = NULL;
                 class StackClass<bond *> *BackEdgeStack = NULL;
@@ -1880 +1880 @@
                           int counter  = 0;
                           for (MoleculeList::iterator BigFinder = molecules->ListOfMolecules.begin(); BigFinder != molecules->ListOfMolecules.end(); BigFinder++) {
-                            if ((Boundary == NULL) || (Boundary->AtomCount < (*BigFinder)->AtomCount)) {
+                            if ((Boundary == NULL) || (Boundary->getAtomCount() < (*BigFinder)->getAtomCount())) {
                               Boundary = *BigFinder;
                             }
@@ -1939 +1939 @@
                 performCriticalExit();
               } else {
+                mol->getAtomCount();
                 SaveFlag = true;
                 DoLog(1) && (Log() << Verbose(1) << "Changing atom " << argv[argptr] << " to element " << argv[argptr+1] << "." << endl);
@@ -2042 +2043 @@
                 int counter  = 0;
                 for (MoleculeList::iterator BigFinder = molecules->ListOfMolecules.begin(); BigFinder != molecules->ListOfMolecules.end(); BigFinder++) {
-                  (*BigFinder)->CountAtoms();
-                  if ((Boundary == NULL) || (Boundary->AtomCount < (*BigFinder)->AtomCount)) {
+                  if ((Boundary == NULL) || (Boundary->getAtomCount() < (*BigFinder)->getAtomCount())) {
                     Boundary = *BigFinder;
                   }
                   counter++;
                 }
-                DoLog(1) && (Log() << Verbose(1) << "Biggest molecule has " << Boundary->AtomCount << " atoms." << endl);
+                DoLog(1) && (Log() << Verbose(1) << "Biggest molecule has " << Boundary->getAtomCount() << " atoms." << endl);
                 start = clock();
                 LCList = new LinkedCell(Boundary, atof(argv[argptr])*2.);
@@ -2115 +2115 @@
             case 'R':
               if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr+1 >= argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])))  {
+              if ((argptr+3 >= argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) || (!IsValidNumber(argv[argptr+3])))  {
                 ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for removing atoms: -R <id> <distance>" << endl);
+                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for removing atoms: -R <x> <y> <z> <distance>" << endl);
                 performCriticalExit();
               } else {
                 SaveFlag = true;
-                DoLog(1) && (Log() << Verbose(1) << "Removing atoms around " << argv[argptr] << " with radius " << argv[argptr+1] << "." << endl);
-                double tmp1 = atof(argv[argptr+1]);
-                atom *third = mol->FindAtom(atoi(argv[argptr]));
-                atom *first = mol->start;
-                if ((third != NULL) && (first != mol->end)) {
-                  atom *second = first->next;
-                  while(second != mol->end) {
-                    first = second;
-                    second = first->next;
-                    if (first->x.DistanceSquared(third->x) > tmp1*tmp1) {// distance to first above radius ...
-                      mol->RemoveAtom(first);
-                    }
+                const double radius = atof(argv[argptr+3]);
+                Vector point(atof(argv[argptr]),atof(argv[argptr+1]),atof(argv[argptr+2]));
+                DoLog(1) && (Log() << Verbose(1) << "Removing atoms around " << point << " with radius " << radius << "." << endl);
+                atom *Walker = NULL;
+                molecule::iterator advancer = mol->begin();
+                for(molecule::iterator iter = advancer; advancer != mol->end();) {
+                  iter = advancer++;
+                  if ((*iter)->x.DistanceSquared(point) > radius*radius){ // distance to first above radius ...
+                    Walker = (*iter);
+                    DoLog(1) && (Log() << Verbose(1) << "Removing atom " << *Walker << "." << endl);
+                    mol->RemoveAtom(*(iter));
+                    World::getInstance().destroyAtom(Walker);
                   }
-                } else {
-                  DoeLog(1) && (eLog()<< Verbose(1) << "Removal failed due to missing atoms on molecule or wrong id." << endl);
                 }
-                argptr+=2;
+                argptr+=4;
               }
               break;
@@ -2262 +2260 @@
                 performCriticalExit();
               } else {
+                mol->getAtomCount();
                 SaveFlag = true;
                 DoLog(1) && (Log() << Verbose(1) << "Removing atom " << argv[argptr] << "." << endl);
@@ -2381 +2380 @@
                     faktor = 1;
                   }
-                  mol->CountAtoms();  // recount atoms
-                  if (mol->AtomCount != 0) {  // if there is more than none
-                    count = mol->AtomCount;   // is changed becausing of adding, thus has to be stored away beforehand
+                  if (mol->getAtomCount() != 0) {  // if there is more than none
+                    count = mol->getAtomCount();   // is changed becausing of adding, thus has to be stored away beforehand
                     Elements = new const element *[count];
                     vectors = new Vector *[count];
                     j = 0;
-                    first = mol->start;
-                    while (first->next != mol->end) {  // make a list of all atoms with coordinates and element
-                      first = first->next;
-                      Elements[j] = first->type;
-                      vectors[j] = &first->x;
+                    for(molecule::iterator iter = mol->begin();iter!=mol->end();++iter){
+                      Elements[j] = (*iter)->type;
+                      vectors[j] = &(*iter)->x;
                       j++;
                     }
@@ -2458 +2454 @@
 {
     config *configuration = World::getInstance().getConfig();
+    // while we are non interactive, we want to abort from asserts
+    //ASSERT_DO(Assert::Abort);
+    molecule *mol = NULL;
     Vector x, y, z, n;
     ifstream test;
@@ -2481 +2480 @@
     // need to init the history before any action is created
     ActionHistory::init();
+
+    // In the interactive mode, we can leave the user the choice in case of error
+    ASSERT_DO(Assert::Ask);
 
     // from this moment on, we need to be sure to deeinitialize in the correct order

src/config.cpp

@@ -1548 +1548 @@
   int AtomNo = -1;
   int MolNo = 0;
-  atom *Walker = NULL;
   FILE *f = NULL;
 
@@ -1561 +1560 @@
   fprintf(f, "# Created by MoleCuilder\n");
 
-  for (MoleculeList::const_iterator Runner = MolList->ListOfMolecules.begin(); Runner != MolList->ListOfMolecules.end(); Runner++) {
-    Walker = (*Runner)->start;
+  for (MoleculeList::const_iterator MolRunner = MolList->ListOfMolecules.begin(); MolRunner != MolList->ListOfMolecules.end(); MolRunner++) {
     int *elementNo = new int[MAX_ELEMENTS];
     for (int i=0;i<MAX_ELEMENTS;i++)
       elementNo[i] = 0;
     AtomNo = 0;
-    while (Walker->next != (*Runner)->end) {
-      Walker = Walker->next;
-      sprintf(name, "%2s%2d",Walker->type->symbol, elementNo[Walker->type->Z]);
-      elementNo[Walker->type->Z] = (elementNo[Walker->type->Z]+1) % 100;   // confine to two digits
+    for (molecule::const_iterator iter = (*MolRunner)->begin(); iter != (*MolRunner)->end(); ++iter) {
+      sprintf(name, "%2s%2d",(*iter)->type->symbol, elementNo[(*iter)->type->Z]);
+      elementNo[(*iter)->type->Z] = (elementNo[(*iter)->type->Z]+1) % 100;   // confine to two digits
       fprintf(f,
              "ATOM %6u %-4s %4s%c%4u    %8.3f%8.3f%8.3f%6.2f%6.2f      %4s%2s%2s\n",
-             Walker->nr,                /* atom serial number */
+             (*iter)->nr,                /* atom serial number */
              name,         /* atom name */
-             (*Runner)->name,      /* residue name */
+             (*MolRunner)->name,      /* residue name */
              'a'+(unsigned char)(AtomNo % 26),           /* letter for chain */
              MolNo,         /* residue sequence number */
-             Walker->node->at(0),                 /* position X in Angstroem */
-             Walker->node->at(1),                 /* position Y in Angstroem */
-             Walker->node->at(2),                 /* position Z in Angstroem */
-             (double)Walker->type->Valence,         /* occupancy */
-             (double)Walker->type->NoValenceOrbitals,          /* temperature factor */
+             (*iter)->node->at(0),                 /* position X in Angstroem */
+             (*iter)->node->at(1),                 /* position Y in Angstroem */
+             (*iter)->node->at(2),                 /* position Z in Angstroem */
+             (double)(*iter)->type->Valence,         /* occupancy */
+             (double)(*iter)->type->NoValenceOrbitals,          /* temperature factor */
              "0",            /* segment identifier */
-             Walker->type->symbol,    /* element symbol */
+             (*iter)->type->symbol,    /* element symbol */
              "0");           /* charge */
       AtomNo++;
@@ -1604 +1601 @@
 {
   int AtomNo = -1;
-  atom *Walker = NULL;
   FILE *f = NULL;
 
@@ -1621 +1617 @@
   fprintf(f, "# Created by MoleCuilder\n");
 
-  Walker = mol->start;
   AtomNo = 0;
-  while (Walker->next != mol->end) {
-    Walker = Walker->next;
-    sprintf(name, "%2s%2d",Walker->type->symbol, elementNo[Walker->type->Z]);
-    elementNo[Walker->type->Z] = (elementNo[Walker->type->Z]+1) % 100;   // confine to two digits
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    sprintf(name, "%2s%2d",(*iter)->type->symbol, elementNo[(*iter)->type->Z]);
+    elementNo[(*iter)->type->Z] = (elementNo[(*iter)->type->Z]+1) % 100;   // confine to two digits
     fprintf(f,
            "ATOM %6u %-4s %4s%c%4u    %8.3f%8.3f%8.3f%6.2f%6.2f      %4s%2s%2s\n",
-           Walker->nr,                /* atom serial number */
+           (*iter)->nr,                /* atom serial number */
            name,         /* atom name */
            mol->name,      /* residue name */
            'a'+(unsigned char)(AtomNo % 26),           /* letter for chain */
            0,         /* residue sequence number */
-           Walker->node->at(0),                 /* position X in Angstroem */
-           Walker->node->at(1),                 /* position Y in Angstroem */
-           Walker->node->at(2),                 /* position Z in Angstroem */
-           (double)Walker->type->Valence,         /* occupancy */
-           (double)Walker->type->NoValenceOrbitals,          /* temperature factor */
+           (*iter)->node->at(0),                 /* position X in Angstroem */
+           (*iter)->node->at(1),                 /* position Y in Angstroem */
+           (*iter)->node->at(2),                 /* position Z in Angstroem */
+           (double)(*iter)->type->Valence,         /* occupancy */
+           (double)(*iter)->type->NoValenceOrbitals,          /* temperature factor */
            "0",            /* segment identifier */
-           Walker->type->symbol,    /* element symbol */
+           (*iter)->type->symbol,    /* element symbol */
            "0");           /* charge */
     AtomNo++;
@@ -1658 +1652 @@
 bool config::SaveTREMOLO(const char * const filename, const molecule * const mol) const
 {
-  atom *Walker = NULL;
   ofstream *output = NULL;
   stringstream * const fname = new stringstream;
@@ -1671 +1664 @@
 
   // scan maximum number of neighbours
-  Walker = mol->start;
   int MaxNeighbours = 0;
-  while (Walker->next != mol->end) {
-    Walker = Walker->next;
-    const int count = Walker->ListOfBonds.size();
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    const int count = (*iter)->ListOfBonds.size();
     if (MaxNeighbours < count)
       MaxNeighbours = count;
   }
-  *output << "# ATOMDATA Id name resName resSeq x=3 charge type neighbors=" << MaxNeighbours << endl;
-
-  Walker = mol->start;
-  while (Walker->next != mol->end) {
-    Walker = Walker->next;
-    *output << Walker->nr << "\t";
-    *output << Walker->getName() << "\t";
+  *output << "# ATOMDATA Id name resName resSeq x=3 Charge type neighbors=" << MaxNeighbours << endl;
+
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    *output << (*iter)->nr << "\t";
+    *output << (*iter)->getName() << "\t";
     *output << mol->name << "\t";
     *output << 0 << "\t";
-    *output << Walker->node->at(0) << "\t" << Walker->node->at(1) << "\t" << Walker->node->at(2) << "\t";
-    *output << static_cast<double>(Walker->type->Valence) << "\t";
-    *output << Walker->type->symbol << "\t";
-    for (BondList::iterator runner = Walker->ListOfBonds.begin(); runner != Walker->ListOfBonds.end(); runner++)
-      *output << (*runner)->GetOtherAtom(Walker)->nr << "\t";
-    for(int i=Walker->ListOfBonds.size(); i < MaxNeighbours; i++)
+    *output << (*iter)->node->at(0) << "\t" << (*iter)->node->at(1) << "\t" << (*iter)->node->at(2) << "\t";
+    *output << static_cast<double>((*iter)->type->Valence) << "\t";
+    *output << (*iter)->type->symbol << "\t";
+    for (BondList::iterator runner = (*iter)->ListOfBonds.begin(); runner != (*iter)->ListOfBonds.end(); runner++)
+      *output << (*runner)->GetOtherAtom(*iter)->nr << "\t";
+    for(int i=(*iter)->ListOfBonds.size(); i < MaxNeighbours; i++)
       *output << "-\t";
     *output << endl;
@@ -1714 +1703 @@
 {
   Info FunctionInfo(__func__);
-  atom *Walker = NULL;
   ofstream *output = NULL;
   stringstream * const fname = new stringstream;
@@ -1729 +1717 @@
   int MaxNeighbours = 0;
   for (MoleculeList::const_iterator MolWalker = MolList->ListOfMolecules.begin(); MolWalker != MolList->ListOfMolecules.end(); MolWalker++) {
-    Walker = (*MolWalker)->start;
-    while (Walker->next != (*MolWalker)->end) {
-      Walker = Walker->next;
-      const int count = Walker->ListOfBonds.size();
+    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+      const int count = (*iter)->ListOfBonds.size();
       if (MaxNeighbours < count)
         MaxNeighbours = count;
     }
   }
-  *output << "# ATOMDATA Id name resName resSeq x=3 charge type neighbors=" << MaxNeighbours << endl;
+  *output << "# ATOMDATA Id name resName resSeq x=3 Charge type neighbors=" << MaxNeighbours << endl;
 
   // create global to local id map
@@ -1745 +1731 @@
     int AtomNo = 1;
     for (MoleculeList::const_iterator MolWalker = MolList->ListOfMolecules.begin(); MolWalker != MolList->ListOfMolecules.end(); MolWalker++) {
-      atom *Walker = (*MolWalker)->start;
-      while (Walker->next != (*MolWalker)->end) {
-        Walker = Walker->next;
-        LocalNotoGlobalNoMap.insert( pair<int,int>(Walker->getId(), AtomNo++) );
+      for(molecule::iterator AtomRunner = (*MolWalker)->begin(); AtomRunner != (*MolWalker)->end(); ++AtomRunner) {
+        LocalNotoGlobalNoMap.insert( pair<int,int>((*AtomRunner)->getId(), AtomNo++) );
       }
       MolCounter++;
@@ -1760 +1744 @@
     int AtomNo = 0;
     for (MoleculeList::const_iterator MolWalker = MolList->ListOfMolecules.begin(); MolWalker != MolList->ListOfMolecules.end(); MolWalker++) {
-      Walker = (*MolWalker)->start;
-      while (Walker->next != (*MolWalker)->end) {
-        Walker = Walker->next;
-        *output << LocalNotoGlobalNoMap[ Walker->getId() ] << "\t";
-        *output << Walker->getName() << "\t";
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        *output << LocalNotoGlobalNoMap[ (*iter)->getId() ] << "\t";
+        *output << (*iter)->getName() << "\t";
         *output << (*MolWalker)->name << "\t";
         *output << MolCounter+1 << "\t";
-        *output << Walker->node->at(0) << "\t" << Walker->node->at(1) << "\t" << Walker->node->at(2) << "\t";
-        *output << (double)Walker->type->Valence << "\t";
-        *output << Walker->type->symbol << "\t";
-        for (BondList::iterator runner = Walker->ListOfBonds.begin(); runner != Walker->ListOfBonds.end(); runner++)
-          *output << LocalNotoGlobalNoMap[ (*runner)->GetOtherAtom(Walker)->getId() ] << "\t";
-        for(int i=Walker->ListOfBonds.size(); i < MaxNeighbours; i++)
+        *output << (*iter)->node->at(0) << "\t" << (*iter)->node->at(1) << "\t" << (*iter)->node->at(2) << "\t";
+        *output << (double)(*iter)->type->Valence << "\t";
+        *output << (*iter)->type->symbol << "\t";
+        for (BondList::iterator runner = (*iter)->ListOfBonds.begin(); runner != (*iter)->ListOfBonds.end(); runner++)
+          *output << LocalNotoGlobalNoMap[ (*runner)->GetOtherAtom((*iter))->getId() ] << "\t";
+        for(int i=(*iter)->ListOfBonds.size(); i < MaxNeighbours; i++)
           *output << "-\t";
         *output << endl;
@@ -1813 +1795 @@
   if (output == NULL)
     strcpy(filename,"main_pcp_linux");
-  Log() << Verbose(0) << "Saving as pdb input ";
+  Log() << Verbose(0) << "Saving as pdb input ... " << endl;
   if (SavePDB(filename, molecules))
-    Log() << Verbose(0) << "done." << endl;
+    Log() << Verbose(0) << "\t... done." << endl;
   else
-    Log() << Verbose(0) << "failed." << endl;
+    Log() << Verbose(0) << "\t... failed." << endl;
 
   // then save as tremolo data file
@@ -1824 +1806 @@
   if (output == NULL)
     strcpy(filename,"main_pcp_linux");
-  Log() << Verbose(0) << "Saving as tremolo data input ";
+  Log() << Verbose(0) << "Saving as tremolo data input ... " << endl;
   if (SaveTREMOLO(filename, molecules))
-    Log() << Verbose(0) << "done." << endl;
+    Log() << Verbose(0) << "\t... done." << endl;
   else
-    Log() << Verbose(0) << "failed." << endl;
+    Log() << Verbose(0) << "\t... failed." << endl;
 
   // translate each to its center and merge all molecules in MoleculeListClass into this molecule
@@ -1864 +1846 @@
   output.close();
   output.clear();
-  Log() << Verbose(0) << "Saving of config file ";
+  Log() << Verbose(0) << "Saving of config file ... " << endl;
   if (Save(filename, periode, mol))
-    Log() << Verbose(0) << "successful." << endl;
+    Log() << Verbose(0) << "\t... successful." << endl;
   else
-    Log() << Verbose(0) << "failed." << endl;
+    Log() << Verbose(0) << "\t... failed." << endl;
 
   // and save to xyz file
@@ -1881 +1863 @@
     output.open(filename, ios::trunc);
   }
-  Log() << Verbose(0) << "Saving of XYZ file ";
+  Log() << Verbose(0) << "Saving of XYZ file ... " << endl;
   if (mol->MDSteps <= 1) {
     if (mol->OutputXYZ(&output))
-      Log() << Verbose(0) << "successful." << endl;
+      Log() << Verbose(0) << "\t... successful." << endl;
     else
-      Log() << Verbose(0) << "failed." << endl;
+      Log() << Verbose(0) << "\t... failed." << endl;
   } else {
     if (mol->OutputTrajectoriesXYZ(&output))
-      Log() << Verbose(0) << "successful." << endl;
+      Log() << Verbose(0) << "\t... successful." << endl;
     else
-      Log() << Verbose(0) << "failed." << endl;
+      Log() << Verbose(0) << "\t... failed." << endl;
   }
   output.close();
@@ -1901 +1883 @@
   if (output == NULL)
     strcpy(filename,"main_pcp_linux");
-  Log() << Verbose(0) << "Saving as mpqc input ";
+  Log() << Verbose(0) << "Saving as mpqc input .. " << endl;
   if (SaveMPQC(filename, mol))
-    Log() << Verbose(0) << "done." << endl;
+    Log() << Verbose(0) << "\t... done." << endl;
   else
-    Log() << Verbose(0) << "failed." << endl;
+    Log() << Verbose(0) << "\t... failed." << endl;
 
   if (!strcmp(configpath, GetDefaultPath())) {

src/helpers.cpp

@@ -180 +180 @@
 
 
-/** Allocates a memory range using malloc().
- * Prints the provided error message in case of a failure.
- *
- * \param number of memory slices of type X to allocate
- * \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 <> char* Malloc<char>(size_t size, const char* output)
-{
-  char* buffer = NULL;
-  buffer = (char*) malloc(sizeof(char) * (size + 1));
-  for (size_t i = size; i--;)
-    buffer[i] = (i % 2 == 0) ? 'p': 'c';
-  buffer[size] = '\0';
-
-  if (buffer != NULL) {
-    //MemoryUsageObserver::getInstance()->addMemory(buffer, size);
-  } else {
-    Log() << Verbose(0) << "Malloc for datatype " << typeid(char).name()
-      << " failed - pointer is NULL: " << output << endl;
-  }
-
-  return buffer;
-};
-
 /**
  * Calls exit(255).

src/helpers.hpp

@@ -139 +139 @@
 };
 
+
 /** Frees a two-dimensional array.
  * \param *ptr pointer to array

src/lists.hpp

@@ -134 +134 @@
 };
 
-/** Returns the first marker in a chain list.
- * \param *me one arbitrary item in chain list
- * \return poiner to first marker
- */
-template <typename X> X *GetFirst(X *me)
-{
-  X *Binder = me;
-  while(Binder->previous != 0)
-    Binder = Binder->previous;
-  return Binder;
-};
-
-/** Returns the last marker in a chain list.
- * \param *me one arbitrary item in chain list
- * \return poiner to last marker
- */
-template <typename X> X *GetLast(X *me)
-{
-  X *Binder = me;
-  while(Binder->next != 0)
-    Binder = Binder->next;
-  return Binder;
-};
-
 #endif /* LISTS_HPP_ */

src/molecule.cpp

@@ -35 +35 @@
  * Initialises molecule list with correctly referenced start and end, and sets molecule::last_atom to zero.
  */
-molecule::molecule(const periodentafel * const teil) : elemente(teil), start(World::getInstance().createAtom()), end(World::getInstance().createAtom()),
-  first(new bond(start, end, 1, -1)), last(new bond(start, end, 1, -1)), MDSteps(0), AtomCount(0), 
+molecule::molecule(const periodentafel * const teil) : elemente(teil),
+  first(new bond(0, 0, 1, -1)), last(new bond(0, 0, 1, -1)), MDSteps(0),
   BondCount(0), ElementCount(0), NoNonHydrogen(0), NoNonBonds(0), NoCyclicBonds(0), BondDistance(0.), 
   ActiveFlag(false), IndexNr(-1),
   formula(this,boost::bind(&molecule::calcFormula,this)),
-  last_atom(0),
-  InternalPointer(start)
-{
-  // init atom chain list
-  start->father = NULL;
-  end->father = NULL;
-  link(start,end);
-
+  AtomCount(this,boost::bind(&molecule::doCountAtoms,this)), last_atom(0),  InternalPointer(begin())
+{
   // init bond chain list
   link(first,last);
@@ -69 +63 @@
   delete(first);
   delete(last);
-  end->getWorld()->destroyAtom(end);
-  start->getWorld()->destroyAtom(start);
 };
 
@@ -81 +73 @@
 const std::string molecule::getName(){
   return std::string(name);
+}
+
+int molecule::getAtomCount() const{
+  return *AtomCount;
 }
 
@@ -104 +100 @@
   stringstream sstr;
   periodentafel *periode = World::getInstance().getPeriode();
-  for(atom *Walker = start; Walker != end; Walker = Walker->next) {
-    counts[Walker->type->getNumber()]++;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    counts[(*iter)->type->getNumber()]++;
   }
   std::map<atomicNumber_t,unsigned int>::reverse_iterator iter;
@@ -115 +111 @@
 }
 
+/************************** Access to the List of Atoms ****************/
+
+
+molecule::iterator molecule::begin(){
+  return molecule::iterator(atoms.begin(),this);
+}
+
+molecule::const_iterator molecule::begin() const{
+  return atoms.begin();
+}
+
+molecule::iterator molecule::end(){
+  return molecule::iterator(atoms.end(),this);
+}
+
+molecule::const_iterator molecule::end() const{
+  return atoms.end();
+}
+
+bool molecule::empty() const
+{
+  return (begin() == end());
+}
+
+size_t molecule::size() const
+{
+  size_t counter = 0;
+  for (molecule::const_iterator iter = begin(); iter != end (); ++iter)
+    counter++;
+  return counter;
+}
+
+molecule::const_iterator molecule::erase( const_iterator loc )
+{
+  molecule::const_iterator iter = loc;
+  iter--;
+  atoms.erase( loc );
+  return iter;
+}
+
+molecule::const_iterator molecule::erase( atom *& key )
+{
+  cout << "trying to erase atom" << endl;
+  molecule::const_iterator iter = find(key);
+  if (iter != end()){
+    // remove this position and step forward (post-increment)
+    atoms.erase( iter++ );
+  }
+  return iter;
+}
+
+molecule::const_iterator molecule::find ( atom *& key ) const
+{
+  return atoms.find( key );
+}
+
+pair<molecule::iterator,bool> molecule::insert ( atom * const key )
+{
+  pair<atomSet::iterator,bool> res = atoms.insert(key);
+  return pair<iterator,bool>(iterator(res.first,this),res.second);
+}
 
 /** Adds given atom \a *pointer from molecule list.
@@ -123 +180 @@
 bool molecule::AddAtom(atom *pointer)
 {
-  bool retval = false;
   OBSERVE;
   if (pointer != NULL) {
     pointer->sort = &pointer->nr;
-    pointer->nr = last_atom++;  // increase number within molecule
-    AtomCount++;
     if (pointer->type != NULL) {
       if (ElementsInMolecule[pointer->type->Z] == 0)
@@ -141 +195 @@
       }
     }
-    retval = add(pointer, end);
-  }
-  return retval;
+    insert(pointer);
+  }
+  return true;
 };
 
@@ -157 +211 @@
   if (pointer != NULL) {
     atom *walker = pointer->clone();
-    stringstream sstr;
-    sstr << pointer->getName();
-    walker->setName(sstr.str());
+    walker->setName(pointer->getName());
     walker->nr = last_atom++;  // increase number within molecule
-    add(walker, end);
+    insert(walker);
     if ((pointer->type != NULL) && (pointer->type->Z != 1))
       NoNonHydrogen++;
-    AtomCount++;
     retval=walker;
   }
@@ -575 +626 @@
 
   // copy values
-  copy->CountAtoms();
   copy->CountElements();
   if (first->next != last) {  // if adjaceny list is present
@@ -610 +660 @@
 {
   bond *Binder = NULL;
-  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++;
-    add(Binder, last);
-  } else {
-    DoeLog(1) && (eLog()<< Verbose(1) << "Could not add bond between " << atom1->getName() << " and " << atom2->getName() << " as one or both are not present in the molecule." << endl);
-  }
+
+  // some checks to make sure we are able to create the bond
+  ASSERT(atom1, "First atom in bond-creation was an invalid pointer");
+  ASSERT(atom2, "Second atom in bond-creation was an invalid pointer");
+  ASSERT(FindAtom(atom1->nr),"First atom in bond-creation was not part of molecule");
+  ASSERT(FindAtom(atom2->nr),"Second atom in bond-creation was not parto of molecule");
+
+  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++;
+  add(Binder, last);
+
   return Binder;
 };
@@ -693 +747 @@
 bool molecule::RemoveAtom(atom *pointer)
 {
+  ASSERT(pointer, "Null pointer passed to molecule::RemoveAtom().");
+  OBSERVE;
   if (ElementsInMolecule[pointer->type->Z] != 0)  { // this would indicate an error
     ElementsInMolecule[pointer->type->Z]--;  // decrease number of atom of this element
-    AtomCount--;
   } else
     DoeLog(1) && (eLog()<< Verbose(1) << "Atom " << pointer->getName() << " is of element " << pointer->type->Z << " but the entry in the table of the molecule is 0!" << endl);
@@ -701 +756 @@
     ElementCount--;
   RemoveBonds(pointer);
-  return remove(pointer, start, end);
+  erase(pointer);
+  return true;
 };
 
@@ -718 +774 @@
   if (ElementsInMolecule[pointer->type->Z] == 0)  // was last atom of this element?
     ElementCount--;
-  unlink(pointer);
+  erase(pointer);
   return true;
 };
@@ -727 +783 @@
 bool molecule::CleanupMolecule()
 {
-  return (cleanup(first,last) && cleanup(start,end));
+  for (molecule::iterator iter = begin(); !empty(); iter = begin())
+      erase(iter);
+  return (cleanup(first,last));
 };
 
@@ -734 +792 @@
  * \return pointer to atom or NULL
  */
-atom * molecule::FindAtom(int Nr)  const{
-  atom * walker = find(&Nr, start,end);
-  if (walker != NULL) {
+atom * molecule::FindAtom(int Nr)  const
+{
+  molecule::const_iterator iter = begin();
+  for (; iter != end(); ++iter)
+    if ((*iter)->nr == Nr)
+      break;
+  if (iter != end()) {
     //Log() << Verbose(0) << "Found Atom Nr. " << walker->nr << endl;
-    return walker;
+    return (*iter);
   } else {
     DoLog(0) && (Log() << Verbose(0) << "Atom not found in list." << endl);
@@ -868 +930 @@
     now = time((time_t *)NULL);   // Get the system time and put it into 'now' as 'calender time'
     for (int step=0;step<MDSteps;step++) {
-      *output << AtomCount << "\n\tCreated by molecuilder, step " << step << ", on " << ctime(&now);
+      *output << getAtomCount() << "\n\tCreated by molecuilder, step " << step << ", on " << ctime(&now);
       ActOnAllAtoms( &atom::OutputTrajectoryXYZ, output, step );
     }
@@ -885 +947 @@
   if (output != NULL) {
     now = time((time_t *)NULL);   // Get the system time and put it into 'now' as 'calender time'
-    *output << AtomCount << "\n\tCreated by molecuilder on " << ctime(&now);
+    *output << getAtomCount() << "\n\tCreated by molecuilder on " << ctime(&now);
     ActOnAllAtoms( &atom::OutputXYZLine, output );
     return true;
@@ -895 +957 @@
  * \param *out output stream for debugging
  */
-void molecule::CountAtoms()
-{
+int molecule::doCountAtoms()
+{
+  int res = size();
   int i = 0;
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
+  NoNonHydrogen = 0;
+  for (molecule::const_iterator iter = atoms.begin(); iter != atoms.end(); ++iter) {
+    (*iter)->nr = i;   // update number in molecule (for easier referencing in FragmentMolecule lateron)
+    if ((*iter)->type->Z != 1) // count non-hydrogen atoms whilst at it
+      NoNonHydrogen++;
+    stringstream sstr;
+    sstr << (*iter)->type->symbol << (*iter)->nr+1;
+    (*iter)->setName(sstr.str());
+    Log() << Verbose(3) << "Naming atom nr. " << (*iter)->nr << " " << (*iter)->getName() << "." << endl;
     i++;
   }
-  if ((AtomCount == 0) || (i != AtomCount)) {
-    DoLog(3) && (Log() << Verbose(3) << "Mismatch in AtomCount " << AtomCount << " and recounted number " << i << ", renaming all." << endl);
-    AtomCount = i;
-
-    // count NonHydrogen atoms and give each atom a unique name
-    if (AtomCount != 0) {
-      i=0;
-      NoNonHydrogen = 0;
-      Walker = start;
-      while (Walker->next != end) {
-        Walker = Walker->next;
-        Walker->nr = i;   // update number in molecule (for easier referencing in FragmentMolecule lateron)
-        if (Walker->type->Z != 1) // count non-hydrogen atoms whilst at it
-          NoNonHydrogen++;
-        stringstream sstr;
-        sstr << Walker->type->symbol << Walker->nr+1;
-        Walker->setName(sstr.str());
-        DoLog(3) && (Log() << Verbose(3) << "Naming atom nr. " << Walker->nr << " " << Walker->getName() << "." << endl);
-        i++;
-      }
-    } else
-      DoLog(3) && (Log() << Verbose(3) << "AtomCount is still " << AtomCount << ", thus counting nothing." << endl);
-  }
+  return res;
 };
 
@@ -987 +1034 @@
   /// first count both their atoms and elements and update lists thereby ...
   //Log() << Verbose(0) << "Counting atoms, updating list" << endl;
-  CountAtoms();
-  OtherMolecule->CountAtoms();
   CountElements();
   OtherMolecule->CountElements();
@@ -995 +1040 @@
   /// -# AtomCount
   if (result) {
-    if (AtomCount != OtherMolecule->AtomCount) {
-      DoLog(4) && (Log() << Verbose(4) << "AtomCounts don't match: " << AtomCount << " == " << OtherMolecule->AtomCount << endl);
+    if (getAtomCount() != OtherMolecule->getAtomCount()) {
+      DoLog(4) && (Log() << Verbose(4) << "AtomCounts don't match: " << getAtomCount() << " == " << OtherMolecule->getAtomCount() << endl);
       result = false;
-    } else Log() << Verbose(4) << "AtomCounts match: " << AtomCount << " == " << OtherMolecule->AtomCount << endl;
+    } else Log() << Verbose(4) << "AtomCounts match: " << getAtomCount() << " == " << OtherMolecule->getAtomCount() << endl;
   }
   /// -# ElementCount
@@ -1035 +1080 @@
   if (result) {
     DoLog(5) && (Log() << Verbose(5) << "Calculating distances" << endl);
-    Distances = new double[AtomCount];
-    OtherDistances = new double[AtomCount];
+    Distances = new double[getAtomCount()];
+    OtherDistances = new double[getAtomCount()];
     SetIndexedArrayForEachAtomTo ( Distances, &atom::nr, &atom::DistanceSquaredToVector, (const Vector &)CenterOfGravity);
     SetIndexedArrayForEachAtomTo ( OtherDistances, &atom::nr, &atom::DistanceSquaredToVector, (const Vector &)CenterOfGravity);
-    for(int i=0;i<AtomCount;i++) {
+    for(int i=0;i<getAtomCount();i++) {
       Distances[i] = 0.;
       OtherDistances[i] = 0.;
@@ -1046 +1091 @@
     /// ... sort each list (using heapsort (o(N log N)) from GSL)
     DoLog(5) && (Log() << Verbose(5) << "Sorting distances" << endl);
-    PermMap = new size_t[AtomCount];
-    OtherPermMap = new size_t[AtomCount];
-    for(int i=0;i<AtomCount;i++) {
+    PermMap = new size_t[getAtomCount()];
+    OtherPermMap = new size_t[getAtomCount()];
+    for(int i=0;i<getAtomCount();i++) {
       PermMap[i] = 0;
       OtherPermMap[i] = 0;
     }
-    gsl_heapsort_index (PermMap, Distances, AtomCount, sizeof(double), CompareDoubles);
-    gsl_heapsort_index (OtherPermMap, OtherDistances, AtomCount, sizeof(double), CompareDoubles);
-    PermutationMap = new int[AtomCount];
-    for(int i=0;i<AtomCount;i++)
+    gsl_heapsort_index (PermMap, Distances, getAtomCount(), sizeof(double), CompareDoubles);
+    gsl_heapsort_index (OtherPermMap, OtherDistances, getAtomCount(), sizeof(double), CompareDoubles);
+    PermutationMap = new int[getAtomCount()];
+    for(int i=0;i<getAtomCount();i++)
       PermutationMap[i] = 0;
     DoLog(5) && (Log() << Verbose(5) << "Combining Permutation Maps" << endl);
-    for(int i=AtomCount;i--;)
+    for(int i=getAtomCount();i--;)
       PermutationMap[PermMap[i]] = (int) OtherPermMap[i];
 
@@ -1064 +1109 @@
     DoLog(4) && (Log() << Verbose(4) << "Comparing distances" << endl);
     flag = 0;
-    for (int i=0;i<AtomCount;i++) {
+    for (int i=0;i<getAtomCount();i++) {
       DoLog(5) && (Log() << Verbose(5) << "Distances squared: |" << Distances[PermMap[i]] << " - " << OtherDistances[OtherPermMap[i]] << "| = " << fabs(Distances[PermMap[i]] - OtherDistances[OtherPermMap[i]]) << " ?<? " <<  threshold << endl);
       if (fabs(Distances[PermMap[i]] - OtherDistances[OtherPermMap[i]]) > threshold*threshold)
@@ -1100 +1145 @@
 int * molecule::GetFatherSonAtomicMap(molecule *OtherMolecule)
 {
-  atom *Walker = NULL, *OtherWalker = NULL;
   DoLog(3) && (Log() << Verbose(3) << "Begin of GetFatherAtomicMap." << endl);
-  int *AtomicMap = new int[AtomCount];
-  for (int i=AtomCount;i--;)
+  int *AtomicMap = new int[getAtomCount()];
+  for (int i=getAtomCount();i--;)
     AtomicMap[i] = -1;
   if (OtherMolecule == this) {  // same molecule
-    for (int i=AtomCount;i--;) // no need as -1 means already that there is trivial correspondence
+    for (int i=getAtomCount();i--;) // no need as -1 means already that there is trivial correspondence
       AtomicMap[i] = i;
     DoLog(4) && (Log() << Verbose(4) << "Map is trivial." << endl);
   } else {
     DoLog(4) && (Log() << Verbose(4) << "Map is ");
-    Walker = start;
-    while (Walker->next != end) {
-      Walker = Walker->next;
-      if (Walker->father == NULL) {
-        AtomicMap[Walker->nr] = -2;
+    for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+      if ((*iter)->father == NULL) {
+        AtomicMap[(*iter)->nr] = -2;
       } else {
-        OtherWalker = OtherMolecule->start;
-        while (OtherWalker->next != OtherMolecule->end) {
-          OtherWalker = OtherWalker->next;
+        for (molecule::const_iterator runner = OtherMolecule->begin(); runner != OtherMolecule->end(); ++runner) {
       //for (int i=0;i<AtomCount;i++) { // search atom
-        //for (int j=0;j<OtherMolecule->AtomCount;j++) {
-          //Log() << Verbose(4) << "Comparing father " << Walker->father << " with the other one " << OtherWalker->father << "." << endl;
-          if (Walker->father == OtherWalker)
-            AtomicMap[Walker->nr] = OtherWalker->nr;
+        //for (int j=0;j<OtherMolecule->getAtomCount();j++) {
+          //Log() << Verbose(4) << "Comparing father " << (*iter)->father << " with the other one " << (*runner)->father << "." << endl;
+          if ((*iter)->father == (*runner))
+            AtomicMap[(*iter)->nr] = (*runner)->nr;
         }
       }
-      DoLog(0) && (Log() << Verbose(0) << AtomicMap[Walker->nr] << "\t");
+      DoLog(0) && (Log() << Verbose(0) << AtomicMap[(*iter)->nr] << "\t");
     }
     DoLog(0) && (Log() << Verbose(0) << endl);
@@ -1161 +1201 @@
 void molecule::SetIndexedArrayForEachAtomTo ( atom **array, int ParticleInfo::*index) const
 {
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    array[(Walker->*index)] = Walker;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    array[((*iter)->*index)] = (*iter);
   }
 };

src/molecule.hpp

@@ -34 +34 @@
 #include "tesselation.hpp"
 #include "Patterns/Observer.hpp"
+#include "Patterns/ObservedIterator.hpp"
 #include "Patterns/Cacheable.hpp"
 
@@ -90 +91 @@
   friend molecule *NewMolecule();
   friend void DeleteMolecule(molecule *);
+
   public:
+    typedef std::set<atom*> atomSet;
+    typedef ObservedIterator<atomSet> iterator;
+    typedef atomSet::const_iterator const_iterator;
+
     const periodentafel * const elemente; //!< periodic table with each element
-    atom *start;        //!< start of atom list
-    atom *end;          //!< end of atom list
+    // old deprecated atom handling
+    //atom *start;        //!< start of atom list
+    //atom *end;          //!< end of atom list
     bond *first;        //!< start of bond list
     bond *last;         //!< end of bond list
     int MDSteps;        //!< The number of MD steps in Trajectories
-    int AtomCount;          //!< number of atoms, brought up-to-date by CountAtoms()
+    //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
@@ -112 +119 @@
   private:
     Cacheable<string> formula;
+    Cacheable<int>    AtomCount;
     moleculeId_t id;
+    atomSet atoms; //<!set of atoms
   protected:
+    //void CountAtoms();
+    /**
+     * this iterator type should be used for internal variables, \
+     * since it will not lock
+     */
+    typedef atomSet::iterator internal_iterator;
+
+
     molecule(const periodentafel * const teil);
     virtual ~molecule();
@@ -121 +138 @@
   //getter and setter
   const std::string getName();
+  int getAtomCount() const;
+  int doCountAtoms();
   moleculeId_t getId();
   void setId(moleculeId_t);
@@ -127 +146 @@
   std::string calcFormula();
 
+  iterator begin();
+  const_iterator begin() const;
+  iterator end();
+  const_iterator end() const;
+  bool empty() const;
+  size_t size() const;
+  const_iterator erase( const_iterator loc );
+  const_iterator erase( atom *& key );
+  const_iterator find (  atom *& key ) const;
+  pair<iterator,bool> insert ( atom * const key );
+
 
   // re-definition of virtual functions from PointCloud
@@ -132 +162 @@
   Vector *GetCenter() const ;
   TesselPoint *GetPoint() const ;
-  TesselPoint *GetTerminalPoint() const ;
   int GetMaxId() const;
   void GoToNext() const ;
-  void GoToPrevious() const ;
   void GoToFirst() const ;
-  void GoToLast() const ;
   bool IsEmpty() const ;
   bool IsEnd() const ;
@@ -232 +259 @@
 
   /// Count and change present atoms' coordination.
-  void CountAtoms();
   void CountElements();
   void CalculateOrbitals(class config &configuration);
@@ -302 +328 @@
   bool StoreForcesFile(MoleculeListClass *BondFragments, char *path, int *SortIndex);
   bool CreateMappingLabelsToConfigSequence(int *&SortIndex);
+  bool CreateFatherLookupTable(atom **&LookupTable, int count = 0);
   void BreadthFirstSearchAdd(molecule *Mol, atom **&AddedAtomList, bond **&AddedBondList, atom *Root, bond *Bond, int BondOrder, bool IsAngstroem);
   /// -# BOSSANOVA
@@ -330 +357 @@
   private:
   int last_atom;      //!< number given to last atom
-  mutable atom *InternalPointer;  //!< internal pointer for PointCloud
+  mutable internal_iterator InternalPointer;  //!< internal pointer for PointCloud
 };
 

src/molecule_dynamics.cpp

@@ -29 +29 @@
   gsl_matrix *A = gsl_matrix_alloc(NDIM,NDIM);
   gsl_vector *x = gsl_vector_alloc(NDIM);
-  atom * Runner = mol->start;
   atom *Sprinter = NULL;
   Vector trajectory1, trajectory2, normal, TestVector;
   double Norm1, Norm2, tmp, result = 0.;
 
-  while (Runner->next != mol->end) {
-    Runner = Runner->next;
-    if (Runner == Walker) // hence, we only go up to the Walker, not beyond (similar to i=0; i<j; i++)
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    if ((*iter) == Walker) // hence, we only go up to the Walker, not beyond (similar to i=0; i<j; i++)
       break;
     // determine normalized trajectories direction vector (n1, n2)
@@ -43 +41 @@
     trajectory1.Normalize();
     Norm1 = trajectory1.Norm();
-    Sprinter = Params.PermutationMap[Runner->nr];   // find second target point
-    trajectory2 = Sprinter->Trajectory.R.at(Params.endstep) - Runner->Trajectory.R.at(Params.startstep);
+    Sprinter = Params.PermutationMap[(*iter)->nr];   // find second target point
+    trajectory2 = Sprinter->Trajectory.R.at(Params.endstep) - (*iter)->Trajectory.R.at(Params.startstep);
     trajectory2.Normalize();
     Norm2 = trajectory1.Norm();
     // check whether either is zero()
     if ((Norm1 < MYEPSILON) && (Norm2 < MYEPSILON)) {
-      tmp = Walker->Trajectory.R.at(Params.startstep).distance(Runner->Trajectory.R.at(Params.startstep));
+      tmp = Walker->Trajectory.R.at(Params.startstep).distance((*iter)->Trajectory.R.at(Params.startstep));
     } else if (Norm1 < MYEPSILON) {
       Sprinter = Params.PermutationMap[Walker->nr];   // find first target point
-      trajectory1 = Sprinter->Trajectory.R.at(Params.endstep) - Runner->Trajectory.R.at(Params.startstep);
+      trajectory1 = Sprinter->Trajectory.R.at(Params.endstep) - (*iter)->Trajectory.R.at(Params.startstep);
       trajectory2 *= trajectory1.ScalarProduct(trajectory2); // trajectory2 is scaled to unity, hence we don't need to divide by anything
       trajectory1 -= trajectory2;   // project the part in norm direction away
       tmp = trajectory1.Norm();  // remaining norm is distance
     } else if (Norm2 < MYEPSILON) {
-      Sprinter = Params.PermutationMap[Runner->nr];   // find second target point
+      Sprinter = Params.PermutationMap[(*iter)->nr];   // find second target point
       trajectory2 = Sprinter->Trajectory.R.at(Params.endstep) - Walker->Trajectory.R.at(Params.startstep);  // copy second offset
       trajectory1 *= trajectory2.ScalarProduct(trajectory1); // trajectory1 is scaled to unity, hence we don't need to divide by anything
@@ -67 +65 @@
   //        Log() << Verbose(0) << " and ";
   //        Log() << Verbose(0) << trajectory2;
-      tmp = Walker->Trajectory.R.at(Params.startstep).distance(Runner->Trajectory.R.at(Params.startstep));
+      tmp = Walker->Trajectory.R.at(Params.startstep).distance((*iter)->Trajectory.R.at(Params.startstep));
   //        Log() << Verbose(0) << " with distance " << tmp << "." << endl;
     } else { // determine distance by finding minimum distance
-  //        Log() << Verbose(3) << "Both trajectories of " << *Walker << " and " << *Runner << " are linear independent ";
+  //        Log() << Verbose(3) << "Both trajectories of " << *Walker << " and " << *(*iter) << " are linear independent ";
   //        Log() << Verbose(0) << endl;
   //        Log() << Verbose(0) << "First Trajectory: ";
@@ -86 +84 @@
         gsl_matrix_set(A, 1, i, trajectory2[i]);
         gsl_matrix_set(A, 2, i, normal[i]);
-        gsl_vector_set(x,i, (Walker->Trajectory.R.at(Params.startstep)[i] - Runner->Trajectory.R.at(Params.startstep)[i]));
+        gsl_vector_set(x,i, (Walker->Trajectory.R.at(Params.startstep)[i] - (*iter)->Trajectory.R.at(Params.startstep)[i]));
       }
       // solve the linear system by Householder transformations
@@ -97 +95 @@
       trajectory2.Scale(gsl_vector_get(x,1));
       normal.Scale(gsl_vector_get(x,2));
-      TestVector = Runner->Trajectory.R.at(Params.startstep) + trajectory2 + normal
+      TestVector = (*iter)->Trajectory.R.at(Params.startstep) + trajectory2 + normal
                    - (Walker->Trajectory.R.at(Params.startstep) + trajectory1);
       if (TestVector.Norm() < MYEPSILON) {
@@ -126 +124 @@
 {
   double result = 0.;
-  atom * Runner = mol->start;
-  while (Runner->next != mol->end) {
-    Runner = Runner->next;
-    if ((Params.PermutationMap[Walker->nr] == Params.PermutationMap[Runner->nr]) && (Walker->nr < Runner->nr)) {
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    if ((Params.PermutationMap[Walker->nr] == Params.PermutationMap[(*iter)->nr]) && (Walker->nr < (*iter)->nr)) {
   //    atom *Sprinter = PermutationMap[Walker->nr];
-  //        Log() << Verbose(0) << *Walker << " and " << *Runner << " are heading to the same target at ";
+  //        Log() << Verbose(0) << *Walker << " and " << *(*iter) << " are heading to the same target at ";
   //        Log() << Verbose(0) << Sprinter->Trajectory.R.at(endstep);
   //        Log() << Verbose(0) << ", penalting." << endl;
@@ -162 +158 @@
   // go through every atom
   atom *Runner = NULL;
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     // first term: distance to target
-    Runner = Params.PermutationMap[Walker->nr];   // find target point
-    tmp = (Walker->Trajectory.R.at(Params.startstep).distance(Runner->Trajectory.R.at(Params.endstep)));
+    Runner = Params.PermutationMap[(*iter)->nr];   // find target point
+    tmp = ((*iter)->Trajectory.R.at(Params.startstep).distance(Runner->Trajectory.R.at(Params.endstep)));
     tmp *= Params.IsAngstroem ? 1. : 1./AtomicLengthToAngstroem;
     result += Params.PenaltyConstants[0] * tmp;
@@ -173 +167 @@
 
     // second term: sum of distances to other trajectories
-    result += SumDistanceOfTrajectories(Walker, this, Params);
+    result += SumDistanceOfTrajectories((*iter), this, Params);
 
     // third term: penalty for equal targets
-    result += PenalizeEqualTargets(Walker, this, Params);
+    result += PenalizeEqualTargets((*iter), this, Params);
   }
 
@@ -216 +210 @@
 void FillDistanceList(molecule *mol, struct EvaluatePotential &Params)
 {
-  for (int i=mol->AtomCount; i--;) {
+  for (int i=mol->getAtomCount(); i--;) {
     Params.DistanceList[i] = new DistanceMap;    // is the distance sorted target list per atom
     Params.DistanceList[i]->clear();
   }
 
-  atom *Runner = NULL;
-  atom *Walker = mol->start;
-  while (Walker->next != mol->end) {
-    Walker = Walker->next;
-    Runner = mol->start;
-    while(Runner->next != mol->end) {
-      Runner = Runner->next;
-      Params.DistanceList[Walker->nr]->insert( DistancePair(Walker->Trajectory.R.at(Params.startstep).distance(Runner->Trajectory.R.at(Params.endstep)), Runner) );
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    for (molecule::const_iterator runner = mol->begin(); runner != mol->end(); ++runner) {
+      Params.DistanceList[(*iter)->nr]->insert( DistancePair((*iter)->Trajectory.R.at(Params.startstep).distance((*runner)->Trajectory.R.at(Params.endstep)), (*runner)) );
     }
   }
@@ -240 +229 @@
 void CreateInitialLists(molecule *mol, struct EvaluatePotential &Params)
 {
-  atom *Walker = mol->start;
-  while (Walker->next != mol->end) {
-    Walker = Walker->next;
-    Params.StepList[Walker->nr] = Params.DistanceList[Walker->nr]->begin();    // stores the step to the next iterator that could be a possible next target
-    Params.PermutationMap[Walker->nr] = Params.DistanceList[Walker->nr]->begin()->second;   // always pick target with the smallest distance
-    Params.DoubleList[Params.DistanceList[Walker->nr]->begin()->second->nr]++;            // increase this target's source count (>1? not injective)
-    Params.DistanceIterators[Walker->nr] = Params.DistanceList[Walker->nr]->begin();    // and remember which one we picked
-    DoLog(2) && (Log() << Verbose(2) << *Walker << " starts with distance " << Params.DistanceList[Walker->nr]->begin()->first << "." << endl);
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    Params.StepList[(*iter)->nr] = Params.DistanceList[(*iter)->nr]->begin();    // stores the step to the next iterator that could be a possible next target
+    Params.PermutationMap[(*iter)->nr] = Params.DistanceList[(*iter)->nr]->begin()->second;   // always pick target with the smallest distance
+    Params.DoubleList[Params.DistanceList[(*iter)->nr]->begin()->second->nr]++;            // increase this target's source count (>1? not injective)
+    Params.DistanceIterators[(*iter)->nr] = Params.DistanceList[(*iter)->nr]->begin();    // and remember which one we picked
+    DoLog(2) && (Log() << Verbose(2) << **iter << " starts with distance " << Params.DistanceList[(*iter)->nr]->begin()->first << "." << endl);
   }
 };
@@ -288 +275 @@
 void MakeInjectivePermutation(molecule *mol, struct EvaluatePotential &Params)
 {
-  atom *Walker = mol->start;
+  molecule::const_iterator iter = mol->begin();
   DistanceMap::iterator NewBase;
   double Potential = fabs(mol->ConstrainedPotential(Params));
 
+  if (mol->empty()) {
+    eLog() << Verbose(1) << "Molecule is empty." << endl;
+    return;
+  }
   while ((Potential) > Params.PenaltyConstants[2]) {
-    PrintPermutationMap(mol->AtomCount, Params);
-    Walker = Walker->next;
-    if (Walker == mol->end) // round-robin at the end
-      Walker = mol->start->next;
-    if (Params.DoubleList[Params.DistanceIterators[Walker->nr]->second->nr] <= 1)  // no need to make those injective that aren't
+    PrintPermutationMap(mol->getAtomCount(), Params);
+    iter++;
+    if (iter == mol->end()) // round-robin at the end
+      iter = mol->begin();
+    if (Params.DoubleList[Params.DistanceIterators[(*iter)->nr]->second->nr] <= 1)  // no need to make those injective that aren't
       continue;
     // now, try finding a new one
-    Potential = TryNextNearestNeighbourForInjectivePermutation(mol, Walker, Potential, Params);
-  }
-  for (int i=mol->AtomCount; i--;) // now each single entry in the DoubleList should be <=1
+    Potential = TryNextNearestNeighbourForInjectivePermutation(mol, (*iter), Potential, Params);
+  }
+  for (int i=mol->getAtomCount(); i--;) // now each single entry in the DoubleList should be <=1
     if (Params.DoubleList[i] > 1) {
       DoeLog(0) && (eLog()<< Verbose(0) << "Failed to create an injective PermutationMap!" << endl);
@@ -341 +332 @@
   double Potential, OldPotential, OlderPotential;
   struct EvaluatePotential Params;
-  Params.PermutationMap = new atom *[AtomCount];
-  Params.DistanceList = new DistanceMap *[AtomCount];
-  Params.DistanceIterators = new DistanceMap::iterator[AtomCount];
-  Params.DoubleList = new int[AtomCount];
-  Params.StepList = new DistanceMap::iterator[AtomCount];
+  Params.PermutationMap = new atom *[getAtomCount()];
+  Params.DistanceList = new DistanceMap *[getAtomCount()];
+  Params.DistanceIterators = new DistanceMap::iterator[getAtomCount()];
+  Params.DoubleList = new int[getAtomCount()];
+  Params.StepList = new DistanceMap::iterator[getAtomCount()];
   int round;
-  atom *Walker = NULL, *Runner = NULL, *Sprinter = NULL;
+  atom *Sprinter = NULL;
   DistanceMap::iterator Rider, Strider;
 
   // set to zero
-  for (int i=0;i<AtomCount;i++) {
+  for (int i=0;i<getAtomCount();i++) {
     Params.PermutationMap[i] = NULL;
     Params.DoubleList[i] = 0;
@@ -380 +371 @@
     DoLog(2) && (Log() << Verbose(2) << "Starting round " << ++round << ", at current potential " << OldPotential << " ... " << endl);
     OlderPotential = OldPotential;
+    molecule::const_iterator iter;
     do {
-      Walker = start;
-      while (Walker->next != end) { // pick one
-        Walker = Walker->next;
-        PrintPermutationMap(AtomCount, Params);
-        Sprinter = Params.DistanceIterators[Walker->nr]->second;   // store initial partner
-        Strider = Params.DistanceIterators[Walker->nr];  //remember old iterator
-        Params.DistanceIterators[Walker->nr] = Params.StepList[Walker->nr];
-        if (Params.DistanceIterators[Walker->nr] == Params.DistanceList[Walker->nr]->end()) {// stop, before we run through the list and still on
-          Params.DistanceIterators[Walker->nr] == Params.DistanceList[Walker->nr]->begin();
+      iter = begin();
+      for (; iter != end(); ++iter) {
+        PrintPermutationMap(getAtomCount(), Params);
+        Sprinter = Params.DistanceIterators[(*iter)->nr]->second;   // store initial partner
+        Strider = Params.DistanceIterators[(*iter)->nr];  //remember old iterator
+        Params.DistanceIterators[(*iter)->nr] = Params.StepList[(*iter)->nr];
+        if (Params.DistanceIterators[(*iter)->nr] == Params.DistanceList[(*iter)->nr]->end()) {// stop, before we run through the list and still on
+          Params.DistanceIterators[(*iter)->nr] == Params.DistanceList[(*iter)->nr]->begin();
           break;
         }
-        //Log() << Verbose(2) << "Current Walker: " << *Walker << " with old/next candidate " << *Sprinter << "/" << *DistanceIterators[Walker->nr]->second << "." << endl;
+        //Log() << Verbose(2) << "Current Walker: " << *(*iter) << " with old/next candidate " << *Sprinter << "/" << *DistanceIterators[(*iter)->nr]->second << "." << endl;
         // find source of the new target
-        Runner = start->next;
-        while(Runner != end) { // find the source whose toes we might be stepping on (Walker's new target should be in use by another already)
-          if (Params.PermutationMap[Runner->nr] == Params.DistanceIterators[Walker->nr]->second) {
-            //Log() << Verbose(2) << "Found the corresponding owner " << *Runner << " to " << *PermutationMap[Runner->nr] << "." << endl;
+        molecule::const_iterator runner = begin();
+        for (; runner != end(); ++runner) { // find the source whose toes we might be stepping on (Walker's new target should be in use by another already)
+          if (Params.PermutationMap[(*runner)->nr] == Params.DistanceIterators[(*iter)->nr]->second) {
+            //Log() << Verbose(2) << "Found the corresponding owner " << *(*runner) << " to " << *PermutationMap[(*runner)->nr] << "." << endl;
             break;
           }
-          Runner = Runner->next;
         }
-        if (Runner != end) { // we found the other source
+        if (runner != end()) { // we found the other source
           // then look in its distance list for Sprinter
-          Rider = Params.DistanceList[Runner->nr]->begin();
-          for (; Rider != Params.DistanceList[Runner->nr]->end(); Rider++)
+          Rider = Params.DistanceList[(*runner)->nr]->begin();
+          for (; Rider != Params.DistanceList[(*runner)->nr]->end(); Rider++)
             if (Rider->second == Sprinter)
               break;
-          if (Rider != Params.DistanceList[Runner->nr]->end()) { // if we have found one
-            //Log() << Verbose(2) << "Current Other: " << *Runner << " with old/next candidate " << *PermutationMap[Runner->nr] << "/" << *Rider->second << "." << endl;
+          if (Rider != Params.DistanceList[(*runner)->nr]->end()) { // if we have found one
+            //Log() << Verbose(2) << "Current Other: " << *(*runner) << " with old/next candidate " << *PermutationMap[(*runner)->nr] << "/" << *Rider->second << "." << endl;
             // exchange both
-            Params.PermutationMap[Walker->nr] = Params.DistanceIterators[Walker->nr]->second; // put next farther distance into PermutationMap
-            Params.PermutationMap[Runner->nr] = Sprinter;  // and hand the old target to its respective owner
-            PrintPermutationMap(AtomCount, Params);
+            Params.PermutationMap[(*iter)->nr] = Params.DistanceIterators[(*iter)->nr]->second; // put next farther distance into PermutationMap
+            Params.PermutationMap[(*runner)->nr] = Sprinter;  // and hand the old target to its respective owner
+            PrintPermutationMap(getAtomCount(), Params);
             // calculate the new potential
             //Log() << Verbose(2) << "Checking new potential ..." << endl;
@@ -419 +409 @@
             if (Potential > OldPotential) { // we made everything worse! Undo ...
               //Log() << Verbose(3) << "Nay, made the potential worse: " << Potential << " vs. " << OldPotential << "!" << endl;
-              //Log() << Verbose(3) << "Setting " << *Runner << "'s source to " << *Params.DistanceIterators[Runner->nr]->second << "." << endl;
+              //Log() << Verbose(3) << "Setting " << *(*runner) << "'s source to " << *Params.DistanceIterators[(*runner)->nr]->second << "." << endl;
               // Undo for Runner (note, we haven't moved the iteration yet, we may use this)
-              Params.PermutationMap[Runner->nr] = Params.DistanceIterators[Runner->nr]->second;
+              Params.PermutationMap[(*runner)->nr] = Params.DistanceIterators[(*runner)->nr]->second;
               // Undo for Walker
-              Params.DistanceIterators[Walker->nr] = Strider;  // take next farther distance target
-              //Log() << Verbose(3) << "Setting " << *Walker << "'s source to " << *Params.DistanceIterators[Walker->nr]->second << "." << endl;
-              Params.PermutationMap[Walker->nr] = Params.DistanceIterators[Walker->nr]->second;
+              Params.DistanceIterators[(*iter)->nr] = Strider;  // take next farther distance target
+              //Log() << Verbose(3) << "Setting " << *(*iter) << "'s source to " << *Params.DistanceIterators[(*iter)->nr]->second << "." << endl;
+              Params.PermutationMap[(*iter)->nr] = Params.DistanceIterators[(*iter)->nr]->second;
             } else {
-              Params.DistanceIterators[Runner->nr] = Rider;  // if successful also move the pointer in the iterator list
+              Params.DistanceIterators[(*runner)->nr] = Rider;  // if successful also move the pointer in the iterator list
               DoLog(3) && (Log() << Verbose(3) << "Found a better permutation, new potential is " << Potential << " vs." << OldPotential << "." << endl);
               OldPotential = Potential;
@@ -437 +427 @@
             //Log() << Verbose(0) << endl;
           } else {
-            DoeLog(1) && (eLog()<< Verbose(1) << *Runner << " was not the owner of " << *Sprinter << "!" << endl);
+            DoeLog(1) && (eLog()<< Verbose(1) << **runner << " was not the owner of " << *Sprinter << "!" << endl);
             exit(255);
           }
         } else {
-          Params.PermutationMap[Walker->nr] = Params.DistanceIterators[Walker->nr]->second; // new target has no source!
+          Params.PermutationMap[(*iter)->nr] = Params.DistanceIterators[(*iter)->nr]->second; // new target has no source!
         }
-        Params.StepList[Walker->nr]++; // take next farther distance target
+        Params.StepList[(*iter)->nr]++; // take next farther distance target
       }
-    } while (Walker->next != end);
+    } while (++iter != end());
   } while ((OlderPotential - OldPotential) > 1e-3);
   DoLog(1) && (Log() << Verbose(1) << "done." << endl);
@@ -451 +441 @@
 
   /// free memory and return with evaluated potential
-  for (int i=AtomCount; i--;)
+  for (int i=getAtomCount(); i--;)
     Params.DistanceList[i]->clear();
   delete[](Params.DistanceList);
@@ -492 +482 @@
   // Get the Permutation Map by MinimiseConstrainedPotential
   atom **PermutationMap = NULL;
-  atom *Walker = NULL, *Sprinter = NULL;
+  atom *Sprinter = NULL;
   if (!MapByIdentity)
     MinimiseConstrainedPotential(PermutationMap, startstep, endstep, configuration.GetIsAngstroem());
   else {
-    PermutationMap = new atom *[AtomCount];
+    PermutationMap = new atom *[getAtomCount()];
     SetIndexedArrayForEachAtomTo( PermutationMap, &atom::nr );
   }
@@ -511 +501 @@
     mol = World::getInstance().createMolecule();
     MoleculePerStep->insert(mol);
-    Walker = start;
-    while (Walker->next != end) {
-      Walker = Walker->next;
+    for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
       // add to molecule list
-      Sprinter = mol->AddCopyAtom(Walker);
+      Sprinter = mol->AddCopyAtom((*iter));
       for (int n=NDIM;n--;) {
-        Sprinter->x[n] = Walker->Trajectory.R.at(startstep)[n] + (PermutationMap[Walker->nr]->Trajectory.R.at(endstep)[n] - Walker->Trajectory.R.at(startstep)[n])*((double)step/(double)MaxSteps);
+        Sprinter->x[n] = (*iter)->Trajectory.R.at(startstep)[n] + (PermutationMap[(*iter)->nr]->Trajectory.R.at(endstep)[n] - (*iter)->Trajectory.R.at(startstep)[n])*((double)step/(double)MaxSteps);
         // add to Trajectories
         //Log() << Verbose(3) << step << ">=" << MDSteps-1 << endl;
         if (step < MaxSteps) {
-          Walker->Trajectory.R.at(step)[n] = Walker->Trajectory.R.at(startstep)[n] + (PermutationMap[Walker->nr]->Trajectory.R.at(endstep)[n] - Walker->Trajectory.R.at(startstep)[n])*((double)step/(double)MaxSteps);
-          Walker->Trajectory.U.at(step)[n] = 0.;
-          Walker->Trajectory.F.at(step)[n] = 0.;
+          (*iter)->Trajectory.R.at(step)[n] = (*iter)->Trajectory.R.at(startstep)[n] + (PermutationMap[(*iter)->nr]->Trajectory.R.at(endstep)[n] - (*iter)->Trajectory.R.at(startstep)[n])*((double)step/(double)MaxSteps);
+          (*iter)->Trajectory.U.at(step)[n] = 0.;
+          (*iter)->Trajectory.F.at(step)[n] = 0.;
         }
       }
@@ -531 +519 @@
 
   // store the list to single step files
-  int *SortIndex = new int[AtomCount];
-  for (int i=AtomCount; i--; )
+  int *SortIndex = new int[getAtomCount()];
+  for (int i=getAtomCount(); i--; )
     SortIndex[i] = i;
   status = MoleculePerStep->OutputConfigForListOfFragments(&configuration, SortIndex);
@@ -578 +566 @@
       return false;
     }
-    if (Force.RowCounter[0] != AtomCount) {
-      DoeLog(0) && (eLog()<< Verbose(0) << "Mismatch between number of atoms in file " << Force.RowCounter[0] << " and in molecule " << AtomCount << "." << endl);
+    if (Force.RowCounter[0] != getAtomCount()) {
+      DoeLog(0) && (eLog()<< Verbose(0) << "Mismatch between number of atoms in file " << Force.RowCounter[0] << " and in molecule " << getAtomCount() << "." << endl);
       performCriticalExit();
       return false;
@@ -585 +573 @@
     // correct Forces
     Velocity.Zero();
-    for(int i=0;i<AtomCount;i++)
+    for(int i=0;i<getAtomCount();i++)
       for(int d=0;d<NDIM;d++) {
         Velocity[d] += Force.Matrix[0][i][d+5];
       }
-    for(int i=0;i<AtomCount;i++)
+    for(int i=0;i<getAtomCount();i++)
       for(int d=0;d<NDIM;d++) {
-        Force.Matrix[0][i][d+5] -= Velocity[d]/(double)AtomCount;
+        Force.Matrix[0][i][d+5] -= Velocity[d]/static_cast<double>(getAtomCount());
       }
     // solve a constrained potential if we are meant to
@@ -694 +682 @@
       delta_alpha = 0.;
       ActOnAllAtoms( &atom::Thermostat_NoseHoover_init, MDSteps, &delta_alpha );
-      delta_alpha = (delta_alpha - (3.*AtomCount+1.) * configuration.TargetTemp)/(configuration.HooverMass*Units2Electronmass);
+      delta_alpha = (delta_alpha - (3.*getAtomCount()+1.) * configuration.TargetTemp)/(configuration.HooverMass*Units2Electronmass);
       configuration.alpha += delta_alpha*configuration.Deltat;
       DoLog(3) && (Log() << Verbose(3) << "alpha = " << delta_alpha << " * " << configuration.Deltat << " = " << configuration.alpha << "." << endl);

src/molecule_fragmentation.cpp

@@ -39 +39 @@
   int FragmentCount;
   // get maximum bond degree
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    c = (Walker->ListOfBonds.size() > c) ? Walker->ListOfBonds.size() : c;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    c = ((*iter)->ListOfBonds.size() > c) ? (*iter)->ListOfBonds.size() : c;
   }
   FragmentCount = NoNonHydrogen*(1 << (c*order));
@@ -353 +351 @@
 map<double, pair<int,int> >  * ReMapAdaptiveCriteriaListToValue(map<int, pair<double,int> > *AdaptiveCriteriaList, molecule *mol)
 {
-  atom *Walker = mol->start;
+  atom *Walker = NULL;
   map<double, pair<int,int> > *FinalRootCandidates = new map<double, pair<int,int> > ;
   DoLog(1) && (Log() << Verbose(1) << "Root candidate list is: " << endl);
@@ -385 +383 @@
 bool MarkUpdateCandidates(bool *AtomMask, map<double, pair<int,int> > &FinalRootCandidates, int Order, molecule *mol)
 {
-  atom *Walker = mol->start;
+  atom *Walker = NULL;
   int No = -1;
   bool status = false;
@@ -429 +427 @@
 bool molecule::CheckOrderAtSite(bool *AtomMask, Graph *GlobalKeySetList, int Order, int *MinimumRingSize, char *path)
 {
-  atom *Walker = start;
   bool status = false;
 
   // initialize mask list
-  for(int i=AtomCount;i--;)
+  for(int i=getAtomCount();i--;)
     AtomMask[i] = false;
 
   if (Order < 0) { // adaptive increase of BondOrder per site
-    if (AtomMask[AtomCount] == true)  // break after one step
+    if (AtomMask[getAtomCount()] == true)  // break after one step
       return false;
 
@@ -451 +448 @@
     if (AdaptiveCriteriaList->empty()) {
       DoeLog(2) && (eLog()<< Verbose(2) << "Unable to parse file, incrementing all." << endl);
-      while (Walker->next != end) {
-        Walker = Walker->next;
+      for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     #ifdef ADDHYDROGEN
-        if (Walker->type->Z != 1) // skip hydrogen
+        if ((*iter)->type->Z != 1) // skip hydrogen
     #endif
         {
-          AtomMask[Walker->nr] = true;  // include all (non-hydrogen) atoms
+          AtomMask[(*iter)->nr] = true;  // include all (non-hydrogen) atoms
           status = true;
         }
@@ -472 +468 @@
     delete[](FinalRootCandidates);
   } else { // global increase of Bond Order
-    while (Walker->next != end) {
-      Walker = Walker->next;
+    for(molecule::const_iterator iter = begin(); iter != end(); ++iter) {
   #ifdef ADDHYDROGEN
-      if (Walker->type->Z != 1) // skip hydrogen
+      if ((*iter)->type->Z != 1) // skip hydrogen
   #endif
       {
-        AtomMask[Walker->nr] = true;  // include all (non-hydrogen) atoms
-        if ((Order != 0) && (Walker->AdaptiveOrder < Order)) // && (Walker->AdaptiveOrder < MinimumRingSize[Walker->nr]))
+        AtomMask[(*iter)->nr] = true;  // include all (non-hydrogen) atoms
+        if ((Order != 0) && ((*iter)->AdaptiveOrder < Order)) // && ((*iter)->AdaptiveOrder < MinimumRingSize[(*iter)->nr]))
           status = true;
       }
     }
-    if ((Order == 0) && (AtomMask[AtomCount] == false))  // single stepping, just check
+    if ((!Order) && (!AtomMask[getAtomCount()]))  // single stepping, just check
       status = true;
 
@@ -494 +489 @@
   }
 
-  PrintAtomMask(AtomMask, AtomCount); // for debugging
+  PrintAtomMask(AtomMask, getAtomCount()); // for debugging
 
   return status;
@@ -510 +505 @@
     return false;
   }
-  SortIndex = new int[AtomCount];
-  for(int i=AtomCount;i--;)
+  SortIndex = new int[getAtomCount()];
+  for(int i=getAtomCount();i--;)
     SortIndex[i] = -1;
 
@@ -518 +513 @@
 
   return true;
+};
+
+
+
+/** Creates a lookup table for true father's Atom::Nr -> atom ptr.
+ * \param *start begin of list (STL iterator, i.e. first item)
+ * \paran *end end of list (STL iterator, i.e. one past last item)
+ * \param **Lookuptable pointer to return allocated lookup table (should be NULL on start)
+ * \param count optional predetermined size for table (otherwise we set the count to highest true father id)
+ * \return true - success, false - failure
+ */
+bool molecule::CreateFatherLookupTable(atom **&LookupTable, int count)
+{
+  bool status = true;
+  int AtomNo;
+
+  if (LookupTable != NULL) {
+    Log() << Verbose(0) << "Pointer for Lookup table is not NULL! Aborting ..." <<endl;
+    return false;
+  }
+
+  // count them
+  if (count == 0) {
+    for (molecule::iterator iter = begin(); iter != end(); ++iter) { // create a lookup table (Atom::nr -> atom) used as a marker table lateron
+      count = (count < (*iter)->GetTrueFather()->nr) ? (*iter)->GetTrueFather()->nr : count;
+    }
+  }
+  if (count <= 0) {
+    Log() << Verbose(0) << "Count of lookup list is 0 or less." << endl;
+    return false;
+  }
+
+  // allocate and fill
+  LookupTable = new atom *[count];
+  if (LookupTable == NULL) {
+    eLog() << Verbose(0) << "LookupTable memory allocation failed!" << endl;
+    performCriticalExit();
+    status = false;
+  } else {
+    for (int i=0;i<count;i++)
+      LookupTable[i] = NULL;
+    for (molecule::iterator iter = begin(); iter != end(); ++iter) {
+      AtomNo = (*iter)->GetTrueFather()->nr;
+      if ((AtomNo >= 0) && (AtomNo < count)) {
+        //*out << "Setting LookupTable[" << AtomNo << "] to " << *(*iter) << endl;
+        LookupTable[AtomNo] = (*iter);
+      } else {
+        Log() << Verbose(0) << "Walker " << *(*iter) << " exceeded range of nuclear ids [0, " << count << ")." << endl;
+        status = false;
+        break;
+      }
+    }
+  }
+
+  return status;
 };
 
@@ -541 +591 @@
 {
   MoleculeListClass *BondFragments = NULL;
-  int *MinimumRingSize = new int[AtomCount];
+  int *MinimumRingSize = new int[getAtomCount()];
   int FragmentCounter;
   MoleculeLeafClass *MolecularWalker = NULL;
@@ -569 +619 @@
 
   // create lookup table for Atom::nr
-  FragmentationToDo = FragmentationToDo && CreateFatherLookupTable(start, end, ListOfAtoms, AtomCount);
+  FragmentationToDo = FragmentationToDo && CreateFatherLookupTable(ListOfAtoms, getAtomCount());
 
   // === compare it with adjacency file ===
@@ -579 +629 @@
 
   // analysis of the cycles (print rings, get minimum cycle length) for each subgraph
-  for(int i=AtomCount;i--;)
-    MinimumRingSize[i] = AtomCount;
+  for(int i=getAtomCount();i--;)
+    MinimumRingSize[i] = getAtomCount();
   MolecularWalker = Subgraphs;
   FragmentCounter = 0;
@@ -586 +636 @@
     MolecularWalker = MolecularWalker->next;
     // fill the bond structure of the individually stored subgraphs
-  MolecularWalker->FillBondStructureFromReference(this, FragmentCounter, ListOfLocalAtoms, false);  // we want to keep the created ListOfLocalAtoms
+    MolecularWalker->FillBondStructureFromReference(this, FragmentCounter, ListOfLocalAtoms, false);  // we want to keep the created ListOfLocalAtoms
     DoLog(0) && (Log() << Verbose(0) << "Analysing the cycles of subgraph " << MolecularWalker->Leaf << " with nr. " << FragmentCounter << "." << endl);
     LocalBackEdgeStack = new StackClass<bond *> (MolecularWalker->Leaf->BondCount);
 //    // check the list of local atoms for debugging
 //    Log() << Verbose(0) << "ListOfLocalAtoms for this subgraph is:" << endl;
-//    for (int i=0;i<AtomCount;i++)
+//    for (int i=0;i<getAtomCount();i++)
 //      if (ListOfLocalAtoms[FragmentCounter][i] == NULL)
 //        Log() << Verbose(0) << "\tNULL";
@@ -617 +667 @@
   // ===== 6b. prepare and go into the adaptive (Order<0), single-step (Order==0) or incremental (Order>0) cycle
   KeyStack *RootStack = new KeyStack[Subgraphs->next->Count()];
-  AtomMask = new bool[AtomCount+1];
-  AtomMask[AtomCount] = false;
+  AtomMask = new bool[getAtomCount()+1];
+  AtomMask[getAtomCount()] = false;
   FragmentationToDo = false;  // if CheckOrderAtSite just ones recommends fragmentation, we will save fragments afterwards
   while ((CheckOrder = CheckOrderAtSite(AtomMask, ParsedFragmentList, Order, MinimumRingSize, configuration->configpath))) {
     FragmentationToDo = FragmentationToDo || CheckOrder;
-    AtomMask[AtomCount] = true;   // last plus one entry is used as marker that we have been through this loop once already in CheckOrderAtSite()
+    AtomMask[getAtomCount()] = true;   // last plus one entry is used as marker that we have been through this loop once already in CheckOrderAtSite()
     // ===== 6b. fill RootStack for each subgraph (second adaptivity check) =====
     Subgraphs->next->FillRootStackForSubgraphs(RootStack, AtomMask, (FragmentCounter = 0));
@@ -762 +812 @@
 bool molecule::ParseOrderAtSiteFromFile(char *path)
 {
-  unsigned char *OrderArray = new unsigned char[AtomCount];
-  bool *MaxArray = new bool[AtomCount];
+  unsigned char *OrderArray = new unsigned char[getAtomCount()];
+  bool *MaxArray = new bool[getAtomCount()];
   bool status;
   int AtomNr, value;
@@ -769 +819 @@
   ifstream file;
 
-  for(int i=0;i<AtomCount;i++) {
+  for(int i=0;i<getAtomCount();i++) {
     OrderArray[i] = 0;
     MaxArray[i] = false;
@@ -871 +921 @@
   atom *OtherFather = NULL;
   atom *FatherOfRunner = NULL;
-  Leaf->CountAtoms();
-
-  atom *Runner = Leaf->start;
-  while (Runner->next != Leaf->end) {
-    Runner = Runner->next;
+
+#ifdef ADDHYDROGEN
+  molecule::const_iterator runner;
+#endif
+  // we increment the iter just before skipping the hydrogen
+  for (molecule::const_iterator iter = Leaf->begin(); iter != Leaf->end();) {
     LonelyFlag = true;
-    FatherOfRunner = Runner->father;
+    FatherOfRunner = (*iter)->father;
+    ASSERT(FatherOfRunner,"Atom without father found");
     if (SonList[FatherOfRunner->nr] != NULL)  {  // check if this, our father, is present in list
       // create all bonds
@@ -888 +940 @@
 //            Log() << Verbose(3) << "Adding Bond: ";
 //            Log() << Verbose(0) <<
-            Leaf->AddBond(Runner, SonList[OtherFather->nr], (*BondRunner)->BondDegree);
+            Leaf->AddBond((*iter), SonList[OtherFather->nr], (*BondRunner)->BondDegree);
 //            Log() << Verbose(0) << "." << endl;
-            //NumBonds[Runner->nr]++;
+            //NumBonds[(*iter)->nr]++;
           } else {
 //            Log() << Verbose(3) << "Not adding bond, labels in wrong order." << endl;
@@ -898 +950 @@
 //          Log() << Verbose(0) << ", who has no son in this fragment molecule." << endl;
 #ifdef ADDHYDROGEN
-          //Log() << Verbose(3) << "Adding Hydrogen to " << Runner->Name << " and a bond in between." << endl;
-          if(!Leaf->AddHydrogenReplacementAtom((*BondRunner), Runner, FatherOfRunner, OtherFather, IsAngstroem))
+          //Log() << Verbose(3) << "Adding Hydrogen to " << (*iter)->Name << " and a bond in between." << endl;
+          if(!Leaf->AddHydrogenReplacementAtom((*BondRunner), (*iter), FatherOfRunner, OtherFather, IsAngstroem))
             exit(1);
 #endif
-          //NumBonds[Runner->nr] += Binder->BondDegree;
+          //NumBonds[(*iter)->nr] += Binder->BondDegree;
         }
       }
     } else {
-      DoeLog(1) && (eLog()<< Verbose(1) << "Son " << Runner->getName() << " has father " << FatherOfRunner->getName() << " but its entry in SonList is " << SonList[FatherOfRunner->nr] << "!" << endl);
-    }
-    if ((LonelyFlag) && (Leaf->AtomCount > 1)) {
-      DoLog(0) && (Log() << Verbose(0) << *Runner << "has got bonds only to hydrogens!" << endl);
-    }
+    DoeLog(1) && (eLog()<< Verbose(1) << "Son " << (*iter)->getName() << " has father " << FatherOfRunner->getName() << " but its entry in SonList is " << SonList[FatherOfRunner->nr] << "!" << endl);
+    }
+    if ((LonelyFlag) && (Leaf->getAtomCount() > 1)) {
+      DoLog(0) && (Log() << Verbose(0) << **iter << "has got bonds only to hydrogens!" << endl);
+    }
+    ++iter;
 #ifdef ADDHYDROGEN
-    while ((Runner->next != Leaf->end) && (Runner->next->type->Z == 1)) // skip added hydrogen
-      Runner = Runner->next;
+    while ((iter != Leaf->end()) && ((*iter)->type->Z == 1)){ // skip added hydrogen
+      iter++;
+    }
 #endif
   }
@@ -928 +982 @@
 molecule * molecule::StoreFragmentFromKeySet(KeySet &Leaflet, bool IsAngstroem)
 {
-  atom **SonList = new atom*[AtomCount];
+  atom **SonList = new atom*[getAtomCount()];
   molecule *Leaf = World::getInstance().createMolecule();
 
-  for(int i=0;i<AtomCount;i++)
+  for(int i=0;i<getAtomCount();i++)
     SonList[i] = NULL;
 
@@ -1561 +1615 @@
   FragmentSearch.FragmentSet = new KeySet;
   FragmentSearch.Root = FindAtom(RootKeyNr);
-  FragmentSearch.ShortestPathList = new int[AtomCount];
-  for (int i=AtomCount;i--;) {
+  FragmentSearch.ShortestPathList = new int[getAtomCount()];
+  for (int i=getAtomCount();i--;) {
     FragmentSearch.ShortestPathList[i] = -1;
   }
 
   // Construct the complete KeySet which we need for topmost level only (but for all Roots)
-  atom *Walker = start;
   KeySet CompleteMolecule;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    CompleteMolecule.insert(Walker->GetTrueFather()->nr);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    CompleteMolecule.insert((*iter)->GetTrueFather()->nr);
   }
 
@@ -1582 +1634 @@
     RootKeyNr = RootStack.front();
     RootStack.pop_front();
-    Walker = FindAtom(RootKeyNr);
+    atom *Walker = FindAtom(RootKeyNr);
     // check cyclic lengths
     //if ((MinimumRingSize[Walker->GetTrueFather()->nr] != -1) && (Walker->GetTrueFather()->AdaptiveOrder+1 > MinimumRingSize[Walker->GetTrueFather()->nr])) {
@@ -1671 +1723 @@
   Vector Translationvector;
   //class StackClass<atom *> *CompStack = NULL;
-  class StackClass<atom *> *AtomStack = new StackClass<atom *>(AtomCount);
+  class StackClass<atom *> *AtomStack = new StackClass<atom *>(getAtomCount());
   bool flag = true;
 
   DoLog(2) && (Log() << Verbose(2) << "Begin of ScanForPeriodicCorrection." << endl);
 
-  ColorList = new enum Shading[AtomCount];
-  for (int i=0;i<AtomCount;i++)
+  ColorList = new enum Shading[getAtomCount()];
+  for (int i=0;i<getAtomCount();i++)
     ColorList[i] = (enum Shading)0;
   while (flag) {
     // remove bonds that are beyond bonddistance
-    for(int i=NDIM;i--;)
-      Translationvector[i] = 0.;
+    Translationvector.Zero();
     // scan all bonds
     Binder = first;
@@ -1711 +1762 @@
       Log() << Verbose(0) << Translationvector <<  endl;
       // apply to all atoms of first component via BFS
-      for (int i=AtomCount;i--;)
+      for (int i=getAtomCount();i--;)
         ColorList[i] = white;
       AtomStack->Push(Binder->leftatom);
@@ -1735 +1786 @@
     //delete(CompStack);
   }
-
   // free allocated space from ReturnFullMatrixforSymmetric()
   delete(AtomStack);

src/molecule_geometry.cpp

@@ -71 +71 @@
 
 //  Log() << Verbose(3) << "Begin of CenterEdge." << endl;
-  atom *ptr = start->next;  // start at first in list
-  if (ptr != end) {   //list not empty?
+  molecule::const_iterator iter = begin();  // start at first in list
+  if (iter != end()) { //list not empty?
     for (int i=NDIM;i--;) {
-      max->at(i) = ptr->x[i];
-      min->at(i) = ptr->x[i];
-    }
-    while (ptr->next != end) {  // continue with second if present
-      ptr = ptr->next;
-      //ptr->Output(1,1,out);
+      max->at(i) = (*iter)->x[i];
+      min->at(i) = (*iter)->x[i];
+    }
+    for (; iter != end(); ++iter) {// continue with second if present
+      //(*iter)->Output(1,1,out);
       for (int i=NDIM;i--;) {
-        max->at(i) = (max->at(i) < ptr->x[i]) ? ptr->x[i] : max->at(i);
-        min->at(i) = (min->at(i) > ptr->x[i]) ? ptr->x[i] : min->at(i);
+        max->at(i) = (max->at(i) < (*iter)->x[i]) ? (*iter)->x[i] : max->at(i);
+        min->at(i) = (min->at(i) > (*iter)->x[i]) ? (*iter)->x[i] : min->at(i);
       }
     }
@@ -106 +105 @@
 {
   int Num = 0;
-  atom *ptr = start;  // start at first in list
+  molecule::const_iterator iter = begin();  // start at first in list
 
   Center.Zero();
 
-  if (ptr->next != end) {   //list not empty?
-    while (ptr->next != end) {
-      ptr = ptr->next;
+  if (iter != end()) {   //list not empty?
+    for (; iter != end(); ++iter) {  // continue with second if present
       Num++;
-      Center += ptr->x;
+      Center += (*iter)->x;
     }
     Center.Scale(-1./Num); // divide through total number (and sign for direction)
@@ -127 +125 @@
 Vector * molecule::DetermineCenterOfAll() const
 {
-  atom *ptr = start;  // start at first in list
+  molecule::const_iterator iter = begin();  // start at first in list
   Vector *a = new Vector();
   double Num = 0;
@@ -133 +131 @@
   a->Zero();
 
-  if (ptr->next != end) {   //list not empty?
-    while (ptr->next != end) {
-      ptr = ptr->next;
+  if (iter != end()) {   //list not empty?
+    for (; iter != end(); ++iter) {  // continue with second if present
       Num += 1.;
-      (*a) += ptr->x;
+      (*a) += (*iter)->x;
     }
     a->Scale(1./Num); // divide through total mass (and sign for direction)
@@ -165 +162 @@
 Vector * molecule::DetermineCenterOfGravity()
 {
-  atom *ptr = start->next;  // start at first in list
+  molecule::const_iterator iter = begin();  // start at first in list
   Vector *a = new Vector();
   Vector tmp;
@@ -172 +169 @@
   a->Zero();
 
-  if (ptr != end) {   //list not empty?
-    while (ptr->next != end) {  // continue with second if present
-      ptr = ptr->next;
-      Num += ptr->type->mass;
-      tmp = ptr->type->mass * ptr->x;
+  if (iter != end()) {   //list not empty?
+    for (; iter != end(); ++iter) {  // continue with second if present
+      Num += (*iter)->type->mass;
+      tmp = (*iter)->type->mass * (*iter)->x;
       (*a) += tmp;
     }
@@ -217 +213 @@
 void molecule::Scale(const double ** const factor)
 {
-  atom *ptr = start;
-
-  while (ptr->next != end) {
-    ptr = ptr->next;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     for (int j=0;j<MDSteps;j++)
-      ptr->Trajectory.R.at(j).ScaleAll(*factor);
-    ptr->x.ScaleAll(*factor);
+      (*iter)->Trajectory.R.at(j).ScaleAll(*factor);
+    (*iter)->x.ScaleAll(*factor);
   }
 };
@@ -232 +225 @@
 void molecule::Translate(const Vector *trans)
 {
-  atom *ptr = start;
-
-  while (ptr->next != end) {
-    ptr = ptr->next;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     for (int j=0;j<MDSteps;j++)
-      ptr->Trajectory.R.at(j) += (*trans);
-    ptr->x += (*trans);
+      (*iter)->Trajectory.R.at(j) += (*trans);
+    (*iter)->x += (*trans);
   }
 };
@@ -274 +264 @@
 void molecule::DeterminePeriodicCenter(Vector &center)
 {
-  atom *Walker = start;
   double * const cell_size = World::getInstance().getDomain();
   double *matrix = ReturnFullMatrixforSymmetric(cell_size);
@@ -285 +274 @@
     Center.Zero();
     flag = true;
-    while (Walker->next != end) {
-      Walker = Walker->next;
+    for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
 #ifdef ADDHYDROGEN
-      if (Walker->type->Z != 1) {
+      if ((*iter)->type->Z != 1) {
 #endif
-        Testvector = Walker->x;
+        Testvector = (*iter)->x;
         Testvector.MatrixMultiplication(inversematrix);
         Translationvector.Zero();
-        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 (BondList::const_iterator Runner = (*iter)->ListOfBonds.begin(); Runner != (*iter)->ListOfBonds.end(); (++Runner)) {
+         if ((*iter)->nr < (*Runner)->GetOtherAtom((*iter))->nr) // otherwise we shift one to, the other fro and gain nothing
             for (int j=0;j<NDIM;j++) {
-              tmp = Walker->x[j] - (*Runner)->GetOtherAtom(Walker)->x[j];
+              tmp = (*iter)->x[j] - (*Runner)->GetOtherAtom(*iter)->x[j];
               if ((fabs(tmp)) > BondDistance) {
                 flag = false;
-                DoLog(0) && (Log() << Verbose(0) << "Hit: atom " << Walker->getName() << " in bond " << *(*Runner) << " has to be shifted due to " << tmp << "." << endl);
+                DoLog(0) && (Log() << Verbose(0) << "Hit: atom " << (*iter)->getName() << " in bond " << *(*Runner) << " has to be shifted due to " << tmp << "." << endl);
                 if (tmp > 0)
                   Translationvector[j] -= 1.;
@@ -313 +301 @@
 #ifdef ADDHYDROGEN
         // now also change all hydrogens
-        for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
-          if ((*Runner)->GetOtherAtom(Walker)->type->Z == 1) {
-            Testvector = (*Runner)->GetOtherAtom(Walker)->x;
+        for (BondList::const_iterator Runner = (*iter)->ListOfBonds.begin(); Runner != (*iter)->ListOfBonds.end(); (++Runner)) {
+          if ((*Runner)->GetOtherAtom((*iter))->type->Z == 1) {
+            Testvector = (*Runner)->GetOtherAtom((*iter))->x;
             Testvector.MatrixMultiplication(inversematrix);
             Testvector += Translationvector;
@@ -330 +318 @@
   delete[](inversematrix);
 
-  Center.Scale(1./(double)AtomCount);
+  Center.Scale(1./static_cast<double>(getAtomCount()));
 };
 
@@ -340 +328 @@
 void molecule::PrincipalAxisSystem(bool DoRotate)
 {
-  atom *ptr = start;  // start at first in list
   double InertiaTensor[NDIM*NDIM];
   Vector *CenterOfGravity = DetermineCenterOfGravity();
@@ -351 +338 @@
 
   // sum up inertia tensor
-  while (ptr->next != end) {
-    ptr = ptr->next;
-    Vector x = ptr->x;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    Vector x = (*iter)->x;
     //x.SubtractVector(CenterOfGravity);
-    InertiaTensor[0] += ptr->type->mass*(x[1]*x[1] + x[2]*x[2]);
-    InertiaTensor[1] += ptr->type->mass*(-x[0]*x[1]);
-    InertiaTensor[2] += ptr->type->mass*(-x[0]*x[2]);
-    InertiaTensor[3] += ptr->type->mass*(-x[1]*x[0]);
-    InertiaTensor[4] += ptr->type->mass*(x[0]*x[0] + x[2]*x[2]);
-    InertiaTensor[5] += ptr->type->mass*(-x[1]*x[2]);
-    InertiaTensor[6] += ptr->type->mass*(-x[2]*x[0]);
-    InertiaTensor[7] += ptr->type->mass*(-x[2]*x[1]);
-    InertiaTensor[8] += ptr->type->mass*(x[0]*x[0] + x[1]*x[1]);
+    InertiaTensor[0] += (*iter)->type->mass*(x[1]*x[1] + x[2]*x[2]);
+    InertiaTensor[1] += (*iter)->type->mass*(-x[0]*x[1]);
+    InertiaTensor[2] += (*iter)->type->mass*(-x[0]*x[2]);
+    InertiaTensor[3] += (*iter)->type->mass*(-x[1]*x[0]);
+    InertiaTensor[4] += (*iter)->type->mass*(x[0]*x[0] + x[2]*x[2]);
+    InertiaTensor[5] += (*iter)->type->mass*(-x[1]*x[2]);
+    InertiaTensor[6] += (*iter)->type->mass*(-x[2]*x[0]);
+    InertiaTensor[7] += (*iter)->type->mass*(-x[2]*x[1]);
+    InertiaTensor[8] += (*iter)->type->mass*(x[0]*x[0] + x[1]*x[1]);
   }
   // print InertiaTensor for debugging
@@ -401 +387 @@
 
     // sum up inertia tensor
-    ptr = start;
-    while (ptr->next != end) {
-      ptr = ptr->next;
-      Vector x = ptr->x;
-      //x.SubtractVector(CenterOfGravity);
-      InertiaTensor[0] += ptr->type->mass*(x[1]*x[1] + x[2]*x[2]);
-      InertiaTensor[1] += ptr->type->mass*(-x[0]*x[1]);
-      InertiaTensor[2] += ptr->type->mass*(-x[0]*x[2]);
-      InertiaTensor[3] += ptr->type->mass*(-x[1]*x[0]);
-      InertiaTensor[4] += ptr->type->mass*(x[0]*x[0] + x[2]*x[2]);
-      InertiaTensor[5] += ptr->type->mass*(-x[1]*x[2]);
-      InertiaTensor[6] += ptr->type->mass*(-x[2]*x[0]);
-      InertiaTensor[7] += ptr->type->mass*(-x[2]*x[1]);
-      InertiaTensor[8] += ptr->type->mass*(x[0]*x[0] + x[1]*x[1]);
+    for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+      Vector x = (*iter)->x;
+      InertiaTensor[0] += (*iter)->type->mass*(x[1]*x[1] + x[2]*x[2]);
+      InertiaTensor[1] += (*iter)->type->mass*(-x[0]*x[1]);
+      InertiaTensor[2] += (*iter)->type->mass*(-x[0]*x[2]);
+      InertiaTensor[3] += (*iter)->type->mass*(-x[1]*x[0]);
+      InertiaTensor[4] += (*iter)->type->mass*(x[0]*x[0] + x[2]*x[2]);
+      InertiaTensor[5] += (*iter)->type->mass*(-x[1]*x[2]);
+      InertiaTensor[6] += (*iter)->type->mass*(-x[2]*x[0]);
+      InertiaTensor[7] += (*iter)->type->mass*(-x[2]*x[1]);
+      InertiaTensor[8] += (*iter)->type->mass*(x[0]*x[0] + x[1]*x[1]);
     }
     // print InertiaTensor for debugging
@@ -438 +421 @@
 void molecule::Align(Vector *n)
 {
-  atom *ptr = start;
   double alpha, tmp;
   Vector z_axis;
@@ -449 +431 @@
   alpha = atan(-n->at(0)/n->at(2));
   DoLog(1) && (Log() << Verbose(1) << "Z-X-angle: " << alpha << " ... ");
-  while (ptr->next != end) {
-    ptr = ptr->next;
-    tmp = ptr->x[0];
-    ptr->x[0] =  cos(alpha) * tmp + sin(alpha) * ptr->x[2];
-    ptr->x[2] = -sin(alpha) * tmp + cos(alpha) * ptr->x[2];
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    tmp = (*iter)->x[0];
+    (*iter)->x[0] =  cos(alpha) * tmp + sin(alpha) * (*iter)->x[2];
+    (*iter)->x[2] = -sin(alpha) * tmp + cos(alpha) * (*iter)->x[2];
     for (int j=0;j<MDSteps;j++) {
-      tmp = ptr->Trajectory.R.at(j)[0];
-      ptr->Trajectory.R.at(j)[0] =  cos(alpha) * tmp + sin(alpha) * ptr->Trajectory.R.at(j)[2];
-      ptr->Trajectory.R.at(j)[2] = -sin(alpha) * tmp + cos(alpha) * ptr->Trajectory.R.at(j)[2];
+      tmp = (*iter)->Trajectory.R.at(j)[0];
+      (*iter)->Trajectory.R.at(j)[0] =  cos(alpha) * tmp + sin(alpha) * (*iter)->Trajectory.R.at(j)[2];
+      (*iter)->Trajectory.R.at(j)[2] = -sin(alpha) * tmp + cos(alpha) * (*iter)->Trajectory.R.at(j)[2];
     }
   }
@@ -467 +448 @@
 
   // rotate on z-y plane
-  ptr = start;
   alpha = atan(-n->at(1)/n->at(2));
   DoLog(1) && (Log() << Verbose(1) << "Z-Y-angle: " << alpha << " ... ");
-  while (ptr->next != end) {
-    ptr = ptr->next;
-    tmp = ptr->x[1];
-    ptr->x[1] =  cos(alpha) * tmp + sin(alpha) * ptr->x[2];
-    ptr->x[2] = -sin(alpha) * tmp + cos(alpha) * ptr->x[2];
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    tmp = (*iter)->x[1];
+    (*iter)->x[1] =  cos(alpha) * tmp + sin(alpha) * (*iter)->x[2];
+    (*iter)->x[2] = -sin(alpha) * tmp + cos(alpha) * (*iter)->x[2];
     for (int j=0;j<MDSteps;j++) {
-      tmp = ptr->Trajectory.R.at(j)[1];
-      ptr->Trajectory.R.at(j)[1] =  cos(alpha) * tmp + sin(alpha) * ptr->Trajectory.R.at(j)[2];
-      ptr->Trajectory.R.at(j)[2] = -sin(alpha) * tmp + cos(alpha) * ptr->Trajectory.R.at(j)[2];
+      tmp = (*iter)->Trajectory.R.at(j)[1];
+      (*iter)->Trajectory.R.at(j)[1] =  cos(alpha) * tmp + sin(alpha) * (*iter)->Trajectory.R.at(j)[2];
+      (*iter)->Trajectory.R.at(j)[2] = -sin(alpha) * tmp + cos(alpha) * (*iter)->Trajectory.R.at(j)[2];
     }
   }
@@ -502 +481 @@
   Vector a,b,c,d;
   struct lsq_params *par = (struct lsq_params *)params;
-  atom *ptr = par->mol->start;
 
   // initialize vectors
@@ -512 +490 @@
   b[2] = gsl_vector_get(x,5);
   // go through all atoms
-  while (ptr != par->mol->end) {
-    ptr = ptr->next;
-    if (ptr->type == ((struct lsq_params *)params)->type) { // for specific type
-      c = ptr->x - a;
+  for (molecule::const_iterator iter = par->mol->begin(); iter != par->mol->end(); ++iter) {
+    if ((*iter)->type == ((struct lsq_params *)params)->type) { // for specific type
+      c = (*iter)->x - a;
       t = c.ScalarProduct(b);           // get direction parameter
       d = t*b;       // and create vector

src/molecule_graph.cpp

@@ -20 +20 @@
 #include "World.hpp"
 #include "Helpers/fast_functions.hpp"
+#include "Helpers/Assert.hpp"
+
 
 struct BFSAccounting
@@ -80 +82 @@
       flip(atom1, atom2);
     Walker = FindAtom(atom1);
+    ASSERT(Walker,"Could not find an atom with the ID given in dbond file");
     OtherWalker = FindAtom(atom2);
+    ASSERT(OtherWalker,"Could not find an atom with the ID given in dbond file");
     AddBond(Walker, OtherWalker); //Add the bond between the two atoms with respective indices.
   }
@@ -109 +113 @@
   atom *Walker = NULL;
   atom *OtherWalker = NULL;
-  atom **AtomMap = NULL;
   int n[NDIM];
   double MinDistance, MaxDistance;
@@ -134 +137 @@
 
   // count atoms in molecule = dimension of matrix (also give each unique name and continuous numbering)
-  CountAtoms();
-  DoLog(1) && (Log() << Verbose(1) << "AtomCount " << AtomCount << " and bonddistance is " << bonddistance << "." << endl);
-
-  if ((AtomCount > 1) && (bonddistance > 1.)) {
+  DoLog(1) && (Log() << Verbose(1) << "AtomCount " << getAtomCount() << " and bonddistance is " << bonddistance << "." << endl);
+
+  if ((getAtomCount() > 1) && (bonddistance > 1.)) {
     DoLog(2) && (Log() << Verbose(2) << "Creating Linked Cell structure ... " << endl);
     LC = new LinkedCell(this, bonddistance);
@@ -143 +145 @@
     // create a list to map Tesselpoint::nr to atom *
     DoLog(2) && (Log() << Verbose(2) << "Creating TesselPoint to atom map ... " << endl);
-    AtomMap = new atom *[AtomCount];
-    for (int i=0;i<AtomCount;i++)
-      AtomMap[i] = NULL;
-    Walker = start;
-    while (Walker->next != end) {
-      Walker = Walker->next;
-      AtomMap[Walker->nr] = Walker;
+
+    // set numbers for atoms that can later be used
+    int i=0;
+    for(internal_iterator iter = atoms.begin();iter!= atoms.end(); ++iter){
+      (*iter)->nr = i++;
     }
 
@@ -161 +161 @@
           if (List != NULL) {
             for (LinkedCell::LinkedNodes::const_iterator Runner = List->begin(); Runner != List->end(); Runner++) {
-              Walker = AtomMap[(*Runner)->nr];
-//              Log() << Verbose(0) << "Current Atom is " << *Walker << "." << endl;
+              Walker = dynamic_cast<atom*>(*Runner);
+              ASSERT(Walker,"Tesselpoint that was not an atom retrieved from LinkedNode");
+              //Log() << 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]++)
@@ -172 +173 @@
                       for (LinkedCell::LinkedNodes::const_iterator OtherRunner = OtherList->begin(); OtherRunner != OtherList->end(); OtherRunner++) {
                         if ((*OtherRunner)->nr > Walker->nr) {
-                          OtherWalker = AtomMap[(*OtherRunner)->nr];
-//                          Log() << Verbose(0) << "Current other Atom is " << *OtherWalker << "." << endl;
-                          const double distance = OtherWalker->x.PeriodicDistanceSquared(Walker->x, cell_size);
-//                          Log() << Verbose(1) << "Checking distance " << distance << " against typical bond length of " << bonddistance*bonddistance << "." << endl;
+                          OtherWalker = dynamic_cast<atom*>(*OtherRunner);
+                          ASSERT(OtherWalker,"TesselPoint that was not an atom retrieved from LinkedNode");
+                          //Log() << 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);
 //                          Log() << Verbose(1) << "MinDistance is " << MinDistance << " and MaxDistance is " << MaxDistance << "." << endl;
@@ -196 +197 @@
           }
         }
-    delete[](AtomMap);
     delete (LC);
     DoLog(1) && (Log() << Verbose(1) << "I detected " << BondCount << " bonds in the molecule with distance " << BondDistance << "." << endl);
@@ -207 +207 @@
     ActOnAllAtoms( &atom::OutputBondOfAtom );
   } else
-    DoLog(1) && (Log() << Verbose(1) << "AtomCount is " << AtomCount << ", thus no bonds, no connections!." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "AtomCount is " << getAtomCount() << ", thus no bonds, no connections!." << endl);
   DoLog(0) && (Log() << Verbose(0) << "End of CreateAdjacencyList." << endl);
   if (free_BG)
@@ -249 +249 @@
     DoLog(0) && (Log() << Verbose(0) << " done." << endl);
   } else {
-    DoLog(1) && (Log() << Verbose(1) << "BondCount is " << BondCount << ", no bonds between any of the " << AtomCount << " atoms." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "BondCount is " << BondCount << ", no bonds between any of the " << getAtomCount() << " atoms." << endl);
   }
   DoLog(0) && (Log() << Verbose(0) << No << " bonds could not be corrected." << endl);
@@ -469 +469 @@
 void DepthFirstSearchAnalysis_Init(struct DFSAccounting &DFS, const molecule * const mol)
 {
-  DFS.AtomStack = new StackClass<atom *> (mol->AtomCount);
+  DFS.AtomStack = new StackClass<atom *> (mol->getAtomCount());
   DFS.CurrentGraphNr = 0;
   DFS.ComponentNumber = 0;
@@ -510 +510 @@
   bond *Binder = NULL;
 
-  if (AtomCount == 0)
+  if (getAtomCount() == 0)
     return SubGraphs;
   DoLog(0) && (Log() << Verbose(0) << "Begin of DepthFirstSearchAnalysis" << endl);
   DepthFirstSearchAnalysis_Init(DFS, this);
 
-  DFS.Root = start->next;
-  while (DFS.Root != end) { // if there any atoms at all
+  for (molecule::const_iterator iter = begin(); iter != end();) {
+    DFS.Root = *iter;
     // (1) mark all edges unused, empty stack, set atom->GraphNr = -1 for all
     DFS.AtomStack->ClearStack();
@@ -556 +556 @@
 
     // step on to next root
-    while ((DFS.Root != end) && (DFS.Root->GraphNr != -1)) {
-      //Log() << Verbose(1) << "Current next subgraph root candidate is " << Root->Name << "." << endl;
-      if (DFS.Root->GraphNr != -1) // if already discovered, step on
-        DFS.Root = DFS.Root->next;
+    while ((iter != end()) && ((*iter)->GraphNr != -1)) {
+      //Log() << Verbose(1) << "Current next subgraph root candidate is " << (*iter)->Name << "." << endl;
+      if ((*iter)->GraphNr != -1) // if already discovered, step on
+        iter++;
     }
   }
@@ -864 +864 @@
   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
+    for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+      Root = *iter;
+
+      if (MinimumRingSize[Root->GetTrueFather()->nr] == mol->getAtomCount()) { // check whether MinimumRingSize is set, if not BFS to next where it is
         Walker = Root;
 
         //Log() << Verbose(1) << "---------------------------------------------------------------------------------------------------------" << endl;
-        CyclicStructureAnalysis_BFSToNextCycle(Root, Walker, MinimumRingSize, mol->AtomCount);
+        CyclicStructureAnalysis_BFSToNextCycle(Root, Walker, MinimumRingSize, mol->getAtomCount());
 
       }
@@ -902 +901 @@
   int MinRingSize = -1;
 
-  InitializeBFSAccounting(BFS, AtomCount);
+  InitializeBFSAccounting(BFS, getAtomCount());
 
   //Log() << Verbose(1) << "Back edge list - ";
@@ -1145 +1144 @@
     CurrentBondsOfAtom = -1; // we count one too far due to line end
     // parse into structure
-    if ((AtomNr >= 0) && (AtomNr < AtomCount)) {
+    if ((AtomNr >= 0) && (AtomNr < getAtomCount())) {
       Walker = ListOfAtoms[AtomNr];
       while (!line.eof())
@@ -1324 +1323 @@
     AddedAtomList[Root->nr] = Mol->AddCopyAtom(Root);
 
-  BreadthFirstSearchAdd_Init(BFS, Root, BondOrder, AtomCount, AddedAtomList);
+  BreadthFirstSearchAdd_Init(BFS, Root, BondOrder, getAtomCount(), AddedAtomList);
 
   // and go on ... Queue always contains all lightgray vertices
@@ -1382 +1381 @@
   // fill parent list with sons
   DoLog(3) && (Log() << Verbose(3) << "Filling Parent List." << endl);
-  atom *Walker = mol->start;
-  while (Walker->next != mol->end) {
-    Walker = Walker->next;
-    ParentList[Walker->father->nr] = Walker;
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    ParentList[(*iter)->father->nr] = (*iter);
     // Outputting List for debugging
-    DoLog(4) && (Log() << Verbose(4) << "Son[" << Walker->father->nr << "] of " << Walker->father << " is " << ParentList[Walker->father->nr] << "." << endl);
-  }
-
-}
-;
+    DoLog(4) && (Log() << Verbose(4) << "Son[" << (*iter)->father->nr << "] of " << (*iter)->father << " is " << ParentList[(*iter)->father->nr] << "." << endl);
+  }
+};
 
 void BuildInducedSubgraph_Finalize(atom **&ParentList)
@@ -1402 +1397 @@
 {
   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
   DoLog(3) && (Log() << Verbose(3) << "Creating bonds." << endl);
-  Walker = Father->start;
-  while (Walker->next != Father->end) {
-    Walker = Walker->next;
-    if (ParentList[Walker->nr] != NULL) {
-      if (ParentList[Walker->nr]->father != Walker) {
+  for (molecule::const_iterator iter = Father->begin(); iter != Father->end(); ++iter) {
+    if (ParentList[(*iter)->nr] != NULL) {
+      if (ParentList[(*iter)->nr]->father != (*iter)) {
         status = false;
       } else {
-        for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
-          OtherAtom = (*Runner)->GetOtherAtom(Walker);
+        for (BondList::const_iterator Runner = (*iter)->ListOfBonds.begin(); Runner != (*iter)->ListOfBonds.end(); (++Runner)) {
+          OtherAtom = (*Runner)->GetOtherAtom((*iter));
           if (ParentList[OtherAtom->nr] != NULL) { // if otheratom is also a father of an atom on this molecule, create the bond
-            DoLog(4) && (Log() << Verbose(4) << "Endpoints of Bond " << (*Runner) << " are both present: " << ParentList[Walker->nr]->getName() << " and " << ParentList[OtherAtom->nr]->getName() << "." << endl);
-            mol->AddBond(ParentList[Walker->nr], ParentList[OtherAtom->nr], (*Runner)->BondDegree);
+            DoLog(4) && (Log() << Verbose(4) << "Endpoints of Bond " << (*Runner) << " are both present: " << ParentList[(*iter)->nr]->getName() << " and " << ParentList[OtherAtom->nr]->getName() << "." << endl);
+            mol->AddBond(ParentList[(*iter)->nr], ParentList[OtherAtom->nr], (*Runner)->BondDegree);
           }
         }
@@ -1440 +1432 @@
   bool status = true;
   atom **ParentList = NULL;
-
   DoLog(2) && (Log() << Verbose(2) << "Begin of BuildInducedSubgraph." << endl);
-  BuildInducedSubgraph_Init(ParentList, Father->AtomCount);
+  BuildInducedSubgraph_Init(ParentList, Father->getAtomCount());
   BuildInducedSubgraph_FillParentList(this, Father, ParentList);
   status = BuildInducedSubgraph_CreateBondsFromParent(this, Father, ParentList);

src/molecule_pointcloud.cpp

@@ -8 +8 @@
 #include "atom.hpp"
 #include "config.hpp"
+#include "info.hpp"
 #include "memoryallocator.hpp"
 #include "molecule.hpp"
@@ -31 +32 @@
 };
 
-/** Return current atom in the list.
- * \return pointer to atom or NULL if none present
+
+/** PointCloud implementation of GoPoint
+ * Uses atoms and STL stuff.
  */
-TesselPoint *molecule::GetPoint() const
+TesselPoint* molecule::GetPoint() const
 {
-  if ((InternalPointer != start) && (InternalPointer != end))
-    return InternalPointer;
-  else
-    return NULL;
+  Info FunctionInfo(__func__);
+  return (*InternalPointer);
 };
 
-/** Return pointer to one after last atom in the list.
- * \return pointer to end marker
- */
-TesselPoint *molecule::GetTerminalPoint() const
-{
-  return end;
-};
-
-/** Return the greatest index of all atoms in the list.
- * \return greatest index
- */
-int molecule::GetMaxId() const
-{
-  return last_atom;
-};
-
-/** Go to next atom.
- * Stops at last one.
+/** PointCloud implementation of GoToNext.
+ * Uses atoms and STL stuff.
  */
 void molecule::GoToNext() const
 {
-  if (InternalPointer != end)
-    InternalPointer = InternalPointer->next;
+  Info FunctionInfo(__func__);
+  if (InternalPointer != atoms.end())
+    InternalPointer++;
 };
 
-/** Go to previous atom.
- * Stops at first one.
- */
-void molecule::GoToPrevious() const
-{
-  if (InternalPointer->previous != start)
-    InternalPointer = InternalPointer->previous;
-};
-
-/** Goes to first atom.
+/** PointCloud implementation of GoToFirst.
+ * Uses atoms and STL stuff.
  */
 void molecule::GoToFirst() const
 {
-  InternalPointer = start->next;
+  Info FunctionInfo(__func__);
+  InternalPointer = atoms.begin();
 };
 
-/** Goes to last atom.
- */
-void molecule::GoToLast() const
-{
-  InternalPointer = end->previous;
-};
-
-/** Checks whether we have any atoms in molecule.
- * \return true - no atoms, false - not empty
+/** PointCloud implementation of IsEmpty.
+ * Uses atoms and STL stuff.
  */
 bool molecule::IsEmpty() const
 {
-  return (start->next == end);
+  Info FunctionInfo(__func__);
+  return (empty());
 };
 
-/** Checks whether we are at the last atom
- * \return true - current atom is last one, false - is not last one
+/** PointCloud implementation of IsLast.
+ * Uses atoms and STL stuff.
  */
 bool molecule::IsEnd() const
 {
-  return (InternalPointer == end);
+  Info FunctionInfo(__func__);
+  return (InternalPointer == atoms.end());
 };
+
+int molecule::GetMaxId() const {
+  return getAtomCount();
+}

src/molecule_template.hpp

@@ -24 +24 @@
 template <typename res> void molecule::ActOnAllVectors( res (Vector::*f)() ) const
     {
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    ((Walker->node)->*f)();
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)();
   }
 };
 template <typename res> void molecule::ActOnAllVectors( res (Vector::*f)() const ) const
     {
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    ((Walker->node)->*f)();
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)();
   }
 };
@@ -41 +37 @@
 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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)(t);
   }
 };
 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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)(t);
   }
 };
@@ -74 +62 @@
 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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)(t, u);
   }
 };
@@ -91 +75 @@
 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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)(t, u, v);
   }
 };
@@ -112 +92 @@
 {
   res result = 0;
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    result += (Walker->*f)();
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    result += ((*iter)->*f)();
   }
   return result;
@@ -122 +100 @@
 {
   res result = 0;
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    result += (Walker->*f)();
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    result += ((*iter)->*f)();
   }
   return result;
@@ -133 +109 @@
 {
   res result = 0;
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    result += (Walker->*f)(t);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    result += ((*iter)->*f)(t);
   }
   return result;
@@ -143 +117 @@
 {
   res result = 0;
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    result += (Walker->*f)(t);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    result += ((*iter)->*f)(t);
   }
   return result;
@@ -157 +129 @@
 template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *)) const
 {
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*f)((*iter));
   }
 };
 template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *) const) const
 {
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*f)((*iter));
   }
 };
@@ -177 +145 @@
 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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (copy->*f)((*iter));
   }
 };
 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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (copy->*f)((*iter));
   }
 };
@@ -197 +161 @@
 template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () ) const
 {
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    if ((Walker->*condition)())
-      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)())
+      (copy->*f)((*iter));
   }
 };
 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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)())
+      (copy->*f)((*iter));
   }
 };
 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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)())
+      (copy->*f)((*iter));
   }
 };
 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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)())
+      (copy->*f)((*iter));
   }
 };
@@ -234 +190 @@
 template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , 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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t))
+      (copy->*f)((*iter));
   }
 };
 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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t))
+      (copy->*f)((*iter));
   }
 };
 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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t))
+      (copy->*f)((*iter));
   }
 };
 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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t))
+      (copy->*f)((*iter));
   }
 };
@@ -271 +219 @@
 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;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    if ((Walker->*condition)(t,u))
-      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t,u))
+      (copy->*f)((*iter));
   }
 };
 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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t,u))
+      (copy->*f)((*iter));
   }
 };
 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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t,u))
+      (copy->*f)((*iter));
   }
 };
 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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t,u))
+      (copy->*f)((*iter));
   }
 };
@@ -308 +248 @@
 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;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    if ((Walker->*condition)(t,u,v))
-      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t,u,v))
+      (copy->*f)((*iter));
   }
 };
 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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t,u,v))
+      (copy->*f)((*iter));
   }
 };
 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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t,u,v))
+      (copy->*f)((*iter));
   }
 };
 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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t,u,v))
+      (copy->*f)((*iter));
   }
 };
@@ -348 +280 @@
 template <typename res, typename typ> void molecule::ActOnAllAtoms( res (typ::*f)()) const
 {
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (Walker->*f)();
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)();
   }
 };
 template <typename res, typename typ> void molecule::ActOnAllAtoms( res (typ::*f)() const) const
 {
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (Walker->*f)();
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)();
   }
 };
@@ -365 +293 @@
 template <typename res, typename typ, typename T> void molecule::ActOnAllAtoms( res (typ::*f)(T), T t ) const
 {
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (Walker->*f)(t);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)(t);
   }
 };
 template <typename res, typename typ, typename T> void molecule::ActOnAllAtoms( res (typ::*f)(T) const, T t ) const
 {
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (Walker->*f)(t);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)(t);
   }
 };
@@ -382 +306 @@
 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;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (Walker->*f)(t, u);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)(t, 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;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (Walker->*f)(t, u);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)(t, u);
   }
 };
@@ -399 +319 @@
 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;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (Walker->*f)(t, u, v);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)(t, u, 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;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (Walker->*f)(t, u, v);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)(t, u, v);
   }
 };
@@ -416 +332 @@
 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;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (Walker->*f)(t, u, v, w);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)(t, u, v, 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;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (Walker->*f)(t, u, v, w);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)(t, u, v, w);
   }
 };
@@ -436 +348 @@
 template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *) ) const
 {
-  atom *Walker = start;
   int inc = 1;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (*Setor) (&array[(Walker->*index)], &inc);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*Setor) (&array[((*iter)->*index)], &inc);
   }
 };
 template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *), T value ) const
 {
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (*Setor) (&array[(Walker->*index)], &value);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*Setor) (&array[((*iter)->*index)], &value);
   }
 };
 template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *), T *value ) const
 {
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (*Setor) (&array[(Walker->*index)], value);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*Setor) (&array[((*iter)->*index)], value);
   }
 };
@@ -462 +368 @@
 template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *) ) const
 {
-  atom *Walker = start;
   int inc = 1;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (*Setor) (&array[(Walker->type->*index)], &inc);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*Setor) (&array[((*iter)->type->*index)], &inc);
   }
 };
 template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *), T value ) const
 {
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (*Setor) (&array[(Walker->type->*index)], &value);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*Setor) (&array[((*iter)->type->*index)], &value);
   }
 };
 template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *), T *value ) const
 {
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (*Setor) (&array[(Walker->type->*index)], value);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*Setor) (&array[((*iter)->type->*index)], value);
   }
 };
@@ -488 +388 @@
 template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &), typ atom::*value ) const
 {
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    array[(Walker->*index)] = (Walker->*Setor) (Walker->*value);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    array[((*iter)->*index)] = ((*iter)->*Setor) ((*iter)->*value);
   }
 };
 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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    array[((*iter)->*index)] = ((*iter)->*Setor) ((*iter)->*value);
   }
 };
 template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &), typ &vect ) const
 {
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    array[(Walker->*index)] = (Walker->*Setor) (vect);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    array[((*iter)->*index)] = ((*iter)->*Setor) (vect);
   }
 };
 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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    array[((*iter)->*index)] = ((*iter)->*Setor) (vect);
   }
 };
 template <typename T, typename typ, typename typ2> void molecule::SetAtomValueToIndexedArray ( T *array, int typ::*index, T typ2::*value ) const
 {
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    Walker->*value = array[(Walker->*index)];
-    //Log() << Verbose(2) << *Walker << " gets " << (Walker->*value); << endl;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*iter)->*value = array[((*iter)->*index)];
+    //Log() << Verbose(2) << *(*iter) << " gets " << ((*iter)->*value); << endl;
   }
 };
@@ -530 +420 @@
 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;
-    //Log() << Verbose(2) << *Walker << " gets " << (Walker->*ptr) << endl;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*iter)->*ptr = value;
+    //Log() << Verbose(2) << *(*iter) << " gets " << ((*iter)->*ptr) << endl;
   }
 };

src/moleculelist.cpp

@@ -20 +20 @@
 #include "memoryallocator.hpp"
 #include "periodentafel.hpp"
-#include "World.hpp"
+#include "Helpers/Assert.hpp"
 
 #include "Helpers/Assert.hpp"
@@ -71 +71 @@
   int Count, Counter, aCounter, bCounter;
   int flag;
-  atom *aWalker = NULL;
-  atom *bWalker = NULL;
 
   // sort each atom list and put the numbers into a list, then go through
   //Log() << Verbose(0) << "Comparing fragment no. " << *(molecule **)a << " to " << *(molecule **)b << "." << endl;
-  if ((**(molecule **) a).AtomCount < (**(molecule **) b).AtomCount) {
+  // Yes those types are awkward... but check it for yourself it checks out this way
+  molecule *const *mol1_ptr= static_cast<molecule *const *>(a);
+  molecule *mol1 = *mol1_ptr;
+  molecule *const *mol2_ptr= static_cast<molecule *const *>(b);
+  molecule *mol2 = *mol2_ptr;
+  if (mol1->getAtomCount() < mol2->getAtomCount()) {
     return -1;
   } else {
-    if ((**(molecule **) a).AtomCount > (**(molecule **) b).AtomCount)
+    if (mol1->getAtomCount() > mol2->getAtomCount())
       return +1;
     else {
-      Count = (**(molecule **) a).AtomCount;
+      Count = mol1->getAtomCount();
       aList = new int[Count];
       bList = new int[Count];
 
       // fill the lists
-      aWalker = (**(molecule **) a).start;
-      bWalker = (**(molecule **) b).start;
       Counter = 0;
       aCounter = 0;
       bCounter = 0;
-      while ((aWalker->next != (**(molecule **) a).end) && (bWalker->next != (**(molecule **) b).end)) {
-        aWalker = aWalker->next;
-        bWalker = bWalker->next;
-        if (aWalker->GetTrueFather() == NULL)
+      molecule::const_iterator aiter = mol1->begin();
+      molecule::const_iterator biter = mol2->begin();
+      for (;(aiter != mol1->end()) && (biter != mol2->end());
+          ++aiter, ++biter) {
+        if ((*aiter)->GetTrueFather() == NULL)
           aList[Counter] = Count + (aCounter++);
         else
-          aList[Counter] = aWalker->GetTrueFather()->nr;
-        if (bWalker->GetTrueFather() == NULL)
+          aList[Counter] = (*aiter)->GetTrueFather()->nr;
+        if ((*biter)->GetTrueFather() == NULL)
           bList[Counter] = Count + (bCounter++);
         else
-          bList[Counter] = bWalker->GetTrueFather()->nr;
+          bList[Counter] = (*biter)->GetTrueFather()->nr;
         Counter++;
       }
       // check if AtomCount was for real
       flag = 0;
-      if ((aWalker->next == (**(molecule **) a).end) && (bWalker->next != (**(molecule **) b).end)) {
+      if ((aiter == mol1->end()) && (biter != mol2->end())) {
         flag = -1;
       } else {
-        if ((aWalker->next != (**(molecule **) a).end) && (bWalker->next == (**(molecule **) b).end))
+        if ((aiter != mol1->end()) && (biter == mol2->end()))
           flag = 1;
       }
@@ -144 +146 @@
 void MoleculeListClass::Enumerate(ostream *out)
 {
-  atom *Walker = NULL;
   periodentafel *periode = World::getInstance().getPeriode();
   std::map<atomicNumber_t,unsigned int> counts;
@@ -160 +161 @@
       // count atoms per element and determine size of bounding sphere
       size=0.;
-      Walker = (*ListRunner)->start;
-      while (Walker->next != (*ListRunner)->end) {
-        Walker = Walker->next;
-        counts[Walker->type->getNumber()]++;
-        if (Walker->x.DistanceSquared(Origin) > size)
-          size = Walker->x.DistanceSquared(Origin);
+      for (molecule::const_iterator iter = (*ListRunner)->begin(); iter != (*ListRunner)->end(); ++iter) {
+        counts[(*iter)->type->getNumber()]++;
+        if ((*iter)->x.DistanceSquared(Origin) > size)
+          size = (*iter)->x.DistanceSquared(Origin);
       }
       // output Index, Name, number of atoms, chemical formula
-      (*out) << ((*ListRunner)->ActiveFlag ? "*" : " ") << (*ListRunner)->IndexNr << "\t" << (*ListRunner)->name << "\t\t" << (*ListRunner)->AtomCount << "\t";
+      (*out) << ((*ListRunner)->ActiveFlag ? "*" : " ") << (*ListRunner)->IndexNr << "\t" << (*ListRunner)->name << "\t\t" << (*ListRunner)->getAtomCount() << "\t";
 
       std::map<atomicNumber_t,unsigned int>::reverse_iterator iter;
@@ -204 +203 @@
 
   // put all molecules of src into mol
-  atom *Walker = srcmol->start;
-  atom *NextAtom = Walker->next;
-  while (NextAtom != srcmol->end) {
-    Walker = NextAtom;
-    NextAtom = Walker->next;
-    srcmol->UnlinkAtom(Walker);
-    mol->AddAtom(Walker);
+  molecule::iterator runner;
+  for (molecule::iterator iter = srcmol->begin(); iter != srcmol->end(); ++iter) {
+    runner = iter++;
+    srcmol->UnlinkAtom((*runner));
+    mol->AddAtom((*runner));
   }
 
@@ -230 +227 @@
 
   // put all molecules of src into mol
-  atom *Walker = srcmol->start;
-  atom *NextAtom = Walker->next;
-  while (NextAtom != srcmol->end) {
-    Walker = NextAtom;
-    NextAtom = Walker->next;
-    Walker = mol->AddCopyAtom(Walker);
+  atom *Walker = NULL;
+  for (molecule::iterator iter = srcmol->begin(); iter != srcmol->end(); ++iter) {
+    Walker = mol->AddCopyAtom((*iter));
     Walker->father = Walker;
   }
@@ -332 +326 @@
 
   // prepare index list for bonds
-  srcmol->CountAtoms();
-  atom ** CopyAtoms = new atom*[srcmol->AtomCount];
-  for(int i=0;i<srcmol->AtomCount;i++)
+  atom ** CopyAtoms = new atom*[srcmol->getAtomCount()];
+  for(int i=0;i<srcmol->getAtomCount();i++)
     CopyAtoms[i] = NULL;
 
   // for each of the source atoms check whether we are in- or outside and add copy atom
-  atom *Walker = srcmol->start;
   int nr=0;
-  while (Walker->next != srcmol->end) {
-    Walker = Walker->next;
-    DoLog(2) && (Log() << Verbose(2) << "INFO: Current Walker is " << *Walker << "." << endl);
-    if (!TesselStruct->IsInnerPoint(Walker->x, LCList)) {
-      CopyAtoms[Walker->nr] = Walker->clone();
-      mol->AddAtom(CopyAtoms[Walker->nr]);
+  for (molecule::const_iterator iter = srcmol->begin(); iter != srcmol->end(); ++iter) {
+    DoLog(2) && (Log() << Verbose(2) << "INFO: Current Walker is " << **iter << "." << endl);
+    if (!TesselStruct->IsInnerPoint((*iter)->x, LCList)) {
+      CopyAtoms[(*iter)->nr] = (*iter)->clone();
+      mol->AddAtom(CopyAtoms[(*iter)->nr]);
       nr++;
     } else {
@@ -351 +342 @@
     }
   }
-  DoLog(1) && (Log() << Verbose(1) << nr << " of " << srcmol->AtomCount << " atoms have been merged.");
+  DoLog(1) && (Log() << Verbose(1) << nr << " of " << srcmol->getAtomCount() << " atoms have been merged.");
 
   // go through all bonds and add as well
@@ -384 +375 @@
 bool MoleculeListClass::AddHydrogenCorrection(char *path)
 {
-  atom *Walker = NULL;
-  atom *Runner = NULL;
   bond *Binder = NULL;
   double ***FitConstant = NULL, **correction = NULL;
@@ -493 +482 @@
         correction[k][j] = 0.;
     // 2. take every hydrogen that is a saturated one
-    Walker = (*ListRunner)->start;
-    while (Walker->next != (*ListRunner)->end) {
-      Walker = Walker->next;
-      //Log() << 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
-        Runner = (*ListRunner)->start;
-        while (Runner->next != (*ListRunner)->end) {
-          Runner = Runner->next;
-          //Log() << Verbose(2) << "Runner: " << *Runner << " with first bond " << *(Walker->ListOfBonds.begin()) << "." << endl;
+    for (molecule::const_iterator iter = (*ListRunner)->begin(); iter != (*ListRunner)->end(); ++iter) {
+      //Log() << Verbose(1) << "(*iter): " << *(*iter) << " with first bond " << *((*iter)->ListOfBonds.begin()) << "." << endl;
+      if (((*iter)->type->Z == 1) && (((*iter)->father == NULL)
+          || ((*iter)->father->type->Z != 1))) { // if it's a hydrogen
+        for (molecule::const_iterator runner = (*ListRunner)->begin(); runner != (*ListRunner)->end(); ++runner) {
+          //Log() << Verbose(2) << "Runner: " << *(*runner) << " with first bond " << *((*iter)->ListOfBonds.begin()) << "." << endl;
           // 3. take every other hydrogen that is the not the first and not bound to same 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!)
+          Binder = *((*runner)->ListOfBonds.begin());
+          if (((*runner)->type->Z == 1) && ((*runner)->nr > (*iter)->nr) && (Binder->GetOtherAtom((*runner)) != Binder->GetOtherAtom((*iter)))) { // (hydrogens have only one bonding partner!)
             // 4. evaluate the morse potential for each matrix component and add up
-            distance = Runner->x.distance(Walker->x);
-            //Log() << Verbose(0) << "Fragment " << (*ListRunner)->name << ": " << *Runner << "<= " << distance << "=>" << *Walker << ":" << endl;
+            distance = (*runner)->x.distance((*iter)->x);
+            //Log() << Verbose(0) << "Fragment " << (*ListRunner)->name << ": " << *(*runner) << "<= " << distance << "=>" << *(*iter) << ":" << endl;
             for (int k = 0; k < a; k++) {
               for (int j = 0; j < b; j++) {
@@ -586 +571 @@
   ofstream ForcesFile;
   stringstream line;
-  atom *Walker = NULL;
   periodentafel *periode=World::getInstance().getPeriode();
 
@@ -599 +583 @@
       periodentafel::const_iterator elemIter;
       for(elemIter=periode->begin();elemIter!=periode->end();++elemIter){
-          if ((*ListRunner)->ElementsInMolecule[(*elemIter).first]) { // if this element got atoms
-          Walker = (*ListRunner)->start;
-          while (Walker->next != (*ListRunner)->end) { // go through every atom of this element
-            Walker = Walker->next;
-            if (Walker->type->getNumber() == (*elemIter).first) {
-              if ((Walker->GetTrueFather() != NULL) && (Walker->GetTrueFather() != Walker)) {// if there is a rea
+        if ((*ListRunner)->ElementsInMolecule[(*elemIter).first]) { // if this element got atoms
+          for(molecule::iterator atomIter = (*ListRunner)->begin(); atomIter !=(*ListRunner)->end();++atomIter){
+            if ((*atomIter)->type->getNumber() == (*elemIter).first) {
+              if (((*atomIter)->GetTrueFather() != NULL) && ((*atomIter)->GetTrueFather() != (*atomIter))) {// if there is a rea
                 //Log() << Verbose(0) << "Walker is " << *Walker << " with true father " << *( Walker->GetTrueFather()) << ", it
-                ForcesFile << SortIndex[Walker->GetTrueFather()->nr] << "\t";
+                ForcesFile << SortIndex[(*atomIter)->GetTrueFather()->nr] << "\t";
               } else
                 // otherwise a -1 to indicate an added saturation hydrogen
@@ -640 +622 @@
   bool result = true;
   bool intermediateResult = true;
-  atom *Walker = NULL;
   Vector BoxDimension;
   char *FragmentNumber = NULL;
@@ -681 +662 @@
     // list atoms in fragment for debugging
     DoLog(2) && (Log() << Verbose(2) << "Contained atoms: ");
-    Walker = (*ListRunner)->start;
-    while (Walker->next != (*ListRunner)->end) {
-      Walker = Walker->next;
-      DoLog(0) && (Log() << Verbose(0) << Walker->getName() << " ");
+    for (molecule::const_iterator iter = (*ListRunner)->begin(); iter != (*ListRunner)->end(); ++iter) {
+      DoLog(0) && (Log() << Verbose(0) << (*iter)->getName() << " ");
     }
     DoLog(0) && (Log() << Verbose(0) << endl);
@@ -764 +743 @@
 {
   molecule *mol = World::getInstance().createMolecule();
-  atom *Walker = NULL;
-  atom *Advancer = NULL;
   bond *Binder = NULL;
   bond *Stepper = NULL;
@@ -771 +748 @@
   for (MoleculeList::iterator MolRunner = ListOfMolecules.begin(); !ListOfMolecules.empty(); MolRunner = ListOfMolecules.begin()) {
     // shift all atoms to new molecule
-    Advancer = (*MolRunner)->start->next;
-    while (Advancer != (*MolRunner)->end) {
-      Walker = Advancer;
-      Advancer = Advancer->next;
-      DoLog(3) && (Log() << Verbose(3) << "Re-linking " << *Walker << "..." << endl);
-      unlink(Walker);
-      Walker->father = Walker;
-      mol->AddAtom(Walker);    // counting starts at 1
+    for (molecule::iterator iter = (*MolRunner)->begin(); (*MolRunner)->empty(); iter = (*MolRunner)->begin()) {
+      DoLog(3) && (Log() << Verbose(3) << "Re-linking " << (*iter) << "..." << endl);
+      (*iter)->father = (*iter);
+      mol->AddAtom((*iter));    // counting starts at 1
+      (*MolRunner)->erase(iter);
     }
     // remove all bonds
@@ -832 +806 @@
   // 4b. create and fill map of which atom is associated to which connected molecule (note, counting starts at 1)
   int FragmentCounter = 0;
-  int *MolMap = new int[mol->AtomCount];
-  for (int i=0;i<mol->AtomCount;i++)
+  int *MolMap = new int[mol->getAtomCount()];
+  for (int i=0;i<mol->getAtomCount();i++)
     MolMap[i] = 0;
   MoleculeLeafClass *MolecularWalker = Subgraphs;
-  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;
+    for (molecule::const_iterator iter = MolecularWalker->Leaf->begin(); iter != MolecularWalker->Leaf->end(); ++iter) {
+      MolMap[(*iter)->GetTrueFather()->nr] = FragmentCounter+1;
     }
     FragmentCounter++;
@@ -848 +819 @@
 
   // 4c. relocate atoms to new molecules and remove from Leafs
-  Walker = NULL;
-  while (mol->start->next != mol->end) {
-    Walker = mol->start->next;
-    if ((Walker->nr <0) || (Walker->nr >= mol->AtomCount)) {
-      DoeLog(0) && (eLog()<< Verbose(0) << "Index of atom " << *Walker << " is invalid!" << endl);
+  for (molecule::iterator iter = mol->begin(); !mol->empty(); iter = mol->begin()) {
+    if (((*iter)->nr <0) || ((*iter)->nr >= mol->getAtomCount())) {
+      DoeLog(0) && (eLog()<< Verbose(0) << "Index of atom " << **iter << " is invalid!" << endl);
       performCriticalExit();
     }
-    FragmentCounter = MolMap[Walker->nr];
+    FragmentCounter = MolMap[(*iter)->nr];
     if (FragmentCounter != 0) {
-      DoLog(3) && (Log() << Verbose(3) << "Re-linking " << *Walker << "..." << endl);
-      unlink(Walker);
-      molecules[FragmentCounter-1]->AddAtom(Walker);    // counting starts at 1
+      DoLog(3) && (Log() << Verbose(3) << "Re-linking " << **iter << "..." << endl);
+      molecules[FragmentCounter-1]->AddAtom((*iter));    // counting starts at 1
+      mol->erase(iter);
     } else {
-      DoeLog(0) && (eLog()<< Verbose(0) << "Atom " << *Walker << " not associated to molecule!" << endl);
+      DoeLog(0) && (eLog()<< Verbose(0) << "Atom " << **iter << " not associated to molecule!" << endl);
       performCriticalExit();
     }
@@ -869 +838 @@
   while (mol->first->next != mol->last) {
     Binder = mol->first->next;
-    Walker = Binder->leftatom;
+    const atom * const Walker = Binder->leftatom;
     unlink(Binder);
     link(Binder,molecules[MolMap[Walker->nr]-1]->last);   // counting starts at 1
@@ -891 +860 @@
 int MoleculeListClass::CountAllAtoms() const
 {
-  atom *Walker = NULL;
   int AtomNo = 0;
   for (MoleculeList::const_iterator MolWalker = ListOfMolecules.begin(); MolWalker != ListOfMolecules.end(); MolWalker++) {
-    Walker = (*MolWalker)->start;
-    while (Walker->next != (*MolWalker)->end) {
-      Walker = Walker->next;
-      AtomNo++;
-    }
+    AtomNo += (*MolWalker)->size();
   }
   return AtomNo;
@@ -1073 +1037 @@
 bool MoleculeLeafClass::FillBondStructureFromReference(const molecule * const reference, int &FragmentCounter, atom ***&ListOfLocalAtoms, bool FreeList)
 {
-  atom *Walker = NULL;
   atom *OtherWalker = NULL;
   atom *Father = NULL;
@@ -1081 +1044 @@
   DoLog(1) && (Log() << Verbose(1) << "Begin of FillBondStructureFromReference." << endl);
   // fill ListOfLocalAtoms if NULL was given
-  if (!FillListOfLocalAtoms(ListOfLocalAtoms, FragmentCounter, reference->AtomCount, FreeList)) {
+  if (!FillListOfLocalAtoms(ListOfLocalAtoms, FragmentCounter, reference->getAtomCount(), FreeList)) {
     DoLog(1) && (Log() << Verbose(1) << "Filling of ListOfLocalAtoms failed." << endl);
     return false;
@@ -1097 +1060 @@
     }
 
-    Walker = Leaf->start;
-    while (Walker->next != Leaf->end) {
-      Walker = Walker->next;
-      Father = Walker->GetTrueFather();
+    for(molecule::const_iterator iter = Leaf->begin(); iter != Leaf->end(); ++iter) {
+      Father = (*iter)->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
+        OtherWalker = ListOfLocalAtoms[FragmentCounter][(*Runner)->GetOtherAtom((*iter)->GetTrueFather())->nr]; // local copy of current bond partner of walker
         if (OtherWalker != NULL) {
-          if (OtherWalker->nr > Walker->nr)
-            Leaf->AddBond(Walker, OtherWalker, (*Runner)->BondDegree);
+          if (OtherWalker->nr > (*iter)->nr)
+            Leaf->AddBond((*iter), OtherWalker, (*Runner)->BondDegree);
         } else {
-          DoLog(1) && (Log() << Verbose(1) << "OtherWalker = ListOfLocalAtoms[" << FragmentCounter << "][" << (*Runner)->GetOtherAtom(Walker->GetTrueFather())->nr << "] is NULL!" << endl);
+          DoLog(1) && (Log() << Verbose(1) << "OtherWalker = ListOfLocalAtoms[" << FragmentCounter << "][" << (*Runner)->GetOtherAtom((*iter)->GetTrueFather())->nr << "] is NULL!" << endl);
           status = false;
         }
@@ -1135 +1096 @@
 bool MoleculeLeafClass::FillRootStackForSubgraphs(KeyStack *&RootStack, bool *AtomMask, int &FragmentCounter)
 {
-  atom *Walker = NULL, *Father = NULL;
+  atom *Father = NULL;
 
   if (RootStack != NULL) {
@@ -1141 +1102 @@
     if (&(RootStack[FragmentCounter]) != NULL) {
       RootStack[FragmentCounter].clear();
-      Walker = Leaf->start;
-      while (Walker->next != Leaf->end) { // go through all (non-hydrogen) atoms
-        Walker = Walker->next;
-        Father = Walker->GetTrueFather();
+      for(molecule::const_iterator iter = Leaf->begin(); iter != Leaf->end(); ++iter) {
+        Father = (*iter)->GetTrueFather();
         if (AtomMask[Father->nr]) // apply mask
 #ifdef ADDHYDROGEN
-          if (Walker->type->Z != 1) // skip hydrogen
+          if ((*iter)->type->Z != 1) // skip hydrogen
 #endif
-          RootStack[FragmentCounter].push_front(Walker->nr);
+          RootStack[FragmentCounter].push_front((*iter)->nr);
       }
       if (next != NULL)
@@ -1191 +1150 @@
 
   if ((ListOfLocalAtoms != NULL) && (ListOfLocalAtoms[FragmentCounter] == NULL)) { // allocate and fill list of this fragment/subgraph
-    status = status && CreateFatherLookupTable(Leaf->start, Leaf->end, ListOfLocalAtoms[FragmentCounter], GlobalAtomCount);
+    status = status && Leaf->CreateFatherLookupTable(ListOfLocalAtoms[FragmentCounter], GlobalAtomCount);
     FreeList = FreeList && true;
   }
@@ -1215 +1174 @@
   DoLog(1) && (Log() << Verbose(1) << "Begin of AssignKeySetsToFragment." << endl);
   // fill ListOfLocalAtoms if NULL was given
-  if (!FillListOfLocalAtoms(ListOfLocalAtoms, FragmentCounter, reference->AtomCount, FreeList)) {
+  if (!FillListOfLocalAtoms(ListOfLocalAtoms, FragmentCounter, reference->getAtomCount(), FreeList)) {
     DoLog(1) && (Log() << Verbose(1) << "Filling of ListOfLocalAtoms failed." << endl);
     return false;

src/tesselation.cpp

@@ -21 +21 @@
 #include "Plane.hpp"
 #include "Exceptions/LinearDependenceException.hpp"
+#include "Helpers/Assert.hpp"
+
+#include "Helpers/Assert.hpp"
 
 class molecule;
@@ -357 +360 @@
   // get ascending order of endpoints
   PointMap OrderMap;
-  for (int i = 0; i < 3; i++)
+  for (int i = 0; i < 3; i++) {
     // for all three lines
     for (int j = 0; j < 2; j++) { // for both endpoints
@@ -363 +366 @@
       // and we don't care whether insertion fails
     }
+  }
   // set endpoints
   int Counter = 0;
@@ -371 +375 @@
     Counter++;
   }
-  if (Counter < 3) {
-    DoeLog(0) && (eLog() << Verbose(0) << "We have a triangle with only two distinct endpoints!" << endl);
-    performCriticalExit();
-  }
-}
-;
+  ASSERT(Counter >= 3,"We have a triangle with only two distinct endpoints!");
+};
+
 
 /** Destructor of BoundaryTriangleSet.
@@ -682 +683 @@
 }
 
+/**
+ * gets the Plane defined by the three triangle Basepoints
+ */
+Plane BoundaryTriangleSet::getPlane() const{
+  ASSERT(endpoints[0] && endpoints[1] && endpoints[2], "Triangle not fully defined");
+
+  return Plane(*endpoints[0]->node->node,
+               *endpoints[1]->node->node,
+               *endpoints[2]->node->node);
+}
+
+Vector BoundaryTriangleSet::getEndpoint(int i) const{
+  ASSERT(i>=0 && i<3,"Index of Endpoint out of Range");
+
+  return *endpoints[i]->node->node;
+}
+
+string BoundaryTriangleSet::getEndpointName(int i) const{
+  ASSERT(i>=0 && i<3,"Index of Endpoint out of Range");
+
+  return endpoints[i]->node->getName();
+}
+
 /** output operator for BoundaryTriangleSet.
  * \param &ost output stream
@@ -688 +712 @@
 ostream &operator <<(ostream &ost, const BoundaryTriangleSet &a)
 {
-  ost << "[" << a.Nr << "|" << a.endpoints[0]->node->getName() << "," << a.endpoints[1]->node->getName() << "," << a.endpoints[2]->node->getName() << "]";
+  ost << "[" << a.Nr << "|" << a.getEndpointName(0) << "," << a.getEndpointName(1) << "," << a.getEndpointName(2) << "]";
   //  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 << "," << a.endpoints[2]->node->Name << " at " << *a.endpoints[2]->node->node << "]";
@@ -1208 +1232 @@
 ;
 
-/** PointCloud implementation of GetTerminalPoint.
- * Uses PointsOnBoundary and STL stuff.
- */
-TesselPoint * Tesselation::GetTerminalPoint() const
-{
-  Info FunctionInfo(__func__);
-  PointMap::const_iterator Runner = PointsOnBoundary.end();
-  Runner--;
-  return (Runner->second->node);
-}
-;
-
 /** PointCloud implementation of GoToNext.
  * Uses PointsOnBoundary and STL stuff.
@@ -1231 +1243 @@
 ;
 
-/** PointCloud implementation of GoToPrevious.
- * Uses PointsOnBoundary and STL stuff.
- */
-void Tesselation::GoToPrevious() const
-{
-  Info FunctionInfo(__func__);
-  if (InternalPointer != PointsOnBoundary.begin())
-    InternalPointer--;
-}
-;
-
 /** PointCloud implementation of GoToFirst.
  * Uses PointsOnBoundary and STL stuff.
@@ -1249 +1250 @@
   Info FunctionInfo(__func__);
   InternalPointer = PointsOnBoundary.begin();
-}
-;
-
-/** PointCloud implementation of GoToLast.
- * Uses PointsOnBoundary and STL stuff.
- */
-void Tesselation::GoToLast() const
-{
-  Info FunctionInfo(__func__);
-  InternalPointer = PointsOnBoundary.end();
-  InternalPointer--;
 }
 ;
@@ -1455 +1445 @@
         CenterVector.Zero();
         for (int i = 0; i < 3; i++)
-          CenterVector += (*BTS->endpoints[i]->node->node);
+          CenterVector += BTS->getEndpoint(i);
         CenterVector.Scale(1. / 3.);
         DoLog(2) && (Log() << Verbose(2) << "CenterVector of base triangle is " << CenterVector << endl);
@@ -2569 +2559 @@
   // fill the set of neighbours
   TesselPointSet SetOfNeighbours;
+
   SetOfNeighbours.insert(CandidateLine.BaseLine->endpoints[1]->node);
   for (TesselPointList::iterator Runner = CandidateLine.pointlist.begin(); Runner != CandidateLine.pointlist.end(); Runner++)
@@ -4802 +4793 @@
   if (LastTriangle != NULL) {
     stringstream sstr;
-    sstr << "-"<< TrianglesOnBoundary.size() << "-" << LastTriangle->endpoints[0]->node->getName() << "_" << LastTriangle->endpoints[1]->node->getName() << "_" << LastTriangle->endpoints[2]->node->getName();
+    sstr << "-"<< TrianglesOnBoundary.size() << "-" << LastTriangle->getEndpointName(0) << "_" << LastTriangle->getEndpointName(1) << "_" << LastTriangle->getEndpointName(2);
     NumberName = sstr.str();
     if (DoTecplotOutput) {

src/tesselation.hpp

@@ -38 +38 @@
 class PointCloud;
 class Tesselation;
+class Plane;
 
 /********************************************** definitions *********************************/
@@ -166 +167 @@
     bool IsPresentTupel(const BoundaryTriangleSet * const T) const;
 
+    Plane getPlane() const;
+    Vector getEndpoint(int) const;
+    std::string getEndpointName(int) const;
+
     class BoundaryPointSet *endpoints[3];
     class BoundaryLineSet *lines[3];
@@ -171 +176 @@
     Vector SphereCenter;
     int Nr;
+
+  private:
+
 };
 
@@ -236 +244 @@
   virtual Vector *GetCenter() const { return NULL; };
   virtual TesselPoint *GetPoint() const { return NULL; };
-  virtual TesselPoint *GetTerminalPoint() const { return NULL; };
   virtual int GetMaxId() const { return 0; };
   virtual void GoToNext() const {};
-  virtual void GoToPrevious() const {};
   virtual void GoToFirst() const {};
-  virtual void GoToLast() const {};
   virtual bool IsEmpty() const { return true; };
   virtual bool IsEnd() const { return true; };
@@ -355 +360 @@
     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;

src/tesselationhelpers.cpp

@@ -16 +16 @@
 #include "vector_ops.hpp"
 #include "verbose.hpp"
+#include "Plane.hpp"
 
 double DetGet(gsl_matrix * const A, const int inPlace)
@@ -687 +688 @@
     return -1;
   }
-  distance = x->DistanceToPlane(triangle->NormalVector, *triangle->endpoints[0]->node->node);
+  distance = x->DistanceToSpace(triangle->getPlane());
   return distance;
 };
@@ -837 +838 @@
     int i=cloud->GetMaxId();
     int *LookupList = new int[i];
-    for (cloud->GoToFirst(), i=0; !cloud->IsEnd(); cloud->GoToNext(), i++)
+    for (cloud->GoToFirst(), i=0; !cloud->IsEnd(); cloud->GoToNext(), i++){
       LookupList[i] = -1;
+    }
 
     // print atom coordinates
     int Counter = 1;
     TesselPoint *Walker = NULL;
-    for (PointMap::const_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++;

src/unittests/AnalysisCorrelationToPointUnitTest.cpp

@@ -66 +66 @@
 
   // check that TestMolecule was correctly constructed
-  CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 4 );
 
   TestList = World::getInstance().getMolecules();

src/unittests/AnalysisCorrelationToSurfaceUnitTest.cpp

@@ -25 +25 @@
 #include "tesselation.hpp"
 #include "World.hpp"
+#include "Helpers/Assert.hpp"
 
 #include "Helpers/Assert.hpp"
@@ -39 +40 @@
 void AnalysisCorrelationToSurfaceUnitTest::setUp()
 {
-  //ASSERT_DO(Assert::Throw);
+  ASSERT_DO(Assert::Throw);
 
   atom *Walker = NULL;
@@ -54 +55 @@
   hydrogen = World::getInstance().getPeriode()->FindElement(1);
   TestSurfaceMolecule = World::getInstance().createMolecule();
+
   Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   *Walker->node = Vector(1., 0., 1. );
-
-  TestSurfaceMolecule->AddAtom(Walker);
+  TestSurfaceMolecule->AddAtom(Walker);
+
   Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   *Walker->node = Vector(0., 1., 1. );
   TestSurfaceMolecule->AddAtom(Walker);
+
   Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   *Walker->node = Vector(1., 1., 0. );
   TestSurfaceMolecule->AddAtom(Walker);
+
   Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
@@ -73 +77 @@
 
   // check that TestMolecule was correctly constructed
-  CPPUNIT_ASSERT_EQUAL( TestSurfaceMolecule->AtomCount, 4 );
+  CPPUNIT_ASSERT_EQUAL( TestSurfaceMolecule->getAtomCount(), 4 );
 
   TestList = World::getInstance().getMolecules();
@@ -91 +95 @@
   *Walker->node = Vector(4., 0., 4. );
   TestSurfaceMolecule->AddAtom(Walker);
+
   Walker = World::getInstance().createAtom();
   Walker->type = carbon;
   *Walker->node = Vector(0., 4., 4. );
   TestSurfaceMolecule->AddAtom(Walker);
+
   Walker = World::getInstance().createAtom();
   Walker->type = carbon;
   *Walker->node = Vector(4., 4., 0. );
   TestSurfaceMolecule->AddAtom(Walker);
+
   // add inner atoms
   Walker = World::getInstance().createAtom();
@@ -104 +111 @@
   *Walker->node = Vector(0.5, 0.5, 0.5 );
   TestSurfaceMolecule->AddAtom(Walker);
+
   TestSurfaceMolecule->ActiveFlag = true;
   TestList->insert(TestSurfaceMolecule);
@@ -133 +141 @@
 void AnalysisCorrelationToSurfaceUnitTest::SurfaceTest()
 {
-  CPPUNIT_ASSERT_EQUAL( 4, TestSurfaceMolecule->AtomCount );
+  CPPUNIT_ASSERT_EQUAL( 4, TestSurfaceMolecule->getAtomCount() );
   CPPUNIT_ASSERT_EQUAL( (size_t)2, TestList->ListOfMolecules.size() );
   CPPUNIT_ASSERT_EQUAL( (size_t)4, Surface->PointsOnBoundary.size() );

src/unittests/AnalysisPairCorrelationUnitTest.cpp

@@ -68 +68 @@
 
   // check that TestMolecule was correctly constructed
-  CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 4 );
 
   TestList = World::getInstance().getMolecules();

src/unittests/CountBondsUnitTest.cpp

@@ -92 +92 @@
 
   // check that TestMolecule was correctly constructed
-  CPPUNIT_ASSERT_EQUAL( TestMolecule1->AtomCount, 3 );
-  Walker = TestMolecule1->start->next;
-  CPPUNIT_ASSERT( TestMolecule1->end != Walker );
-  CPPUNIT_ASSERT_EQUAL( TestMolecule2->AtomCount, 3 );
-  Walker = TestMolecule2->start->next;
-  CPPUNIT_ASSERT( TestMolecule2->end != Walker );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule1->getAtomCount(), 3 );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule2->getAtomCount(), 3 );
 
   // create a small file with table

src/unittests/LinkedCellUnitTest.cpp

@@ -60 +60 @@
 
   // check that TestMolecule was correctly constructed
-  CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 3*3*3 );
-  Walker = TestMolecule->start->next;
-  CPPUNIT_ASSERT( TestMolecule->end != Walker );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 3*3*3 );
 };
 
@@ -187 +185 @@
 {
   // check all atoms
-  atom *Walker = TestMolecule->start;
-  while (Walker->next != TestMolecule->end) {
-    Walker = Walker->next;
-    CPPUNIT_ASSERT_EQUAL( true, LC->SetIndexToNode(Walker) );
+  for(molecule::iterator iter = TestMolecule->begin(); iter != TestMolecule->end();++iter){
+    CPPUNIT_ASSERT_EQUAL( true, LC->SetIndexToNode(*iter) );
   }
 
   // check internal vectors, returns false, because this atom is not in LC-list!
-  Walker = World::getInstance().createAtom();
-  Walker->setName("test");
-  Walker->x= Vector(1,1,1);
-  CPPUNIT_ASSERT_EQUAL( false, LC->SetIndexToNode(Walker) );
-  World::getInstance().destroyAtom(Walker);
+  atom *newAtom = World::getInstance().createAtom();
+  newAtom->setName("test");
+  newAtom->x= Vector(1,1,1);
+  CPPUNIT_ASSERT_EQUAL( false, LC->SetIndexToNode(newAtom) );
+  World::getInstance().destroyAtom(newAtom);
 
   // check out of bounds vectors
-  Walker = World::getInstance().createAtom();
-  Walker->setName("test");
-  Walker->x = Vector(0,-1,0);
-  CPPUNIT_ASSERT_EQUAL( false, LC->SetIndexToNode(Walker) );
-  World::getInstance().destroyAtom(Walker);
+  newAtom = World::getInstance().createAtom();
+  newAtom->setName("test");
+  newAtom->x = Vector(0,-1,0);
+  CPPUNIT_ASSERT_EQUAL( false, LC->SetIndexToNode(newAtom) );
+  World::getInstance().destroyAtom(newAtom);
 };
 
@@ -277 +273 @@
   size = ListOfPoints->size();
   CPPUNIT_ASSERT_EQUAL( (size_t)27, size );
-  Walker = TestMolecule->start;
-  Walker = TestMolecule->start;
-  while (Walker->next != TestMolecule->end) {
-    Walker = Walker->next;
-    ListOfPoints->remove(Walker);
+
+  for(molecule::iterator iter = TestMolecule->begin(); iter != TestMolecule->end(); ++iter){
+    ListOfPoints->remove((*iter));
     size--;
     CPPUNIT_ASSERT_EQUAL( size, ListOfPoints->size() );
@@ -296 +290 @@
   size=ListOfPoints->size();
   CPPUNIT_ASSERT_EQUAL( (size_t)8, size );
-  Walker = TestMolecule->start;
-  while (Walker->next != TestMolecule->end) {
-    Walker = Walker->next;
-    if ((Walker->x[0] <2) && (Walker->x[1] <2) && (Walker->x[2] <2)) {
-      ListOfPoints->remove(Walker);
+  for(molecule::iterator iter = TestMolecule->begin(); iter != TestMolecule->end(); ++iter){
+    if (((*iter)->x[0] <2) && ((*iter)->x[1] <2) && ((*iter)->x[2] <2)) {
+      ListOfPoints->remove(*iter);
       size--;
       CPPUNIT_ASSERT_EQUAL( size, ListOfPoints->size() );
@@ -316 +308 @@
   size=ListOfPoints->size();
   CPPUNIT_ASSERT_EQUAL( (size_t)27, size );
-  Walker = TestMolecule->start;
-  while (Walker->next != TestMolecule->end) {
-    Walker = Walker->next;
-    ListOfPoints->remove(Walker);
+  for(molecule::iterator iter = TestMolecule->begin(); iter!=TestMolecule->end();++iter){
+    ListOfPoints->remove(*iter);
     size--;
     CPPUNIT_ASSERT_EQUAL( size, ListOfPoints->size() );
@@ -345 +335 @@
   size = ListOfPoints->size();
   CPPUNIT_ASSERT_EQUAL( (size_t)7, size );
-  Walker = TestMolecule->start;
-  while (Walker->next != TestMolecule->end) {
-    Walker = Walker->next;
-    if ((Walker->x.DistanceSquared(tester) - 1.) < MYEPSILON ) {
-      ListOfPoints->remove(Walker);
+  for(molecule::iterator iter = TestMolecule->begin(); iter!=TestMolecule->end();++iter){
+    if (((*iter)->x.DistanceSquared(tester) - 1.) < MYEPSILON ) {
+      ListOfPoints->remove(*iter);
       size--;
       CPPUNIT_ASSERT_EQUAL( size, ListOfPoints->size() );

src/unittests/Makefile.am

@@ -49 +49 @@
 noinst_PROGRAMS = $(TESTS) TestRunner
 
-GSLLIBS = ../libgslwrapper.a
-ALLLIBS = ../libmolecuilder.a ${GSLLIBS} $(BOOST_LIB) ${BOOST_THREAD_LIB}
+GSLLIBS = ../libgslwrapper.a $(BOOST_LIB) ${BOOST_THREAD_LIB}
+ALLLIBS = ../libmolecuilder.a ${GSLLIBS} 
 
 TESTSOURCES = \
@@ -182 +182 @@
 manipulateAtomsTest_LDADD = ${ALLLIBS}
 
-MemoryAllocatorUnitTest_SOURCES = UnitTestMain.cpp ../memoryallocator.hpp ../memoryusageobserver.cpp ../memoryusageobserver.hpp memoryallocatorunittest.cpp memoryallocatorunittest.hpp 
+MemoryAllocatorUnitTest_SOURCES = UnitTestMain.cpp ../memoryallocator.hpp ../memoryallocator.cpp ../memoryusageobserver.cpp ../memoryusageobserver.hpp memoryallocatorunittest.cpp memoryallocatorunittest.hpp 
 MemoryAllocatorUnitTest_LDADD = ${ALLLIBS}
 
@@ -218 +218 @@
 Tesselation_InOutsideUnitTest_LDADD = ${ALLLIBS}
 
-TestRunner_SOURCES = TestRunnerMain.cpp ../memoryallocator.hpp ../memoryusageobserver.cpp ../memoryusageobserver.hpp $(TESTSOURCES) $(TESTHEADERS)
+TestRunner_SOURCES = TestRunnerMain.cpp ../memoryallocator.hpp ../memoryallocator.cpp ../memoryusageobserver.cpp ../memoryusageobserver.hpp $(TESTSOURCES) $(TESTHEADERS)
 TestRunner_LDADD = ${ALLLIBS}
 

src/unittests/ObserverTest.cpp

@@ -11 +11 @@
 #include <cppunit/extensions/TestFactoryRegistry.h>
 #include <cppunit/ui/text/TestRunner.h>
+#include <set>
 
 #include "Patterns/Observer.hpp"
+#include "Patterns/ObservedIterator.hpp"
 #include "Helpers/Assert.hpp"
 
@@ -162 +164 @@
   bool wasNotified;
 };
+
+class ObservableCollection : public Observable {
+public:
+  typedef std::set<SimpleObservable*> set;
+  typedef ObservedIterator<set> iterator;
+  typedef set::const_iterator const_iterator;
+
+  ObservableCollection(int _num) :
+  num(_num)
+  {
+    for(int i=0; i<num; ++i){
+      SimpleObservable *content = new SimpleObservable();
+      content->signOn(this);
+      theSet.insert(content);
+    }
+  }
+
+  ~ObservableCollection(){
+    set::iterator iter;
+    for(iter=theSet.begin(); iter!=theSet.end(); ++iter ){
+      delete (*iter);
+    }
+  }
+
+  iterator begin(){
+    return iterator(theSet.begin(),this);
+  }
+
+  iterator end(){
+    return iterator(theSet.end(),this);
+  }
+
+  const int num;
+
+private:
+  set theSet;
+};
+
 
 /******************* actuall tests ***************/
@@ -173 +213 @@
   blockObservable = new BlockObservable();
   notificationObservable = new NotificationObservable();
+  collection = new ObservableCollection(5);
 
   observer1 = new UpdateCountObserver();
@@ -181 +222 @@
   notificationObserver1 = new NotificationObserver(notificationObservable->notification1);
   notificationObserver2 = new NotificationObserver(notificationObservable->notification2);
-
 }
 
@@ -191 +231 @@
   delete blockObservable;
   delete notificationObservable;
+  delete collection;
 
   delete observer1;
@@ -277 +318 @@
   blockObservable->changeMethod2();
   blockObservable->noChangeMethod();
+}
+
+void ObserverTest::iteratorTest(){
+  int i = 0;
+  // test the general iterator methods
+  for(ObservableCollection::iterator iter=collection->begin(); iter!=collection->end();++iter){
+    CPPUNIT_ASSERT(i< collection->num);
+    i++;
+  }
+
+  i=0;
+  for(ObservableCollection::const_iterator iter=collection->begin(); iter!=collection->end();++iter){
+    CPPUNIT_ASSERT(i<collection->num);
+    i++;
+  }
+
+  collection->signOn(observer1);
+  {
+    // we construct this out of the loop, so the iterator dies at the end of
+    // the scope and not the end of the loop (allows more testing)
+    ObservableCollection::iterator iter;
+    for(iter=collection->begin(); iter!=collection->end(); ++iter){
+      (*iter)->changeMethod();
+    }
+    // At this point no change should have been propagated
+    CPPUNIT_ASSERT_EQUAL( 0, observer1->updates);
+  }
+  // After the Iterator has died the propagation should take place
+  CPPUNIT_ASSERT_EQUAL( 1, observer1->updates);
+
+  // when using a const_iterator no changes should be propagated
+  for(ObservableCollection::const_iterator iter = collection->begin(); iter!=collection->end();++iter);
+  CPPUNIT_ASSERT_EQUAL( 1, observer1->updates);
+  collection->signOff(observer1);
 }
 

src/unittests/ObserverTest.hpp

@@ -17 +17 @@
 class CallObservable;
 class SuperObservable;
+class ObservableCollection;
 class BlockObservable;
 class NotificationObservable;
-
 
 class ObserverTest :  public CppUnit::TestFixture
@@ -29 +29 @@
   CPPUNIT_TEST ( doesNotifyTest );
   CPPUNIT_TEST ( doesReportTest );
+  CPPUNIT_TEST ( iteratorTest );
   CPPUNIT_TEST ( CircleDetectionTest );
   CPPUNIT_TEST_SUITE_END();
@@ -41 +42 @@
   void doesNotifyTest();
   void doesReportTest();
+  void iteratorTest();
   void CircleDetectionTest();
 
@@ -58 +60 @@
   SuperObservable *superObservable;
   NotificationObservable *notificationObservable;
+  ObservableCollection *collection;
+
 };
 

src/unittests/analysisbondsunittest.cpp

@@ -25 +25 @@
 #include "molecule.hpp"
 #include "periodentafel.hpp"
+#include "World.hpp"
 
 #ifdef HAVE_TESTRUNNER
@@ -76 +77 @@
 
   // check that TestMolecule was correctly constructed
-  CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 5 );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 5 );
 
   // create a small file with table

src/unittests/bondgraphunittest.cpp

@@ -77 +77 @@
 
   // check that TestMolecule was correctly constructed
-  CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 4 );
 
   // create a small file with table
@@ -114 +114 @@
 };
 
+/** Tests whether setup worked.
+ */
+void BondGraphTest::SetupTest()
+{
+  CPPUNIT_ASSERT_EQUAL (false, TestMolecule->empty());
+  CPPUNIT_ASSERT_EQUAL ((size_t)4, TestMolecule->size());
+};
+
 /** UnitTest for BondGraphTest::LoadBondLengthTable().
  */
@@ -128 +136 @@
 void BondGraphTest::ConstructGraphFromTableTest()
 {
-  atom *Walker = TestMolecule->start->next;
-  atom *Runner = TestMolecule->end->previous;
-  CPPUNIT_ASSERT( TestMolecule->end != Walker );
+  molecule::iterator Walker = TestMolecule->begin();
+  molecule::iterator Runner = TestMolecule->begin();
+  Runner++;
   CPPUNIT_ASSERT_EQUAL( true , BG->LoadBondLengthTable(*filename) );
   CPPUNIT_ASSERT_EQUAL( true , BG->ConstructBondGraph(TestMolecule) );
-  CPPUNIT_ASSERT_EQUAL( true , Walker->IsBondedTo(Runner) );
+  CPPUNIT_ASSERT_EQUAL( true , (*Walker)->IsBondedTo((*Runner)) );
 };
 
@@ -140 +148 @@
 void BondGraphTest::ConstructGraphFromCovalentRadiiTest()
 {
-  atom *Walker = TestMolecule->start->next;
-  atom *Runner = TestMolecule->end->previous;
-  CPPUNIT_ASSERT( TestMolecule->end != Walker );
+
+  //atom *Walker = TestMolecule->start->next;
+  //atom *Runner = TestMolecule->end->previous;
+  //CPPUNIT_ASSERT( TestMolecule->end != Walker );
   CPPUNIT_ASSERT_EQUAL( false , BG->LoadBondLengthTable(*dummyname) );
   CPPUNIT_ASSERT_EQUAL( true , BG->ConstructBondGraph(TestMolecule) );
-  CPPUNIT_ASSERT_EQUAL( true , Walker->IsBondedTo(Runner) );
+
+  // this cannot be assured using dynamic IDs
+  //CPPUNIT_ASSERT_EQUAL( true , Walker->IsBondedTo(Runner) );
 };
 

src/unittests/bondgraphunittest.hpp

@@ -22 +22 @@
 {
     CPPUNIT_TEST_SUITE( BondGraphTest) ;
+    CPPUNIT_TEST ( SetupTest );
     CPPUNIT_TEST ( LoadTableTest );
     CPPUNIT_TEST ( ConstructGraphFromTableTest );
@@ -30 +31 @@
       void setUp();
       void tearDown();
+      void SetupTest();
       void LoadTableTest();
       void ConstructGraphFromTableTest();

src/unittests/listofbondsunittest.cpp

@@ -67 +67 @@
 
   // check that TestMolecule was correctly constructed
-  CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 4 );
 };
 
@@ -81 +81 @@
 };
 
+/** Tests whether setup worked correctly.
+ *
+ */
+void ListOfBondsTest::SetupTest()
+{
+  CPPUNIT_ASSERT_EQUAL( false, TestMolecule->empty() );
+  CPPUNIT_ASSERT_EQUAL( (size_t)4, TestMolecule->size() );
+};
+
 /** Unit Test of molecule::AddBond()
  *
@@ -87 +96 @@
 {
   bond *Binder = NULL;
-  atom *atom1 = TestMolecule->start->next;
-  atom *atom2 = atom1->next;
+  molecule::iterator iter = TestMolecule->begin();
+  atom *atom1 = *iter;
+  iter++;
+  atom *atom2 = *iter;
   CPPUNIT_ASSERT( atom1 != NULL );
   CPPUNIT_ASSERT( atom2 != NULL );
@@ -115 +126 @@
 {
   bond *Binder = NULL;
-  atom *atom1 = TestMolecule->start->next;
-  atom *atom2 = atom1->next;
+  molecule::iterator iter = TestMolecule->begin();
+  atom *atom1 = *iter;
+  iter++;
+  atom *atom2 = *iter;
   CPPUNIT_ASSERT( atom1 != NULL );
   CPPUNIT_ASSERT( atom2 != NULL );
@@ -141 +154 @@
 {
   bond *Binder = NULL;
-  atom *atom1 = TestMolecule->start->next;
-  atom *atom2 = atom1->next;
-  atom *atom3 = atom2->next;
+  molecule::iterator iter = TestMolecule->begin();
+  atom *atom1 = *iter;
+  iter++;
+  atom *atom2 = *iter;
+  iter++;
+  atom *atom3 = *iter;
   CPPUNIT_ASSERT( atom1 != NULL );
   CPPUNIT_ASSERT( atom2 != NULL );
@@ -180 +196 @@
 {
   bond *Binder = NULL;
-  atom *atom1 = TestMolecule->start->next;
-  atom *atom2 = atom1->next;
+  molecule::iterator iter = TestMolecule->begin();
+  atom *atom1 = *iter;
+  iter++;
+  atom *atom2 = *iter;
   CPPUNIT_ASSERT( atom1 != NULL );
   CPPUNIT_ASSERT( atom2 != NULL );
@@ -206 +224 @@
 {
   bond *Binder = NULL;
-  atom *atom1 = TestMolecule->start->next;
-  atom *atom2 = atom1->next;
+  molecule::iterator iter = TestMolecule->begin();
+  atom *atom1 = *iter;
+  iter++;
+  atom *atom2 = *iter;
   CPPUNIT_ASSERT( atom1 != NULL );
   CPPUNIT_ASSERT( atom2 != NULL );
@@ -231 +251 @@
 {
   bond *Binder = NULL;
-  atom *atom1 = TestMolecule->start->next;
-  atom *atom2 = atom1->next;
+  molecule::iterator iter = TestMolecule->begin();
+  atom *atom1 = *iter;
+  iter++;
+  atom *atom2 = *iter;
   CPPUNIT_ASSERT( atom1 != NULL );
   CPPUNIT_ASSERT( atom2 != NULL );

src/unittests/listofbondsunittest.hpp

@@ -20 +20 @@
 {
     CPPUNIT_TEST_SUITE( ListOfBondsTest) ;
+    CPPUNIT_TEST ( SetupTest );
     CPPUNIT_TEST ( AddingBondTest );
     CPPUNIT_TEST ( RemovingBondTest );
@@ -31 +32 @@
       void setUp();
       void tearDown();
+      void SetupTest();
       void AddingBondTest();
       void RemovingBondTest();

src/vector.cpp

@@ -266 +266 @@
  * \return distance to plane
  */
-double Vector::DistanceToPlane(const Vector &PlaneNormal, const Vector &PlaneOffset) const
-{
-  return GetDistanceVectorToPlane(PlaneNormal,PlaneOffset).Norm();
+double Vector::DistanceToSpace(const Space &space) const
+{
+  return space.distance(*this);
 };
 

src/vector.hpp

@@ -40 +40 @@
   double DistanceSquared(const Vector &y) const;
   Vector GetDistanceVectorToPlane(const Vector &PlaneNormal, const Vector &PlaneOffset) const;
-  double DistanceToPlane(const Vector &PlaneNormal, const Vector &PlaneOffset) const;
+  double DistanceToSpace(const Space& space) const;
   double PeriodicDistance(const Vector &y, const double * const cell_size) const;
   double PeriodicDistanceSquared(const Vector &y, const double * const cell_size) const;

tests/regression/Domain/5/post/test.conf

@@ -71 +71 @@
 Ion_Type2       3       6       1.0     3       3       12.01100000000  Carbon  C
 #Ion_TypeNr._Nr.R[0]    R[1]    R[2]    MoveType (0 MoveIon, 1 FixedIon)
-Ion_Type2_1     4.891042973     3.275186040     3.182297433     0 # molecule nr 0
-Ion_Type2_2     4.266392982     4.158586027     3.182297433     0 # molecule nr 1
-Ion_Type2_3     3.641792991     3.275186040     3.182297433     0 # molecule nr 2
-Ion_Type1_1     4.891042973     2.645886050     2.381297445     0 # molecule nr 3
-Ion_Type1_2     4.891042973     2.645886050     3.983297422     0 # molecule nr 4
-Ion_Type1_3     5.336019804     3.904536878     3.182297433     0 # molecule nr 5
-Ion_Type1_4     4.266392982     4.787886018     2.381297445     0 # molecule nr 6
-Ion_Type1_5     4.266392982     4.787886018     3.983297422     0 # molecule nr 7
-Ion_Type1_6     3.196816159     3.904536877     3.182297433     0 # molecule nr 8
-Ion_Type1_7     3.641792991     2.645886050     2.381297445     0 # molecule nr 9
-Ion_Type1_8     3.641792991     2.645886050     3.983297422     0 # molecule nr 10
+Ion_Type1_1     4.891042973     2.645886050     2.381297445     0 # molecule nr 0
+Ion_Type1_2     4.891042973     2.645886050     3.983297422     0 # molecule nr 1
+Ion_Type1_3     5.336019804     3.904536878     3.182297433     0 # molecule nr 2
+Ion_Type1_4     4.266392982     4.787886018     2.381297445     0 # molecule nr 3
+Ion_Type1_5     4.266392982     4.787886018     3.983297422     0 # molecule nr 4
+Ion_Type1_6     3.196816159     3.904536877     3.182297433     0 # molecule nr 5
+Ion_Type1_7     3.641792991     2.645886050     2.381297445     0 # molecule nr 6
+Ion_Type1_8     3.641792991     2.645886050     3.983297422     0 # molecule nr 7
+Ion_Type2_1     4.891042973     3.275186040     3.182297433     0 # molecule nr 8
+Ion_Type2_2     4.266392982     4.158586027     3.182297433     0 # molecule nr 9
+Ion_Type2_3     3.641792991     3.275186040     3.182297433     0 # molecule nr 10

tests/regression/Domain/5/pre/test.conf

@@ -71 +71 @@
 Ion_Type2       3       6       1.0     3       3       12.01100000000  Carbon  C
 #Ion_TypeNr._Nr.R[0]    R[1]    R[2]    MoveType (0 MoveIon, 1 FixedIon)
-Ion_Type2_1     9.782085945     3.275186040     3.535886037     0 # molecule nr 0
-Ion_Type2_2     8.532785963     4.158586027     3.535886037     0 # molecule nr 1
-Ion_Type2_3     7.283585982     3.275186040     3.535886037     0 # molecule nr 2
-Ion_Type1_1     9.782085945     2.645886050     2.645886050     0 # molecule nr 3
-Ion_Type1_2     9.782085945     2.645886050     4.425886024     0 # molecule nr 4
-Ion_Type1_3     10.672039608    3.904536878     3.535886037     0 # molecule nr 5
-Ion_Type1_4     8.532785963     4.787886018     2.645886050     0 # molecule nr 6
-Ion_Type1_5     8.532785963     4.787886018     4.425886024     0 # molecule nr 7
-Ion_Type1_6     6.393632318     3.904536877     3.535886037     0 # molecule nr 8
-Ion_Type1_7     7.283585982     2.645886050     2.645886050     0 # molecule nr 9
-Ion_Type1_8     7.283585982     2.645886050     4.425886024     0 # molecule nr 10
+Ion_Type1_1     9.782085945     2.645886050     2.645886050     0 # molecule nr 0
+Ion_Type1_2     9.782085945     2.645886050     4.425886024     0 # molecule nr 1
+Ion_Type1_3     10.672039608    3.904536878     3.535886037     0 # molecule nr 2
+Ion_Type1_4     8.532785963     4.787886018     2.645886050     0 # molecule nr 3
+Ion_Type1_5     8.532785963     4.787886018     4.425886024     0 # molecule nr 4
+Ion_Type1_6     6.393632318     3.904536877     3.535886037     0 # molecule nr 5
+Ion_Type1_7     7.283585982     2.645886050     2.645886050     0 # molecule nr 6
+Ion_Type1_8     7.283585982     2.645886050     4.425886024     0 # molecule nr 7
+Ion_Type2_1     9.782085945     3.275186040     3.535886037     0 # molecule nr 8
+Ion_Type2_2     8.532785963     4.158586027     3.535886037     0 # molecule nr 9
+Ion_Type2_3     7.283585982     3.275186040     3.535886037     0 # molecule nr 10

tests/regression/Domain/6/pre/test.conf

@@ -71 +71 @@
 Ion_Type2       3       6       1.0     3       3       12.01100000000  Carbon  C
 #Ion_TypeNr._Nr.R[0]    R[1]    R[2]    MoveType (0 MoveIon, 1 FixedIon)
-Ion_Type2_1     9.782085945     3.275186040     3.535886037     0 # molecule nr 0
-Ion_Type2_2     8.532785963     4.158586027     3.535886037     0 # molecule nr 1
-Ion_Type2_3     7.283585982     3.275186040     3.535886037     0 # molecule nr 2
-Ion_Type1_1     9.782085945     2.645886050     2.645886050     0 # molecule nr 3
-Ion_Type1_2     9.782085945     2.645886050     4.425886024     0 # molecule nr 4
-Ion_Type1_3     10.672039608    3.904536878     3.535886037     0 # molecule nr 5
-Ion_Type1_4     8.532785963     4.787886018     2.645886050     0 # molecule nr 6
-Ion_Type1_5     8.532785963     4.787886018     4.425886024     0 # molecule nr 7
-Ion_Type1_6     6.393632318     3.904536877     3.535886037     0 # molecule nr 8
-Ion_Type1_7     7.283585982     2.645886050     2.645886050     0 # molecule nr 9
-Ion_Type1_8     7.283585982     2.645886050     4.425886024     0 # molecule nr 10
+Ion_Type1_1     9.782085945     2.645886050     2.645886050     0 # molecule nr 0
+Ion_Type1_2     9.782085945     2.645886050     4.425886024     0 # molecule nr 1
+Ion_Type1_3     10.672039608    3.904536878     3.535886037     0 # molecule nr 2
+Ion_Type1_4     8.532785963     4.787886018     2.645886050     0 # molecule nr 3
+Ion_Type1_5     8.532785963     4.787886018     4.425886024     0 # molecule nr 4
+Ion_Type1_6     6.393632318     3.904536877     3.535886037     0 # molecule nr 5
+Ion_Type1_7     7.283585982     2.645886050     2.645886050     0 # molecule nr 6
+Ion_Type1_8     7.283585982     2.645886050     4.425886024     0 # molecule nr 7
+Ion_Type2_1     9.782085945     3.275186040     3.535886037     0 # molecule nr 8
+Ion_Type2_2     8.532785963     4.158586027     3.535886037     0 # molecule nr 9
+Ion_Type2_3     7.283585982     3.275186040     3.535886037     0 # molecule nr 10

tests/regression/testsuite-domain.at

@@ -45 +45 @@
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -d 1 1 1], 0, [stdout], [stderr])
-AT_CHECK([diff test.conf ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/post/test.conf], 0, [stdout], [stderr])
-AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/pre/test.conf .], 0)
-AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -d 2 1 1], 0, [stdout], [stderr])
-AT_CHECK([diff test.conf ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/post/test-x.conf], 0, [stdout], [stderr])
-AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/pre/test.conf .], 0)
-AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -d 1 2 1], 0, [stdout], [stderr])
-AT_CHECK([diff test.conf ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/post/test-y.conf], 0, [stdout], [stderr])
-AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/pre/test.conf .], 0)
-AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -d 1 1 2], 0, [stdout], [stderr])
-AT_CHECK([diff test.conf ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/post/test-z.conf], 0, [stdout], [stderr])
+AT_CHECK([file=test.conf.xyz;sort -n $file | grep -v "Created by" >$file-sorted], 0, [ignore], [ignore])
+AT_CHECK([file=test.conf.xyz;sort -n ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/post/$file  | grep -v "Created by" >$file-sorted2], 0, [ignore], [ignore])
+AT_CHECK([file=test.conf.xyz; diff $file-sorted $file-sorted2], 0, [ignore], [ignore])
+AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/pre/test.conf test-x.conf], 0)
+AT_CHECK([../../molecuilder test-x.conf -e ${abs_top_srcdir}/src/ -d 2 1 1], 0, [stdout], [stderr])
+AT_CHECK([file=test-x.conf.xyz;sort -n $file | grep -v "Created by" >$file-sorted], 0, [ignore], [ignore])
+AT_CHECK([file=test-x.conf.xyz;sort -n ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/post/$file  | grep -v "Created by" >$file-sorted2], 0, [ignore], [ignore])
+AT_CHECK([file=test-x.conf.xyz; diff $file-sorted $file-sorted2], 0, [ignore], [ignore])
+AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/pre/test.conf test-y.conf], 0)
+AT_CHECK([../../molecuilder test-y.conf -e ${abs_top_srcdir}/src/ -d 1 2 1], 0, [stdout], [stderr])
+AT_CHECK([file=test-y.conf.xyz;sort -n $file | grep -v "Created by" >$file-sorted], 0, [ignore], [ignore])
+AT_CHECK([file=test-y.conf.xyz;sort -n ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/post/$file  | grep -v "Created by" >$file-sorted2], 0, [ignore], [ignore])
+AT_CHECK([file=test-y.conf.xyz; diff $file-sorted $file-sorted2], 0, [ignore], [ignore])
+AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/pre/test.conf test-z.conf], 0)
+AT_CHECK([../../molecuilder test-z.conf -e ${abs_top_srcdir}/src/ -d 1 1 2], 0, [stdout], [stderr])
+AT_CHECK([file=test-z.conf.xyz;sort -n $file | grep -v "Created by" >$file-sorted], 0, [ignore], [ignore])
+AT_CHECK([file=test-z.conf.xyz;sort -n ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/post/$file  | grep -v "Created by" >$file-sorted2], 0, [ignore], [ignore])
+AT_CHECK([file=test-z.conf.xyz; diff $file-sorted $file-sorted2], 0, [ignore], [ignore])
+#AT_CHECK([/bin/false], 12, [ignore], [ignore])
 AT_CLEANUP

tests/regression/testsuite-simple_configuration.at

@@ -87 +87 @@
 AT_KEYWORDS([configuration])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/pre/test.* .], 0)
-AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -R 2 7.], 0, [stdout], [stderr])
-AT_CHECK([file=test.conf; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/$file], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -R 7.283585982 3.275186040 3.535886037 7.], 0, [stdout], [stderr])
+AT_CHECK([sort -n test.conf.xyz | grep -v "Created by" >test.conf.xyz-sorted], 0, [ignore], [ignore])
+AT_CHECK([sort -n ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/test.conf.xyz  | grep -v "Created by" >${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/test.conf.xyz-sorted], 0, [ignore], [ignore])
+AT_CHECK([file=test.conf.xyz-sorted; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/$file], 0, [ignore], [ignore])
 AT_CLEANUP