Changeset 872b51 for molecuilder/src/molecule_graph.cpp

Timestamp:

Oct 18, 2009, 2:51:38 PM (16 years ago)

Author:

Frederik Heber <heber@…>

Children:

77894f

Parents:

b0ee98

git-author:

Frederik Heber <heber@…> (10/18/09 14:15:37)

git-committer:

Frederik Heber <heber@…> (10/18/09 14:51:38)

Message:

Huge refactoring: molecule::ListOfBondsPerAtom and molecule::NumberOfBondsPerAtom removed, atom::ListOfBonds introduced. Unit Test for ListOfBonds manipulation introduced.

• changes to class atom:
  • ~atom(): removes all bonds it is part of and unlink()s
  • new functions: CountBonds() - counts bonds times BondDegree, OutputGraphInfo() - graph data is output, OutputComponentNumber() - output of component numbers, OutputAdjacency() - indices of this and its neighbours, CorrectBondDegree() - corrects bond degree incrementally (by at most one) -- all since ListOfBonds is now local info
  • OutputBondOfAtom() - does not need ListOfBondsPerAtom, ... as ListOfBonds is now local info
  • new functions for ListOfBonds access: RegisterBond(), UnregisterBond(), UnregisterAllBonds() (the latter only remove from the list, do not delete, as molecule still has a global list of all bonds and does deletion.)

• changes to class bond:
  • ~bond() uses unlink(), uses UnregisterBond() on leftatom and rightatom
  • removed unused bond::GetFirstBond() and bond::GetLastBond()
  • GetOtherAtom() has now const parameter

• changes to builder.cpp: removed CreateListOfBondsPerAtom() calls, as the creation of the global arrays is not necessary anymore

• changes to LinkedCell: LinkedCell::CheckBounds(int[NDIM]) does not admonish out of bonds as this is not desired for the local offset which may become out of bounds.

• changes to lists.hpp templates: BUGFIX: unlink() now sets ->next and ->previous to NULL, cleanup() uses removedwithoutcheck()

• new templates for molecule.hpp: SumPerAtom() allows for summation of the return value of atom:...() member fiunctions. This is needed e.g. for atom::CorrectBondDegree()

• changes to MoleculeListClass:
  • changes due to ListOfBondsPerAtom -> atom::ListOfBonds: AddHydrogenCorrection(), FillBondStructureFromReference()

• changes to class molecule:
  • changes due to ListOfBondsPerAtom -> atom::ListOfBonds: GuesstimateFragmentCount(), FragmentMolecule(), FillSPListandLabelVertices(), ScanForPeriodicCorrection(), DeterminePeriodicCenter(), CyclicStructureAnalysis(), InitComponentNumbers(), FindNextUnused(), CheckAdjacencyFileAgainstMolecule(), PickLocalBackEdges(), BreadthFirstSearchAdd(), BuildInducedSubgraph(), CheckForConnectedSubgraph(), molecule(), ~molecule(), AddHydrogenReplacementAtom(), RemoveBonds(), OutputListOfBonds(), removed CreateListOfBondsPerAtom()
  • due to removal of CreateListOfBonds(): FragmentMolecule(), CreateAdjacencyListFromDbondFile(), CreateAdjacencyList(), SetNextComponentNumber()
  • ActOnAllAtoms() used: CreateAdjacencyList() - uses atom::OutputBondOfAtom(), StoreAdjacencyToFile() - uses atom::OutputAdjacency(),
  • SumPerAtom() used: CorrectBondDegree() - uses atom::CorrectBondDegree(),
  • function removed: molecule::CountAtomsBonds() - shifted to atom::CountBonds(), OutputComponentNumber() - shifted to atom::OutputComponentNumber()
  • CountCyclicBonds() - manipulates molecule::NoCyclicBonds directly.
  • rewritten DepthFirstSearchAnalysis() - refactored to CyclicBondAnalysis(), OutputGraphInfoPerAtom(), OutputGraphInfoPerBond()
  • rewritten RemoveAtom() - uses RemoveBonds()
  • FIX: rewritten CleanupMolecule() - cleanup was wrong order, now is first bonds, then atoms
  • rewritten BreadthFirstSearchAdd() - uses molecule::CopyBond() (equal code was present multiple(!) times before)
  • new functions CyclicBondAnalysis(), OutputGraphInfoPerAtom(), OutputGraphInfoPerBond(), CopyBond()

