Changes in / [a7b761b:8f215d]

Location:

src

Files:

• Helpers/Assert.cpp (modified) (2 diffs)
• Legacy/oldmenu.cpp (modified) (8 diffs)
• Makefile.am (modified) (4 diffs)
• Patterns/Cacheable.hpp (modified) (8 diffs)
• Patterns/ObservedIterator.hpp (deleted)
• Patterns/Observer.cpp (modified) (2 diffs)
• Patterns/Observer.hpp (modified) (4 diffs)
• analysis_bonds.cpp (modified) (9 diffs)
• analysis_correlation.cpp (modified) (10 diffs)
• atom.cpp (modified) (1 diff)
• bondgraph.cpp (modified) (2 diffs)
• boundary.cpp (modified) (16 diffs)
• builder.cpp (modified) (10 diffs)
• config.cpp (modified) (9 diffs)
• helpers.hpp (modified) (1 diff)
• lists.cpp (added)
• lists.hpp (modified) (1 diff)
• molecule.cpp (modified) (25 diffs)
• molecule.hpp (modified) (9 diffs)
• molecule_dynamics.cpp (modified) (22 diffs)
• molecule_fragmentation.cpp (modified) (22 diffs)
• molecule_geometry.cpp (modified) (20 diffs)
• molecule_graph.cpp (modified) (20 diffs)
• molecule_pointcloud.cpp (modified) (2 diffs)
• molecule_template.hpp (modified) (23 diffs)
• moleculelist.cpp (modified) (27 diffs)
• tesselation.cpp (modified) (8 diffs)
• tesselation.hpp (modified) (2 diffs)
• tesselationhelpers.cpp (modified) (1 diff)
• unittests/AnalysisCorrelationToPointUnitTest.cpp (modified) (2 diffs)
• unittests/AnalysisCorrelationToSurfaceUnitTest.cpp (modified) (7 diffs)
• unittests/AnalysisPairCorrelationUnitTest.cpp (modified) (1 diff)
• unittests/CountBondsUnitTest.cpp (modified) (1 diff)
• unittests/LinkedCellUnitTest.cpp (modified) (6 diffs)
• unittests/ObserverTest.cpp (modified) (6 diffs)
• unittests/ObserverTest.hpp (modified) (4 diffs)
• unittests/analysisbondsunittest.cpp (modified) (2 diffs)
• unittests/bondgraphunittest.cpp (modified) (4 diffs)
• unittests/bondgraphunittest.hpp (modified) (2 diffs)
• unittests/listofbondsunittest.cpp (modified) (8 diffs)
• unittests/listofbondsunittest.hpp (modified) (2 diffs)

src/Helpers/Assert.cpp

@@ -54 +54 @@
 
 
+
 bool _my_assert::check(const bool res,
                        const char* condition,
@@ -62 +63 @@
 {
   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/Legacy/oldmenu.cpp

@@ -423 +423 @@
 void oldmenu::RemoveAtoms(molecule *mol)
 {
-  atom *second;
+  atom *first, *second;
   int axis;
   double tmp1, tmp2;
@@ -446 +446 @@
       break;
     case 'b':
-      {
-        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));
-        }
+      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);
       }
       break;
@@ -465 +465 @@
       Log() << Verbose(0) << "Upper boundary: ";
       cin >> tmp2;
-      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));
+      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);
         }
       }
@@ -513 +515 @@
         min[i] = 0.;
 
-      for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
-        Z = (*iter)->type->Z;
+      second = mol->start;
+      while ((second->next != mol->end)) {
+        second = second->next; // advance
+        Z = second->type->Z;
         tmp1 = 0.;
-        if (first != (*iter)) {
-          x = first->x - (*iter)->x;
+        if (first != second) {
+          x = first->x - second->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 " << ((*iter)->nr << ": " << tmp1 << " a.u." << endl;
+        //Log() << Verbose(0) << "Bond length between Atom " << first->nr << " and " << second->nr << ": " << tmp1 << " a.u." << endl;
       }
       for (int i=MAX_ELEMENTS;i--;)
@@ -750 +754 @@
     Log() << Verbose(0) << "State the factor: ";
     cin >> faktor;
-    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
+
+    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
       Elements = new const element *[count];
       vectors = new Vector *[count];
       j = 0;
-      for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
-        Elements[j] = (*iter)->type;
-        vectors[j] = &(*iter)->x;
+      first = mol->start;
+      while (first->next != mol->end) { // make a list of all atoms with coordinates and element
+        first = first->next;
+        Elements[j] = first->type;
+        vectors[j] = &first->x;
         j++;
       }
@@ -1016 +1024 @@
     return;
   }
+  atom *Walker = mol->start;
 
   // generate some KeySets
   Log() << Verbose(0) << "Generating KeySets." << endl;
-  KeySet TestSets[mol->getAtomCount()+1];
+  KeySet TestSets[mol->AtomCount+1];
   i=1;
-  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
     for (int j=0;j<i;j++) {
-      TestSets[j].insert((*iter)->nr);
+      TestSets[j].insert(Walker->nr);
     }
     i++;
@@ -1029 +1039 @@
   Log() << Verbose(0) << "Testing insertion of already present item in KeySets." << endl;
   KeySetTestPair test;
-  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;
-    }
+  test = TestSets[mol->AtomCount-1].insert(Walker->nr);
+  if (test.second) {
+    Log() << Verbose(1) << "Insertion worked?!" << endl;
   } else {
-    eLog() << Verbose(1) << "No atoms to test double insertion." << endl;
-  }
+    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);
 
   // constructing Graph structure
@@ -1047 +1054 @@
   // insert KeySets into Subgraphs
   Log() << Verbose(0) << "Inserting KeySets into Subgraph class." << endl;
-  for (int j=0;j<mol->getAtomCount();j++) {
+  for (int j=0;j<mol->AtomCount;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->getAtomCount()],pair<int, double>(counter++, 1.)));
+  test2 = Subgraphs.insert(GraphPair (TestSets[mol->AtomCount],pair<int, double>(counter++, 1.)));
   if (test2.second) {
     Log() << Verbose(1) << "Insertion worked?!" << endl;

src/Makefile.am

@@ -76 +76 @@
                                    Descriptors/MoleculeIdDescriptor.cpp 
                                    
-
+                                   
 DESCRIPTORHEADER = Descriptors/AtomDescriptor.hpp \
                                    Descriptors/AtomIdDescriptor.hpp \
@@ -94 +94 @@
                                   Exceptions/MathException.hpp \
                                   Exceptions/ZeroVectorException.hpp
-
 
 SOURCE = ${ANALYSISSOURCE} \
@@ -113 +112 @@
                  graph.cpp \
                  helpers.cpp \
-                 Helpers/Assert.cpp \
                  info.cpp \
                  leastsquaremin.cpp \
                  Line.cpp \
                  linkedcell.cpp \
+                 lists.cpp \
                  log.cpp \
                  logger.cpp \
@@ -134 +133 @@
                  tesselationhelpers.cpp \
                  triangleintersectionlist.cpp \
-                 vector.cpp \
                  verbose.cpp \
                  vector_ops.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);
 
@@ -143 +144 @@
 
     Observable *owner;
+
     boost::function<T()> recalcMethod;
 
@@ -219 +221 @@
 
     const bool isValid() const;
-    const T& operator*() const;
+    const T operator*() const;
 
     // methods implemented for base-class Observer
@@ -235 +237 @@
 
   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);
@@ -195 +189 @@
   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.
@@ -56 +53 @@
   friend class Observable;
   friend class Notification;
-  template<class> friend class ObservedIterator;
-
 public:
   Observer();
@@ -157 +152 @@
   static std::set<Observable*> busyObservables;
 
+
   //! @cond
   // Structure for RAII-Style notification
@@ -168 +164 @@
   public:
     _Observable_protector(Observable *);
-    _Observable_protector(const _Observable_protector&);
     ~_Observable_protector();
   private:

src/analysis_bonds.cpp

@@ -26 +26 @@
   Mean = 0.;
 
+  atom *Walker = mol->start;
   int AtomCount = 0;
-  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
-    const int count = (*iter)->ListOfBonds.size();
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    const int count = Walker->ListOfBonds.size();
     if (Max < count)
       Max = count;
@@ -56 +58 @@
 
   int AtomNo = 0;
-  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) {
+  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) {
           const double distance = (*BondRunner)->GetDistanceSquared();
           if (Min > distance)
@@ -122 +126 @@
 int CountHydrogenBridgeBonds(MoleculeListClass *molecules, element * InterfaceElement = NULL)
 {
+  atom *Walker = NULL;
+  atom *Runner = NULL;
   int count = 0;
   int OtherHydrogens = 0;
@@ -127 +133 @@
   bool InterfaceFlag = false;
   bool OtherHydrogenFlag = true;
-  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)) {
+  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)) {
             // 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
@@ -143 +151 @@
               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;
@@ -168 +176 @@
               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;
@@ -197 +205 @@
 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++) {
-    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)) {
+    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)) {
             count++;
             DoLog(1) && (Log() << Verbose(1) << first->name << "-" << second->name << " bond found between " << *Walker << " and " << *OtherAtom << "." << endl);
@@ -231 +240 @@
   bool MatchFlag[2];
   bool result = false;
+  atom *Walker = NULL;
   const element * ElementArray[2];
   ElementArray[0] = first;
@@ -236 +246 @@
 
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin();MolWalker != molecules->ListOfMolecules.end(); MolWalker++) {
-    molecule::iterator Walker = (*MolWalker)->begin();
-    for(;Walker!=(*MolWalker)->end();++Walker){
-      atom *theAtom = *Walker;
-      if (theAtom->type == second) {  // first element matches
+    Walker = (*MolWalker)->start;
+    while (Walker->next != (*MolWalker)->end) {
+      Walker = Walker->next;
+      if (Walker->type == second) {  // first element matches
         for (int i=0;i<2;i++)
           MatchFlag[i] = false;
-        for (BondList::const_iterator BondRunner = theAtom->ListOfBonds.begin(); BondRunner != theAtom->ListOfBonds.end(); BondRunner++) {
-          atom * const OtherAtom = (*BondRunner)->GetOtherAtom(theAtom);
+        for (BondList::const_iterator BondRunner = Walker->ListOfBonds.begin(); BondRunner != Walker->ListOfBonds.end(); BondRunner++) {
+          atom * const OtherAtom = (*BondRunner)->GetOtherAtom(Walker);
           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);
-      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++){
+      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++)
             if ((*MolOtherWalker)->ActiveFlag) {
               DoLog(2) && (Log() << Verbose(2) << "Current other molecule is " << *MolOtherWalker << "." << endl);
-              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)) ) );
+              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) ) );
                   }
-                }
               }
-            }
           }
         }
       }
     }
-  }
+
   return outmap;
 };
@@ -100 +101 @@
       double * FullInverseMatrix = InverseMatrix(FullMatrix);
       DoeLog(2) && (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)) {
-          periodicX = *(*iter)->node;
+      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);
           periodicX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
           // go through every range in xyz and get distance
@@ -114 +117 @@
                   if ((*MolOtherWalker)->ActiveFlag) {
                     DoLog(2) && (Log() << Verbose(2) << "Current other molecule is " << *MolOtherWalker << "." << endl);
-                    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;
+                    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);
                           periodicOtherX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
                           // go through every range in xyz and get distance
@@ -127 +132 @@
                                 checkOtherX.MatrixMultiplication(FullMatrix);
                                 distance = checkX.distance(checkOtherX);
-                                //Log() << Verbose(1) <<"Inserting " << *(*iter) << " and " << *(*runner) << endl;
-                                outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> ((*iter), (*runner)) ) );
+                                //Log() << Verbose(1) <<"Inserting " << *Walker << " and " << *OtherWalker << endl;
+                                outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> (Walker, OtherWalker) ) );
                               }
                         }
@@ -164 +169 @@
     if ((*MolWalker)->ActiveFlag) {
       DoLog(2) && (Log() << 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 ((type == NULL) || ((*iter)->type == type)) {
-          distance = (*iter)->node->PeriodicDistance(*point, World::getInstance().getDomain());
+      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());
           DoLog(4) && (Log() << Verbose(4) << "Current distance is " << distance << "." << endl);
-          outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> ((*iter), point) ) );
+          outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> (Walker, point) ) );
         }
       }
@@ -204 +211 @@
       double * FullInverseMatrix = InverseMatrix(FullMatrix);
       DoLog(2) && (Log() << 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 ((type == NULL) || ((*iter)->type == type)) {
-          periodicX = *(*iter)->node;
+      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);
           periodicX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
           // go through every range in xyz and get distance
@@ -217 +226 @@
                 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*> (*iter, point) ) );
+                outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> (Walker, point) ) );
               }
         }
@@ -252 +261 @@
     if ((*MolWalker)->ActiveFlag) {
       DoLog(1) && (Log() << Verbose(1) << "Current molecule is " << (*MolWalker)->name << "." << endl);
-      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);
+      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);
           distance = Intersections.GetSmallestDistance();
           triangle = Intersections.GetClosestTriangle();
-          outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(distance, pair<atom *, BoundaryTriangleSet*> ((*iter), triangle) ) );
+          outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(distance, pair<atom *, BoundaryTriangleSet*> (Walker, triangle) ) );
         }
       }
@@ -303 +314 @@
       double * FullInverseMatrix = InverseMatrix(FullMatrix);
       DoLog(2) && (Log() << 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 ((type == NULL) || ((*iter)->type == type)) {
-          periodicX = *(*iter)->node;
+      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);
           periodicX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
           // go through every range in xyz and get distance
@@ -324 +337 @@
               }
           // insert
-          outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(ShortestDistance, pair<atom *, BoundaryTriangleSet*> (*iter, ShortestTriangle) ) );
+          outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(ShortestDistance, pair<atom *, BoundaryTriangleSet*> (Walker, 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->empty()) // only construct if molecule is not empty
+  if (mol->start->next == mol->end) // only construct if molecule is not empty
     return false;
 
@@ -124 +124 @@
   max_distance = 0.;
 
-  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
-    if ((*iter)->type->CovalentRadius > max_distance)
-      max_distance = (*iter)->type->CovalentRadius;
+  atom *Runner = mol->start;
+  while (Runner->next != mol->end) {
+    Runner = Runner->next;
+    if (Runner->type->CovalentRadius > max_distance)
+      max_distance = Runner->type->CovalentRadius;
   }
   max_distance *= 2.;

src/boundary.cpp

@@ -139 +139 @@
 {
         Info FunctionInfo(__func__);
+  atom *Walker = NULL;
   PointMap PointsOnBoundary;
   LineMap LinesOnBoundary;
@@ -164 +165 @@
 
     // 3b. construct set of all points, transformed into cylindrical system and with left and right neighbours
-    for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
-      ProjectedVector = (*iter)->x - (*MolCenter);
+    Walker = mol->start;
+    while (Walker->next != mol->end) {
+      Walker = Walker->next;
+      ProjectedVector = Walker->x - (*MolCenter);
       ProjectedVector.ProjectOntoPlane(AxisVector);
 
@@ -179 +182 @@
         angle = 2. * M_PI - angle;
       }
-    DoLog(1) && (Log() << Verbose(1) << "Inserting " << **iter << ": (r, alpha) = (" << radius << "," << angle << "): " << ProjectedVector << endl);
-      BoundaryTestPair = BoundaryPoints[axis].insert(BoundariesPair(angle, DistancePair (radius, (*iter))));
+      DoLog(1) && (Log() << Verbose(1) << "Inserting " << *Walker << ": (r, alpha) = (" << radius << "," << angle << "): " << ProjectedVector << endl);
+      BoundaryTestPair = BoundaryPoints[axis].insert(BoundariesPair(angle, DistancePair (radius, Walker)));
       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: " << **iter << endl);
+        DoLog(2) && (Log() << Verbose(2) << "New vector: " << *Walker << endl);
         const double ProjectedVectorNorm = ProjectedVector.NormSquared();
         if ((ProjectedVectorNorm - BoundaryTestPair.first->second.first) > MYEPSILON) {
           BoundaryTestPair.first->second.first = ProjectedVectorNorm;
-          BoundaryTestPair.first->second.second = (*iter);
+          BoundaryTestPair.first->second.second = Walker;
           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 = (*iter)->x;
-          helper -= *MolCenter;
+          helper = Walker->x - (*MolCenter);
           const double oldhelperNorm = helper.NormSquared();
           helper = BoundaryTestPair.first->second.second->x - (*MolCenter);
           if (helper.NormSquared() < oldhelperNorm) {
-            BoundaryTestPair.first->second.second = (*iter);
+            BoundaryTestPair.first->second.second = Walker;
             DoLog(2) && (Log() << Verbose(2) << "Keeping new vector due to larger distance to molecule center " << helper.NormSquared() << "." << endl);
           } else {
@@ -693 +695 @@
   int repetition[NDIM] = { 1, 1, 1 };
   int TotalNoClusters = 1;
+  atom *Walker = NULL;
   double totalmass = 0.;
   double clustervolume = 0.;
@@ -716 +719 @@
 
   // sum up the atomic masses
-  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
-      totalmass += (*iter)->type->mass;
+  Walker = mol->start;
+  while (Walker->next != mol->end) {
+      Walker = Walker->next;
+      totalmass += Walker->type->mass;
   }
   DoLog(0) && (Log() << Verbose(0) << "RESULT: The summed mass is " << setprecision(10) << totalmass << " atomicmassunit." << endl);
@@ -799 +804 @@
   Vector Inserter;
   double FillIt = false;
+  atom *Walker = NULL;
   bond *Binder = NULL;
   double phi[NDIM];
@@ -805 +811 @@
 
   for (MoleculeList::iterator ListRunner = List->ListOfMolecules.begin(); ListRunner != List->ListOfMolecules.end(); ListRunner++)
-    if ((*ListRunner)->getAtomCount() > 0) {
+    if ((*ListRunner)->AtomCount > 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
@@ -823 +829 @@
   }
 
-  atom * CopyAtoms[filler->getAtomCount()];
+  filler->CountAtoms();
+  atom * CopyAtoms[filler->AtomCount];
 
   // calculate filler grid in [0,1]^3
@@ -848 +855 @@
 
         // go through all atoms
-        for (int i=0;i<filler->getAtomCount();i++)
+        for (int i=0;i<filler->AtomCount;i++)
           CopyAtoms[i] = NULL;
-        for(molecule::iterator iter = filler->begin(); iter !=filler->end();++filler){
+        Walker = filler->start;
+        while (Walker->next != filler->end) {
+          Walker = Walker->next;
 
           // create atomic random translation vector ...
@@ -874 +883 @@
 
           // ... and put at new position
-          Inserter = (*iter)->x;
+          Inserter = Walker->x;
           if (DoRandomRotation)
             Inserter.MatrixMultiplication(Rotations);
@@ -898 +907 @@
             DoLog(1) && (Log() << Verbose(1) << "INFO: Position at " << Inserter << " is outer point." << endl);
             // copy atom ...
-            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);
+            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);
           } else {
             DoLog(1) && (Log() << Verbose(1) << "INFO: Position at " << Inserter << " is inner point, within boundary or outside of MaxDistance." << endl);
-            CopyAtoms[(*iter)->nr] = NULL;
+            CopyAtoms[Walker->nr] = NULL;
             continue;
           }
@@ -943 +952 @@
   bool TesselationFailFlag = false;
 
-  mol->getAtomCount();
-
   if (TesselStruct == NULL) {
     DoLog(1) && (Log() << Verbose(1) << "Allocating Tesselation struct ..." << endl);
@@ -1016 +1023 @@
 //  // look whether all points are inside of the convex envelope, otherwise add them via degenerated triangles
 //  //->InsertStraddlingPoints(mol, LCList);
-//  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+//  mol->GoToFirst();
 //  class TesselPoint *Runner = NULL;
-//    Runner = *iter;
+//  while (!mol->IsEnd()) {
+//    Runner = mol->GetPoint();
 //    Log() << Verbose(1) << "Checking on " << Runner->Name << " ... " << endl;
 //    if (!->IsInnerPoint(Runner, LCList)) {
@@ -1026 +1034 @@
 //      Log() << Verbose(2) << Runner->Name << " is inside of or on envelope." << endl;
 //    }
+//    mol->GoToNext();
 //  }
 
@@ -1034 +1043 @@
   status = CheckListOfBaselines(TesselStruct);
 
-  cout << "before correction" << endl;
-
   // store before correction
-  StoreTrianglesinFile(mol, TesselStruct, filename, "");
+  StoreTrianglesinFile(mol, (const Tesselation *&)TesselStruct, filename, "");
 
 //  // correct degenerated polygons
@@ -1047 +1054 @@
   // write final envelope
   CalculateConcavityPerBoundaryPoint(TesselStruct);
-  cout << "after correction" << endl;
-  StoreTrianglesinFile(mol, TesselStruct, filename, "");
+  StoreTrianglesinFile(mol, (const Tesselation *&)TesselStruct, filename, "");
 
   if (freeLC)

src/builder.cpp

@@ -1744 +1744 @@
                 if (first->type != NULL) {
                   mol->AddAtom(first);  // add to molecule
-                  if ((configPresent == empty) && (mol->getAtomCount() != 0))
+                  if ((configPresent == empty) && (mol->AtomCount != 0))
                     configPresent = present;
                 } else
@@ -1773 +1773 @@
                 DoLog(1) && (Log() << Verbose(1) << "Depth-First-Search Analysis." << endl);
                 MoleculeLeafClass *Subgraphs = NULL;      // list of subgraphs from DFS analysis
-                int *MinimumRingSize = new int[mol->getAtomCount()];
+                int *MinimumRingSize = new int[mol->AtomCount];
                 atom ***ListOfLocalAtoms = NULL;
                 class StackClass<bond *> *BackEdgeStack = NULL;
@@ -1921 +1921 @@
                           int counter  = 0;
                           for (MoleculeList::iterator BigFinder = molecules->ListOfMolecules.begin(); BigFinder != molecules->ListOfMolecules.end(); BigFinder++) {
-                            if ((Boundary == NULL) || (Boundary->getAtomCount() < (*BigFinder)->getAtomCount())) {
+                            if ((Boundary == NULL) || (Boundary->AtomCount < (*BigFinder)->AtomCount)) {
                               Boundary = *BigFinder;
                             }
@@ -1980 +1980 @@
                 performCriticalExit();
               } else {
-                mol->getAtomCount();
                 SaveFlag = true;
                 DoLog(1) && (Log() << Verbose(1) << "Changing atom " << argv[argptr] << " to element " << argv[argptr+1] << "." << endl);
@@ -2099 +2098 @@
                 int counter  = 0;
                 for (MoleculeList::iterator BigFinder = molecules->ListOfMolecules.begin(); BigFinder != molecules->ListOfMolecules.end(); BigFinder++) {
-                  if ((Boundary == NULL) || (Boundary->getAtomCount() < (*BigFinder)->getAtomCount())) {
+                  (*BigFinder)->CountAtoms();
+                  if ((Boundary == NULL) || (Boundary->AtomCount < (*BigFinder)->AtomCount)) {
                     Boundary = *BigFinder;
                   }
                   counter++;
                 }
-                DoLog(1) && (Log() << Verbose(1) << "Biggest molecule has " << Boundary->getAtomCount() << " atoms." << endl);
+                DoLog(1) && (Log() << Verbose(1) << "Biggest molecule has " << Boundary->AtomCount << " atoms." << endl);
                 start = clock();
                 LCList = new LinkedCell(Boundary, atof(argv[argptr])*2.);
@@ -2180 +2180 @@
                 double tmp1 = atof(argv[argptr+1]);
                 atom *third = mol->FindAtom(atoi(argv[argptr]));
-                if(third){
-                  for(molecule::iterator iter = mol->begin(); iter != mol->end();){
-                    if ((*iter)->x.DistanceSquared(third->x) > tmp1*tmp1){ // distance to first above radius ...
-                      mol->RemoveAtom(*(iter++));
-                    }
-                    else{
-                      ++iter;
-                    }
+                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);
                   }
                 } else {
@@ -2332 +2332 @@
                 performCriticalExit();
               } else {
-                mol->getAtomCount();
                 SaveFlag = true;
                 DoLog(1) && (Log() << Verbose(1) << "Removing atom " << argv[argptr] << "." << endl);
@@ -2452 +2451 @@
                     faktor = 1;
                   }
-                  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
+                  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
                     Elements = new const element *[count];
                     vectors = new Vector *[count];
                     j = 0;
-                    for(molecule::iterator iter = mol->begin();iter!=mol->end();++iter){
-                      Elements[j] = (*iter)->type;
-                      vectors[j] = &(*iter)->x;
+                    first = mol->start;
+                    while (first->next != mol->end) {  // make a list of all atoms with coordinates and element
+                      first = first->next;
+                      Elements[j] = first->type;
+                      vectors[j] = &first->x;
                       j++;
                     }
@@ -2554 +2556 @@
 int main(int argc, char **argv)
 {
-    // while we are non interactive, we want to abort from asserts
-    //ASSERT_DO(Assert::Abort);
     molecule *mol = NULL;
     config *configuration = new config;
@@ -2595 +2595 @@
     }
 
-    // In the interactive mode, we can leave the user the choice in case of error
-    ASSERT_DO(Assert::Ask);
-
     {
       cout << ESPACKVersion << endl;

src/config.cpp

@@ -1547 +1547 @@
   int AtomNo = -1;
   int MolNo = 0;
+  atom *Walker = NULL;
   FILE *f = NULL;
 
@@ -1559 +1560 @@
   fprintf(f, "# Created by MoleCuilder\n");
 
-  for (MoleculeList::const_iterator MolRunner = MolList->ListOfMolecules.begin(); MolRunner != MolList->ListOfMolecules.end(); MolRunner++) {
+  for (MoleculeList::const_iterator Runner = MolList->ListOfMolecules.begin(); Runner != MolList->ListOfMolecules.end(); Runner++) {
+    Walker = (*Runner)->start;
     int *elementNo = Calloc<int>(MAX_ELEMENTS, "config::SavePDB - elementNo");
     AtomNo = 0;
-    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
+    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
       fprintf(f,
              "ATOM %6u %-4s %4s%c%4u    %8.3f%8.3f%8.3f%6.2f%6.2f      %4s%2s%2s\n",
-             (*iter)->nr,                /* atom serial number */
+             Walker->nr,                /* atom serial number */
              name,         /* atom name */
-             (*MolRunner)->name,      /* residue name */
+             (*Runner)->name,      /* residue name */
              'a'+(unsigned char)(AtomNo % 26),           /* letter for chain */
              MolNo,         /* residue sequence number */
-             (*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 */
+             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 */
              "0",            /* segment identifier */
-             (*iter)->type->symbol,    /* element symbol */
+             Walker->type->symbol,    /* element symbol */
              "0");           /* charge */
       AtomNo++;
@@ -1598 +1601 @@
 {
   int AtomNo = -1;
+  atom *Walker = NULL;
   FILE *f = NULL;
 
@@ -1612 +1616 @@
   fprintf(f, "# Created by MoleCuilder\n");
 
+  Walker = mol->start;
   AtomNo = 0;
-  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
+  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
     fprintf(f,
            "ATOM %6u %-4s %4s%c%4u    %8.3f%8.3f%8.3f%6.2f%6.2f      %4s%2s%2s\n",
-           (*iter)->nr,                /* atom serial number */
+           Walker->nr,                /* atom serial number */
            name,         /* atom name */
            mol->name,      /* residue name */
            'a'+(unsigned char)(AtomNo % 26),           /* letter for chain */
            0,         /* residue sequence number */
-           (*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 */
+           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 */
            "0",            /* segment identifier */
-           (*iter)->type->symbol,    /* element symbol */
+           Walker->type->symbol,    /* element symbol */
            "0");           /* charge */
     AtomNo++;
@@ -1647 +1653 @@
 bool config::SaveTREMOLO(const char * const filename, const molecule * const mol) const
 {
+  atom *Walker = NULL;
   ofstream *output = NULL;
   stringstream * const fname = new stringstream;
@@ -1659 +1666 @@
 
   // scan maximum number of neighbours
+  Walker = mol->start;
   int MaxNeighbours = 0;
-  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
-    const int count = (*iter)->ListOfBonds.size();
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    const int count = Walker->ListOfBonds.size();
     if (MaxNeighbours < count)
       MaxNeighbours = count;
   }
-  *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 << "# 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 << mol->name << "\t";
     *output << 0 << "\t";
-    *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 << 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 << "-\t";
     *output << endl;
@@ -1697 +1708 @@
 bool config::SaveTREMOLO(const char * const filename, const MoleculeListClass * const MolList) const
 {
+  atom *Walker = NULL;
   ofstream *output = NULL;
   stringstream * const fname = new stringstream;
@@ -1711 +1723 @@
   int MaxNeighbours = 0;
   for (MoleculeList::const_iterator MolWalker = MolList->ListOfMolecules.begin(); MolWalker != MolList->ListOfMolecules.end(); MolWalker++) {
-    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
-      const int count = (*iter)->ListOfBonds.size();
+    Walker = (*MolWalker)->start;
+    while (Walker->next != (*MolWalker)->end) {
+      Walker = Walker->next;
+      const int count = Walker->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
@@ -1738 +1752 @@
     int AtomNo = 0;
     for (MoleculeList::const_iterator MolWalker = MolList->ListOfMolecules.begin(); MolWalker != MolList->ListOfMolecules.end(); MolWalker++) {
-      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+      Walker = (*MolWalker)->start;
+      while (Walker->next != (*MolWalker)->end) {
+        Walker = Walker->next;
         *output << AtomNo+1 << "\t";
-        *output << (*iter)->getName() << "\t";
+        *output << Walker->getName() << "\t";
         *output << (*MolWalker)->name << "\t";
         *output << MolCounter+1 << "\t";
-        *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[MolCounter][ (*runner)->GetOtherAtom(*iter)->nr ]+1 << "\t";
-        for(int i=(*iter)->ListOfBonds.size(); i < MaxNeighbours; i++)
+        *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[MolCounter][ (*runner)->GetOtherAtom(Walker)->nr ]+1 << "\t";
+        for(int i=Walker->ListOfBonds.size(); i < MaxNeighbours; i++)
           *output << "-\t";
         *output << endl;

src/helpers.hpp

@@ -83 +83 @@
 };
 
+/** Creates a lookup table for true father's Atom::Nr -> atom ptr.
+ * \param *start begin of chain list
+ * \paran *end end of chain list
+ * \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
+ */
+template <typename T> bool CreateFatherLookupTable(T *start, T *end, T **&LookupTable, int count = 0)
+{
+  bool status = true;
+  T *Walker = NULL;
+  int AtomNo;
+
+  if (LookupTable != NULL) {
+    DoLog(0) && (Log() << Verbose(0) << "Pointer for Lookup table is not NULL! Aborting ..." <<endl);
+    return false;
+  }
+
+  // count them
+  if (count == 0) {
+    Walker = start;
+    while (Walker->next != end) { // create a lookup table (Atom::nr -> atom) used as a marker table lateron
+      Walker = Walker->next;
+      count = (count < Walker->GetTrueFather()->nr) ? Walker->GetTrueFather()->nr : count;
+    }
+  }
+  if (count <= 0) {
+    DoLog(0) && (Log() << Verbose(0) << "Count of lookup list is 0 or less." << endl);
+    return false;
+  }
+
+  // allocate and fill
+  LookupTable = Calloc<T*>(count, "CreateFatherLookupTable - **LookupTable");
+  if (LookupTable == NULL) {
+    DoeLog(0) && (eLog()<< Verbose(0) << "LookupTable memory allocation failed!" << endl);
+    performCriticalExit();
+    status = false;
+  } else {
+    Walker = start;
+    while (Walker->next != end) { // create a lookup table (Atom::nr -> atom) used as a marker table lateron
+      Walker = Walker->next;
+      AtomNo = Walker->GetTrueFather()->nr;
+      if ((AtomNo >= 0) && (AtomNo < count)) {
+        //*out << "Setting LookupTable[" << AtomNo << "] to " << *Walker << endl;
+        LookupTable[AtomNo] = Walker;
+      } else {
+        DoLog(0) && (Log() << Verbose(0) << "Walker " << *Walker << " exceeded range of nuclear ids [0, " << count << ")." << endl);
+        status = false;
+        break;
+      }
+    }
+  }
+
+  return status;
+};
+
 /** 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),
-  first(new bond(0, 0, 1, -1)), last(new bond(0, 0, 1, -1)), MDSteps(0),
+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), 
   BondCount(0), ElementCount(0), NoNonHydrogen(0), NoNonBonds(0), NoCyclicBonds(0), BondDistance(0.), 
   ActiveFlag(false), IndexNr(-1),
   formula(this,boost::bind(&molecule::calcFormula,this)),
-  AtomCount(this,boost::bind(&molecule::doCountAtoms,this)), last_atom(0),  InternalPointer(begin())
-{
+  last_atom(0),
+  InternalPointer(start)
+{
+  // init atom chain list
+  start->father = NULL;
+  end->father = NULL;
+  link(start,end);
+
   // init bond chain list
   link(first,last);
@@ -63 +69 @@
   delete(first);
   delete(last);
+  end->getWorld()->destroyAtom(end);
+  start->getWorld()->destroyAtom(start);
 };
 
@@ -75 +83 @@
 }
 
-int molecule::getAtomCount() const{
-  return *AtomCount;
-}
-
 void molecule::setName(const std::string _name){
   OBSERVE;
@@ -100 +104 @@
   stringstream sstr;
   periodentafel *periode = World::getInstance().getPeriode();
-  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
-    counts[(*iter)->type->getNumber()]++;
+  for(atom *Walker = start; Walker != end; Walker = Walker->next) {
+    counts[Walker->type->getNumber()]++;
   }
   std::map<atomicNumber_t,unsigned int>::reverse_iterator iter;
@@ -111 +115 @@
 }
 
-/************************** 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.
@@ -180 +123 @@
 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)
@@ -195 +141 @@
       }
     }
-    insert(pointer);
-  }
-  return true;
+    retval = add(pointer, end);
+  }
+  return retval;
 };
 
@@ -211 +157 @@
   if (pointer != NULL) {
     atom *walker = pointer->clone();
-    walker->setName(pointer->getName());
+    stringstream sstr;
+    sstr << pointer->getName();
+    walker->setName(sstr.str());
     walker->nr = last_atom++;  // increase number within molecule
-    insert(walker);
+    add(walker, end);
     if ((pointer->type != NULL) && (pointer->type->Z != 1))
       NoNonHydrogen++;
+    AtomCount++;
     retval=walker;
   }
@@ -625 +574 @@
 
   // copy values
+  copy->CountAtoms();
   copy->CountElements();
   if (first->next != last) {  // if adjaceny list is present
@@ -659 +609 @@
 {
   bond *Binder = NULL;
-
-  // 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);
-
+  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);
+  }
   return Binder;
 };
@@ -746 +692 @@
 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);
@@ -755 +700 @@
     ElementCount--;
   RemoveBonds(pointer);
-  erase(pointer);
-  return true;
+  return remove(pointer, start, end);
 };
 
@@ -773 +717 @@
   if (ElementsInMolecule[pointer->type->Z] == 0)  // was last atom of this element?
     ElementCount--;
-  erase(pointer);
+  unlink(pointer);
   return true;
 };
@@ -782 +726 @@
 bool molecule::CleanupMolecule()
 {
-  for (molecule::iterator iter = begin(); !empty(); iter = begin())
-      erase(iter);
-  return (cleanup(first,last));
+  return (cleanup(first,last) && cleanup(start,end));
 };
 
@@ -791 +733 @@
  * \return pointer to atom or NULL
  */
-atom * molecule::FindAtom(int Nr)  const
-{
-  molecule::const_iterator iter = begin();
-  for (; iter != end(); ++iter)
-    if ((*iter)->nr == Nr)
-      break;
-  if (iter != end()) {
+atom * molecule::FindAtom(int Nr)  const{
+  atom * walker = find(&Nr, start,end);
+  if (walker != NULL) {
     //Log() << Verbose(0) << "Found Atom Nr. " << walker->nr << endl;
-    return (*iter);
+    return walker;
   } else {
     DoLog(0) && (Log() << Verbose(0) << "Atom not found in list." << endl);
@@ -929 +867 @@
     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 << getAtomCount() << "\n\tCreated by molecuilder, step " << step << ", on " << ctime(&now);
+      *output << AtomCount << "\n\tCreated by molecuilder, step " << step << ", on " << ctime(&now);
       ActOnAllAtoms( &atom::OutputTrajectoryXYZ, output, step );
     }
@@ -946 +884 @@
   if (output != NULL) {
     now = time((time_t *)NULL);   // Get the system time and put it into 'now' as 'calender time'
-    *output << getAtomCount() << "\n\tCreated by molecuilder on " << ctime(&now);
+    *output << AtomCount << "\n\tCreated by molecuilder on " << ctime(&now);
     ActOnAllAtoms( &atom::OutputXYZLine, output );
     return true;
@@ -956 +894 @@
  * \param *out output stream for debugging
  */
-int molecule::doCountAtoms()
-{
-  int res = size();
+void molecule::CountAtoms()
+{
   int i = 0;
-  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;
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
     i++;
   }
-  return res;
+  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);
+  }
 };
 
@@ -1033 +986 @@
   /// 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();
@@ -1039 +994 @@
   /// -# AtomCount
   if (result) {
-    if (getAtomCount() != OtherMolecule->getAtomCount()) {
-      DoLog(4) && (Log() << Verbose(4) << "AtomCounts don't match: " << getAtomCount() << " == " << OtherMolecule->getAtomCount() << endl);
+    if (AtomCount != OtherMolecule->AtomCount) {
+      DoLog(4) && (Log() << Verbose(4) << "AtomCounts don't match: " << AtomCount << " == " << OtherMolecule->AtomCount << endl);
       result = false;
-    } else Log() << Verbose(4) << "AtomCounts match: " << getAtomCount() << " == " << OtherMolecule->getAtomCount() << endl;
+    } else Log() << Verbose(4) << "AtomCounts match: " << AtomCount << " == " << OtherMolecule->AtomCount << endl;
   }
   /// -# ElementCount
@@ -1079 +1034 @@
   if (result) {
     DoLog(5) && (Log() << Verbose(5) << "Calculating distances" << endl);
-    Distances = Calloc<double>(getAtomCount(), "molecule::IsEqualToWithinThreshold: Distances");
-    OtherDistances = Calloc<double>(getAtomCount(), "molecule::IsEqualToWithinThreshold: OtherDistances");
+    Distances = Calloc<double>(AtomCount, "molecule::IsEqualToWithinThreshold: Distances");
+    OtherDistances = Calloc<double>(AtomCount, "molecule::IsEqualToWithinThreshold: OtherDistances");
     SetIndexedArrayForEachAtomTo ( Distances, &atom::nr, &atom::DistanceSquaredToVector, (const Vector &)CenterOfGravity);
     SetIndexedArrayForEachAtomTo ( OtherDistances, &atom::nr, &atom::DistanceSquaredToVector, (const Vector &)CenterOfGravity);
@@ -1086 +1041 @@
     /// ... sort each list (using heapsort (o(N log N)) from GSL)
     DoLog(5) && (Log() << Verbose(5) << "Sorting distances" << endl);
-    PermMap = Calloc<size_t>(getAtomCount(), "molecule::IsEqualToWithinThreshold: *PermMap");
-    OtherPermMap = Calloc<size_t>(getAtomCount(), "molecule::IsEqualToWithinThreshold: *OtherPermMap");
-    gsl_heapsort_index (PermMap, Distances, getAtomCount(), sizeof(double), CompareDoubles);
-    gsl_heapsort_index (OtherPermMap, OtherDistances, getAtomCount(), sizeof(double), CompareDoubles);
-    PermutationMap = Calloc<int>(getAtomCount(), "molecule::IsEqualToWithinThreshold: *PermutationMap");
+    PermMap = Calloc<size_t>(AtomCount, "molecule::IsEqualToWithinThreshold: *PermMap");
+    OtherPermMap = Calloc<size_t>(AtomCount, "molecule::IsEqualToWithinThreshold: *OtherPermMap");
+    gsl_heapsort_index (PermMap, Distances, AtomCount, sizeof(double), CompareDoubles);
+    gsl_heapsort_index (OtherPermMap, OtherDistances, AtomCount, sizeof(double), CompareDoubles);
+    PermutationMap = Calloc<int>(AtomCount, "molecule::IsEqualToWithinThreshold: *PermutationMap");
     DoLog(5) && (Log() << Verbose(5) << "Combining Permutation Maps" << endl);
-    for(int i=getAtomCount();i--;)
+    for(int i=AtomCount;i--;)
       PermutationMap[PermMap[i]] = (int) OtherPermMap[i];
 
@@ -1098 +1053 @@
     DoLog(4) && (Log() << Verbose(4) << "Comparing distances" << endl);
     flag = 0;
-    for (int i=0;i<getAtomCount();i++) {
+    for (int i=0;i<AtomCount;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)
@@ -1134 +1089 @@
 int * molecule::GetFatherSonAtomicMap(molecule *OtherMolecule)
 {
+  atom *Walker = NULL, *OtherWalker = NULL;
   DoLog(3) && (Log() << Verbose(3) << "Begin of GetFatherAtomicMap." << endl);
-  int *AtomicMap = Malloc<int>(getAtomCount(), "molecule::GetAtomicMap: *AtomicMap");
-  for (int i=getAtomCount();i--;)
+  int *AtomicMap = Malloc<int>(AtomCount, "molecule::GetAtomicMap: *AtomicMap");
+  for (int i=AtomCount;i--;)
     AtomicMap[i] = -1;
   if (OtherMolecule == this) {  // same molecule
-    for (int i=getAtomCount();i--;) // no need as -1 means already that there is trivial correspondence
+    for (int i=AtomCount;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 ");
-    for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
-      if ((*iter)->father == NULL) {
-        AtomicMap[(*iter)->nr] = -2;
+    Walker = start;
+    while (Walker->next != end) {
+      Walker = Walker->next;
+      if (Walker->father == NULL) {
+        AtomicMap[Walker->nr] = -2;
       } else {
-        for (molecule::const_iterator runner = OtherMolecule->begin(); runner != OtherMolecule->end(); ++runner) {
+        OtherWalker = OtherMolecule->start;
+        while (OtherWalker->next != OtherMolecule->end) {
+          OtherWalker = OtherWalker->next;
       //for (int i=0;i<AtomCount;i++) { // search atom
         //for (int j=0;j<OtherMolecule->AtomCount;j++) {
-          //Log() << Verbose(4) << "Comparing father " << (*iter)->father << " with the other one " << (*runner)->father << "." << endl;
-          if ((*iter)->father == (*runner))
-            AtomicMap[(*iter)->nr] = (*runner)->nr;
+          //Log() << Verbose(4) << "Comparing father " << Walker->father << " with the other one " << OtherWalker->father << "." << endl;
+          if (Walker->father == OtherWalker)
+            AtomicMap[Walker->nr] = OtherWalker->nr;
         }
       }
-      DoLog(0) && (Log() << Verbose(0) << AtomicMap[(*iter)->nr] << "\t");
+      DoLog(0) && (Log() << Verbose(0) << AtomicMap[Walker->nr] << "\t");
     }
     DoLog(0) && (Log() << Verbose(0) << endl);
@@ -1190 +1150 @@
 void molecule::SetIndexedArrayForEachAtomTo ( atom **array, int ParticleInfo::*index) const
 {
-  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
-    array[((*iter)->*index)] = (*iter);
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    array[(Walker->*index)] = Walker;
   }
 };

src/molecule.hpp

@@ -34 +34 @@
 #include "tesselation.hpp"
 #include "Patterns/Observer.hpp"
-#include "Patterns/ObservedIterator.hpp"
 #include "Patterns/Cacheable.hpp"
 
@@ -89 +88 @@
   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
-    // old deprecated atom handling
-    //atom *start;        //!< start of atom list
-    //atom *end;          //!< end of atom list
+    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
@@ -117 +110 @@
   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();
@@ -136 +119 @@
   //getter and setter
   const std::string getName();
-  int getAtomCount() const;
-  int doCountAtoms();
   moleculeId_t getId();
   void setId(moleculeId_t);
@@ -144 +125 @@
   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
@@ -160 +130 @@
   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 ;
@@ -257 +230 @@
 
   /// Count and change present atoms' coordination.
+  void CountAtoms();
   void CountElements();
   void CalculateOrbitals(class config &configuration);
@@ -325 +299 @@
   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
@@ -354 +327 @@
   private:
   int last_atom;      //!< number given to last atom
-  mutable internal_iterator InternalPointer;  //!< internal pointer for PointCloud
+  mutable atom *InternalPointer;  //!< internal pointer for PointCloud
 };
 

src/molecule_dynamics.cpp

@@ -28 +28 @@
   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.;
 
-  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++)
+  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++)
       break;
     // determine normalized trajectories direction vector (n1, n2)
@@ -40 +42 @@
     trajectory1.Normalize();
     Norm1 = trajectory1.Norm();
-    Sprinter = Params.PermutationMap[(*iter)->nr];   // find second target point
-    trajectory2 = Sprinter->Trajectory.R.at(Params.endstep) - (*iter)->Trajectory.R.at(Params.startstep);
+    Sprinter = Params.PermutationMap[Runner->nr];   // find second target point
+    trajectory2 = Sprinter->Trajectory.R.at(Params.endstep) - Runner->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((*iter)->Trajectory.R.at(Params.startstep));
+      tmp = Walker->Trajectory.R.at(Params.startstep).distance(Runner->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) - (*iter)->Trajectory.R.at(Params.startstep);
+      trajectory1 = Sprinter->Trajectory.R.at(Params.endstep) - Runner->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[(*iter)->nr];   // find second target point
+      Sprinter = Params.PermutationMap[Runner->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
@@ -64 +66 @@
   //        Log() << Verbose(0) << " and ";
   //        Log() << Verbose(0) << trajectory2;
-      tmp = Walker->Trajectory.R.at(Params.startstep).distance((*iter)->Trajectory.R.at(Params.startstep));
+      tmp = Walker->Trajectory.R.at(Params.startstep).distance(Runner->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 " << *(*iter) << " are linear independent ";
+  //        Log() << Verbose(3) << "Both trajectories of " << *Walker << " and " << *Runner << " are linear independent ";
   //        Log() << Verbose(0) << endl;
   //        Log() << Verbose(0) << "First Trajectory: ";
@@ -83 +85 @@
         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] - (*iter)->Trajectory.R.at(Params.startstep)[i]));
+        gsl_vector_set(x,i, (Walker->Trajectory.R.at(Params.startstep)[i] - Runner->Trajectory.R.at(Params.startstep)[i]));
       }
       // solve the linear system by Householder transformations
@@ -94 +96 @@
       trajectory2.Scale(gsl_vector_get(x,1));
       normal.Scale(gsl_vector_get(x,2));
-      TestVector = (*iter)->Trajectory.R.at(Params.startstep) + trajectory2 + normal
+      TestVector = Runner->Trajectory.R.at(Params.startstep) + trajectory2 + normal
                    - (Walker->Trajectory.R.at(Params.startstep) + trajectory1);
       if (TestVector.Norm() < MYEPSILON) {
@@ -123 +125 @@
 {
   double result = 0.;
-  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 * Runner = mol->start;
+  while (Runner->next != mol->end) {
+    Runner = Runner->next;
+    if ((Params.PermutationMap[Walker->nr] == Params.PermutationMap[Runner->nr]) && (Walker->nr < Runner->nr)) {
   //    atom *Sprinter = PermutationMap[Walker->nr];
-  //        Log() << Verbose(0) << *Walker << " and " << *(*iter) << " are heading to the same target at ";
+  //        Log() << Verbose(0) << *Walker << " and " << *Runner << " are heading to the same target at ";
   //        Log() << Verbose(0) << Sprinter->Trajectory.R.at(endstep);
   //        Log() << Verbose(0) << ", penalting." << endl;
@@ -157 +161 @@
   // go through every atom
   atom *Runner = NULL;
-  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
     // first term: distance to target
-    Runner = Params.PermutationMap[(*iter)->nr];   // find target point
-    tmp = ((*iter)->Trajectory.R.at(Params.startstep).distance(Runner->Trajectory.R.at(Params.endstep)));
+    Runner = Params.PermutationMap[Walker->nr];   // find target point
+    tmp = (Walker->Trajectory.R.at(Params.startstep).distance(Runner->Trajectory.R.at(Params.endstep)));
     tmp *= Params.IsAngstroem ? 1. : 1./AtomicLengthToAngstroem;
     result += Params.PenaltyConstants[0] * tmp;
@@ -166 +172 @@
 
     // second term: sum of distances to other trajectories
-    result += SumDistanceOfTrajectories((*iter), this, Params);
+    result += SumDistanceOfTrajectories(Walker, this, Params);
 
     // third term: penalty for equal targets
-    result += PenalizeEqualTargets((*iter), this, Params);
+    result += PenalizeEqualTargets(Walker, this, Params);
   }
 
@@ -207 +213 @@
 void FillDistanceList(molecule *mol, struct EvaluatePotential &Params)
 {
-  for (int i=mol->getAtomCount(); i--;) {
+  for (int i=mol->AtomCount; i--;) {
     Params.DistanceList[i] = new DistanceMap;    // is the distance sorted target list per atom
     Params.DistanceList[i]->clear();
   }
 
-  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)) );
+  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) );
     }
   }
@@ -226 +237 @@
 void CreateInitialLists(molecule *mol, struct EvaluatePotential &Params)
 {
-  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);
+  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);
   }
 };
@@ -272 +285 @@
 void MakeInjectivePermutation(molecule *mol, struct EvaluatePotential &Params)
 {
-  molecule::const_iterator iter = mol->begin();
+  atom *Walker = mol->start;
   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->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
+    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
       continue;
     // now, try finding a new one
-    Potential = TryNextNearestNeighbourForInjectivePermutation(mol, (*iter), Potential, Params);
-  }
-  for (int i=mol->getAtomCount(); i--;) // now each single entry in the DoubleList should be <=1
+    Potential = TryNextNearestNeighbourForInjectivePermutation(mol, Walker, Potential, Params);
+  }
+  for (int i=mol->AtomCount; 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);
@@ -329 +338 @@
   double Potential, OldPotential, OlderPotential;
   struct EvaluatePotential Params;
-  Params.PermutationMap = Calloc<atom*>(getAtomCount(), "molecule::MinimiseConstrainedPotential: Params.**PermutationMap");
-  Params.DistanceList = Malloc<DistanceMap*>(getAtomCount(), "molecule::MinimiseConstrainedPotential: Params.**DistanceList");
-  Params.DistanceIterators = Malloc<DistanceMap::iterator>(getAtomCount(), "molecule::MinimiseConstrainedPotential: Params.*DistanceIterators");
-  Params.DoubleList = Calloc<int>(getAtomCount(), "molecule::MinimiseConstrainedPotential: Params.*DoubleList");
-  Params.StepList = Malloc<DistanceMap::iterator>(getAtomCount(), "molecule::MinimiseConstrainedPotential: Params.*StepList");
+  Params.PermutationMap = Calloc<atom*>(AtomCount, "molecule::MinimiseConstrainedPotential: Params.**PermutationMap");
+  Params.DistanceList = Malloc<DistanceMap*>(AtomCount, "molecule::MinimiseConstrainedPotential: Params.**DistanceList");
+  Params.DistanceIterators = Malloc<DistanceMap::iterator>(AtomCount, "molecule::MinimiseConstrainedPotential: Params.*DistanceIterators");
+  Params.DoubleList = Calloc<int>(AtomCount, "molecule::MinimiseConstrainedPotential: Params.*DoubleList");
+  Params.StepList = Malloc<DistanceMap::iterator>(AtomCount, "molecule::MinimiseConstrainedPotential: Params.*StepList");
   int round;
-  atom *Sprinter = NULL;
+  atom *Walker = NULL, *Runner = NULL, *Sprinter = NULL;
   DistanceMap::iterator Rider, Strider;
 
@@ -362 +371 @@
     DoLog(2) && (Log() << Verbose(2) << "Starting round " << ++round << ", at current potential " << OldPotential << " ... " << endl);
     OlderPotential = OldPotential;
-    molecule::const_iterator iter;
     do {
-      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();
+      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();
           break;
         }
-        //Log() << Verbose(2) << "Current Walker: " << *(*iter) << " with old/next candidate " << *Sprinter << "/" << *DistanceIterators[(*iter)->nr]->second << "." << endl;
+        //Log() << Verbose(2) << "Current Walker: " << *Walker << " with old/next candidate " << *Sprinter << "/" << *DistanceIterators[Walker->nr]->second << "." << endl;
         // find source of the new target
-        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;
+        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;
             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[(*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);
+            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);
             // calculate the new potential
             //Log() << Verbose(2) << "Checking new potential ..." << endl;
@@ -400 +410 @@
             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[(*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;
+              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;
             } 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;
@@ -418 +428 @@
             //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[(*iter)->nr] = Params.DistanceIterators[(*iter)->nr]->second; // new target has no source!
+          Params.PermutationMap[Walker->nr] = Params.DistanceIterators[Walker->nr]->second; // new target has no source!
         }
-        Params.StepList[(*iter)->nr]++; // take next farther distance target
+        Params.StepList[Walker->nr]++; // take next farther distance target
       }
-    } while (++iter != end());
+    } while (Walker->next != end);
   } while ((OlderPotential - OldPotential) > 1e-3);
   DoLog(1) && (Log() << Verbose(1) << "done." << endl);
@@ -432 +442 @@
 
   /// free memory and return with evaluated potential
-  for (int i=getAtomCount(); i--;)
+  for (int i=AtomCount; i--;)
     Params.DistanceList[i]->clear();
   Free(&Params.DistanceList);
@@ -473 +483 @@
   // Get the Permutation Map by MinimiseConstrainedPotential
   atom **PermutationMap = NULL;
-  atom *Sprinter = NULL;
+  atom *Walker = NULL, *Sprinter = NULL;
   if (!MapByIdentity)
     MinimiseConstrainedPotential(PermutationMap, startstep, endstep, configuration.GetIsAngstroem());
   else {
-    PermutationMap = Malloc<atom *>(getAtomCount(), "molecule::LinearInterpolationBetweenConfiguration: **PermutationMap");
+    PermutationMap = Malloc<atom *>(AtomCount, "molecule::LinearInterpolationBetweenConfiguration: **PermutationMap");
     SetIndexedArrayForEachAtomTo( PermutationMap, &atom::nr );
   }
@@ -492 +502 @@
     mol = World::getInstance().createMolecule();
     MoleculePerStep->insert(mol);
-    for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    Walker = start;
+    while (Walker->next != end) {
+      Walker = Walker->next;
       // add to molecule list
-      Sprinter = mol->AddCopyAtom((*iter));
+      Sprinter = mol->AddCopyAtom(Walker);
       for (int n=NDIM;n--;) {
-        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);
+        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);
         // add to Trajectories
         //Log() << Verbose(3) << step << ">=" << MDSteps-1 << endl;
         if (step < MaxSteps) {
-          (*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.;
+          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.;
         }
       }
@@ -510 +522 @@
 
   // store the list to single step files
-  int *SortIndex = Malloc<int>(getAtomCount(), "molecule::LinearInterpolationBetweenConfiguration: *SortIndex");
-  for (int i=getAtomCount(); i--; )
+  int *SortIndex = Malloc<int>(AtomCount, "molecule::LinearInterpolationBetweenConfiguration: *SortIndex");
+  for (int i=AtomCount; i--; )
     SortIndex[i] = i;
   status = MoleculePerStep->OutputConfigForListOfFragments(&configuration, SortIndex);
@@ -555 +567 @@
       return false;
     }
-    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);
+    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);
       performCriticalExit();
       return false;
@@ -562 +574 @@
     // correct Forces
     Velocity.Zero();
-    for(int i=0;i<getAtomCount();i++)
+    for(int i=0;i<AtomCount;i++)
       for(int d=0;d<NDIM;d++) {
         Velocity[d] += Force.Matrix[0][i][d+5];
       }
-    for(int i=0;i<getAtomCount();i++)
+    for(int i=0;i<AtomCount;i++)
       for(int d=0;d<NDIM;d++) {
-        Force.Matrix[0][i][d+5] -= Velocity[d]/static_cast<double>(getAtomCount());
+        Force.Matrix[0][i][d+5] -= Velocity[d]/(double)AtomCount;
       }
     // solve a constrained potential if we are meant to
@@ -671 +683 @@
       delta_alpha = 0.;
       ActOnAllAtoms( &atom::Thermostat_NoseHoover_init, MDSteps, &delta_alpha );
-      delta_alpha = (delta_alpha - (3.*getAtomCount()+1.) * configuration.TargetTemp)/(configuration.HooverMass*Units2Electronmass);
+      delta_alpha = (delta_alpha - (3.*AtomCount+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
-  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
-    c = ((*iter)->ListOfBonds.size() > c) ? (*iter)->ListOfBonds.size() : c;
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    c = (Walker->ListOfBonds.size() > c) ? Walker->ListOfBonds.size() : c;
   }
   FragmentCount = NoNonHydrogen*(1 << (c*order));
@@ -357 +359 @@
 map<double, pair<int,int> >  * ReMapAdaptiveCriteriaListToValue(map<int, pair<double,int> > *AdaptiveCriteriaList, molecule *mol)
 {
-  atom *Walker = NULL;
+  atom *Walker = mol->start;
   map<double, pair<int,int> > *FinalRootCandidates = new map<double, pair<int,int> > ;
   DoLog(1) && (Log() << Verbose(1) << "Root candidate list is: " << endl);
@@ -389 +391 @@
 bool MarkUpdateCandidates(bool *AtomMask, map<double, pair<int,int> > &FinalRootCandidates, int Order, molecule *mol)
 {
-  atom *Walker = NULL;
+  atom *Walker = mol->start;
   int No = -1;
   bool status = false;
@@ -433 +435 @@
 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=getAtomCount();i--;)
+  for(int i=AtomCount;i--;)
     AtomMask[i] = false;
 
   if (Order < 0) { // adaptive increase of BondOrder per site
-    if (AtomMask[getAtomCount()] == true)  // break after one step
+    if (AtomMask[AtomCount] == true)  // break after one step
       return false;
 
@@ -454 +457 @@
     if (AdaptiveCriteriaList->empty()) {
       DoeLog(2) && (eLog()<< Verbose(2) << "Unable to parse file, incrementing all." << endl);
-      for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+      while (Walker->next != end) {
+        Walker = Walker->next;
     #ifdef ADDHYDROGEN
-        if ((*iter)->type->Z != 1) // skip hydrogen
+        if (Walker->type->Z != 1) // skip hydrogen
     #endif
         {
-          AtomMask[(*iter)->nr] = true;  // include all (non-hydrogen) atoms
+          AtomMask[Walker->nr] = true;  // include all (non-hydrogen) atoms
           status = true;
         }
@@ -474 +478 @@
     Free(&FinalRootCandidates);
   } else { // global increase of Bond Order
-    for(molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    while (Walker->next != end) {
+      Walker = Walker->next;
   #ifdef ADDHYDROGEN
-      if ((*iter)->type->Z != 1) // skip hydrogen
+      if (Walker->type->Z != 1) // skip hydrogen
   #endif
       {
-        AtomMask[(*iter)->nr] = true;  // include all (non-hydrogen) atoms
-        if ((Order != 0) && ((*iter)->AdaptiveOrder < Order)) // && ((*iter)->AdaptiveOrder < MinimumRingSize[(*iter)->nr]))
+        AtomMask[Walker->nr] = true;  // include all (non-hydrogen) atoms
+        if ((Order != 0) && (Walker->AdaptiveOrder < Order)) // && (Walker->AdaptiveOrder < MinimumRingSize[Walker->nr]))
           status = true;
       }
     }
-    if ((!Order) && (!AtomMask[getAtomCount()]))  // single stepping, just check
+    if ((Order == 0) && (AtomMask[AtomCount] == false))  // single stepping, just check
       status = true;
 
@@ -495 +500 @@
   }
 
-  PrintAtomMask(AtomMask, getAtomCount()); // for debugging
+  PrintAtomMask(AtomMask, AtomCount); // for debugging
 
   return status;
@@ -511 +516 @@
     return false;
   }
-  SortIndex = Malloc<int>(getAtomCount(), "molecule::CreateMappingLabelsToConfigSequence: *SortIndex");
-  for(int i=getAtomCount();i--;)
+  SortIndex = Malloc<int>(AtomCount, "molecule::CreateMappingLabelsToConfigSequence: *SortIndex");
+  for(int i=AtomCount;i--;)
     SortIndex[i] = -1;
 
@@ -519 +524 @@
 
   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 = Calloc<atom *>(count, "CreateFatherLookupTable - **LookupTable");
-  if (LookupTable == NULL) {
-    eLog() << Verbose(0) << "LookupTable memory allocation failed!" << endl;
-    performCriticalExit();
-    status = false;
-  } else {
-    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;
 };
 
@@ -596 +548 @@
   MoleculeListClass *BondFragments = NULL;
   int *SortIndex = NULL;
-  int *MinimumRingSize = new int[getAtomCount()];
+  int *MinimumRingSize = new int[AtomCount];
   int FragmentCounter;
   MoleculeLeafClass *MolecularWalker = NULL;
@@ -624 +576 @@
 
   // create lookup table for Atom::nr
-  FragmentationToDo = FragmentationToDo && CreateFatherLookupTable(ListOfAtoms, getAtomCount());
+  FragmentationToDo = FragmentationToDo && CreateFatherLookupTable(start, end, ListOfAtoms, AtomCount);
 
   // === compare it with adjacency file ===
@@ -634 +586 @@
 
   // analysis of the cycles (print rings, get minimum cycle length) for each subgraph
-  for(int i=getAtomCount();i--;)
-    MinimumRingSize[i] = getAtomCount();
+  for(int i=AtomCount;i--;)
+    MinimumRingSize[i] = AtomCount;
   MolecularWalker = Subgraphs;
   FragmentCounter = 0;
@@ -672 +624 @@
   // ===== 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[getAtomCount()+1];
-  AtomMask[getAtomCount()] = false;
+  AtomMask = new bool[AtomCount+1];
+  AtomMask[AtomCount] = 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[getAtomCount()] = true;   // last plus one entry is used as marker that we have been through this loop once already in CheckOrderAtSite()
+    AtomMask[AtomCount] = 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));
@@ -816 +768 @@
 bool molecule::ParseOrderAtSiteFromFile(char *path)
 {
-  unsigned char *OrderArray = Calloc<unsigned char>(getAtomCount(), "molecule::ParseOrderAtSiteFromFile - *OrderArray");
-  bool *MaxArray = Calloc<bool>(getAtomCount(), "molecule::ParseOrderAtSiteFromFile - *MaxArray");
+  unsigned char *OrderArray = Calloc<unsigned char>(AtomCount, "molecule::ParseOrderAtSiteFromFile - *OrderArray");
+  bool *MaxArray = Calloc<bool>(AtomCount, "molecule::ParseOrderAtSiteFromFile - *MaxArray");
   bool status;
   int AtomNr, value;
@@ -920 +872 @@
   atom *OtherFather = NULL;
   atom *FatherOfRunner = NULL;
-
-#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();) {
+  Leaf->CountAtoms();
+
+  atom *Runner = Leaf->start;
+  while (Runner->next != Leaf->end) {
+    Runner = Runner->next;
     LonelyFlag = true;
-    FatherOfRunner = (*iter)->father;
-    ASSERT(FatherOfRunner,"Atom without father found");
+    FatherOfRunner = Runner->father;
     if (SonList[FatherOfRunner->nr] != NULL)  {  // check if this, our father, is present in list
       // create all bonds
@@ -939 +889 @@
 //            Log() << Verbose(3) << "Adding Bond: ";
 //            Log() << Verbose(0) <<
-            Leaf->AddBond((*iter), SonList[OtherFather->nr], (*BondRunner)->BondDegree);
+            Leaf->AddBond(Runner, SonList[OtherFather->nr], (*BondRunner)->BondDegree);
 //            Log() << Verbose(0) << "." << endl;
-            //NumBonds[(*iter)->nr]++;
+            //NumBonds[Runner->nr]++;
           } else {
 //            Log() << Verbose(3) << "Not adding bond, labels in wrong order." << endl;
@@ -949 +899 @@
 //          Log() << Verbose(0) << ", who has no son in this fragment molecule." << endl;
 #ifdef ADDHYDROGEN
-          //Log() << Verbose(3) << "Adding Hydrogen to " << (*iter)->Name << " and a bond in between." << endl;
-          if(!Leaf->AddHydrogenReplacementAtom((*BondRunner), (*iter), FatherOfRunner, OtherFather, IsAngstroem))
+          //Log() << Verbose(3) << "Adding Hydrogen to " << Runner->Name << " and a bond in between." << endl;
+          if(!Leaf->AddHydrogenReplacementAtom((*BondRunner), Runner, FatherOfRunner, OtherFather, IsAngstroem))
             exit(1);
 #endif
-          //NumBonds[(*iter)->nr] += Binder->BondDegree;
+          //NumBonds[Runner->nr] += Binder->BondDegree;
         }
       }
     } else {
-    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;
+      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);
+    }
 #ifdef ADDHYDROGEN
-    while ((iter != Leaf->end()) && ((*iter)->type->Z == 1)){ // skip added hydrogen
-      iter++;
-    }
+    while ((Runner->next != Leaf->end) && (Runner->next->type->Z == 1)) // skip added hydrogen
+      Runner = Runner->next;
 #endif
   }
@@ -981 +929 @@
 molecule * molecule::StoreFragmentFromKeySet(KeySet &Leaflet, bool IsAngstroem)
 {
-  atom **SonList = Calloc<atom*>(getAtomCount(), "molecule::StoreFragmentFromStack: **SonList");
+  atom **SonList = Calloc<atom*>(AtomCount, "molecule::StoreFragmentFromStack: **SonList");
   molecule *Leaf = World::getInstance().createMolecule();
 
@@ -1608 +1556 @@
   FragmentSearch.FragmentSet = new KeySet;
   FragmentSearch.Root = FindAtom(RootKeyNr);
-  FragmentSearch.ShortestPathList = Malloc<int>(getAtomCount(), "molecule::PowerSetGenerator: *ShortestPathList");
-  for (int i=getAtomCount();i--;) {
+  FragmentSearch.ShortestPathList = Malloc<int>(AtomCount, "molecule::PowerSetGenerator: *ShortestPathList");
+  for (int i=AtomCount;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;
-  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
-    CompleteMolecule.insert((*iter)->GetTrueFather()->nr);
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    CompleteMolecule.insert(Walker->GetTrueFather()->nr);
   }
 
@@ -1627 +1577 @@
     RootKeyNr = RootStack.front();
     RootStack.pop_front();
-    atom *Walker = FindAtom(RootKeyNr);
+    Walker = FindAtom(RootKeyNr);
     // check cyclic lengths
     //if ((MinimumRingSize[Walker->GetTrueFather()->nr] != -1) && (Walker->GetTrueFather()->AdaptiveOrder+1 > MinimumRingSize[Walker->GetTrueFather()->nr])) {
@@ -1714 +1664 @@
   Vector Translationvector;
   //class StackClass<atom *> *CompStack = NULL;
-  class StackClass<atom *> *AtomStack = new StackClass<atom *>(getAtomCount());
+  class StackClass<atom *> *AtomStack = new StackClass<atom *>(AtomCount);
   bool flag = true;
 
   DoLog(2) && (Log() << Verbose(2) << "Begin of ScanForPeriodicCorrection." << endl);
 
-  ColorList = Calloc<enum Shading>(getAtomCount(), "molecule::ScanForPeriodicCorrection: *ColorList");
+  ColorList = Calloc<enum Shading>(AtomCount, "molecule::ScanForPeriodicCorrection: *ColorList");
   while (flag) {
     // remove bonds that are beyond bonddistance
@@ -1751 +1701 @@
       Log() << Verbose(0) << Translationvector <<  endl;
       // apply to all atoms of first component via BFS
-      for (int i=getAtomCount();i--;)
+      for (int i=AtomCount;i--;)
         ColorList[i] = white;
       AtomStack->Push(Binder->leftatom);

src/molecule_geometry.cpp

@@ -69 +69 @@
 
 //  Log() << Verbose(3) << "Begin of CenterEdge." << endl;
-  molecule::const_iterator iter = begin();  // start at first in list
-  if (iter != end()) { //list not empty?
+  atom *ptr = start->next;  // start at first in list
+  if (ptr != end) {   //list not empty?
     for (int i=NDIM;i--;) {
-      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);
+      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);
       for (int i=NDIM;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);
+        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);
       }
     }
@@ -103 +104 @@
 {
   int Num = 0;
-  molecule::const_iterator iter = begin();  // start at first in list
+  atom *ptr = start;  // start at first in list
 
   Center.Zero();
 
-  if (iter != end()) {   //list not empty?
-    for (; iter != end(); ++iter) {  // continue with second if present
+  if (ptr->next != end) {   //list not empty?
+    while (ptr->next != end) {  // continue with second if present
+      ptr = ptr->next;
       Num++;
-      Center += (*iter)->x;
+      Center += ptr->x;
     }
     Center.Scale(-1./Num); // divide through total number (and sign for direction)
@@ -123 +125 @@
 Vector * molecule::DetermineCenterOfAll() const
 {
-  molecule::const_iterator iter = begin();  // start at first in list
+  atom *ptr = start->next;  // start at first in list
   Vector *a = new Vector();
   Vector tmp;
@@ -130 +132 @@
   a->Zero();
 
-  if (iter != end()) {   //list not empty?
-    for (; iter != end(); ++iter) {  // continue with second if present
+  if (ptr != end) {   //list not empty?
+    while (ptr->next != end) {  // continue with second if present
+      ptr = ptr->next;
       Num += 1.;
-      tmp = (*iter)->x;
+      tmp = ptr->x;
       (*a) += tmp;
     }
@@ -147 +150 @@
 Vector * molecule::DetermineCenterOfGravity()
 {
-  molecule::const_iterator iter = begin();  // start at first in list
+  atom *ptr = start->next;  // start at first in list
   Vector *a = new Vector();
   Vector tmp;
@@ -154 +157 @@
   a->Zero();
 
-  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;
+  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;
       (*a) += tmp;
     }
@@ -198 +202 @@
 void molecule::Scale(const double ** const factor)
 {
-  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+  atom *ptr = start;
+
+  while (ptr->next != end) {
+    ptr = ptr->next;
     for (int j=0;j<MDSteps;j++)
-      (*iter)->Trajectory.R.at(j).ScaleAll(*factor);
-    (*iter)->x.ScaleAll(*factor);
+      ptr->Trajectory.R.at(j).ScaleAll(*factor);
+    ptr->x.ScaleAll(*factor);
   }
 };
@@ -210 +217 @@
 void molecule::Translate(const Vector *trans)
 {
-  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+  atom *ptr = start;
+
+  while (ptr->next != end) {
+    ptr = ptr->next;
     for (int j=0;j<MDSteps;j++)
-      (*iter)->Trajectory.R.at(j) += (*trans);
-    (*iter)->x += (*trans);
+      ptr->Trajectory.R.at(j) += (*trans);
+    ptr->x += (*trans);
   }
 };
@@ -249 +259 @@
 void molecule::DeterminePeriodicCenter(Vector &center)
 {
+  atom *Walker = start;
   double * const cell_size = World::getInstance().getDomain();
   double *matrix = ReturnFullMatrixforSymmetric(cell_size);
@@ -259 +270 @@
     Center.Zero();
     flag = true;
-    for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    while (Walker->next != end) {
+      Walker = Walker->next;
 #ifdef ADDHYDROGEN
-      if ((*iter)->type->Z != 1) {
+      if (Walker->type->Z != 1) {
 #endif
-        Testvector = (*iter)->x;
+        Testvector = Walker->x;
         Testvector.MatrixMultiplication(inversematrix);
         Translationvector.Zero();
-        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 (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
+         if (Walker->nr < (*Runner)->GetOtherAtom(Walker)->nr) // otherwise we shift one to, the other fro and gain nothing
             for (int j=0;j<NDIM;j++) {
-              tmp = (*iter)->x[j] - (*Runner)->GetOtherAtom(*iter)->x[j];
+              tmp = Walker->x[j] - (*Runner)->GetOtherAtom(Walker)->x[j];
               if ((fabs(tmp)) > BondDistance) {
                 flag = false;
-                DoLog(0) && (Log() << Verbose(0) << "Hit: atom " << (*iter)->getName() << " in bond " << *(*Runner) << " has to be shifted due to " << tmp << "." << endl);
+                DoLog(0) && (Log() << Verbose(0) << "Hit: atom " << Walker->getName() << " in bond " << *(*Runner) << " has to be shifted due to " << tmp << "." << endl);
                 if (tmp > 0)
                   Translationvector[j] -= 1.;
@@ -286 +298 @@
 #ifdef ADDHYDROGEN
         // now also change all hydrogens
-        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;
+        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;
             Testvector.MatrixMultiplication(inversematrix);
             Testvector += Translationvector;
@@ -303 +315 @@
   Free(&inversematrix);
 
-  Center.Scale(1./static_cast<double>(getAtomCount()));
+  Center.Scale(1./(double)AtomCount);
 };
 
@@ -313 +325 @@
 void molecule::PrincipalAxisSystem(bool DoRotate)
 {
+  atom *ptr = start;  // start at first in list
   double InertiaTensor[NDIM*NDIM];
   Vector *CenterOfGravity = DetermineCenterOfGravity();
@@ -323 +336 @@
 
   // sum up inertia tensor
-  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
-    Vector x = (*iter)->x;
+  while (ptr->next != end) {
+    ptr = ptr->next;
+    Vector x = ptr->x;
     //x.SubtractVector(CenterOfGravity);
-    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]);
+    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]);
   }
   // print InertiaTensor for debugging
@@ -372 +386 @@
 
     // sum up inertia tensor
-    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]);
+    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]);
     }
     // print InertiaTensor for debugging
@@ -406 +423 @@
 void molecule::Align(Vector *n)
 {
+  atom *ptr = start;
   double alpha, tmp;
   Vector z_axis;
@@ -416 +434 @@
   alpha = atan(-n->at(0)/n->at(2));
   DoLog(1) && (Log() << Verbose(1) << "Z-X-angle: " << alpha << " ... ");
-  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];
+  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 (int j=0;j<MDSteps;j++) {
-      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];
+      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];
     }
   }
@@ -433 +452 @@
 
   // rotate on z-y plane
+  ptr = start;
   alpha = atan(-n->at(1)/n->at(2));
   DoLog(1) && (Log() << Verbose(1) << "Z-Y-angle: " << alpha << " ... ");
-  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];
+  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 (int j=0;j<MDSteps;j++) {
-      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];
+      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];
     }
   }
@@ -466 +487 @@
   Vector a,b,c,d;
   struct lsq_params *par = (struct lsq_params *)params;
+  atom *ptr = par->mol->start;
 
   // initialize vectors
@@ -475 +497 @@
   b[2] = gsl_vector_get(x,5);
   // go through all atoms
-  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;
+  while (ptr != par->mol->end) {
+    ptr = ptr->next;
+    if (ptr->type == ((struct lsq_params *)params)->type) { // for specific type
+      c = ptr->x - a;
       t = c.ScalarProduct(b);           // get direction parameter
       d = t*b;       // and create vector

src/molecule_graph.cpp

@@ -19 +19 @@
 #include "World.hpp"
 #include "Helpers/fast_functions.hpp"
-#include "Helpers/Assert.hpp"
-
 
 struct BFSAccounting
@@ -76 +74 @@
       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.
   }
@@ -107 +103 @@
   atom *Walker = NULL;
   atom *OtherWalker = NULL;
+  atom **AtomMap = NULL;
   int n[NDIM];
   double MinDistance, MaxDistance;
@@ -131 +128 @@
 
   // count atoms in molecule = dimension of matrix (also give each unique name and continuous numbering)
-  DoLog(1) && (Log() << Verbose(1) << "AtomCount " << getAtomCount() << " and bonddistance is " << bonddistance << "." << endl);
-
-  if ((getAtomCount() > 1) && (bonddistance > 1.)) {
+  CountAtoms();
+  DoLog(1) && (Log() << Verbose(1) << "AtomCount " << AtomCount << " and bonddistance is " << bonddistance << "." << endl);
+
+  if ((AtomCount > 1) && (bonddistance > 1.)) {
     DoLog(2) && (Log() << Verbose(2) << "Creating Linked Cell structure ... " << endl);
     LC = new LinkedCell(this, bonddistance);
@@ -139 +137 @@
     // create a list to map Tesselpoint::nr to atom *
     DoLog(2) && (Log() << Verbose(2) << "Creating TesselPoint to atom map ... " << endl);
-
-    // 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++;
+    AtomMap = Calloc<atom *> (AtomCount, "molecule::CreateAdjacencyList - **AtomCount");
+    Walker = start;
+    while (Walker->next != end) {
+      Walker = Walker->next;
+      AtomMap[Walker->nr] = Walker;
     }
 
@@ -155 +153 @@
           if (List != NULL) {
             for (LinkedCell::LinkedNodes::const_iterator Runner = List->begin(); Runner != List->end(); Runner++) {
-              Walker = dynamic_cast<atom*>(*Runner);
-              ASSERT(Walker,"Tesselpoint that was not an atom retrieved from LinkedNode");
-              //Log() << Verbose(0) << "Current Atom is " << *Walker << "." << endl;
+              Walker = AtomMap[(*Runner)->nr];
+//              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]++)
@@ -167 +164 @@
                       for (LinkedCell::LinkedNodes::const_iterator OtherRunner = OtherList->begin(); OtherRunner != OtherList->end(); OtherRunner++) {
                         if ((*OtherRunner)->nr > Walker->nr) {
-                          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;
+                          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;
                           (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;
@@ -191 +188 @@
           }
         }
+    Free(&AtomMap);
     delete (LC);
     DoLog(1) && (Log() << Verbose(1) << "I detected " << BondCount << " bonds in the molecule with distance " << BondDistance << "." << endl);
@@ -201 +199 @@
     ActOnAllAtoms( &atom::OutputBondOfAtom );
   } else
-    DoLog(1) && (Log() << Verbose(1) << "AtomCount is " << getAtomCount() << ", thus no bonds, no connections!." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "AtomCount is " << AtomCount << ", thus no bonds, no connections!." << endl);
   DoLog(0) && (Log() << Verbose(0) << "End of CreateAdjacencyList." << endl);
   if (free_BG)
@@ -243 +241 @@
     DoLog(0) && (Log() << Verbose(0) << " done." << endl);
   } else {
-    DoLog(1) && (Log() << Verbose(1) << "BondCount is " << BondCount << ", no bonds between any of the " << getAtomCount() << " atoms." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "BondCount is " << BondCount << ", no bonds between any of the " << AtomCount << " atoms." << endl);
   }
   DoLog(0) && (Log() << Verbose(0) << No << " bonds could not be corrected." << endl);
@@ -463 +461 @@
 void DepthFirstSearchAnalysis_Init(struct DFSAccounting &DFS, const molecule * const mol)
 {
-  DFS.AtomStack = new StackClass<atom *> (mol->getAtomCount());
+  DFS.AtomStack = new StackClass<atom *> (mol->AtomCount);
   DFS.CurrentGraphNr = 0;
   DFS.ComponentNumber = 0;
@@ -504 +502 @@
   bond *Binder = NULL;
 
-  if (getAtomCount() == 0)
+  if (AtomCount == 0)
     return SubGraphs;
   DoLog(0) && (Log() << Verbose(0) << "Begin of DepthFirstSearchAnalysis" << endl);
   DepthFirstSearchAnalysis_Init(DFS, this);
 
-  for (molecule::const_iterator iter = begin(); iter != end();) {
-    DFS.Root = *iter;
+  DFS.Root = start->next;
+  while (DFS.Root != end) { // if there any atoms at all
     // (1) mark all edges unused, empty stack, set atom->GraphNr = -1 for all
     DFS.AtomStack->ClearStack();
@@ -550 +548 @@
 
     // step on to next root
-    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++;
+    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;
     }
   }
@@ -856 +854 @@
   if (MinRingSize != -1) { // if rings are present
     // go over all atoms
-    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
+    Root = mol->start;
+    while (Root->next != mol->end) {
+      Root = Root->next;
+
+      if (MinimumRingSize[Root->GetTrueFather()->nr] == mol->AtomCount) { // check whether MinimumRingSize is set, if not BFS to next where it is
         Walker = Root;
 
         //Log() << Verbose(1) << "---------------------------------------------------------------------------------------------------------" << endl;
-        CyclicStructureAnalysis_BFSToNextCycle(Root, Walker, MinimumRingSize, mol->getAtomCount());
+        CyclicStructureAnalysis_BFSToNextCycle(Root, Walker, MinimumRingSize, mol->AtomCount);
 
       }
@@ -893 +892 @@
   int MinRingSize = -1;
 
-  InitializeBFSAccounting(BFS, getAtomCount());
+  InitializeBFSAccounting(BFS, AtomCount);
 
   //Log() << Verbose(1) << "Back edge list - ";
@@ -1135 +1134 @@
     CurrentBondsOfAtom = -1; // we count one too far due to line end
     // parse into structure
-    if ((AtomNr >= 0) && (AtomNr < getAtomCount())) {
+    if ((AtomNr >= 0) && (AtomNr < AtomCount)) {
       Walker = ListOfAtoms[AtomNr];
       while (!line.eof())
@@ -1314 +1313 @@
     AddedAtomList[Root->nr] = Mol->AddCopyAtom(Root);
 
-  BreadthFirstSearchAdd_Init(BFS, Root, BondOrder, getAtomCount(), AddedAtomList);
+  BreadthFirstSearchAdd_Init(BFS, Root, BondOrder, AtomCount, AddedAtomList);
 
   // and go on ... Queue always contains all lightgray vertices
@@ -1370 +1369 @@
   // fill parent list with sons
   DoLog(3) && (Log() << Verbose(3) << "Filling Parent List." << endl);
-  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
-    ParentList[(*iter)->father->nr] = (*iter);
+  atom *Walker = mol->start;
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    ParentList[Walker->father->nr] = Walker;
     // Outputting List for debugging
-    DoLog(4) && (Log() << Verbose(4) << "Son[" << (*iter)->father->nr << "] of " << (*iter)->father << " is " << ParentList[(*iter)->father->nr] << "." << endl);
-  }
-};
+    DoLog(4) && (Log() << Verbose(4) << "Son[" << Walker->father->nr << "] of " << Walker->father << " is " << ParentList[Walker->father->nr] << "." << endl);
+  }
+
+}
+;
 
 void BuildInducedSubgraph_Finalize(atom **&ParentList)
@@ -1386 +1389 @@
 {
   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);
-  for (molecule::const_iterator iter = Father->begin(); iter != Father->end(); ++iter) {
-    if (ParentList[(*iter)->nr] != NULL) {
-      if (ParentList[(*iter)->nr]->father != (*iter)) {
+  Walker = Father->start;
+  while (Walker->next != Father->end) {
+    Walker = Walker->next;
+    if (ParentList[Walker->nr] != NULL) {
+      if (ParentList[Walker->nr]->father != Walker) {
         status = false;
       } else {
-        for (BondList::const_iterator Runner = (*iter)->ListOfBonds.begin(); Runner != (*iter)->ListOfBonds.end(); (++Runner)) {
-          OtherAtom = (*Runner)->GetOtherAtom((*iter));
+        for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
+          OtherAtom = (*Runner)->GetOtherAtom(Walker);
           if (ParentList[OtherAtom->nr] != NULL) { // if otheratom is also a father of an atom on this molecule, create the bond
-            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);
+            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);
           }
         }
@@ -1421 +1427 @@
   bool status = true;
   atom **ParentList = NULL;
+
   DoLog(2) && (Log() << Verbose(2) << "Begin of BuildInducedSubgraph." << endl);
-  BuildInducedSubgraph_Init(ParentList, Father->getAtomCount());
+  BuildInducedSubgraph_Init(ParentList, Father->AtomCount);
   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"
@@ -32 +31 @@
 };
 
-
-/** PointCloud implementation of GoPoint
- * Uses atoms and STL stuff.
+/** Return current atom in the list.
+ * \return pointer to atom or NULL if none present
  */
-TesselPoint* molecule::GetPoint() const
+TesselPoint *molecule::GetPoint() const
 {
-  Info FunctionInfo(__func__);
-  return (*InternalPointer);
+  if ((InternalPointer != start) && (InternalPointer != end))
+    return InternalPointer;
+  else
+    return NULL;
 };
 
-/** PointCloud implementation of GoToNext.
- * Uses atoms and STL stuff.
+/** 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.
  */
 void molecule::GoToNext() const
 {
-  Info FunctionInfo(__func__);
-  if (InternalPointer != atoms.end())
-    InternalPointer++;
+  if (InternalPointer != end)
+    InternalPointer = InternalPointer->next;
 };
 
-/** PointCloud implementation of GoToFirst.
- * Uses atoms and STL stuff.
+/** Go to previous atom.
+ * Stops at first one.
+ */
+void molecule::GoToPrevious() const
+{
+  if (InternalPointer->previous != start)
+    InternalPointer = InternalPointer->previous;
+};
+
+/** Goes to first atom.
  */
 void molecule::GoToFirst() const
 {
-  Info FunctionInfo(__func__);
-  InternalPointer = atoms.begin();
+  InternalPointer = start->next;
 };
 
-/** PointCloud implementation of IsEmpty.
- * Uses atoms and STL stuff.
+/** 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
  */
 bool molecule::IsEmpty() const
 {
-  Info FunctionInfo(__func__);
-  return (empty());
+  return (start->next == end);
 };
 
-/** PointCloud implementation of IsLast.
- * Uses atoms and STL stuff.
+/** Checks whether we are at the last atom
+ * \return true - current atom is last one, false - is not last one
  */
 bool molecule::IsEnd() const
 {
-  Info FunctionInfo(__func__);
-  return (InternalPointer == atoms.end());
+  return (InternalPointer == end);
 };
-
-int molecule::GetMaxId() const {
-  return getAtomCount();
-}

src/molecule_template.hpp

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

src/moleculelist.cpp

@@ -20 +20 @@
 #include "memoryallocator.hpp"
 #include "periodentafel.hpp"
-#include "Helpers/Assert.hpp"
+#include "World.hpp"
 
 /*********************************** Functions for class MoleculeListClass *************************/
@@ -69 +69 @@
   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;
-  // 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()) {
+  if ((**(molecule **) a).AtomCount < (**(molecule **) b).AtomCount) {
     return -1;
   } else {
-    if (mol1->getAtomCount() > mol2->getAtomCount())
+    if ((**(molecule **) a).AtomCount > (**(molecule **) b).AtomCount)
       return +1;
     else {
-      Count = mol1->getAtomCount();
+      Count = (**(molecule **) a).AtomCount;
       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;
-      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)
+      while ((aWalker->next != (**(molecule **) a).end) && (bWalker->next != (**(molecule **) b).end)) {
+        aWalker = aWalker->next;
+        bWalker = bWalker->next;
+        if (aWalker->GetTrueFather() == NULL)
           aList[Counter] = Count + (aCounter++);
         else
-          aList[Counter] = (*aiter)->GetTrueFather()->nr;
-        if ((*biter)->GetTrueFather() == NULL)
+          aList[Counter] = aWalker->GetTrueFather()->nr;
+        if (bWalker->GetTrueFather() == NULL)
           bList[Counter] = Count + (bCounter++);
         else
-          bList[Counter] = (*biter)->GetTrueFather()->nr;
+          bList[Counter] = bWalker->GetTrueFather()->nr;
         Counter++;
       }
       // check if AtomCount was for real
       flag = 0;
-      if ((aiter == mol1->end()) && (biter != mol2->end())) {
+      if ((aWalker->next == (**(molecule **) a).end) && (bWalker->next != (**(molecule **) b).end)) {
         flag = -1;
       } else {
-        if ((aiter != mol1->end()) && (biter == mol2->end()))
+        if ((aWalker->next != (**(molecule **) a).end) && (bWalker->next == (**(molecule **) b).end))
           flag = 1;
       }
@@ -144 +142 @@
 void MoleculeListClass::Enumerate(ostream *out)
 {
+  atom *Walker = NULL;
   periodentafel *periode = World::getInstance().getPeriode();
   std::map<atomicNumber_t,unsigned int> counts;
@@ -159 +158 @@
       // count atoms per element and determine size of bounding sphere
       size=0.;
-      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);
+      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);
       }
       // output Index, Name, number of atoms, chemical formula
-      (*out) << ((*ListRunner)->ActiveFlag ? "*" : " ") << (*ListRunner)->IndexNr << "\t" << (*ListRunner)->name << "\t\t" << (*ListRunner)->getAtomCount() << "\t";
+      (*out) << ((*ListRunner)->ActiveFlag ? "*" : " ") << (*ListRunner)->IndexNr << "\t" << (*ListRunner)->name << "\t\t" << (*ListRunner)->AtomCount << "\t";
 
       std::map<atomicNumber_t,unsigned int>::reverse_iterator iter;
@@ -201 +202 @@
 
   // put all molecules of src into mol
-  molecule::iterator runner;
-  for (molecule::iterator iter = srcmol->begin(); iter != srcmol->end(); ++iter) {
-    runner = iter++;
-    srcmol->UnlinkAtom((*runner));
-    mol->AddAtom((*runner));
+  atom *Walker = srcmol->start;
+  atom *NextAtom = Walker->next;
+  while (NextAtom != srcmol->end) {
+    Walker = NextAtom;
+    NextAtom = Walker->next;
+    srcmol->UnlinkAtom(Walker);
+    mol->AddAtom(Walker);
   }
 
@@ -225 +228 @@
 
   // put all molecules of src into mol
-  atom *Walker = NULL;
-  for (molecule::iterator iter = srcmol->begin(); iter != srcmol->end(); ++iter) {
-    Walker = mol->AddCopyAtom((*iter));
+  atom *Walker = srcmol->start;
+  atom *NextAtom = Walker->next;
+  while (NextAtom != srcmol->end) {
+    Walker = NextAtom;
+    NextAtom = Walker->next;
+    Walker = mol->AddCopyAtom(Walker);
     Walker->father = Walker;
   }
@@ -324 +330 @@
 
   // prepare index list for bonds
-  atom ** CopyAtoms = new atom*[srcmol->getAtomCount()];
-  for(int i=0;i<srcmol->getAtomCount();i++)
+  srcmol->CountAtoms();
+  atom ** CopyAtoms = new atom*[srcmol->AtomCount];
+  for(int i=0;i<srcmol->AtomCount;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;
-  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]);
+  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]);
       nr++;
     } else {
@@ -340 +349 @@
     }
   }
-  DoLog(1) && (Log() << Verbose(1) << nr << " of " << srcmol->getAtomCount() << " atoms have been merged.");
+  DoLog(1) && (Log() << Verbose(1) << nr << " of " << srcmol->AtomCount << " atoms have been merged.");
 
   // go through all bonds and add as well
@@ -373 +382 @@
 bool MoleculeListClass::AddHydrogenCorrection(char *path)
 {
+  atom *Walker = NULL;
+  atom *Runner = NULL;
   bond *Binder = NULL;
   double ***FitConstant = NULL, **correction = NULL;
@@ -477 +488 @@
         correction[k][j] = 0.;
     // 2. take every hydrogen that is a saturated one
-    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;
+    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;
           // 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 > (*iter)->nr) && (Binder->GetOtherAtom((*runner)) != Binder->GetOtherAtom((*iter)))) { // (hydrogens have only one bonding partner!)
+          Binder = *(Runner->ListOfBonds.begin());
+          if ((Runner->type->Z == 1) && (Runner->nr > Walker->nr) && (Binder->GetOtherAtom(Runner) != Binder->GetOtherAtom(Walker))) { // (hydrogens have only one bonding partner!)
             // 4. evaluate the morse potential for each matrix component and add up
-            distance = (*runner)->x.distance((*iter)->x);
-            //Log() << Verbose(0) << "Fragment " << (*ListRunner)->name << ": " << *(*runner) << "<= " << distance << "=>" << *(*iter) << ":" << endl;
+            distance = Runner->x.distance(Walker->x);
+            //Log() << Verbose(0) << "Fragment " << (*ListRunner)->name << ": " << *Runner << "<= " << distance << "=>" << *Walker << ":" << endl;
             for (int k = 0; k < a; k++) {
               for (int j = 0; j < b; j++) {
@@ -562 +577 @@
   ofstream ForcesFile;
   stringstream line;
+  atom *Walker = NULL;
   periodentafel *periode=World::getInstance().getPeriode();
 
@@ -574 +590 @@
       periodentafel::const_iterator elemIter;
       for(elemIter=periode->begin();elemIter!=periode->end();++elemIter){
-        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
+          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
                 //Log() << Verbose(0) << "Walker is " << *Walker << " with true father " << *( Walker->GetTrueFather()) << ", it
-                ForcesFile << SortIndex[(*atomIter)->GetTrueFather()->nr] << "\t";
+                ForcesFile << SortIndex[Walker->GetTrueFather()->nr] << "\t";
               } else
                 // otherwise a -1 to indicate an added saturation hydrogen
@@ -615 +633 @@
   bool result = true;
   bool intermediateResult = true;
+  atom *Walker = NULL;
   Vector BoxDimension;
   char *FragmentNumber = NULL;
@@ -655 +674 @@
     // list atoms in fragment for debugging
     DoLog(2) && (Log() << Verbose(2) << "Contained atoms: ");
-    for (molecule::const_iterator iter = (*ListRunner)->begin(); iter != (*ListRunner)->end(); ++iter) {
-      DoLog(0) && (Log() << Verbose(0) << (*iter)->getName() << " ");
+    Walker = (*ListRunner)->start;
+    while (Walker->next != (*ListRunner)->end) {
+      Walker = Walker->next;
+      DoLog(0) && (Log() << Verbose(0) << Walker->getName() << " ");
     }
     DoLog(0) && (Log() << Verbose(0) << endl);
@@ -736 +757 @@
 {
   molecule *mol = World::getInstance().createMolecule();
+  atom *Walker = NULL;
+  atom *Advancer = NULL;
   bond *Binder = NULL;
   bond *Stepper = NULL;
@@ -741 +764 @@
   for (MoleculeList::iterator MolRunner = ListOfMolecules.begin(); !ListOfMolecules.empty(); MolRunner = ListOfMolecules.begin()) {
     // shift all atoms to new molecule
-    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);
+    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
     }
     // remove all bonds
@@ -799 +825 @@
   // 4b. create and fill map of which atom is associated to which connected molecule (note, counting starts at 1)
   int FragmentCounter = 0;
-  int *MolMap = Calloc<int>(mol->getAtomCount(), "config::Load() - *MolMap");
+  int *MolMap = Calloc<int>(mol->AtomCount, "config::Load() - *MolMap");
   MoleculeLeafClass *MolecularWalker = Subgraphs;
+  Walker = NULL;
   while (MolecularWalker->next != NULL) {
     MolecularWalker = MolecularWalker->next;
-    for (molecule::const_iterator iter = MolecularWalker->Leaf->begin(); iter != MolecularWalker->Leaf->end(); ++iter) {
-      MolMap[(*iter)->GetTrueFather()->nr] = FragmentCounter+1;
+    Walker = MolecularWalker->Leaf->start;
+    while (Walker->next != MolecularWalker->Leaf->end) {
+      Walker = Walker->next;
+      MolMap[Walker->GetTrueFather()->nr] = FragmentCounter+1;
     }
     FragmentCounter++;
@@ -810 +839 @@
 
   // 4c. relocate atoms to new molecules and remove from Leafs
-  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);
+  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);
       performCriticalExit();
     }
-    FragmentCounter = MolMap[(*iter)->nr];
+    FragmentCounter = MolMap[Walker->nr];
     if (FragmentCounter != 0) {
-      DoLog(3) && (Log() << Verbose(3) << "Re-linking " << **iter << "..." << endl);
-      molecules[FragmentCounter-1]->AddAtom((*iter));    // counting starts at 1
-      mol->erase(iter);
+      DoLog(3) && (Log() << Verbose(3) << "Re-linking " << *Walker << "..." << endl);
+      unlink(Walker);
+      molecules[FragmentCounter-1]->AddAtom(Walker);    // counting starts at 1
     } else {
-      DoeLog(0) && (eLog()<< Verbose(0) << "Atom " << **iter << " not associated to molecule!" << endl);
+      DoeLog(0) && (eLog()<< Verbose(0) << "Atom " << *Walker << " not associated to molecule!" << endl);
       performCriticalExit();
     }
@@ -829 +860 @@
   while (mol->first->next != mol->last) {
     Binder = mol->first->next;
-    const atom * const Walker = Binder->leftatom;
+    Walker = Binder->leftatom;
     unlink(Binder);
     link(Binder,molecules[MolMap[Walker->nr]-1]->last);   // counting starts at 1
@@ -851 +882 @@
 int MoleculeListClass::CountAllAtoms() const
 {
+  atom *Walker = NULL;
   int AtomNo = 0;
   for (MoleculeList::const_iterator MolWalker = ListOfMolecules.begin(); MolWalker != ListOfMolecules.end(); MolWalker++) {
-    AtomNo += (*MolWalker)->size();
+    Walker = (*MolWalker)->start;
+    while (Walker->next != (*MolWalker)->end) {
+      Walker = Walker->next;
+      AtomNo++;
+    }
   }
   return AtomNo;
@@ -1028 +1064 @@
 bool MoleculeLeafClass::FillBondStructureFromReference(const molecule * const reference, int &FragmentCounter, atom ***&ListOfLocalAtoms, bool FreeList)
 {
+  atom *Walker = NULL;
   atom *OtherWalker = NULL;
   atom *Father = NULL;
@@ -1035 +1072 @@
   DoLog(1) && (Log() << Verbose(1) << "Begin of FillBondStructureFromReference." << endl);
   // fill ListOfLocalAtoms if NULL was given
-  if (!FillListOfLocalAtoms(ListOfLocalAtoms, FragmentCounter, reference->getAtomCount(), FreeList)) {
+  if (!FillListOfLocalAtoms(ListOfLocalAtoms, FragmentCounter, reference->AtomCount, FreeList)) {
     DoLog(1) && (Log() << Verbose(1) << "Filling of ListOfLocalAtoms failed." << endl);
     return false;
@@ -1051 +1088 @@
     }
 
-    for(molecule::const_iterator iter = Leaf->begin(); iter != Leaf->end(); ++iter) {
-      Father = (*iter)->GetTrueFather();
+    Walker = Leaf->start;
+    while (Walker->next != Leaf->end) {
+      Walker = Walker->next;
+      Father = Walker->GetTrueFather();
       AtomNo = Father->nr; // global id of the current walker
       for (BondList::const_iterator Runner = Father->ListOfBonds.begin(); Runner != Father->ListOfBonds.end(); (++Runner)) {
-        OtherWalker = ListOfLocalAtoms[FragmentCounter][(*Runner)->GetOtherAtom((*iter)->GetTrueFather())->nr]; // local copy of current bond partner of walker
+        OtherWalker = ListOfLocalAtoms[FragmentCounter][(*Runner)->GetOtherAtom(Walker->GetTrueFather())->nr]; // local copy of current bond partner of walker
         if (OtherWalker != NULL) {
-          if (OtherWalker->nr > (*iter)->nr)
-            Leaf->AddBond((*iter), OtherWalker, (*Runner)->BondDegree);
+          if (OtherWalker->nr > Walker->nr)
+            Leaf->AddBond(Walker, OtherWalker, (*Runner)->BondDegree);
         } else {
-          DoLog(1) && (Log() << Verbose(1) << "OtherWalker = ListOfLocalAtoms[" << FragmentCounter << "][" << (*Runner)->GetOtherAtom((*iter)->GetTrueFather())->nr << "] is NULL!" << endl);
+          DoLog(1) && (Log() << Verbose(1) << "OtherWalker = ListOfLocalAtoms[" << FragmentCounter << "][" << (*Runner)->GetOtherAtom(Walker->GetTrueFather())->nr << "] is NULL!" << endl);
           status = false;
         }
@@ -1087 +1126 @@
 bool MoleculeLeafClass::FillRootStackForSubgraphs(KeyStack *&RootStack, bool *AtomMask, int &FragmentCounter)
 {
-  atom *Father = NULL;
+  atom *Walker = NULL, *Father = NULL;
 
   if (RootStack != NULL) {
@@ -1093 +1132 @@
     if (&(RootStack[FragmentCounter]) != NULL) {
       RootStack[FragmentCounter].clear();
-      for(molecule::const_iterator iter = Leaf->begin(); iter != Leaf->end(); ++iter) {
-        Father = (*iter)->GetTrueFather();
+      Walker = Leaf->start;
+      while (Walker->next != Leaf->end) { // go through all (non-hydrogen) atoms
+        Walker = Walker->next;
+        Father = Walker->GetTrueFather();
         if (AtomMask[Father->nr]) // apply mask
 #ifdef ADDHYDROGEN
-          if ((*iter)->type->Z != 1) // skip hydrogen
+          if (Walker->type->Z != 1) // skip hydrogen
 #endif
-          RootStack[FragmentCounter].push_front((*iter)->nr);
+          RootStack[FragmentCounter].push_front(Walker->nr);
       }
       if (next != NULL)
@@ -1138 +1179 @@
 
   if ((ListOfLocalAtoms != NULL) && (ListOfLocalAtoms[FragmentCounter] == NULL)) { // allocate and fill list of this fragment/subgraph
-    status = status && Leaf->CreateFatherLookupTable(ListOfLocalAtoms[FragmentCounter], GlobalAtomCount);
+    status = status && CreateFatherLookupTable(Leaf->start, Leaf->end, ListOfLocalAtoms[FragmentCounter], GlobalAtomCount);
     FreeList = FreeList && true;
   }
@@ -1162 +1203 @@
   DoLog(1) && (Log() << Verbose(1) << "Begin of AssignKeySetsToFragment." << endl);
   // fill ListOfLocalAtoms if NULL was given
-  if (!FillListOfLocalAtoms(ListOfLocalAtoms, FragmentCounter, reference->getAtomCount(), FreeList)) {
+  if (!FillListOfLocalAtoms(ListOfLocalAtoms, FragmentCounter, reference->AtomCount, 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"
 
@@ -360 +358 @@
   // 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
@@ -366 +364 @@
       // and we don't care whether insertion fails
     }
-  }
   // set endpoints
   int Counter = 0;
@@ -375 +372 @@
     Counter++;
   }
-  ASSERT(Counter >= 3,"We have a triangle with only two distinct endpoints!");
-};
-
+  if (Counter < 3) {
+    DoeLog(0) && (eLog() << Verbose(0) << "We have a triangle with only two distinct endpoints!" << endl);
+    performCriticalExit();
+  }
+}
+;
 
 /** Destructor of BoundaryTriangleSet.
@@ -1232 +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.
@@ -1243 +1255 @@
 ;
 
+/** 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.
@@ -1250 +1273 @@
   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--;
 }
 ;
@@ -2559 +2593 @@
   // 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++)

src/tesselation.hpp

@@ -244 +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; };
@@ -360 +363 @@
     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

@@ -838 +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

@@ -25 +25 @@
 #include "periodentafel.hpp"
 #include "tesselation.hpp"
+#include "World.hpp"
 
 #ifdef HAVE_TESTRUNNER
@@ -79 +80 @@
 
   // check that TestMolecule was correctly constructed
-  CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 4 );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
 
   TestList = World::getInstance().getMolecules();

src/unittests/AnalysisCorrelationToSurfaceUnitTest.cpp

@@ -26 +26 @@
 #include "tesselation.hpp"
 #include "World.hpp"
-#include "Helpers/Assert.hpp"
 
 #include "Helpers/Assert.hpp"
@@ -41 +40 @@
 void AnalysisCorrelationToSurfaceUnitTest::setUp()
 {
-  ASSERT_DO(Assert::Throw);
+  //ASSERT_DO(Assert::Throw);
 
   atom *Walker = NULL;
@@ -72 +71 @@
   // construct molecule (tetraeder of hydrogens) base
   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;
@@ -94 +90 @@
 
   // check that TestMolecule was correctly constructed
-  CPPUNIT_ASSERT_EQUAL( TestSurfaceMolecule->getAtomCount(), 4 );
+  CPPUNIT_ASSERT_EQUAL( TestSurfaceMolecule->AtomCount, 4 );
 
   TestList = World::getInstance().getMolecules();
@@ -111 +107 @@
   *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();
@@ -127 +120 @@
   *Walker->node = Vector(0.5, 0.5, 0.5 );
   TestSurfaceMolecule->AddAtom(Walker);
-
   TestSurfaceMolecule->ActiveFlag = true;
   TestList->insert(TestSurfaceMolecule);
@@ -158 +150 @@
 void AnalysisCorrelationToSurfaceUnitTest::SurfaceTest()
 {
-  CPPUNIT_ASSERT_EQUAL( 4, TestSurfaceMolecule->getAtomCount() );
+  CPPUNIT_ASSERT_EQUAL( 4, TestSurfaceMolecule->AtomCount );
   CPPUNIT_ASSERT_EQUAL( (size_t)2, TestList->ListOfMolecules.size() );
   CPPUNIT_ASSERT_EQUAL( (size_t)4, Surface->PointsOnBoundary.size() );

src/unittests/AnalysisPairCorrelationUnitTest.cpp

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

src/unittests/CountBondsUnitTest.cpp

@@ -102 +102 @@
 
   // check that TestMolecule was correctly constructed
-  CPPUNIT_ASSERT_EQUAL( TestMolecule1->getAtomCount(), 3 );
-  CPPUNIT_ASSERT_EQUAL( TestMolecule2->getAtomCount(), 3 );
+  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 );
 
   // create a small file with table

src/unittests/LinkedCellUnitTest.cpp

@@ -69 +69 @@
 
   // check that TestMolecule was correctly constructed
-  CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 3*3*3 );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 3*3*3 );
+  Walker = TestMolecule->start->next;
+  CPPUNIT_ASSERT( TestMolecule->end != Walker );
 };
 
@@ -195 +197 @@
 {
   // check all atoms
-  for(molecule::iterator iter = TestMolecule->begin(); iter != TestMolecule->end();++iter){
-    CPPUNIT_ASSERT_EQUAL( true, LC->SetIndexToNode(*iter) );
+  atom *Walker = TestMolecule->start;
+  while (Walker->next != TestMolecule->end) {
+    Walker = Walker->next;
+    CPPUNIT_ASSERT_EQUAL( true, LC->SetIndexToNode(Walker) );
   }
 
   // check internal vectors, returns false, because this atom is not in LC-list!
-  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);
+  Walker = World::getInstance().createAtom();
+  Walker->setName("test");
+  Walker->x= Vector(1,1,1);
+  CPPUNIT_ASSERT_EQUAL( false, LC->SetIndexToNode(Walker) );
+  World::getInstance().destroyAtom(Walker);
 
   // check out of bounds vectors
-  newAtom = World::getInstance().createAtom();
-  newAtom->setName("test");
-  newAtom->x = Vector(0,-1,0);
-  CPPUNIT_ASSERT_EQUAL( false, LC->SetIndexToNode(newAtom) );
-  World::getInstance().destroyAtom(newAtom);
+  Walker = World::getInstance().createAtom();
+  Walker->setName("test");
+  Walker->x = Vector(0,-1,0);
+  CPPUNIT_ASSERT_EQUAL( false, LC->SetIndexToNode(Walker) );
+  World::getInstance().destroyAtom(Walker);
 };
 
@@ -283 +287 @@
   size = ListOfPoints->size();
   CPPUNIT_ASSERT_EQUAL( (size_t)27, size );
-
-  for(molecule::iterator iter = TestMolecule->begin(); iter != TestMolecule->end(); ++iter){
-    ListOfPoints->remove((*iter));
+  Walker = TestMolecule->start;
+  Walker = TestMolecule->start;
+  while (Walker->next != TestMolecule->end) {
+    Walker = Walker->next;
+    ListOfPoints->remove(Walker);
     size--;
     CPPUNIT_ASSERT_EQUAL( size, ListOfPoints->size() );
@@ -300 +306 @@
   size=ListOfPoints->size();
   CPPUNIT_ASSERT_EQUAL( (size_t)8, size );
-  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);
+  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);
       size--;
       CPPUNIT_ASSERT_EQUAL( size, ListOfPoints->size() );
@@ -318 +326 @@
   size=ListOfPoints->size();
   CPPUNIT_ASSERT_EQUAL( (size_t)27, size );
-  for(molecule::iterator iter = TestMolecule->begin(); iter!=TestMolecule->end();++iter){
-    ListOfPoints->remove(*iter);
+  Walker = TestMolecule->start;
+  while (Walker->next != TestMolecule->end) {
+    Walker = Walker->next;
+    ListOfPoints->remove(Walker);
     size--;
     CPPUNIT_ASSERT_EQUAL( size, ListOfPoints->size() );
@@ -345 +355 @@
   size = ListOfPoints->size();
   CPPUNIT_ASSERT_EQUAL( (size_t)7, size );
-  for(molecule::iterator iter = TestMolecule->begin(); iter!=TestMolecule->end();++iter){
-    if (((*iter)->x.DistanceSquared(tester) - 1.) < MYEPSILON ) {
-      ListOfPoints->remove(*iter);
+  Walker = TestMolecule->start;
+  while (Walker->next != TestMolecule->end) {
+    Walker = Walker->next;
+    if ((Walker->x.DistanceSquared(tester) - 1.) < MYEPSILON ) {
+      ListOfPoints->remove(Walker);
       size--;
       CPPUNIT_ASSERT_EQUAL( size, ListOfPoints->size() );

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"
 
@@ -164 +162 @@
   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 ***************/
@@ -213 +173 @@
   blockObservable = new BlockObservable();
   notificationObservable = new NotificationObservable();
-  collection = new ObservableCollection(5);
 
   observer1 = new UpdateCountObserver();
@@ -222 +181 @@
   notificationObserver1 = new NotificationObserver(notificationObservable->notification1);
   notificationObserver2 = new NotificationObserver(notificationObservable->notification2);
+
 }
 
@@ -231 +191 @@
   delete blockObservable;
   delete notificationObservable;
-  delete collection;
 
   delete observer1;
@@ -318 +277 @@
   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();
@@ -42 +41 @@
   void doesNotifyTest();
   void doesReportTest();
-  void iteratorTest();
   void CircleDetectionTest();
 
@@ -60 +58 @@
   SuperObservable *superObservable;
   NotificationObservable *notificationObservable;
-  ObservableCollection *collection;
-
 };
 

src/unittests/analysisbondsunittest.cpp

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

src/unittests/bondgraphunittest.cpp

@@ -89 +89 @@
 
   // check that TestMolecule was correctly constructed
-  CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 4 );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
 
   // create a small file with table
@@ -120 +120 @@
 };
 
-/** 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().
  */
@@ -142 +134 @@
 void BondGraphTest::ConstructGraphFromTableTest()
 {
-  molecule::iterator Walker = TestMolecule->begin();
-  molecule::iterator Runner = TestMolecule->begin();
-  Runner++;
+  atom *Walker = TestMolecule->start->next;
+  atom *Runner = TestMolecule->end->previous;
+  CPPUNIT_ASSERT( TestMolecule->end != Walker );
   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) );
 };
 
@@ -154 +146 @@
 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) );
-
-  // this cannot be assured using dynamic IDs
-  //CPPUNIT_ASSERT_EQUAL( true , Walker->IsBondedTo(Runner) );
+  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 );
@@ -31 +30 @@
       void setUp();
       void tearDown();
-      void SetupTest();
       void LoadTableTest();
       void ConstructGraphFromTableTest();

src/unittests/listofbondsunittest.cpp

@@ -74 +74 @@
 
   // check that TestMolecule was correctly constructed
-  CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 4 );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
 
 };
@@ -90 +90 @@
 };
 
-/** 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()
  *
@@ -105 +96 @@
 {
   bond *Binder = NULL;
-  molecule::iterator iter = TestMolecule->begin();
-  atom *atom1 = *iter;
-  iter++;
-  atom *atom2 = *iter;
+  atom *atom1 = TestMolecule->start->next;
+  atom *atom2 = atom1->next;
   CPPUNIT_ASSERT( atom1 != NULL );
   CPPUNIT_ASSERT( atom2 != NULL );
@@ -135 +124 @@
 {
   bond *Binder = NULL;
-  molecule::iterator iter = TestMolecule->begin();
-  atom *atom1 = *iter;
-  iter++;
-  atom *atom2 = *iter;
+  atom *atom1 = TestMolecule->start->next;
+  atom *atom2 = atom1->next;
   CPPUNIT_ASSERT( atom1 != NULL );
   CPPUNIT_ASSERT( atom2 != NULL );
@@ -163 +150 @@
 {
   bond *Binder = NULL;
-  molecule::iterator iter = TestMolecule->begin();
-  atom *atom1 = *iter;
-  iter++;
-  atom *atom2 = *iter;
-  iter++;
-  atom *atom3 = *iter;
+  atom *atom1 = TestMolecule->start->next;
+  atom *atom2 = atom1->next;
+  atom *atom3 = atom2->next;
   CPPUNIT_ASSERT( atom1 != NULL );
   CPPUNIT_ASSERT( atom2 != NULL );
@@ -205 +189 @@
 {
   bond *Binder = NULL;
-  molecule::iterator iter = TestMolecule->begin();
-  atom *atom1 = *iter;
-  iter++;
-  atom *atom2 = *iter;
+  atom *atom1 = TestMolecule->start->next;
+  atom *atom2 = atom1->next;
   CPPUNIT_ASSERT( atom1 != NULL );
   CPPUNIT_ASSERT( atom2 != NULL );
@@ -233 +215 @@
 {
   bond *Binder = NULL;
-  molecule::iterator iter = TestMolecule->begin();
-  atom *atom1 = *iter;
-  iter++;
-  atom *atom2 = *iter;
+  atom *atom1 = TestMolecule->start->next;
+  atom *atom2 = atom1->next;
   CPPUNIT_ASSERT( atom1 != NULL );
   CPPUNIT_ASSERT( atom2 != NULL );
@@ -260 +240 @@
 {
   bond *Binder = NULL;
-  molecule::iterator iter = TestMolecule->begin();
-  atom *atom1 = *iter;
-  iter++;
-  atom *atom2 = *iter;
+  atom *atom1 = TestMolecule->start->next;
+  atom *atom2 = atom1->next;
   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 );
@@ -32 +31 @@
       void setUp();
       void tearDown();
-      void SetupTest();
       void AddingBondTest();
       void RemovingBondTest();