Changeset 9eefda for src

Timestamp:

Oct 18, 2009, 7:58:38 PM (15 years ago)

Author:

Frederik Heber <heber@…>

Branches:

Action_Thermostats, Add_AtomRandomPerturbation, Add_FitFragmentPartialChargesAction, Add_RotateAroundBondAction, Add_SelectAtomByNameAction, Added_ParseSaveFragmentResults, AddingActions_SaveParseParticleParameters, Adding_Graph_to_ChangeBondActions, Adding_MD_integration_tests, Adding_ParticleName_to_Atom, Adding_StructOpt_integration_tests, AtomFragments, Automaking_mpqc_open, AutomationFragmentation_failures, Candidate_v1.5.4, Candidate_v1.6.0, Candidate_v1.6.1, ChangeBugEmailaddress, ChangingTestPorts, ChemicalSpaceEvaluator, CombiningParticlePotentialParsing, Combining_Subpackages, Debian_Package_split, Debian_package_split_molecuildergui_only, Disabling_MemDebug, Docu_Python_wait, EmpiricalPotential_contain_HomologyGraph, EmpiricalPotential_contain_HomologyGraph_documentation, Enable_parallel_make_install, Enhance_userguide, Enhanced_StructuralOptimization, Enhanced_StructuralOptimization_continued, Example_ManyWaysToTranslateAtom, Exclude_Hydrogens_annealWithBondGraph, FitPartialCharges_GlobalError, Fix_BoundInBox_CenterInBox_MoleculeActions, Fix_ChargeSampling_PBC, Fix_ChronosMutex, Fix_FitPartialCharges, Fix_FitPotential_needs_atomicnumbers, Fix_ForceAnnealing, Fix_IndependentFragmentGrids, Fix_ParseParticles, Fix_ParseParticles_split_forward_backward_Actions, Fix_PopActions, Fix_QtFragmentList_sorted_selection, Fix_Restrictedkeyset_FragmentMolecule, Fix_StatusMsg, Fix_StepWorldTime_single_argument, Fix_Verbose_Codepatterns, Fix_fitting_potentials, Fixes, ForceAnnealing_goodresults, ForceAnnealing_oldresults, ForceAnnealing_tocheck, ForceAnnealing_with_BondGraph, ForceAnnealing_with_BondGraph_continued, ForceAnnealing_with_BondGraph_continued_betteresults, ForceAnnealing_with_BondGraph_contraction-expansion, FragmentAction_writes_AtomFragments, FragmentMolecule_checks_bonddegrees, GeometryObjects, Gui_Fixes, Gui_displays_atomic_force_velocity, ImplicitCharges, IndependentFragmentGrids, IndependentFragmentGrids_IndividualZeroInstances, IndependentFragmentGrids_IntegrationTest, IndependentFragmentGrids_Sole_NN_Calculation, JobMarket_RobustOnKillsSegFaults, JobMarket_StableWorkerPool, JobMarket_unresolvable_hostname_fix, MoreRobust_FragmentAutomation, ODR_violation_mpqc_open, PartialCharges_OrthogonalSummation, PdbParser_setsAtomName, PythonUI_with_named_parameters, QtGui_reactivate_TimeChanged_changes, Recreated_GuiChecks, Rewrite_FitPartialCharges, RotateToPrincipalAxisSystem_UndoRedo, SaturateAtoms_findBestMatching, SaturateAtoms_singleDegree, StoppableMakroAction, Subpackage_CodePatterns, Subpackage_JobMarket, Subpackage_LinearAlgebra, Subpackage_levmar, Subpackage_mpqc_open, Subpackage_vmg, Switchable_LogView, ThirdParty_MPQC_rebuilt_buildsystem, TrajectoryDependenant_MaxOrder, TremoloParser_IncreasedPrecision, TremoloParser_MultipleTimesteps, TremoloParser_setsAtomName, Ubuntu_1604_changes, stable

Children:

4455f4

Parents:

43587e

git-author:

Frederik Heber <heber@…> (10/18/09 19:41:20)

git-committer:

Frederik Heber <heber@…> (10/18/09 19:58:38)

Message:

Added BFSAccounting and DFSAccounting structures and all functions use these. Added documentation to each of the new functions of previous commits.

• renamed DFS: DepthFirstSearchAnalysis_SetWalkersGraphNr(), DepthFirstSearchAnalysis_ProbeAlongUnusedBond(), DepthFirstSearchAnalysis_CheckForaNewComponent(), DepthFirstSearchAnalysis_CleanRootStackDownTillWalker()
• new DFS: DepthFirstSearchAnalysis_Finalize(), DepthFirstSearchAnalysis_Init()
• rewritten DFS: DepthFirstSearchAnalysis() - uses DFSAccounting and above functions,
• changed&renamed BFS: InitializeBFSAccounting(), FinalizeBFSAccounting(), CleanBFSAccounting(), ResetBFSAccounting()
• renamed BFS: CyclicStructureAnalysis_CyclicBFSFromRootToRoot(), CyclicStructureAnalysis_RetrieveCycleMembers(), CyclicStructureAnalysis_BFSToNextCycle(), CyclicStructureAnalysis_AssignRingSizetoNonCycleMembers()
• changed BFS: BackEdge dropped from CyclicStructureAnalysis_BFSToNextCycle(), CyclicStructureAnalysis_AssignRingSizetoNonCycleMembers()

File:

• src/molecule_graph.cpp (modified) (69 diffs)

src/molecule_graph.cpp

@@ -16 +16 @@
 #include "molecule.hpp"
 
+struct BFSAccounting
+{
+  atom **PredecessorList;
+  int *ShortestPathList;
+  enum Shading *ColorList;
+  class StackClass<atom *> *BFSStack;
+  class StackClass<atom *> *TouchedStack;
+  int AtomCount;
+  int BondOrder;
+  atom *Root;
+  bool BackStepping;
+  int CurrentGraphNr;
+  int ComponentNr;
+};
+
+/** Accounting data for Depth First Search.
+ */
+struct DFSAccounting
+{
+  class StackClass<atom *> *AtomStack;
+  class StackClass<bond *> *BackEdgeStack;
+  int CurrentGraphNr;
+  int ComponentNumber;
+  atom *Root;
+  bool BackStepping;
+};
+
 /************************************* Functions for class molecule *********************************/