• New UnitTest for ListOfBonds:
  • tests AddBond(), RemoveAtom(), RemoveBond(), RemoveBonds() and simple deletion of atoms or bonds, where afterwards chain lists of bonds should remain intact.

Signed-off-by: Frederik Heber <heber@…>

File:

• molecuilder/src/molecule_graph.cpp (modified) (30 diffs)

molecuilder/src/molecule_graph.cpp

@@ -48 +48 @@
     AddBond(Walker, OtherWalker); //Add the bond between the two atoms with respective indices.
   }
-
-  CreateListOfBondsPerAtom(out);
 };
 
@@ -64 +62 @@
  *  -# put each atom into its corresponding cell
  *  -# go through every cell, check the atoms therein against all possible bond partners in the 27 adjacent cells, add bond if true
- *  -# create the list of bonds via CreateListOfBondsPerAtom()
  *  -# correct the bond degree iteratively (single->double->triple bond)
  *  -# finally print the bond list to \a *out if desired
@@ -148 +145 @@
     *out << Verbose(1) << "I detected " << BondCount << " bonds in the molecule with distance " << BondDistance << "." << endl;
 
-    // create the adjacency list per atom
-    CreateListOfBondsPerAtom(out);
-
     // correct bond degree by comparing valence and bond degree
     CorrectBondDegree(out);
 
     // output bonds for debugging (if bond chain list was correctly installed)
-    OutputBondsList(out);
+    ActOnAllAtoms( &atom::OutputBondOfAtom, out );
   } else
     *out << Verbose(1) << "AtomCount is " << AtomCount << ", thus no bonds, no connections!." << endl;
@@ -173 +167 @@
   }
   *out << endl;
-};
-
-/** Sums up the number of bonds times bond::BondDegree the atom with index \a nr has.
- * \param nr indexof atom
- * \return number of bonds each weighted with its bond::BondDegree
- */
-int molecule::CountAtomsBonds(int nr)
-{
-  int NoBonds = 0;
-  for(int j=0;j<NumberOfBondsPerAtom[nr];j++)
-    NoBonds += ListOfBondsPerAtom[nr][j]->BondDegree;
-  return NoBonds;
 };
 
@@ -198 +180 @@
 {
   int No = 0;
-  int NoBonds = 0;
-  int CandidateBondNo = 0;
-  int FalseBondDegree = 0;
-  atom *Walker = NULL;
-  atom *Candidate = NULL;
-  atom *OtherWalker = NULL;
 
   if (BondCount != 0) {
-    NoCyclicBonds = 0;
-    *out << Verbose(1) << "Correcting Bond degree of each bond ... ";
+    *out << Verbose(1) << "Correcting Bond degree of each bond ... " << endl;
     do {
-      No = 0; // No acts as breakup flag (if 1 we still continue)
-      Walker = start;
-      while (Walker->next != end) { // go through every atom
-        Walker = Walker->next;
-
-        NoBonds = CountAtomsBonds(Walker->nr);
-        *out << Verbose(3) << "Walker " << *Walker << ": " << (int)Walker->type->NoValenceOrbitals << " > " << NoBonds << "?" << endl;
-        if ((int)(Walker->type->NoValenceOrbitals) > NoBonds) { // we have a mismatch, check all bonding partners for mismatch
-          Candidate = NULL;
-          CandidateBondNo = -1;
-          for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) { // go through each of its bond partners
-            OtherWalker = ListOfBondsPerAtom[Walker->nr][i]->GetOtherAtom(Walker);
-            NoBonds = CountAtomsBonds(OtherWalker->nr);
-            *out << Verbose(3) << "OtherWalker " << *OtherWalker << ": " << (int)OtherWalker->type->NoValenceOrbitals << " > " << NoBonds << "?" << endl;
-            if ((int)(OtherWalker->type->NoValenceOrbitals) > NoBonds) { // check if possible candidate
-              if ((Candidate == NULL) || (NumberOfBondsPerAtom[Candidate->nr] > NumberOfBondsPerAtom[OtherWalker->nr])) { // pick the one with fewer number of bonds first
-                Candidate = OtherWalker;
-                CandidateBondNo = i;
-                *out << Verbose(3) << "New candidate is " << *Candidate << "." << endl;
-              }
-            }
-          }
-          if ((Candidate != NULL) && (CandidateBondNo != -1)) {
-            ListOfBondsPerAtom[Walker->nr][CandidateBondNo]->BondDegree++;
-            *out << Verbose(2) << "Increased bond degree for bond " << *ListOfBondsPerAtom[Walker->nr][CandidateBondNo] << "." << endl;
-          } else {
-            *out << Verbose(2) << "Could not find correct degree for atom " << *Walker << "." << endl;
-            FalseBondDegree++;
-          }
-        }
-      }
+      No = SumPerAtom( &atom::CorrectBondDegree, out );
     } while (No);
     *out << " done." << endl;
@@ -245 +190 @@
     *out << Verbose(1) << "BondCount is " << BondCount << ", no bonds between any of the " << AtomCount << " atoms." << endl;
   }
