Changes in src/moleculelist.cpp [7fd416:1513a74]

File:

• src/moleculelist.cpp (modified) (40 diffs)

src/moleculelist.cpp

@@ -20 +20 @@
 #include "memoryallocator.hpp"
 #include "periodentafel.hpp"
-#include "Helpers/Assert.hpp"
-
-#include "Helpers/Assert.hpp"
+#include "World.hpp"
 
 /*********************************** Functions for class MoleculeListClass *************************/
@@ -40 +38 @@
 MoleculeListClass::~MoleculeListClass()
 {
-  DoLog(4) && (Log() << Verbose(4) << "Clearing ListOfMolecules." << endl);
-  for(MoleculeList::iterator MolRunner = ListOfMolecules.begin(); MolRunner != ListOfMolecules.end(); ++MolRunner)
-    (*MolRunner)->signOff(this);
+  DoLog(3) && (Log() << Verbose(3) << this << ": Freeing ListOfMolcules." << endl);
+  for (MoleculeList::iterator ListRunner = ListOfMolecules.begin(); ListRunner != ListOfMolecules.end(); ListRunner++) {
+    DoLog(4) && (Log() << Verbose(4) << "ListOfMolecules: Freeing " << *ListRunner << "." << endl);
+    world->destroyMolecule(*ListRunner);
+  }
+  DoLog(4) && (Log() << Verbose(4) << "Freeing ListOfMolecules." << endl);
   ListOfMolecules.clear(); // empty list
 };
@@ -48 +49 @@
 /** Insert a new molecule into the list and set its number.
  * \param *mol molecule to add to list.
+ * \return true - add successful
  */
 void MoleculeListClass::insert(molecule *mol)
@@ -57 +59 @@
 };
 
-/** Erases a molecule from the list.
- * \param *mol molecule to add to list.
- */
-void MoleculeListClass::erase(molecule *mol)
-{
-  OBSERVE;
-  mol->signOff(this);
-  ListOfMolecules.remove(mol);
-};
-
 /** Compare whether two molecules are equal.
  * \param *a molecule one
@@ -77 +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;
       }
@@ -152 +142 @@
 void MoleculeListClass::Enumerate(ostream *out)
 {
+  atom *Walker = NULL;
   periodentafel *periode = World::getInstance().getPeriode();
   std::map<atomicNumber_t,unsigned int> counts;
@@ -167 +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;
@@ -209 +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);
   }
 
@@ -233 +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;
   }
@@ -332 +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 {
@@ -348 +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
-  for(molecule::iterator AtomRunner = srcmol->begin(); AtomRunner != srcmol->end(); ++AtomRunner)
-    for(BondList::iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); BondRunner != (*AtomRunner)->ListOfBonds.end(); ++BondRunner)
-      if ((*BondRunner)->leftatom == *AtomRunner) {
-        DoLog(3) && (Log() << Verbose(3) << "Adding Bond between " << *CopyAtoms[(*BondRunner)->leftatom->nr] << " and " << *CopyAtoms[(*BondRunner)->rightatom->nr]<< "." << endl);
-        mol->AddBond(CopyAtoms[(*BondRunner)->leftatom->nr], CopyAtoms[(*BondRunner)->rightatom->nr], (*BondRunner)->BondDegree);
-      }
+  bond *Binder = srcmol->first;
+  while(Binder->next != srcmol->last) {
+    Binder = Binder->next;
+    DoLog(3) && (Log() << Verbose(3) << "Adding Bond between " << *CopyAtoms[Binder->leftatom->nr] << " and " << *CopyAtoms[Binder->rightatom->nr]<< "." << endl);
+    mol->AddBond(CopyAtoms[Binder->leftatom->nr], CopyAtoms[Binder->rightatom->nr], Binder->BondDegree);
+  }
   delete(LCList);
   return true;
@@ -381 +382 @@
 bool MoleculeListClass::AddHydrogenCorrection(char *path)
 {
+  atom *Walker = NULL;
+  atom *Runner = NULL;
   bond *Binder = NULL;
   double ***FitConstant = NULL, **correction = NULL;
@@ -424 +427 @@
 
   // 0b. allocate memory for constants
-  FitConstant = new double**[3];
+  FitConstant = Calloc<double**>(3, "MoleculeListClass::AddHydrogenCorrection: ***FitConstant");
   for (int k = 0; k < 3; k++) {
-    FitConstant[k] = new double*[a];
+    FitConstant[k] = Calloc<double*>(a, "MoleculeListClass::AddHydrogenCorrection: **FitConstant[]");
     for (int i = a; i--;) {
-      FitConstant[k][i] = new double[b];
-      for (int j = b; j--;) {
-        FitConstant[k][i][j] = 0.;
-      }
+      FitConstant[k][i] = Calloc<double>(b, "MoleculeListClass::AddHydrogenCorrection: *FitConstant[][]");
     }
   }
@@ -477 +477 @@
 
   // 0d. allocate final correction matrix
-  correction = new double*[a];
+  correction = Calloc<double*>(a, "MoleculeListClass::AddHydrogenCorrection: **correction");
   for (int i = a; i--;)
-    correction[i] = new double[b];
+    correction[i] = Calloc<double>(b, "MoleculeListClass::AddHydrogenCorrection: *correction[]");
 
   // 1a. go through every molecule in the list
@@ -488 +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++) {
@@ -527 +531 @@
     FragmentNumber = FixedDigitNumber(ListOfMolecules.size(), (*ListRunner)->IndexNr);
     line += FragmentNumber;
-    delete[] (FragmentNumber);
+    delete (FragmentNumber);
     line += HCORRECTIONSUFFIX;
     output.open(line.c_str());
@@ -538 +542 @@
     output.close();
   }
-  for (int i = a; i--;)
-    delete[](correction[i]);
-  delete[](correction);
-
   line = path;
   line.append("/");
@@ -556 +556 @@
   for (int k = 0; k < 3; k++) {
     for (int i = a; i--;) {
-      delete[](FitConstant[k][i]);
-    }
-    delete[](FitConstant[k]);
-  }
-  delete[](FitConstant);
+      Free(&FitConstant[k][i]);
+    }
+    Free(&FitConstant[k]);
+  }
+  Free(&FitConstant);
   DoLog(0) && (Log() << Verbose(0) << "done." << endl);
   return true;
@@ -577 +577 @@
   ofstream ForcesFile;
   stringstream line;
+  atom *Walker = NULL;
   periodentafel *periode=World::getInstance().getPeriode();
 
@@ -589 +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
@@ -619 +622 @@
  * \param *configuration standard configuration to attach atoms in fragment molecule to.
  * \param *SortIndex Index to map from the BFS labeling to the sequence how of Ion_Type in the config
+ * \param DoPeriodic true - call ScanForPeriodicCorrection, false - don't
+ * \param DoCentering true - call molecule::CenterEdge(), false - don't
  * \return true - success (each file was written), false - something went wrong.
  */