-
 
 /** Creates an adjacency list of the molecule.
@@ -29 +55 @@
   atom *Walker, *OtherWalker;
 
-  if (!input)
-  {
+  if (!input) {
     cout << Verbose(1) << "Opening silica failed \n";
   };
@@ -42 +67 @@
     *input >> ws >> atom2;
 
-    if(atom2<atom1) //Sort indices of atoms in order
+    if (atom2 < atom1) //Sort indices of atoms in order
       flip(atom1, atom2);
-    Walker=FindAtom(atom1);
-    OtherWalker=FindAtom(atom2);
+    Walker = FindAtom(atom1);
+    OtherWalker = FindAtom(atom2);
     AddBond(Walker, OtherWalker); //Add the bond between the two atoms with respective indices.
   }
-};
-
+}
+;
 
 /** Creates an adjacency list of the molecule.
@@ -83 +108 @@
   *out << Verbose(0) << "Begin of CreateAdjacencyList." << endl;
   // remove every bond from the list
-  if ((first->next != last) && (last->previous != first)) {  // there are bonds present
-    cleanup(first,last);
+  if ((first->next != last) && (last->previous != first)) { // there are bonds present
+    cleanup(first, last);
   }
 
@@ -95 +120 @@
 
     // create a list to map Tesselpoint::nr to atom *
-    AtomMap = Malloc<atom *>(AtomCount, "molecule::CreateAdjacencyList - **AtomCount");
+    AtomMap = Malloc<atom *> (AtomCount, "molecule::CreateAdjacencyList - **AtomCount");
     Walker = start;
     while (Walker->next != end) {
@@ -113 +138 @@
               //*out << Verbose(0) << "Current Atom is " << *Walker << "." << endl;
               // 3c. check for possible bond between each atom in this and every one in the 27 cells
-              for (n[0]=-1;n[0]<=1;n[0]++)
-                for (n[1]=-1;n[1]<=1;n[1]++)
-                  for (n[2]=-1;n[2]<=1;n[2]++) {
+              for (n[0] = -1; n[0] <= 1; n[0]++)
+                for (n[1] = -1; n[1] <= 1; n[1]++)
+                  for (n[2] = -1; n[2] <= 1; n[2]++) {
                     OtherList = LC->GetRelativeToCurrentCell(n);
                     //*out << Verbose(2) << "Current relative cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << " containing " << List->size() << " points." << endl;
@@ -124 +149 @@
                           //*out << Verbose(1) << "Checking distance " << OtherWalker->x.PeriodicDistanceSquared(&(Walker->x), cell_size) << " against typical bond length of " << bonddistance*bonddistance << "." << endl;
                           MinDistance = OtherWalker->type->CovalentRadius + Walker->type->CovalentRadius;
-                          MinDistance *= (IsAngstroem) ? 1. : 1./AtomicLengthToAngstroem;
+                          MinDistance *= (IsAngstroem) ? 1. : 1. / AtomicLengthToAngstroem;
                           MaxDistance = MinDistance + BONDTHRESHOLD;
                           MinDistance -= BONDTHRESHOLD;
                           distance = OtherWalker->x.PeriodicDistanceSquared(&(Walker->x), cell_size);
-                          if ((OtherWalker->father->nr > Walker->father->nr) && (distance <= MaxDistance*MaxDistance) && (distance >= MinDistance*MinDistance)) { // create bond if distance is smaller
+                          if ((OtherWalker->father->nr > Walker->father->nr) && (distance <= MaxDistance * MaxDistance) && (distance >= MinDistance * MinDistance)) { // create bond if distance is smaller
                             //*out << Verbose(1) << "Adding Bond between " << *Walker << " and " << *OtherWalker << " in distance " << sqrt(distance) << "." << endl;
-                            AddBond(Walker->father, OtherWalker->father, 1);  // also increases molecule::BondCount
+                            AddBond(Walker->father, OtherWalker->father, 1); // also increases molecule::BondCount
                           } else {
                             //*out << Verbose(1) << "Not Adding: Wrong label order or distance too great." << endl;
@@ -142 +167 @@
         }
     Free(&AtomMap);
-    delete(LC);
+    delete (LC);
     *out << Verbose(1) << "I detected " << BondCount << " bonds in the molecule with distance " << BondDistance << "." << endl;
 
@@ -149 +174 @@
 
     // output bonds for debugging (if bond chain list was correctly installed)
-    ActOnAllAtoms( &atom::OutputBondOfAtom, out );
+    ActOnAllAtoms(&atom::OutputBondOfAtom, out);
   } else
     *out << Verbose(1) << "AtomCount is " << AtomCount << ", thus no bonds, no connections!." << endl;
   *out << Verbose(0) << "End of CreateAdjacencyList." << endl;
-};
+}
+;
 
 /** Prints a list of all bonds to \a *out.
@@ -162 +188 @@
   *out << Verbose(1) << endl << "From contents of bond chain list:";
   bond *Binder = first;
-  while(Binder->next != last) {
+  while (Binder->next != last) {
     Binder = Binder->next;
     *out << *Binder << "\t" << endl;
   }
   *out << endl;
-};
+}
+;
 
 /** correct bond degree by comparing valence and bond degree.
@@ -184 +211 @@
     *out << Verbose(1) << "Correcting Bond degree of each bond ... " << endl;
     do {
-      No = SumPerAtom( &atom::CorrectBondDegree, out );
+      No = SumPerAtom(&atom::CorrectBondDegree, out);
     } while (No);
     *out << " done." << endl;
@@ -193 +220 @@
 
   return (No);
-};
+}
+;
 
 /** Counts all cyclic bonds and returns their number.
@@ -212 +240 @@
     while (Subgraphs->next != NULL) {
       Subgraphs = Subgraphs->next;
-      delete(Subgraphs->previous);
-    }
-    delete(Subgraphs);
-    delete[](MinimumRingSize);
-  }
-  while(Binder->next != last) {
+      delete (Subgraphs->previous);
+    }
+    delete (Subgraphs);
+    delete[] (MinimumRingSize);
+  }
+  while (Binder->next != last) {
     Binder = Binder->next;
     if (Binder->Cyclic)
       NoCyclicBonds++;
   }
-  delete(BackEdgeStack);
+  delete (BackEdgeStack);
   return NoCyclicBonds;
-};
-
+}
+;
 
 /** Returns Shading as a char string.
@@ -233 +261 @@
 string molecule::GetColor(enum Shading color)
 {
-  switch(color) {
+  switch (color) {
     case white:
       return "white";
@@ -250 +278 @@
       break;
   };
-};
-
-void SetWalkersGraphNr(ofstream *out, bool &BackStepping, atom *&Walker, int &CurrentGraphNr, class StackClass<atom *> *&AtomStack)
-{
-  if (!BackStepping) { // if we don't just return from (8)
-    Walker->GraphNr = CurrentGraphNr;
-    Walker->LowpointNr = CurrentGraphNr;
+}
+;
+
+/** Sets atom::GraphNr and atom::LowpointNr to BFSAccounting::CurrentGraphNr.
+ * \param *out output stream for debugging
+ * \param *Walker current node
+ * \param &BFS structure with accounting data for BFS
+ */
+void DepthFirstSearchAnalysis_SetWalkersGraphNr(ofstream *out, atom *&Walker, struct DFSAccounting &DFS)
+{
+  if (!DFS.BackStepping) { // if we don't just return from (8)
+    Walker->GraphNr = DFS.CurrentGraphNr;
+    Walker->LowpointNr = DFS.CurrentGraphNr;
     *out << Verbose(1) << "Setting Walker[" << Walker->Name << "]'s number to " << Walker->GraphNr << " with Lowpoint " << Walker->LowpointNr << "." << endl;
-    AtomStack->Push(Walker);
-    CurrentGraphNr++;
-  }
-};
-
-void ProbeAlongUnusedBond(ofstream *out, molecule *mol, bond *&Binder, bool &BackStepping, atom *&Walker, class StackClass<bond *> *&BackEdgeStack)
+    DFS.AtomStack->Push(Walker);
+    DFS.CurrentGraphNr++;
+  }
+}
+;
+
+/** During DFS goes along unvisited bond and touches other atom.
+ * Sets bond::type, if
+ *  -# BackEdge: set atom::LowpointNr and push on \a BackEdgeStack
+ *  -# TreeEgde: set atom::Ancestor and continue with Walker along this edge
+ * Continue until molecule::FindNextUnused() finds no more unused bonds.
+ * \param *out output stream for debugging
+ * \param *mol molecule with atoms and finding unused bonds
+ * \param *&Binder current edge
+ * \param &DFS DFS accounting data
+ */
+void DepthFirstSearchAnalysis_ProbeAlongUnusedBond(ofstream *out, molecule *mol, atom *&Walker, bond *&Binder, struct DFSAccounting &DFS)
 {
   atom *OtherAtom = NULL;
 
   do { // (3) if Walker has no unused egdes, go to (5)
-    BackStepping = false; // reset backstepping flag for (8)
+    DFS.BackStepping = false; // reset backstepping flag for (8)
     if (Binder == NULL) // if we don't just return from (11), Binder is already set to next unused
       Binder = mol->FindNextUnused(Walker);
@@ -281 +326 @@
       // (4a) ... if "other" atom has been visited (GraphNr != 0), set lowpoint to minimum of both, go to (3)
       Binder->Type = BackEdge;
-      BackEdgeStack->Push(Binder);
-      Walker->LowpointNr = ( Walker->LowpointNr < OtherAtom->GraphNr ) ? Walker->LowpointNr : OtherAtom->GraphNr;
+      DFS.BackEdgeStack->Push(Binder);
+      Walker->LowpointNr = (Walker->LowpointNr < OtherAtom->GraphNr) ? Walker->LowpointNr : OtherAtom->GraphNr;
       *out << Verbose(3) << "(4a) Visited: Setting Lowpoint of Walker[" << Walker->Name << "] to " << Walker->LowpointNr << "." << endl;
     } else {
@@ -293 +338 @@
     }
     Binder = NULL;
-  } while (1);  // (3)
-};
-
-void CheckForaNewComponent(ofstream *out, molecule *mol, bool &BackStepping, atom *&Walker, atom *&Root, int &ComponentNumber, class StackClass<atom *> *&AtomStack, MoleculeLeafClass *&LeafWalker )
+  } while (1); // (3)
+}
+;
+
+/** Checks whether we have a new component.
+ * if atom::LowpointNr of \a *&Walker is greater than atom::GraphNr of its atom::Ancestor, we have a new component.
+ * Meaning that if we touch upon a node who suddenly has a smaller atom::LowpointNr than its ancestor, then we
+ * have a found a new branch in the graph tree.
+ * \param *out output stream for debugging
+ * \param *mol molecule with atoms and finding unused bonds
+ * \param *&Walker current node
+ * \param &DFS DFS accounting data
+ */
+void DepthFirstSearchAnalysis_CheckForaNewComponent(ofstream *out, molecule *mol, atom *&Walker, struct DFSAccounting &DFS, MoleculeLeafClass *&LeafWalker)
 {
   atom *OtherAtom = NULL;
@@ -303 +358 @@
   *out << Verbose(1) << "(5) Number of Walker[" << Walker->Name << "]'s Ancestor[" << Walker->Ancestor->Name << "] is " << Walker->Ancestor->GraphNr << "." << endl;
 
-  if (Walker->Ancestor->GraphNr != Root->GraphNr) {
+  if (Walker->Ancestor->GraphNr != DFS.Root->GraphNr) {
     // (6)  (Ancestor of Walker is not Root)
     if (Walker->LowpointNr < Walker->Ancestor->GraphNr) {
@@ -313 +368 @@
       Walker->Ancestor->SeparationVertex = true;
       *out << Verbose(2) << "(7) Walker[" << Walker->Name << "]'s Ancestor[" << Walker->Ancestor->Name << "]'s is a separating vertex, creating component." << endl;
-      mol->SetNextComponentNumber(Walker->Ancestor, ComponentNumber);
-      *out << Verbose(3) << "(7) Walker[" << Walker->Name << "]'s Ancestor's Compont is " << ComponentNumber << "." << endl;
-      mol->SetNextComponentNumber(Walker, ComponentNumber);
-      *out << Verbose(3) << "(7) Walker[" << Walker->Name << "]'s Compont is " << ComponentNumber << "." << endl;
+      mol->SetNextComponentNumber(Walker->Ancestor, DFS.ComponentNumber);
+      *out << Verbose(3) << "(7) Walker[" << Walker->Name << "]'s Ancestor's Compont is " << DFS.ComponentNumber << "." << endl;
+      mol->SetNextComponentNumber(Walker, DFS.ComponentNumber);
+      *out << Verbose(3) << "(7) Walker[" << Walker->Name << "]'s Compont is " << DFS.ComponentNumber << "." << endl;
       do {
-        OtherAtom = AtomStack->PopLast();
+        OtherAtom = DFS.AtomStack->PopLast();
         LeafWalker->Leaf->AddCopyAtom(OtherAtom);
-        mol->SetNextComponentNumber(OtherAtom, ComponentNumber);
-        *out << Verbose(3) << "(7) Other[" << OtherAtom->Name << "]'s Compont is " << ComponentNumber << "." << endl;
+        mol->SetNextComponentNumber(OtherAtom, DFS.ComponentNumber);
+        *out << Verbose(3) << "(7) Other[" << OtherAtom->Name << "]'s Compont is " << DFS.ComponentNumber << "." << endl;
       } while (OtherAtom != Walker);
-      ComponentNumber++;
+      DFS.ComponentNumber++;
     }
     // (8) Walker becomes its Ancestor, go to (3)
     *out << Verbose(2) << "(8) Walker[" << Walker->Name << "] is now its Ancestor " << Walker->Ancestor->Name << ", backstepping. " << endl;
     Walker = Walker->Ancestor;
-    BackStepping = true;
-  }
-};
-
-void CleanRootStackDownTillWalker(ofstream *out, molecule *mol, bool &BackStepping, atom *&Root, atom *&Walker, bond *&Binder, int &ComponentNumber, class StackClass<atom *> *&AtomStack, MoleculeLeafClass *&LeafWalker)
+    DFS.BackStepping = true;
+  }
+}
+;
+
+/** Cleans the root stack when we have found a component.
+ * If we are not DFSAccounting::BackStepping, then we clear the root stack by putting everything into a
+ * component down till we meet DFSAccounting::Root.
+ * \param *out output stream for debugging
+ * \param *mol molecule with atoms and finding unused bonds
+ * \param *&Walker current node
+ * \param *&Binder current edge
+ * \param &DFS DFS accounting data
+ */
+void DepthFirstSearchAnalysis_CleanRootStackDownTillWalker(ofstream *out, molecule *mol, atom *&Walker, bond *&Binder, struct DFSAccounting &DFS, MoleculeLeafClass *&LeafWalker)
 {
   atom *OtherAtom = NULL;
 
-  if (!BackStepping) {  // coming from (8) want to go to (3)
+  if (!DFS.BackStepping) { // coming from (8) want to go to (3)
     // (9) remove all from stack till Walker (including), these and Root form a component
-    AtomStack->Output(out);
-    mol->SetNextComponentNumber(Root, ComponentNumber);
-    *out << Verbose(3) << "(9) Root[" << Root->Name << "]'s Component is " << ComponentNumber << "." << endl;
-    mol->SetNextComponentNumber(Walker, ComponentNumber);
-    *out << Verbose(3) << "(9) Walker[" << Walker->Name << "]'s Component is " << ComponentNumber << "." << endl;
+    DFS.AtomStack->Output(out);
+    mol->SetNextComponentNumber(DFS.Root, DFS.ComponentNumber);
+    *out << Verbose(3) << "(9) Root[" << DFS.Root->Name << "]'s Component is " << DFS.ComponentNumber << "." << endl;
+    mol->SetNextComponentNumber(Walker, DFS.ComponentNumber);
+    *out << Verbose(3) << "(9) Walker[" << Walker->Name << "]'s Component is " << DFS.ComponentNumber << "." << endl;
     do {
-      OtherAtom = AtomStack->PopLast();
+      OtherAtom = DFS.AtomStack->PopLast();
       LeafWalker->Leaf->AddCopyAtom(OtherAtom);
-      mol->SetNextComponentNumber(OtherAtom, ComponentNumber);
-      *out << Verbose(3) << "(7) Other[" << OtherAtom->Name << "]'s Compont is " << ComponentNumber << "." << endl;
+      mol->SetNextComponentNumber(OtherAtom, DFS.ComponentNumber);
+      *out << Verbose(3) << "(7) Other[" << OtherAtom->Name << "]'s Compont is " << DFS.ComponentNumber << "." << endl;
     } while (OtherAtom != Walker);
-    ComponentNumber++;
+    DFS.ComponentNumber++;
 
     // (11) Root is separation vertex,  set Walker to Root and go to (4)
-    Walker = Root;
+    Walker = DFS.Root;
     Binder = mol->FindNextUnused(Walker);
-    *out << Verbose(1) << "(10) Walker is Root[" << Root->Name << "], next Unused Bond is " << Binder << "." << endl;
+    *out << Verbose(1) << "(10) Walker is Root[" << DFS.Root->Name << "], next Unused Bond is " << Binder << "." << endl;
     if (Binder != NULL) { // Root is separation vertex
       *out << Verbose(1) << "(11) Root is a separation vertex." << endl;
@@ -360 +425 @@
     }
   }
-};
-
+}
+;
+
+/** Initializes DFSAccounting structure.
+ * \param *out output stream for debugging
+ * \param &DFS accounting structure to allocate
+ * \param AtomCount number of nodes in graph
+ * \param BondCount number of edges in graph
+ */
+void DepthFirstSearchAnalysis_Init(ofstream *out, struct DFSAccounting &DFS, int AtomCount, int BondCount)
+{
+  DFS.AtomStack = new StackClass<atom *> (AtomCount);
+  DFS.CurrentGraphNr = 0;
+  DFS.ComponentNumber = 0;
+  DFS.BackStepping = false;
+}
+;
+
+/** Free's DFSAccounting structure.
+ * \param *out output stream for debugging
+ * \param &DFS accounting structure to free
+ */
+void DepthFirstSearchAnalysis_Finalize(ofstream *out, struct DFSAccounting &DFS)
+{
+  delete (DFS.AtomStack);
+}
+;
 
 /** Performs a Depth-First search on this molecule.
@@ -373 +463 @@
 MoleculeLeafClass * molecule::DepthFirstSearchAnalysis(ofstream *out, class StackClass<bond *> *&BackEdgeStack)
 {
-  class StackClass<atom *> *AtomStack = new StackClass<atom *>(AtomCount);
+  struct DFSAccounting DFS;
   BackEdgeStack = new StackClass<bond *> (BondCount);
+  DFS.BackEdgeStack = BackEdgeStack;
   MoleculeLeafClass *SubGraphs = new MoleculeLeafClass(NULL);
   MoleculeLeafClass *LeafWalker = SubGraphs;
-  int CurrentGraphNr = 0, OldGraphNr;
-  int ComponentNumber = 0;
+  int OldGraphNr = 0;
   atom *Walker = NULL;
-  atom *Root = start->next;
   bond *Binder = NULL;
-  bool BackStepping = false;
 
   *out << Verbose(0) << "Begin of DepthFirstSearchAnalysis" << endl;
+  DepthFirstSearchAnalysis_Init(out, DFS, AtomCount, BondCount);
+  DFS.Root = start->next;
 
   ResetAllBondsToUnused();
-  SetAtomValueToValue( -1, &atom::GraphNr );
-  ActOnAllAtoms( &atom::InitComponentNr );
-  BackEdgeStack->ClearStack();
-  while (Root != end) { // if there any atoms at all
+  SetAtomValueToValue(-1, &atom::GraphNr);
+  ActOnAllAtoms(&atom::InitComponentNr);
+  DFS.BackEdgeStack->ClearStack();
+  while (DFS.Root != end) { // if there any atoms at all
     // (1) mark all edges unused, empty stack, set atom->GraphNr = 0 for all
-    AtomStack->ClearStack();
+    DFS.AtomStack->ClearStack();
 
     // put into new subgraph molecule and add this to list of subgraphs
     LeafWalker = new MoleculeLeafClass(LeafWalker);
     LeafWalker->Leaf = new molecule(elemente);
-    LeafWalker->Leaf->AddCopyAtom(Root);
-
-    OldGraphNr = CurrentGraphNr;
-    Walker = Root;
+    LeafWalker->Leaf->AddCopyAtom(DFS.Root);
+
+    OldGraphNr = DFS.CurrentGraphNr;
+    Walker = DFS.Root;
     do { // (10)
       do { // (2) set number and Lowpoint of Atom to i, increase i, push current atom
-        SetWalkersGraphNr(out, BackStepping, Walker, CurrentGraphNr, AtomStack);
-
-        ProbeAlongUnusedBond(out, this, Binder, BackStepping, Walker, BackEdgeStack);
+        DepthFirstSearchAnalysis_SetWalkersGraphNr(out, Walker, DFS);
+
+        DepthFirstSearchAnalysis_ProbeAlongUnusedBond(out, this, Walker, Binder, DFS);
 
         if (Binder == NULL) {
@@ -412 +502 @@
         } else
           Binder = NULL;
-      } while (1);  // (2)
+      } while (1); // (2)
 
       // if we came from backstepping, yet there were no more unused bonds, we end up here with no Ancestor, because Walker is Root! Then we are finished!
-      if ((Walker == Root) && (Binder == NULL))
+      if ((Walker == DFS.Root) && (Binder == NULL))
         break;
 
-      CheckForaNewComponent(out, this, BackStepping, Walker, Root,ComponentNumber, AtomStack, LeafWalker );
-
-      CleanRootStackDownTillWalker(out, this, BackStepping, Root, Walker, Binder, ComponentNumber, AtomStack, LeafWalker);
-
-    } while ((BackStepping) || (Binder != NULL)); // (10) halt only if Root has no unused edges
+      DepthFirstSearchAnalysis_CheckForaNewComponent(out, this, Walker, DFS, LeafWalker);
+
+      DepthFirstSearchAnalysis_CleanRootStackDownTillWalker(out, this, Walker, Binder, DFS, LeafWalker);
+
+    } while ((DFS.BackStepping) || (Binder != NULL)); // (10) halt only if Root has no unused edges
 
     // From OldGraphNr to CurrentGraphNr ranges an disconnected subgraph
-    *out << Verbose(0) << "Disconnected subgraph ranges from " << OldGraphNr << " to " << CurrentGraphNr << "." << endl;
+    *out << Verbose(0) << "Disconnected subgraph ranges from " << OldGraphNr << " to " << DFS.CurrentGraphNr << "." << endl;
     LeafWalker->Leaf->Output(out);
     *out << endl;
 
     // step on to next root
-    while ((Root != end) && (Root->GraphNr != -1)) {
+    while ((DFS.Root != end) && (DFS.Root->GraphNr != -1)) {
       //*out << Verbose(1) << "Current next subgraph root candidate is " << Root->Name << "." << endl;
-      if (Root->GraphNr != -1) // if already discovered, step on
-        Root = Root->next;
+      if (DFS.Root->GraphNr != -1) // if already discovered, step on
+        DFS.Root = DFS.Root->next;
     }
   }
@@ -444 +534 @@
 
   // free all and exit
-  delete(AtomStack);
+  DepthFirstSearchAnalysis_Finalize(out, DFS);
   *out << Verbose(0) << "End of DepthFirstSearchAnalysis" << endl;
   return SubGraphs;
-};
+}
+;
 
 /** Scans through all bonds and set bond::Cyclic to true where atom::LowpointNr of both ends is equal: LP criterion.
@@ -455 +546 @@
   NoCyclicBonds = 0;
   bond *Binder = first;
-  while(Binder->next != last) {
+  while (Binder->next != last) {
     Binder = Binder->next;
     if (Binder->rightatom->LowpointNr == Binder->leftatom->LowpointNr) { // cyclic ??
@@ -462 +553 @@
     }
   }
-};
+}
+;
 
 /** Output graph information per atom.
@@ -470 +562 @@
 {
   *out << Verbose(1) << "Final graph info for each atom is:" << endl;
-  ActOnAllAtoms( &atom::OutputGraphInfo, out );
-};
+  ActOnAllAtoms(&atom::OutputGraphInfo, out);
+}
+;
 
 /** Output graph information per bond.
@@ -480 +573 @@
   *out << Verbose(1) << "Final graph info for each bond is:" << endl;
   bond *Binder = first;
-  while(Binder->next != last) {
+  while (Binder->next != last) {
     Binder = Binder->next;
     *out << Verbose(2) << ((Binder->Type == TreeEdge) ? "TreeEdge " : "BackEdge ") << *Binder << ": <";
@@ -492 +585 @@
       *out << Verbose(3) << "Lowpoint at each side are equal: CYCLIC!" << endl;
   }
+}
+;
+
+/** Initialise each vertex as white with no predecessor, empty queue, color Root lightgray.
+ * \param *out output stream for debugging
+ * \param &BFS accounting structure
+ * \param AtomCount number of entries in the array to allocate
+ */
+void InitializeBFSAccounting(ofstream *out, struct BFSAccounting &BFS, int AtomCount)
+{
+  BFS.AtomCount = AtomCount;
+  BFS.PredecessorList = Malloc<atom*> (AtomCount, "molecule::BreadthFirstSearchAdd_Init: **PredecessorList");
+  BFS.ShortestPathList = Malloc<int> (AtomCount, "molecule::BreadthFirstSearchAdd_Init: *ShortestPathList");
+  BFS.ColorList = Malloc<enum Shading> (AtomCount, "molecule::BreadthFirstSearchAdd_Init: *ColorList");
+  BFS.BFSStack = new StackClass<atom *> (AtomCount);
+
+  for (int i = AtomCount; i--;) {
+    BFS.PredecessorList[i] = NULL;
+    BFS.ShortestPathList[i] = -1;
+    BFS.ColorList[i] = white;
+  }
 };
 