-  *out << FalseBondDegree << " bonds could not be corrected." << endl;
-
-  return (FalseBondDegree);
+  *out << No << " bonds could not be corrected." << endl;
+
+  return (No);
 };
 
@@ -257 +202 @@
 int molecule::CountCyclicBonds(ofstream *out)
 {
-  int No = 0;
+  NoCyclicBonds = 0;
   int *MinimumRingSize = NULL;
   MoleculeLeafClass *Subgraphs = NULL;
@@ -275 +220 @@
     Binder = Binder->next;
     if (Binder->Cyclic)
-      No++;
+      NoCyclicBonds++;
   }
   delete(BackEdgeStack);
-  return No;
+  return NoCyclicBonds;
 };
 
@@ -459 +404 @@
   }
   // set cyclic bond criterium on "same LP" basis
-  Binder = first;
+  CyclicBondAnalysis();
+
+  OutputGraphInfoPerAtom(out);
+
+  OutputGraphInfoPerBond(out);
+
+  // free all and exit
+  delete(AtomStack);
+  *out << Verbose(0) << "End of DepthFirstSearchAnalysis" << endl;
+  return SubGraphs;
+};
+
+/** Scans through all bonds and set bond::Cyclic to true where atom::LowpointNr of both ends is equal: LP criterion.
+ */
+void molecule::CyclicBondAnalysis()
+{
+  NoCyclicBonds = 0;
+  bond *Binder = first;
   while(Binder->next != last) {
     Binder = Binder->next;
@@ -467 +429 @@
     }
   }
-
-
+};
+
+/** Output graph information per atom.
+ * \param *out output stream
+ */
+void molecule::OutputGraphInfoPerAtom(ofstream *out)
+{
   *out << Verbose(1) << "Final graph info for each atom is:" << endl;
-  Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    *out << Verbose(2) << "Atom " << Walker->Name << " is " << ((Walker->SeparationVertex) ? "a" : "not a") << " separation vertex, components are ";
-    OutputComponentNumber(out, Walker);
-    *out << " with Lowpoint " << Walker->LowpointNr << " and Graph Nr. " << Walker->GraphNr << "." << endl;
-  }
-
+  ActOnAllAtoms( &atom::OutputGraphInfo, out );
+};
+
+/** Output graph information per bond.
+ * \param *out output stream
+ */
+void molecule::OutputGraphInfoPerBond(ofstream *out)
+{
   *out << Verbose(1) << "Final graph info for each bond is:" << endl;
-  Binder = first;
+  bond *Binder = first;
   while(Binder->next != last) {
     Binder = Binder->next;
     *out << Verbose(2) << ((Binder->Type == TreeEdge) ? "TreeEdge " : "BackEdge ") << *Binder << ": <";
     *out << ((Binder->leftatom->SeparationVertex) ? "SP," : "") << "L" << Binder->leftatom->LowpointNr << " G" << Binder->leftatom->GraphNr << " Comp.";
-    OutputComponentNumber(out, Binder->leftatom);
+    Binder->leftatom->OutputComponentNumber(out);
     *out << " ===  ";
     *out << ((Binder->rightatom->SeparationVertex) ? "SP," : "") << "L" << Binder->rightatom->LowpointNr << " G" << Binder->rightatom->GraphNr << " Comp.";
-    OutputComponentNumber(out, Binder->rightatom);
+    Binder->rightatom->OutputComponentNumber(out);
     *out << ">." << endl;
     if (Binder->Cyclic) // cyclic ??
       *out << Verbose(3) << "Lowpoint at each side are equal: CYCLIC!" << endl;
   }
-
-  // free all and exit
-  delete(AtomStack);
-  *out << Verbose(0) << "End of DepthFirstSearchAnalysis" << endl;
-  return SubGraphs;
 };
 
@@ -547 +509 @@
       Walker = BFSStack->PopFirst();
       *out << Verbose(2) << "Current Walker is " << *Walker << ", we look for SP to Root " << *Root << "." << endl;
-      for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) {
-        Binder = ListOfBondsPerAtom[Walker->nr][i];
-        if (Binder != BackEdge) { // only walk along DFS spanning tree (otherwise we always find SP of one being backedge Binder)
-          OtherAtom = Binder->GetOtherAtom(Walker);
+      for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
+        if ((*Runner) != BackEdge) { // only walk along DFS spanning tree (otherwise we always find SP of one being backedge Binder)
+          OtherAtom = (*Runner)->GetOtherAtom(Walker);
 #ifdef ADDHYDROGEN
           if (OtherAtom->type->Z != 1) {
@@ -662 +623 @@
           Walker = BFSStack->PopFirst();
           //*out << Verbose(2) << "Current Walker is " << *Walker << ", we look for SP to Root " << *Root << "." << endl;
-          for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) {
-            Binder = ListOfBondsPerAtom[Walker->nr][i];
-            if ((Binder != BackEdge) || (NumberOfBondsPerAtom[Walker->nr] == 1)) { // only walk along DFS spanning tree (otherwise we always find SP of 1 being backedge Binder), but terminal hydrogens may be connected via backedge, hence extra check
-              OtherAtom = Binder->GetOtherAtom(Walker);
+          for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
+            if (((*Runner) != BackEdge) || (Walker->ListOfBonds.size() == 1)) { // only walk along DFS spanning tree (otherwise we always find SP of 1 being backedge Binder), but terminal hydrogens may be connected via backedge, hence extra check
+              OtherAtom = (*Runner)->GetOtherAtom(Walker);
               //*out << Verbose(2) << "Current OtherAtom is: " << OtherAtom->Name << " for bond " << *Binder << "." << endl;
               if (ColorList[OtherAtom->nr] == white) {
@@ -717 +677 @@
 void molecule::SetNextComponentNumber(atom *vertex, int nr)
 {
-  int i=0;
+  size_t i=0;
   if (vertex != NULL) {
-    for(;i<NumberOfBondsPerAtom[vertex->nr];i++) {
+    for(;i<vertex->ListOfBonds.size();i++) {
       if (vertex->ComponentNr[i] == -1) {   // check if not yet used
         vertex->ComponentNr[i] = nr;
@@ -727 +687 @@
         break;  // breaking here will not cause error!
     }
-    if (i == NumberOfBondsPerAtom[vertex->nr])
+    if (i == vertex->ListOfBonds.size())
       cerr << "Error: All Component entries are already occupied!" << endl;
   } else
       cerr << "Error: Given vertex is NULL!" << endl;
-};
-
-/** Output a list of flags, stating whether the bond was visited or not.
- * \param *out output stream for debugging
- */
-void molecule::OutputComponentNumber(ofstream *out, atom *vertex)
-{
-  for(int i=0;i<NumberOfBondsPerAtom[vertex->nr];i++)
-    *out << vertex->ComponentNr[i] << "  ";
 };
 
@@ -751 +702 @@
     if (Walker->ComponentNr != NULL)
       Free(&Walker->ComponentNr);
-    Walker->ComponentNr = Malloc<int>(NumberOfBondsPerAtom[Walker->nr], "molecule::InitComponentNumbers: *Walker->ComponentNr");
-    for (int i=NumberOfBondsPerAtom[Walker->nr];i--;)
+    Walker->ComponentNr = Malloc<int>(Walker->ListOfBonds.size()+1, "molecule::InitComponentNumbers: *Walker->ComponentNr");
+    for (int i=Walker->ListOfBonds.size()+1;i--;)
       Walker->ComponentNr[i] = -1;
   }
@@ -763 +714 @@
 bond * molecule::FindNextUnused(atom *vertex)
 {
-  for(int i=0;i<NumberOfBondsPerAtom[vertex->nr];i++)
-    if (ListOfBondsPerAtom[vertex->nr][i]->IsUsed() == white)
-      return(ListOfBondsPerAtom[vertex->nr][i]);
+  for (BondList::const_iterator Runner = vertex->ListOfBonds.begin(); Runner != vertex->ListOfBonds.end(); (++Runner))
+    if ((*Runner)->IsUsed() == white)
+      return((*Runner));
   return NULL;
 };
@@ -813 +764 @@
 {
   ofstream AdjacencyFile;
-  atom *Walker = NULL;
   stringstream line;
   bool status = true;
@@ -821 +771 @@
   *out << Verbose(1) << "Saving adjacency list ... ";
   if (AdjacencyFile != NULL) {
-    Walker = start;
-    while(Walker->next != end) {
-      Walker = Walker->next;
-      AdjacencyFile << Walker->nr << "\t";
-      for (int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++)
-        AdjacencyFile << ListOfBondsPerAtom[Walker->nr][i]->GetOtherAtom(Walker)->nr << "\t";
-      AdjacencyFile << endl;
-    }
+    ActOnAllAtoms( &atom::OutputAdjacency, &AdjacencyFile );
     AdjacencyFile.close();
     *out << Verbose(1) << "done." << endl;
@@ -850 +793 @@
   stringstream filename;
   bool status = true;
+  atom *Walker = NULL;
   char *buffer = Malloc<char>(MAXSTRINGSIZE, "molecule::CheckAdjacencyFileAgainstMolecule: *buffer");
 
@@ -859 +803 @@
     int NonMatchNumber = 0;   // will number of atoms with differing bond structure
     int *CurrentBonds = Malloc<int>(8, "molecule::CheckAdjacencyFileAgainstMolecule - CurrentBonds"); // contains parsed bonds of current atom
-    int CurrentBondsOfAtom;
+    size_t CurrentBondsOfAtom;
 
     // Parse the file line by line and count the bonds
@@ -871 +815 @@
       // parse into structure
       if ((AtomNr >= 0) && (AtomNr < AtomCount)) {
+        Walker = ListOfAtoms[AtomNr];
         while (!line.eof())
           line >> CurrentBonds[ ++CurrentBondsOfAtom ];
         // compare against present bonds
         //cout << Verbose(2) << "Walker is " << *Walker << ", bond partners: ";
-        if (CurrentBondsOfAtom == NumberOfBondsPerAtom[AtomNr]) {
-          for(int i=0;i<NumberOfBondsPerAtom[AtomNr];i++) {
-            int id = ListOfBondsPerAtom[AtomNr][i]->GetOtherAtom(ListOfAtoms[AtomNr])->nr;
-            int j = 0;
+        if (CurrentBondsOfAtom == Walker->ListOfBonds.size()) {
+          for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
+            int id = (*Runner)->GetOtherAtom(Walker)->nr;
+            size_t j = 0;
             for (;(j<CurrentBondsOfAtom) && (CurrentBonds[j++] != id);); // check against all parsed bonds
             if (CurrentBonds[j-1] != id) { // no match ? Then mark in ListOfAtoms
@@ -891 +836 @@
           //out << endl;
         } else {
-          *out << "Number of bonds for Atom " << *ListOfAtoms[AtomNr] << " does not match, parsed " << CurrentBondsOfAtom << " against " << NumberOfBondsPerAtom[AtomNr] << "." << endl;
+          *out << "Number of bonds for Atom " << *Walker << " does not match, parsed " << CurrentBondsOfAtom << " against " << Walker->ListOfBonds.size() << "." << endl;
           status = false;
         }
@@ -937 +882 @@
     Walker = ListOfLocalAtoms[Binder->leftatom->nr];  // get one atom in the reference molecule
     if (Walker != NULL) // if this Walker exists in the subgraph ...
-      for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) {    // go through the local list of bonds
-        OtherAtom = ListOfBondsPerAtom[Walker->nr][i]->GetOtherAtom(Walker);
-        if (OtherAtom == ListOfLocalAtoms[Binder->rightatom->nr]) { // found the bond
-          LocalStack->Push(ListOfBondsPerAtom[Walker->nr][i]);
-          *out << Verbose(3) << "Found local edge " << *(ListOfBondsPerAtom[Walker->nr][i]) << "." << endl;
+      for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
+        OtherAtom = (*Runner)->GetOtherAtom(Walker);
+        if (OtherAtom == ListOfLocalAtoms[(*Runner)->rightatom->nr]) { // found the bond
+          LocalStack->Push((*Runner));
+          *out << Verbose(3) << "Found local edge " << *(*Runner) << "." << endl;
           break;
         }
@@ -973 +918 @@
   class StackClass<atom *> *AtomStack = new StackClass<atom *>(AtomCount);
   atom *Walker = NULL, *OtherAtom = NULL;
-  bond *Binder = NULL;
 
   // add Root if not done yet
@@ -999 +943 @@
     // followed by n+1 till top of stack.
     Walker = AtomStack->PopFirst(); // pop oldest added
-    *out << Verbose(1) << "Current Walker is: " << Walker->Name << ", and has " << NumberOfBondsPerAtom[Walker->nr] << " bonds." << endl;
-    for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) {
-      Binder = ListOfBondsPerAtom[Walker->nr][i];
-      if (Binder != NULL) { // don't look at bond equal NULL
-        OtherAtom = Binder->GetOtherAtom(Walker);
-        *out << Verbose(2) << "Current OtherAtom is: " << OtherAtom->Name << " for bond " << *Binder << "." << endl;
+    *out << Verbose(1) << "Current Walker is: " << Walker->Name << ", and has " << Walker->ListOfBonds.size() << " bonds." << endl;
+    for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
+      if ((*Runner) != NULL) { // don't look at bond equal NULL
+        OtherAtom = (*Runner)->GetOtherAtom(Walker);
+        *out << Verbose(2) << "Current OtherAtom is: " << OtherAtom->Name << " for bond " << *(*Runner) << "." << endl;
         if (ColorList[OtherAtom->nr] == white) {
-          if (Binder != Bond) // let other atom white if it's via Root bond. In case it's cyclic it has to be reached again (yet Root is from OtherAtom already black, thus no problem)
+          if ((*Runner) != Bond) // let other atom white if it's via Root bond. In case it's cyclic it has to be reached again (yet Root is from OtherAtom already black, thus no problem)
             ColorList[OtherAtom->nr] = lightgray;
           PredecessorList[OtherAtom->nr] = Walker;  // Walker is the predecessor
           ShortestPathList[OtherAtom->nr] = ShortestPathList[Walker->nr]+1;
           *out << Verbose(2) << "Coloring OtherAtom " << OtherAtom->Name << " " << ((ColorList[OtherAtom->nr] == white) ? "white" : "lightgray") << ", its predecessor is " << Walker->Name << " and its Shortest Path is " << ShortestPathList[OtherAtom->nr] << " egde(s) long." << endl;
-          if ((((ShortestPathList[OtherAtom->nr] < BondOrder) && (Binder != Bond))) ) { // Check for maximum distance
+          if ((((ShortestPathList[OtherAtom->nr] < BondOrder) && ((*Runner) != Bond))) ) { // Check for maximum distance
             *out << Verbose(3);
             if (AddedAtomList[OtherAtom->nr] == NULL) { // add if it's not been so far
               AddedAtomList[OtherAtom->nr] = Mol->AddCopyAtom(OtherAtom);
               *out << "Added OtherAtom " << OtherAtom->Name;
-              AddedBondList[Binder->nr] = Mol->AddBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder->BondDegree);
-              AddedBondList[Binder->nr]->Cyclic = Binder->Cyclic;
-              AddedBondList[Binder->nr]->Type = Binder->Type;
-              *out << " and bond " << *(AddedBondList[Binder->nr]) << ", ";
+              AddedBondList[(*Runner)->nr] = Mol->CopyBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], (*Runner));
+              *out << " and bond " << *(AddedBondList[(*Runner)->nr]) << ", ";
             } else {  // this code should actually never come into play (all white atoms are not yet present in BondMolecule, that's why they are white in the first place)
               *out << "Not adding OtherAtom " << OtherAtom->Name;
-              if (AddedBondList[Binder->nr] == NULL) {
-                AddedBondList[Binder->nr] = Mol->AddBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder->BondDegree);
-                AddedBondList[Binder->nr]->Cyclic = Binder->Cyclic;
-                AddedBondList[Binder->nr]->Type = Binder->Type;
-                *out << ", added Bond " << *(AddedBondList[Binder->nr]);
+              if (AddedBondList[(*Runner)->nr] == NULL) {
+                AddedBondList[(*Runner)->nr] = Mol->CopyBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], (*Runner));
+                *out << ", added Bond " << *(AddedBondList[(*Runner)->nr]);
               } else
                 *out << ", not added Bond ";
@@ -1033 +972 @@
             AtomStack->Push(OtherAtom);
           } else { // out of bond order, then replace
-            if ((AddedAtomList[OtherAtom->nr] == NULL) && (Binder->Cyclic))
+            if ((AddedAtomList[OtherAtom->nr] == NULL) && ((*Runner)->Cyclic))
               ColorList[OtherAtom->nr] = white; // unmark if it has not been queued/added, to make it available via its other bonds (cyclic)
-            if (Binder == Bond)
+            if ((*Runner) == Bond)
               *out << Verbose(3) << "Not Queueing, is the Root bond";
             else if (ShortestPathList[OtherAtom->nr] >= BondOrder)
               *out << Verbose(3) << "Not Queueing, is out of Bond Count of " << BondOrder;
-            if (!Binder->Cyclic)
+            if (!(*Runner)->Cyclic)
               *out << ", is not part of a cyclic bond, saturating bond with Hydrogen." << endl;
-            if (AddedBondList[Binder->nr] == NULL) {
+            if (AddedBondList[(*Runner)->nr] == NULL) {
               if ((AddedAtomList[OtherAtom->nr] != NULL)) { // .. whether we add or saturate
-                AddedBondList[Binder->nr] = Mol->AddBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder->BondDegree);
-                AddedBondList[Binder->nr]->Cyclic = Binder->Cyclic;
-                AddedBondList[Binder->nr]->Type = Binder->Type;
+                AddedBondList[(*Runner)->nr] = Mol->CopyBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], (*Runner));
               } else {
 #ifdef ADDHYDROGEN
-                if (!Mol->AddHydrogenReplacementAtom(out, Binder, AddedAtomList[Walker->nr], Walker, OtherAtom, ListOfBondsPerAtom[Walker->nr], NumberOfBondsPerAtom[Walker->nr], IsAngstroem))
+                if (!Mol->AddHydrogenReplacementAtom(out, (*Runner), AddedAtomList[Walker->nr], Walker, OtherAtom, IsAngstroem))
                   exit(1);
 #endif
@@ -1057 +994 @@
           *out << Verbose(3) << "Not Adding, has already been visited." << endl;
           // This has to be a cyclic bond, check whether it's present ...
-          if (AddedBondList[Binder->nr] == NULL) {
-            if ((Binder != Bond) && (Binder->Cyclic) && (((ShortestPathList[Walker->nr]+1) < BondOrder))) {
-              AddedBondList[Binder->nr] = Mol->AddBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder->BondDegree);
-              AddedBondList[Binder->nr]->Cyclic = Binder->Cyclic;
-              AddedBondList[Binder->nr]->Type = Binder->Type;
+          if (AddedBondList[(*Runner)->nr] == NULL) {
+            if (((*Runner) != Bond) && ((*Runner)->Cyclic) && (((ShortestPathList[Walker->nr]+1) < BondOrder))) {
+              AddedBondList[(*Runner)->nr] = Mol->CopyBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], (*Runner));
             } else { // if it's root bond it has to broken (otherwise we would not create the fragments)
 #ifdef ADDHYDROGEN
-              if(!Mol->AddHydrogenReplacementAtom(out, Binder, AddedAtomList[Walker->nr], Walker, OtherAtom, ListOfBondsPerAtom[Walker->nr], NumberOfBondsPerAtom[Walker->nr], IsAngstroem))
+              if(!Mol->AddHydrogenReplacementAtom(out, (*Runner), AddedAtomList[Walker->nr], Walker, OtherAtom, IsAngstroem))
                 exit(1);
 #endif
@@ -1080 +1015 @@
   delete(AtomStack);
 };
+
+/** Adds a bond as a copy to a given one
+ * \param *left leftatom of new bond
+ * \param *right rightatom of new bond
+ * \param *CopyBond rest of fields in bond are copied from this
+ * \return pointer to new bond
+ */
+bond * molecule::CopyBond(atom *left, atom *right, bond *CopyBond)
+{
+  bond *Binder = AddBond(left, right, CopyBond->BondDegree);
+  Binder->Cyclic = CopyBond->Cyclic;
+  Binder->Type = CopyBond->Type;
+  return Binder;
+};
+
 
 /** Adds bond structure to this molecule from \a Father molecule.
@@ -1122 +1072 @@
         status = false;
       } else {
-        for (int i=0;i<Father->NumberOfBondsPerAtom[Walker->nr];i++) {
-          OtherAtom = Father->ListOfBondsPerAtom[Walker->nr][i]->GetOtherAtom(Walker);
+        for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
+          OtherAtom = (*Runner)->GetOtherAtom(Walker);
           if (ParentList[OtherAtom->nr] != NULL) { // if otheratom is also a father of an atom on this molecule, create the bond
-            *out << Verbose(4) << "Endpoints of Bond " << Father->ListOfBondsPerAtom[Walker->nr][i] << " are both present: " << ParentList[Walker->nr]->Name << " and " << ParentList[OtherAtom->nr]->Name << "." << endl;
-            AddBond(ParentList[Walker->nr], ParentList[OtherAtom->nr], Father->ListOfBondsPerAtom[Walker->nr][i]->BondDegree);
+            *out << Verbose(4) << "Endpoints of Bond " << (*Runner) << " are both present: " << ParentList[Walker->nr]->Name << " and " << ParentList[OtherAtom->nr]->Name << "." << endl;
+            AddBond(ParentList[Walker->nr], ParentList[OtherAtom->nr], (*Runner)->BondDegree);
           }
         }
@@ -1164 +1114 @@
       for(KeySet::iterator runners = Fragment->begin(); runners != Fragment->end(); runners++) {
         Walker2 = FindAtom(*runners);
-        for (int i=0;i<NumberOfBondsPerAtom[Walker->nr]; i++) {
-          if (ListOfBondsPerAtom[Walker->nr][i]->GetOtherAtom(Walker) == Walker2) {
+        for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
+          if ((*Runner)->GetOtherAtom(Walker) == Walker2) {
             BondStatus = true;
             break;