@@ -628 +633 @@
   bool result = true;
   bool intermediateResult = true;
+  atom *Walker = NULL;
   Vector BoxDimension;
   char *FragmentNumber = NULL;
@@ -668 +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->Name << " ");
     }
     DoLog(0) && (Log() << Verbose(0) << endl);
@@ -716 +724 @@
     //outputFragment.close();
     //outputFragment.clear();
-    delete[](FragmentNumber);
+    Free(&FragmentNumber);
   }
   DoLog(0) && (Log() << Verbose(0) << " done." << endl);
@@ -748 +756 @@
 void MoleculeListClass::DissectMoleculeIntoConnectedSubgraphs(const periodentafel * const periode, config * const configuration)
 {
-  // 0a. remove all present molecules
-  vector<molecule *> allmolecules = World::getInstance().getAllMolecules();
-  for (vector<molecule *>::iterator MolRunner = allmolecules.begin(); MolRunner != allmolecules.end(); ++MolRunner) {
-    erase(*MolRunner);
+  molecule *mol = World::getInstance().createMolecule();
+  atom *Walker = NULL;
+  atom *Advancer = NULL;
+  bond *Binder = NULL;
+  bond *Stepper = NULL;
+  // 0. gather all atoms into single molecule
+  for (MoleculeList::iterator MolRunner = ListOfMolecules.begin(); !ListOfMolecules.empty(); MolRunner = ListOfMolecules.begin()) {
+    // shift all atoms to new molecule
+    Advancer = (*MolRunner)->start->next;
+    while (Advancer != (*MolRunner)->end) {
+      Walker = Advancer;
+      Advancer = Advancer->next;
+      DoLog(3) && (Log() << Verbose(3) << "Re-linking " << *Walker << "..." << endl);
+      unlink(Walker);
+      Walker->father = Walker;
+      mol->AddAtom(Walker);    // counting starts at 1
+    }
+    // remove all bonds
+    Stepper = (*MolRunner)->first->next;
+    while (Stepper != (*MolRunner)->last) {
+      Binder = Stepper;
+      Stepper = Stepper->next;
+      delete(Binder);
+    }
+    // remove the molecule
     World::getInstance().destroyMolecule(*MolRunner);
-  }
-  // 0b. remove all bonds and construct a molecule with all atoms
-  molecule *mol = World::getInstance().createMolecule();
-  vector <atom *> allatoms = World::getInstance().getAllAtoms();
-  for(vector<atom *>::iterator AtomRunner = allatoms.begin(); AtomRunner != allatoms.end(); ++AtomRunner) {
-    for(BondList::iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); !(*AtomRunner)->ListOfBonds.empty(); BondRunner = (*AtomRunner)->ListOfBonds.begin())
-      delete(*BondRunner);
-    mol->AddAtom(*AtomRunner);
+    ListOfMolecules.erase(MolRunner);
   }
 
@@ -788 +810 @@
   const int MolCount = Subgraphs->next->Count();
   char number[MAXSTRINGSIZE];
-  molecule **molecules = new molecule *[MolCount];
-  MoleculeLeafClass *MolecularWalker = Subgraphs;
+  molecule **molecules = Malloc<molecule *>(MolCount, "config::Load() - **molecules");
   for (int i=0;i<MolCount;i++) {
-    MolecularWalker = MolecularWalker->next;
     molecules[i] = World::getInstance().createMolecule();
     molecules[i]->ActiveFlag = true;
@@ -800 +820 @@
     }
     DoLog(1) && (Log() << Verbose(1) << "MolName is " << molecules[i]->name << endl);
-    for (molecule::iterator iter = MolecularWalker->Leaf->begin(); iter != MolecularWalker->Leaf->end(); ++iter) {
-      DoLog(1) && (Log() << Verbose(1) << **iter << endl);
-    }
     insert(molecules[i]);
   }
@@ -808 +825 @@
   // 4b. create and fill map of which atom is associated to which connected molecule (note, counting starts at 1)
   int FragmentCounter = 0;
-  map<int, atom *> AtomToFragmentMap;
-  MolecularWalker = Subgraphs;
+  int *MolMap = Calloc<int>(mol->AtomCount, "config::Load() - *MolMap");
+  MoleculeLeafClass *MolecularWalker = Subgraphs;
+  Walker = NULL;
   while (MolecularWalker->next != NULL) {
     MolecularWalker = MolecularWalker->next;
-    for (molecule::iterator iter = MolecularWalker->Leaf->begin(); !MolecularWalker->Leaf->empty(); iter = MolecularWalker->Leaf->begin()) {
-      atom * Walker = *iter;
-      DoLog(1) && (Log() << Verbose(1) << "Re-linking " << Walker << "..." << endl);
-      MolecularWalker->Leaf->erase(iter);
-      molecules[FragmentCounter]->AddAtom(Walker);    // counting starts at 1
+    Walker = MolecularWalker->Leaf->start;
+    while (Walker->next != MolecularWalker->Leaf->end) {
+      Walker = Walker->next;
+      MolMap[Walker->GetTrueFather()->nr] = FragmentCounter+1;
     }
     FragmentCounter++;
   }
-  World::getInstance().destroyMolecule(mol);
-
+
+  // 4c. relocate atoms to new molecules and remove from Leafs
+  Walker = NULL;
+  while (mol->start->next != mol->end) {
+    Walker = mol->start->next;
+    if ((Walker->nr <0) || (Walker->nr >= mol->AtomCount)) {
+      DoeLog(0) && (eLog()<< Verbose(0) << "Index of atom " << *Walker << " is invalid!" << endl);
+      performCriticalExit();
+    }
+    FragmentCounter = MolMap[Walker->nr];
+    if (FragmentCounter != 0) {
+      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 " << *Walker << " not associated to molecule!" << endl);
+      performCriticalExit();
+    }
+  }
   // 4d. we don't need to redo bonds, as they are connected subgraphs and still maintain their ListOfBonds, but we have to remove them from first..last list
-  // TODO: check whether this is really not needed anymore
+  Binder = mol->first;
+  while (mol->first->next != mol->last) {
+    Binder = mol->first->next;
+    Walker = Binder->leftatom;
+    unlink(Binder);
+    link(Binder,molecules[MolMap[Walker->nr]-1]->last);   // counting starts at 1
+  }
   // 4e. free Leafs
   MolecularWalker = Subgraphs;
@@ -831 +871 @@
   }
   delete(MolecularWalker);
-  delete[](molecules);
+  Free(&MolMap);
+  Free(&molecules);
   DoLog(1) && (Log() << Verbose(1) << "I scanned " << FragmentCounter << " molecules." << endl);
 };
@@ -841 +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;
@@ -1018 +1064 @@
 bool MoleculeLeafClass::FillBondStructureFromReference(const molecule * const reference, int &FragmentCounter, atom ***&ListOfLocalAtoms, bool FreeList)
 {
+  atom *Walker = NULL;
   atom *OtherWalker = NULL;
   atom *Father = NULL;
@@ -1025 +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;
@@ -1033 +1080 @@
     DoLog(1) && (Log() << Verbose(1) << "Creating adjacency list for subgraph " << Leaf << "." << endl);
     // remove every bond from the list
-    for(molecule::iterator AtomRunner = Leaf->begin(); AtomRunner != Leaf->end(); ++AtomRunner)
-      for(BondList::iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); !(*AtomRunner)->ListOfBonds.empty(); BondRunner = (*AtomRunner)->ListOfBonds.begin())
-        if ((*BondRunner)->leftatom == *AtomRunner)
-          delete((*BondRunner));
-
-    for(molecule::const_iterator iter = Leaf->begin(); iter != Leaf->end(); ++iter) {
-      Father = (*iter)->GetTrueFather();
+    bond *Binder = NULL;
+    while (Leaf->last->previous != Leaf->first) {
+      Binder = Leaf->last->previous;
+      Binder->leftatom->UnregisterBond(Binder);
+      Binder->rightatom->UnregisterBond(Binder);
+      removewithoutcheck(Binder);
+    }
+
+    Walker = Leaf->start;
+    while (Walker->next != Leaf->end) {
+      Walker = Walker->next;
+      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;
         }
@@ -1056 +1108 @@
   if ((FreeList) && (ListOfLocalAtoms != NULL)) {
     // free the index lookup list
-    delete[](ListOfLocalAtoms[FragmentCounter]);
+    Free(&ListOfLocalAtoms[FragmentCounter]);
     if (FragmentCounter == 0) // first fragments frees the initial pointer to list
-      delete[](ListOfLocalAtoms);
+      Free(&ListOfLocalAtoms);
   }
   DoLog(1) && (Log() << Verbose(1) << "End of FillBondStructureFromReference." << endl);
@@ -1074 +1126 @@
 bool MoleculeLeafClass::FillRootStackForSubgraphs(KeyStack *&RootStack, bool *AtomMask, int &FragmentCounter)
 {
-  atom *Father = NULL;
+  atom *Walker = NULL, *Father = NULL;
 
   if (RootStack != NULL) {
@@ -1080 +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)
@@ -1117 +1171 @@
     // allocate and set each field to NULL
     const int Counter = Count();
-    ASSERT(FragmentCounter < Counter, "FillListOfLocalAtoms: FragmenCounter greater than present fragments.");
-    ListOfLocalAtoms = new atom**[Counter];
+    ListOfLocalAtoms = Calloc<atom**>(Counter, "MoleculeLeafClass::FillListOfLocalAtoms - ***ListOfLocalAtoms");
     if (ListOfLocalAtoms == NULL) {
       FreeList = FreeList && false;
       status = false;
     }
-    for (int i=0;i<Counter;i++)
-      ListOfLocalAtoms[i] = NULL;
   }
 
   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;
   }
@@ -1152 +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;
@@ -1160 +1211 @@
   if (FragmentList == NULL) {
     KeySetCounter = Count();
-    FragmentList = new Graph*[KeySetCounter];
-    for (int i=0;i<KeySetCounter;i++)
-      FragmentList[i] = NULL;
+    FragmentList = Calloc<Graph*>(KeySetCounter, "MoleculeLeafClass::AssignKeySetsToFragment - **FragmentList");
     KeySetCounter = 0;
   }
@@ -1196 +1245 @@
   if ((FreeList) && (ListOfLocalAtoms != NULL)) {
     // free the index lookup list
-    delete[](ListOfLocalAtoms[FragmentCounter]);
+    Free(&ListOfLocalAtoms[FragmentCounter]);
     if (FragmentCounter == 0) // first fragments frees the initial pointer to list
-      delete[](ListOfLocalAtoms);
+      Free(&ListOfLocalAtoms);
   }
   DoLog(1) && (Log() << Verbose(1) << "End of AssignKeySetsToFragment." << endl);