-/**  initialise each vertex as white with no predecessor, empty queue, color Root lightgray.
- *
- */
-void InitializeAccounting(atom **&PredecessorList, int *&ShortestPathList, enum Shading *&ColorList, int AtomCount)
-{
-  for (int i=AtomCount;i--;) {
-    PredecessorList[i] = NULL;
-    ShortestPathList[i] = -1;
-    ColorList[i] = white;
-  }
+/** Free's accounting structure.
+ * \param *out output stream for debugging
+ * \param &BFS accounting structure
+ */
+void FinalizeBFSAccounting(ofstream *out, struct BFSAccounting &BFS)
+{
+  Free(&BFS.PredecessorList);
+  Free(&BFS.ShortestPathList);
+  Free(&BFS.ColorList);
+  delete (BFS.BFSStack);
+  BFS.AtomCount = 0;
 };
 
-void ResetAccounting(atom *&Walker, class StackClass<atom *> *&TouchedStack, int *&ShortestPathList, class StackClass<atom *> *&BFSStack)
-{
-  ShortestPathList[Walker->nr] = 0;
-  BFSStack->ClearStack();  // start with empty BFS stack
-  BFSStack->Push(Walker);
-  TouchedStack->Push(Walker);
+/** Clean the accounting structure.
+ * \param *out output stream for debugging
+ * \param &BFS accounting structure
+ */
+void CleanBFSAccounting(ofstream *out, struct BFSAccounting &BFS)
+{
+  atom *Walker = NULL;
+  while (!BFS.TouchedStack->IsEmpty()) {
+    Walker = BFS.TouchedStack->PopFirst();
+    BFS.PredecessorList[Walker->nr] = NULL;
+    BFS.ShortestPathList[Walker->nr] = -1;
+    BFS.ColorList[Walker->nr] = white;
+  }
 };
 
-void CyclicBFSFromRootToRoot(ofstream *out, atom *&Root, bond *&BackEdge, class StackClass<atom *> *&TouchedStack, int *&ShortestPathList, atom **&PredecessorList, class StackClass<atom *> *&BFSStack, enum Shading *&ColorList)
+/** Resets shortest path list and BFSStack.
+ * \param *out output stream for debugging
+ * \param *&Walker current node, pushed onto BFSAccounting::BFSStack and BFSAccounting::TouchedStack
+ * \param &BFS accounting structure
+ */
+void ResetBFSAccounting(ofstream *out, atom *&Walker, struct BFSAccounting &BFS)
+{
+  BFS.ShortestPathList[Walker->nr] = 0;
+  BFS.BFSStack->ClearStack(); // start with empty BFS stack
+  BFS.BFSStack->Push(Walker);
+  BFS.TouchedStack->Push(Walker);
+};
+
+/** Performs a BFS from \a *Root, trying to find the same node and hence a cycle.
+ * \param *out output stream for debugging
+ * \param *&BackEdge the edge from root that we don't want to move along
+ * \param &BFS accounting structure
+ */
+void CyclicStructureAnalysis_CyclicBFSFromRootToRoot(ofstream *out, bond *&BackEdge, struct BFSAccounting &BFS)
 {
   atom *Walker = NULL;
   atom *OtherAtom = NULL;
-  do {  // look for Root
-    Walker = BFSStack->PopFirst();
-    *out << Verbose(2) << "Current Walker is " << *Walker << ", we look for SP to Root " << *Root << "." << endl;
+  do { // look for Root
+    Walker = BFS.BFSStack->PopFirst();
+    *out << Verbose(2) << "Current Walker is " << *Walker << ", we look for SP to Root " << *BFS.Root << "." << endl;
     for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
       if ((*Runner) != BackEdge) { // only walk along DFS spanning tree (otherwise we always find SP of one being backedge Binder)
         OtherAtom = (*Runner)->GetOtherAtom(Walker);
-  #ifdef ADDHYDROGEN
+#ifdef ADDHYDROGEN
         if (OtherAtom->type->Z != 1) {
-  #endif
-          *out << Verbose(2) << "Current OtherAtom is: " << OtherAtom->Name << " for bond " << *(*Runner) << "." << endl;
-          if (ColorList[OtherAtom->nr] == white) {
-            TouchedStack->Push(OtherAtom);
-            ColorList[OtherAtom->nr] = lightgray;
-            PredecessorList[OtherAtom->nr] = Walker;  // Walker is the predecessor
-            ShortestPathList[OtherAtom->nr] = ShortestPathList[Walker->nr]+1;
-            *out << Verbose(2) << "Coloring OtherAtom " << OtherAtom->Name << " lightgray, its predecessor is " << Walker->Name << " and its Shortest Path is " << ShortestPathList[OtherAtom->nr] << " egde(s) long." << endl;
-            //if (ShortestPathList[OtherAtom->nr] < MinimumRingSize[Walker->GetTrueFather()->nr]) { // Check for maximum distance
-              *out << Verbose(3) << "Putting OtherAtom into queue." << endl;
-              BFSStack->Push(OtherAtom);
-            //}
-          } else {
-            *out << Verbose(3) << "Not Adding, has already been visited." << endl;
-          }
-          if (OtherAtom == Root)
-            break;
-  #ifdef ADDHYDROGEN
+#endif
+        *out << Verbose(2) << "Current OtherAtom is: " << OtherAtom->Name << " for bond " << *(*Runner) << "." << endl;
+        if (BFS.ColorList[OtherAtom->nr] == white) {
+          BFS.TouchedStack->Push(OtherAtom);
+          BFS.ColorList[OtherAtom->nr] = lightgray;
+          BFS.PredecessorList[OtherAtom->nr] = Walker; // Walker is the predecessor
+          BFS.ShortestPathList[OtherAtom->nr] = BFS.ShortestPathList[Walker->nr] + 1;
+          *out << Verbose(2) << "Coloring OtherAtom " << OtherAtom->Name << " lightgray, its predecessor is " << Walker->Name << " and its Shortest Path is " << BFS.ShortestPathList[OtherAtom->nr] << " egde(s) long." << endl;
+          //if (BFS.ShortestPathList[OtherAtom->nr] < MinimumRingSize[Walker->GetTrueFather()->nr]) { // Check for maximum distance
+          *out << Verbose(3) << "Putting OtherAtom into queue." << endl;
+          BFS.BFSStack->Push(OtherAtom);
+          //}
         } else {
-          *out << Verbose(2) << "Skipping hydrogen atom " << *OtherAtom << "." << endl;
-          ColorList[OtherAtom->nr] = black;
+          *out << Verbose(3) << "Not Adding, has already been visited." << endl;
         }
-  #endif
+        if (OtherAtom == BFS.Root)
+          break;
+#ifdef ADDHYDROGEN
+      } else {
+        *out << Verbose(2) << "Skipping hydrogen atom " << *OtherAtom << "." << endl;
+        BFS.ColorList[OtherAtom->nr] = black;
+      }
+#endif
       } else {
         *out << Verbose(2) << "Bond " << *(*Runner) << " not Visiting, is the back edge." << endl;
       }
     }
-    ColorList[Walker->nr] = black;
+    BFS.ColorList[Walker->nr] = black;
     *out << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl;
-    if (OtherAtom == Root) { // if we have found the root, check whether this cycle wasn't already found beforehand
+    if (OtherAtom == BFS.Root) { // if we have found the root, check whether this cycle wasn't already found beforehand
       // step through predecessor list
       while (OtherAtom != BackEdge->rightatom) {
-        if (!OtherAtom->GetTrueFather()->IsCyclic)  // if one bond in the loop is not marked as cyclic, we haven't found this cycle yet
+        if (!OtherAtom->GetTrueFather()->IsCyclic) // if one bond in the loop is not marked as cyclic, we haven't found this cycle yet
           break;
         else
-          OtherAtom = PredecessorList[OtherAtom->nr];
+          OtherAtom = BFS.PredecessorList[OtherAtom->nr];
       }
       if (OtherAtom == BackEdge->rightatom) { // if each atom in found cycle is cyclic, loop's been found before already
-        *out << Verbose(3) << "This cycle was already found before, skipping and removing seeker from search." << endl;\
+        *out << Verbose(3) << "This cycle was already found before, skipping and removing seeker from search." << endl;
         do {
-          OtherAtom = TouchedStack->PopLast();
-          if (PredecessorList[OtherAtom->nr] == Walker) {
+          OtherAtom = BFS.TouchedStack->PopLast();
+          if (BFS.PredecessorList[OtherAtom->nr] == Walker) {
             *out << Verbose(4) << "Removing " << *OtherAtom << " from lists and stacks." << endl;
-            PredecessorList[OtherAtom->nr] = NULL;
-            ShortestPathList[OtherAtom->nr] = -1;
-            ColorList[OtherAtom->nr] = white;
-            BFSStack->RemoveItem(OtherAtom);
+            BFS.PredecessorList[OtherAtom->nr] = NULL;
+            BFS.ShortestPathList[OtherAtom->nr] = -1;
+            BFS.ColorList[OtherAtom->nr] = white;
+            BFS.BFSStack->RemoveItem(OtherAtom);
           }
-        } while ((!TouchedStack->IsEmpty()) && (PredecessorList[OtherAtom->nr] == NULL));
-        TouchedStack->Push(OtherAtom);  // last was wrongly popped
+        } while ((!BFS.TouchedStack->IsEmpty()) && (BFS.PredecessorList[OtherAtom->nr] == NULL));
+        BFS.TouchedStack->Push(OtherAtom); // last was wrongly popped
         OtherAtom = BackEdge->rightatom; // set to not Root
       } else
-        OtherAtom = Root;
-    }
-  } while ((!BFSStack->IsEmpty()) && (OtherAtom != Root) && (OtherAtom != NULL)); // || (ShortestPathList[OtherAtom->nr] < MinimumRingSize[Walker->GetTrueFather()->nr])));
+        OtherAtom = BFS.Root;
+    }
+  } while ((!BFS.BFSStack->IsEmpty()) && (OtherAtom != BFS.Root) && (OtherAtom != NULL)); // || (ShortestPathList[OtherAtom->nr] < MinimumRingSize[Walker->GetTrueFather()->nr])));
 };
 
-void RetrieveCycleMembers(ofstream *out, atom *&Root, atom *&OtherAtom, bond *&BackEdge, atom **&PredecessorList, int *&MinimumRingSize, int &MinRingSize)
+/** Climb back the BFSAccounting::PredecessorList and find cycle members.
+ * \param *out output stream for debugging
+ * \param *&OtherAtom
+ * \param *&BackEdge denotes the edge we did not want to travel along when doing CyclicBFSFromRootToRoot()
+ * \param &BFS accounting structure
+ * \param *&MinimumRingSize minimum distance from this node possible without encountering oneself, set on return for each atom
+ * \param &MinRingSize global minimum distance from one node without encountering oneself, set on return
+ */
+void CyclicStructureAnalysis_RetrieveCycleMembers(ofstream *out, atom *&OtherAtom, bond *&BackEdge, struct BFSAccounting &BFS, int *&MinimumRingSize, int &MinRingSize)
 {
   atom *Walker = NULL;
@@ -589 +737 @@
   int RingSize = -1;
 
-  if (OtherAtom == Root) {
+  if (OtherAtom == BFS.Root) {
     // now climb back the predecessor list and thus find the cycle members
     NumCycles++;
     RingSize = 1;
-    Root->GetTrueFather()->IsCyclic = true;
+    BFS.Root->GetTrueFather()->IsCyclic = true;
     *out << Verbose(1) << "Found ring contains: ";
-    Walker = Root;
+    Walker = BFS.Root;
     while (Walker != BackEdge->rightatom) {
       *out << Walker->Name << " <-> ";
-      Walker = PredecessorList[Walker->nr];
+      Walker = BFS.PredecessorList[Walker->nr];
       Walker->GetTrueFather()->IsCyclic = true;
       RingSize++;
@@ -604 +752 @@
     *out << Walker->Name << "  with a length of " << RingSize << "." << endl << endl;
     // walk through all and set MinimumRingSize
-    Walker = Root;
+    Walker = BFS.Root;
     MinimumRingSize[Walker->GetTrueFather()->nr] = RingSize;
     while (Walker != BackEdge->rightatom) {
-      Walker = PredecessorList[Walker->nr];
+      Walker = BFS.PredecessorList[Walker->nr];
       if (RingSize < MinimumRingSize[Walker->GetTrueFather()->nr])
         MinimumRingSize[Walker->GetTrueFather()->nr] = RingSize;
@@ -614 +762 @@
       MinRingSize = RingSize;
   } else {
-    *out << Verbose(1) << "No ring containing " << *Root << " with length equal to or smaller than " << MinimumRingSize[Walker->GetTrueFather()->nr] << " found." << endl;
+    *out << Verbose(1) << "No ring containing " << *BFS.Root << " with length equal to or smaller than " << MinimumRingSize[Walker->GetTrueFather()->nr] << " found." << endl;
   }
 };
 
-void CleanAccounting(class StackClass<atom *> *&TouchedStack, atom **&PredecessorList, int *&ShortestPathList, enum Shading *&ColorList)
-{
-  atom *Walker = NULL;
-  while (!TouchedStack->IsEmpty()){
-    Walker = TouchedStack->PopFirst();
-    PredecessorList[Walker->nr] = NULL;
-    ShortestPathList[Walker->nr] = -1;
-    ColorList[Walker->nr] = white;
-  }
-};
-
-
-void BFSToNextCycle(ofstream *out, atom *&Root, atom *&Walker, bond *&BackEdge, int *&MinimumRingSize, int AtomCount)
-{
-  atom **PredecessorList = Malloc<atom*>(AtomCount, "molecule::CyclicStructureAnalysis: **PredecessorList");
-  int *ShortestPathList = Malloc<int>(AtomCount, "molecule::CyclicStructureAnalysis: *ShortestPathList");
-  enum Shading *ColorList = Malloc<enum Shading>(AtomCount, "molecule::CyclicStructureAnalysis: *ColorList");
-  class StackClass<atom *> *BFSStack = new StackClass<atom *> (AtomCount);   // will hold the current ring
-  class StackClass<atom *> *TouchedStack = new StackClass<atom *> (AtomCount);   // contains all "touched" atoms (that need to be reset after BFS loop)
+/** From a given node performs a BFS to touch the next cycle, for whose nodes \a *&MinimumRingSize is set and set it accordingly.
+ * \param *out output stream for debugging
+ * \param *&Root node to look for closest cycle from, i.e. \a *&MinimumRingSize is set for this node
+ * \param *&MinimumRingSize minimum distance from this node possible without encountering oneself, set on return for each atom
+ * \param AtomCount number of nodes in graph
+ */
+void CyclicStructureAnalysis_BFSToNextCycle(ofstream *out, atom *&Root, atom *&Walker, int *&MinimumRingSize, int AtomCount)
+{
+  struct BFSAccounting BFS;
   atom *OtherAtom = Walker;
 
-  InitializeAccounting(PredecessorList, ShortestPathList, ColorList, AtomCount);
-
-  ResetAccounting(Walker, TouchedStack, ShortestPathList, BFSStack);
-  while (OtherAtom != NULL) {  // look for Root
-    Walker = BFSStack->PopFirst();
+  InitializeBFSAccounting(out, BFS, AtomCount);
+
+  ResetBFSAccounting(out, Walker, BFS);
+  while (OtherAtom != NULL) { // look for Root
+    Walker = BFS.BFSStack->PopFirst();
     //*out << Verbose(2) << "Current Walker is " << *Walker << ", we look for SP to Root " << *Root << "." << endl;
     for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
-      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
+      // "removed (*Runner) != BackEdge) || " from next if, is u
+      if ((Walker->ListOfBonds.size() == 1)) { // only walk along DFS spanning tree (otherwise we always find SP of 1 being backedge Binder), but terminal hydrogens may be connected via backedge, hence extra check
         OtherAtom = (*Runner)->GetOtherAtom(Walker);
         //*out << Verbose(2) << "Current OtherAtom is: " << OtherAtom->Name << " for bond " << *Binder << "." << endl;
-        if (ColorList[OtherAtom->nr] == white) {
-          TouchedStack->Push(OtherAtom);
-          ColorList[OtherAtom->nr] = lightgray;
-          PredecessorList[OtherAtom->nr] = Walker;  // Walker is the predecessor
-          ShortestPathList[OtherAtom->nr] = ShortestPathList[Walker->nr]+1;
+        if (BFS.ColorList[OtherAtom->nr] == white) {
+          BFS.TouchedStack->Push(OtherAtom);
+          BFS.ColorList[OtherAtom->nr] = lightgray;
+          BFS.PredecessorList[OtherAtom->nr] = Walker; // Walker is the predecessor
+          BFS.ShortestPathList[OtherAtom->nr] = BFS.ShortestPathList[Walker->nr] + 1;
           //*out << Verbose(2) << "Coloring OtherAtom " << OtherAtom->Name << " lightgray, its predecessor is " << Walker->Name << " and its Shortest Path is " << ShortestPathList[OtherAtom->nr] << " egde(s) long." << endl;
           if (OtherAtom->GetTrueFather()->IsCyclic) { // if the other atom is connected to a ring
-            MinimumRingSize[Root->GetTrueFather()->nr] = ShortestPathList[OtherAtom->nr]+MinimumRingSize[OtherAtom->GetTrueFather()->nr];
+            MinimumRingSize[Root->GetTrueFather()->nr] = BFS.ShortestPathList[OtherAtom->nr] + MinimumRingSize[OtherAtom->GetTrueFather()->nr];
             OtherAtom = NULL; //break;
             break;
           } else
-            BFSStack->Push(OtherAtom);
+            BFS.BFSStack->Push(OtherAtom);
         } else {
           //*out << Verbose(3) << "Not Adding, has already been visited." << endl;
@@ -668 +807 @@
       }
     }
-    ColorList[Walker->nr] = black;
+    BFS.ColorList[Walker->nr] = black;
     //*out << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl;
   }
   //CleanAccountingLists(TouchedStack, PredecessorList, ShortestPathList, ColorList);
 
-  Free(&PredecessorList);
-  Free(&ShortestPathList);
-  Free(&ColorList);
-  delete(BFSStack);
-};
-
-void AssignRingSizetoNonCycleMembers(ofstream *out, int *&MinimumRingSize, int &MinRingSize, int &NumCycles, molecule *mol, bond *&BackEdge)
-{
-  atom *Root= NULL;
+  FinalizeBFSAccounting(out, BFS);
+}
+;
+
+/** All nodes that are not in cycles get assigned a \a *&MinimumRingSizeby BFS to next cycle.
+ * \param *out output stream for debugging
+ * \param *&MinimumRingSize array with minimum distance without encountering onself for each atom
+ * \param &MinRingSize global minium distance
+ * \param &NumCyles number of cycles in graph
+ * \param *mol molecule with atoms
+ */
+void CyclicStructureAnalysis_AssignRingSizetoNonCycleMembers(ofstream *out, int *&MinimumRingSize, int &MinRingSize, int &NumCycles, molecule *mol)
+{
+  atom *Root = NULL;
   atom *Walker = NULL;
   if (MinRingSize != -1) { // if rings are present
     // go over all atoms
     Root = mol->start;
-    while(Root->next != mol->end) {
+    while (Root->next != mol->end) {
       Root = Root->next;
 
@@ -693 +837 @@
 
         //*out << Verbose(1) << "---------------------------------------------------------------------------------------------------------" << endl;
-        BFSToNextCycle(out, Root, Walker, BackEdge, MinimumRingSize, mol->AtomCount);
+        CyclicStructureAnalysis_BFSToNextCycle(out, Root, Walker, MinimumRingSize, mol->AtomCount);
 
       }
@@ -701 +845 @@
   } else
     *out << Verbose(1) << "No rings were detected in the molecular structure." << endl;
-};
+}
+;
 
 /** Analyses the cycles found and returns minimum of all cycle lengths.
@@ -713 +858 @@
  * \todo BFS from the not-same-LP to find back to starting point of tributary cycle over more than one bond
  */
-void molecule::CyclicStructureAnalysis(ofstream *out, class StackClass<bond *> *  BackEdgeStack, int *&MinimumRingSize)
-{
-  atom **PredecessorList = Malloc<atom*>(AtomCount, "molecule::CyclicStructureAnalysis: **PredecessorList");
-  int *ShortestPathList = Malloc<int>(AtomCount, "molecule::CyclicStructureAnalysis: *ShortestPathList");
-  enum Shading *ColorList = Malloc<enum Shading>(AtomCount, "molecule::CyclicStructureAnalysis: *ColorList");
-  class StackClass<atom *> *BFSStack = new StackClass<atom *> (AtomCount);   // will hold the current ring
-  class StackClass<atom *> *TouchedStack = new StackClass<atom *> (AtomCount);   // contains all "touched" atoms (that need to be reset after BFS loop)
+void molecule::CyclicStructureAnalysis(ofstream *out, class StackClass<bond *> * BackEdgeStack, int *&MinimumRingSize)
+{
+  struct BFSAccounting BFS;
   atom *Walker = NULL;
   atom *OtherAtom = NULL;
-  atom *Root = NULL;
   bond *BackEdge = NULL;
   int NumCycles = 0;
   int MinRingSize = -1;
 
-  InitializeAccounting(PredecessorList, ShortestPathList, ColorList, AtomCount);
+  InitializeBFSAccounting(out, BFS, AtomCount);
 
   *out << Verbose(1) << "Back edge list - ";
@@ -737 +877 @@
     BackEdge = BackEdgeStack->PopFirst();
     // this is the target
-    Root = BackEdge->leftatom;
+    BFS.Root = BackEdge->leftatom;
     // this is the source point
     Walker = BackEdge->rightatom;
 
-    ResetAccounting(Walker, TouchedStack, ShortestPathList, BFSStack);
+    ResetBFSAccounting(out, Walker, BFS);
 
     *out << Verbose(1) << "---------------------------------------------------------------------------------------------------------" << endl;
     OtherAtom = NULL;
-    CyclicBFSFromRootToRoot(out, Root, BackEdge, TouchedStack, ShortestPathList, PredecessorList, BFSStack, ColorList);
-
-    RetrieveCycleMembers(out, Root, OtherAtom, BackEdge, PredecessorList, MinimumRingSize, MinRingSize);
-
-    CleanAccounting(TouchedStack, PredecessorList, ShortestPathList, ColorList);
-  }
-  Free(&PredecessorList);
-  Free(&ShortestPathList);
-  Free(&ColorList);
-  delete(BFSStack);
-
-  AssignRingSizetoNonCycleMembers(out, MinimumRingSize, MinRingSize, NumCycles, this, BackEdge);
-
-};
+    CyclicStructureAnalysis_CyclicBFSFromRootToRoot(out, BackEdge, BFS);
+
+    CyclicStructureAnalysis_RetrieveCycleMembers(out, OtherAtom, BackEdge, BFS, MinimumRingSize, MinRingSize);
+
+    CleanBFSAccounting(out, BFS);
+  }
+  FinalizeBFSAccounting(out, BFS);
+
+  CyclicStructureAnalysis_AssignRingSizetoNonCycleMembers(out, MinimumRingSize, MinRingSize, NumCycles, this);
+
+}
+;
 
 /** Sets the next component number.
@@ -767 +905 @@
 void molecule::SetNextComponentNumber(atom *vertex, int nr)
 {
-  size_t i=0;
+  size_t i = 0;
   if (vertex != NULL) {
-    for(;i<vertex->ListOfBonds.size();i++) {
-      if (vertex->ComponentNr[i] == -1) {   // check if not yet used
+    for (; i < vertex->ListOfBonds.size(); i++) {
+      if (vertex->ComponentNr[i] == -1) { // check if not yet used
         vertex->ComponentNr[i] = nr;
         break;
-      }
-      else if (vertex->ComponentNr[i] == nr) // if number is already present, don't add another time
-        break;  // breaking here will not cause error!
+      } else if (vertex->ComponentNr[i] == nr) // if number is already present, don't add another time
+        break; // breaking here will not cause error!
     }
     if (i == vertex->ListOfBonds.size())
       cerr << "Error: All Component entries are already occupied!" << endl;
   } else
-      cerr << "Error: Given vertex is NULL!" << endl;
-};
+    cerr << "Error: Given vertex is NULL!" << endl;
+}
+;
 
 /** Returns next unused bond for this atom \a *vertex or NULL of none exists.
@@ -791 +929 @@
   for (BondList::const_iterator Runner = vertex->ListOfBonds.begin(); Runner != vertex->ListOfBonds.end(); (++Runner))
     if ((*Runner)->IsUsed() == white)
-      return((*Runner));
+      return ((*Runner));
   return NULL;
-};
+}
+;
 
 /** Resets bond::Used flag of all bonds in this molecule.
@@ -805 +944 @@
     Binder->ResetUsed();
   }
-};
+}
+;
 
 /** Output a list of flags, stating whether the bond was visited or not.
@@ -814 +954 @@
 {
   *out << Verbose(4) << "Already Visited Bonds:\t";
-  for(int i=1;i<=list[0];i++) *out << Verbose(0) << list[i] << "  ";
+  for (int i = 1; i <= list[0]; i++)
+    *out << Verbose(0) << list[i] << "  ";
   *out << endl;
-};
-
+}
+;
 
 /** Storing the bond structure of a molecule to file.
@@ -835 +976 @@
   *out << Verbose(1) << "Saving adjacency list ... ";
   if (AdjacencyFile != NULL) {
-    ActOnAllAtoms( &atom::OutputAdjacency, &AdjacencyFile );
+    ActOnAllAtoms(&atom::OutputAdjacency, &AdjacencyFile);
     AdjacencyFile.close();
     *out << Verbose(1) << "done." << endl;
@@ -844 +985 @@
 
   return status;
-};
+}
+;
 
 bool CheckAdjacencyFileAgainstMolecule_Init(ofstream *out, char *path, ifstream &File, int *&CurrentBonds)
@@ -856 +998 @@
 
   // allocate storage structure
-  CurrentBonds = Malloc<int>(8, "molecule::CheckAdjacencyFileAgainstMolecule - CurrentBonds"); // contains parsed bonds of current atom
+  CurrentBonds = Malloc<int> (8, "molecule::CheckAdjacencyFileAgainstMolecule - CurrentBonds"); // contains parsed bonds of current atom
   return true;
-};
+}
+;
 
 void CheckAdjacencyFileAgainstMolecule_Finalize(ofstream *out, ifstream &File, int *&CurrentBonds)
@@ -865 +1008 @@
   File.clear();
   Free(&CurrentBonds);
-};
+}
+;
 
 void CheckAdjacencyFileAgainstMolecule_CompareBonds(ofstream *out, bool &status, int &NonMatchNumber, atom *&Walker, size_t &CurrentBondsOfAtom, int AtomNr, int *&CurrentBonds, atom **ListOfAtoms)
@@ -877 +1021 @@
       id = (*Runner)->GetOtherAtom(Walker)->nr;
       j = 0;
-      for (;(j<CurrentBondsOfAtom) && (CurrentBonds[j++] != id);)
+      for (; (j < CurrentBondsOfAtom) && (CurrentBonds[j++] != id);)
         ; // check against all parsed bonds
-      if (CurrentBonds[j-1] != id) { // no match ? Then mark in ListOfAtoms
+      if (CurrentBonds[j - 1] != id) { // no match ? Then mark in ListOfAtoms
         ListOfAtoms[AtomNr] = NULL;
         NonMatchNumber++;
@@ -893 +1037 @@
     status = false;
   }
-};
+}
+;
 
 /** Checks contents of adjacency file against bond structure in structure molecule.
@@ -908 +1053 @@
   char *buffer = NULL;
   int *CurrentBonds = NULL;
-  int NonMatchNumber = 0;   // will number of atoms with differing bond structure
+  int NonMatchNumber = 0; // will number of atoms with differing bond structure
   size_t CurrentBondsOfAtom = -1;
 
@@ -916 +1061 @@
   }
 
-  buffer = Malloc<char>(MAXSTRINGSIZE, "molecule::CheckAdjacencyFileAgainstMolecule: *buffer");
+  buffer = Malloc<char> (MAXSTRINGSIZE, "molecule::CheckAdjacencyFileAgainstMolecule: *buffer");
   // Parse the file line by line and count the bonds
   while (!File.eof()) {
@@ -929 +1074 @@
       Walker = ListOfAtoms[AtomNr];
       while (!line.eof())
-        line >> CurrentBonds[ ++CurrentBondsOfAtom ];
+        line >> CurrentBonds[++CurrentBondsOfAtom];
       // compare against present bonds
       CheckAdjacencyFileAgainstMolecule_CompareBonds(out, status, NonMatchNumber, Walker, CurrentBondsOfAtom, AtomNr, CurrentBonds, ListOfAtoms);
@@ -942 +1087 @@
     *out << Verbose(1) << "done: Not equal by " << NonMatchNumber << " atoms." << endl;
   return status;
-};
-
+}
+;
 
 /** Picks from a global stack with all back edges the ones in the fragment.
@@ -960 +1105 @@
   }
   bond *Binder = ReferenceStack->PopFirst();
-  bond *FirstBond = Binder;   // mark the first bond, so that we don't loop through the stack indefinitely
+  bond *FirstBond = Binder; // mark the first bond, so that we don't loop through the stack indefinitely
   atom *Walker = NULL, *OtherAtom = NULL;
   ReferenceStack->Push(Binder);
 
-  do {  // go through all bonds and push local ones
-    Walker = ListOfLocalAtoms[Binder->leftatom->nr];  // get one atom in the reference molecule
+  do { // go through all bonds and push local ones
+    Walker = ListOfLocalAtoms[Binder->leftatom->nr]; // get one atom in the reference molecule
     if (Walker != NULL) // if this Walker exists in the subgraph ...
       for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
@@ -975 +1120 @@
         }
       }
-    Binder = ReferenceStack->PopFirst();  // loop the stack for next item
+    Binder = ReferenceStack->PopFirst(); // loop the stack for next item
     *out << Verbose(3) << "Current candidate edge " << Binder << "." << endl;
     ReferenceStack->Push(Binder);
@@ -981 +1126 @@
 
   return status;
-};
-
-struct BFSAccounting {
-  atom **PredecessorList;
-  int *ShortestPathList;
-  enum Shading *ColorList;
-  class StackClass<atom *> *AtomStack;
-  int AtomCount;
-  int BondOrder;
-  atom *Root;
-};
+}
+;
 
 void BreadthFirstSearchAdd_Init(struct BFSAccounting &BFS, atom *&Root, int AtomCount, int BondOrder, atom **AddedAtomList = NULL)
@@ -997 +1133 @@
   BFS.AtomCount = AtomCount;
   BFS.BondOrder = BondOrder;
-  BFS.PredecessorList = Malloc<atom*>(AtomCount, "molecule::BreadthFirstSearchAdd_Init: **PredecessorList");
-  BFS.ShortestPathList = Malloc<int>(AtomCount, "molecule::BreadthFirstSearchAdd_Init: *ShortestPathList");
-  BFS.ColorList = Malloc<enum Shading>(AtomCount, "molecule::BreadthFirstSearchAdd_Init: *ColorList");
-  BFS.AtomStack = new StackClass<atom *>(AtomCount);
+  BFS.PredecessorList = Malloc<atom*> (AtomCount, "molecule::BreadthFirstSearchAdd_Init: **PredecessorList");
+  BFS.ShortestPathList = Malloc<int> (AtomCount, "molecule::BreadthFirstSearchAdd_Init: *ShortestPathList");
+  BFS.ColorList = Malloc<enum Shading> (AtomCount, "molecule::BreadthFirstSearchAdd_Init: *ColorList");
+  BFS.BFSStack = new StackClass<atom *> (AtomCount);
 
   BFS.Root = Root;
-  BFS.AtomStack->ClearStack();
-  BFS.AtomStack->Push(Root);
+  BFS.BFSStack->ClearStack();
+  BFS.BFSStack->Push(Root);
 
   // initialise each vertex as white with no predecessor, empty queue, color Root lightgray
-  for (int i=AtomCount;i--;) {
+  for (int i = AtomCount; i--;) {
     BFS.PredecessorList[i] = NULL;
     BFS.ShortestPathList[i] = -1;
@@ -1016 +1152 @@
   }
   BFS.ShortestPathList[Root->nr] = 0;
-};
+}
+;
 
 void BreadthFirstSearchAdd_Free(struct BFSAccounting &BFS)
@@ -1023 +1160 @@
   Free(&BFS.ShortestPathList);
   Free(&BFS.ColorList);
-  delete(BFS.AtomStack);
+  delete (BFS.BFSStack);
   BFS.AtomCount = 0;
-};
-
+}
+;
 
 void BreadthFirstSearchAdd_UnvisitedNode(ofstream *out, molecule *Mol, struct BFSAccounting &BFS, atom *&Walker, atom *&OtherAtom, bond *&Binder, bond *&Bond, atom **&AddedAtomList, bond **&AddedBondList, bool IsAngstroem)
@@ -1032 +1169 @@
   if (Binder != Bond) // let other atom white if it's via Root bond. In case it's cyclic it has to be reached again (yet Root is from OtherAtom already black, thus no problem)
     BFS.ColorList[OtherAtom->nr] = lightgray;
-  BFS.PredecessorList[OtherAtom->nr] = Walker;  // Walker is the predecessor
-  BFS.ShortestPathList[OtherAtom->nr] = BFS.ShortestPathList[Walker->nr]+1;
+  BFS.PredecessorList[OtherAtom->nr] = Walker; // Walker is the predecessor
+  BFS.ShortestPathList[OtherAtom->nr] = BFS.ShortestPathList[Walker->nr] + 1;
   *out << Verbose(2) << "Coloring OtherAtom " << OtherAtom->Name << " " << ((BFS.ColorList[OtherAtom->nr] == white) ? "white" : "lightgray") << ", its predecessor is " << Walker->Name << " and its Shortest Path is " << BFS.ShortestPathList[OtherAtom->nr] << " egde(s) long." << endl;
-  if ((((BFS.ShortestPathList[OtherAtom->nr] < BFS.BondOrder) && (Binder != Bond))) ) { // Check for maximum distance
+  if ((((BFS.ShortestPathList[OtherAtom->nr] < BFS.BondOrder) && (Binder != Bond)))) { // Check for maximum distance
     *out << Verbose(3);
     if (AddedAtomList[OtherAtom->nr] == NULL) { // add if it's not been so far
@@ -1042 +1179 @@
       AddedBondList[Binder->nr] = Mol->CopyBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder);
       *out << " and bond " << *(AddedBondList[Binder->nr]) << ", ";
-    } else {  // this code should actually never come into play (all white atoms are not yet present in BondMolecule, that's why they are white in the first place)
+    } 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) {
@@ -1051 +1188 @@
     }
     *out << ", putting OtherAtom into queue." << endl;
-    BFS.AtomStack->Push(OtherAtom);
+    BFS.BFSStack->Push(OtherAtom);
   } else { // out of bond order, then replace
     if ((AddedAtomList[OtherAtom->nr] == NULL) && (Binder->Cyclic))
@@ -1065 +1202 @@
         AddedBondList[Binder->nr] = Mol->CopyBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder);
       } else {
-  #ifdef ADDHYDROGEN
+#ifdef ADDHYDROGEN
         if (!Mol->AddHydrogenReplacementAtom(out, Binder, AddedAtomList[Walker->nr], Walker, OtherAtom, IsAngstroem))
-          exit(1);
-  #endif
+        exit(1);
+#endif
       }
     }
   }
-};
+}
+;
 
 void BreadthFirstSearchAdd_VisitedNode(ofstream *out, molecule *Mol, struct BFSAccounting &BFS, atom *&Walker, atom *&OtherAtom, bond *&Binder, bond *&Bond, atom **&AddedAtomList, bond **&AddedBondList, bool IsAngstroem)
@@ -1079 +1217 @@
   // This has to be a cyclic bond, check whether it's present ...
   if (AddedBondList[Binder->nr] == NULL) {
-    if ((Binder != Bond) && (Binder->Cyclic) && (((BFS.ShortestPathList[Walker->nr]+1) < BFS.BondOrder))) {
+    if ((Binder != Bond) && (Binder->Cyclic) && (((BFS.ShortestPathList[Walker->nr] + 1) < BFS.BondOrder))) {
       AddedBondList[Binder->nr] = Mol->CopyBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder);
     } else { // if it's root bond it has to broken (otherwise we would not create the fragments)
-  #ifdef ADDHYDROGEN
+#ifdef ADDHYDROGEN
       if(!Mol->AddHydrogenReplacementAtom(out, Binder, AddedAtomList[Walker->nr], Walker, OtherAtom, IsAngstroem))
-        exit(1);
-  #endif
-    }
-  }
-};
+      exit(1);
+#endif
+    }
+  }
+}
+;
 
 /** Adds atoms up to \a BondCount distance from \a *Root and notes them down in \a **AddedAtomList.
@@ -1109 +1248 @@
 
   // add Root if not done yet
-  if (AddedAtomList[Root->nr] == NULL)  // add Root if not yet present
+  if (AddedAtomList[Root->nr] == NULL) // add Root if not yet present
     AddedAtomList[Root->nr] = Mol->AddCopyAtom(Root);
 
@@ -1115 +1254 @@
 
   // and go on ... Queue always contains all lightgray vertices
-  while (!BFS.AtomStack->IsEmpty()) {
+  while (!BFS.BFSStack->IsEmpty()) {
     // we have to pop the oldest atom from stack. This keeps the atoms on the stack always of the same ShortestPath distance.
     // e.g. if current atom is 2, push to end of stack are of length 3, but first all of length 2 would be popped. They again
     // append length of 3 (their neighbours). Thus on stack we have always atoms of a certain length n at bottom of stack and
     // followed by n+1 till top of stack.
-    Walker = BFS.AtomStack->PopFirst(); // pop oldest added
+    Walker = BFS.BFSStack->PopFirst(); // pop oldest added
     *out << Verbose(1) << "Current Walker is: " << Walker->Name << ", and has " << Walker->ListOfBonds.size() << " bonds." << endl;
     for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
@@ -1138 +1277 @@
   }
   BreadthFirstSearchAdd_Free(BFS);
-};
+}
+;
 
 /** Adds a bond as a copy to a given one
@@ -1152 +1292 @@
   Binder->Type = CopyBond->Type;
   return Binder;
-};
+}
+;
 
 void BuildInducedSubgraph_Init(ofstream *out, atom **&ParentList, int AtomCount)
 {
   // reset parent list
-  ParentList = Malloc<atom*>(AtomCount, "molecule::BuildInducedSubgraph_Init: **ParentList");
+  ParentList = Malloc<atom*> (AtomCount, "molecule::BuildInducedSubgraph_Init: **ParentList");
   *out << Verbose(3) << "Resetting ParentList." << endl;
-  for (int i=AtomCount;i--;)
+  for (int i = AtomCount; i--;)
     ParentList[i] = NULL;
-};
+}
+;
 
 void BuildInducedSubgraph_FillParentList(ofstream *out, const molecule *mol, const molecule *Father, atom **&ParentList)
@@ -1172 +1314 @@
     ParentList[Walker->father->nr] = Walker;
     // Outputting List for debugging
-    *out << Verbose(4) << "Son["<< Walker->father->nr <<"] of " << Walker->father <<  " is " << ParentList[Walker->father->nr] << "." << endl;
-  }
-
-};
+    *out << Verbose(4) << "Son[" << Walker->father->nr << "] of " << Walker->father << " is " << ParentList[Walker->father->nr] << "." << endl;
+  }
+
+}
+;
 
 void BuildInducedSubgraph_Finalize(ofstream *out, atom **&ParentList)
 {
   Free(&ParentList);
-};
+}
+;
 
 bool BuildInducedSubgraph_CreateBondsFromParent(ofstream *out, molecule *mol, const molecule *Father, atom **&ParentList)
@@ -1207 +1351 @@
   }
   return status;
-};
+}
+;
 
 /** Adds bond structure to this molecule from \a Father molecule.
@@ -1230 +1375 @@
   *out << Verbose(2) << "End of BuildInducedSubgraph." << endl;
   return status;
-};
-
+}
+;
 
 /** For a given keyset \a *Fragment, checks whether it is connected in the current molecule.
@@ -1250 +1395 @@
   // count number of atoms in graph
   size = 0;
-  for(KeySet::iterator runner = Fragment->begin(); runner != Fragment->end(); runner++)
+  for (KeySet::iterator runner = Fragment->begin(); runner != Fragment->end(); runner++)
     size++;
   if (size > 1)
-    for(KeySet::iterator runner = Fragment->begin(); runner != Fragment->end(); runner++) {
+    for (KeySet::iterator runner = Fragment->begin(); runner != Fragment->end(); runner++) {
       Walker = FindAtom(*runner);
       BondStatus = false;
-      for(KeySet::iterator runners = Fragment->begin(); runners != Fragment->end(); runners++) {
+      for (KeySet::iterator runners = Fragment->begin(); runners != Fragment->end(); runners++) {
         Walker2 = FindAtom(*runners);
         for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {