Changeset 543ce4 for molecuilder/src/molecule_graph.cpp

Timestamp:

Nov 4, 2009, 7:56:04 PM (16 years ago)

Author:

Frederik Heber <heber@…>

Children:

4ef101, aa8542

Parents:

ec70ec

Message:

Huge change from ofstream * (const) out --> Log().

• first shift was done via regular expressions
• then via error messages from the code
• note that class atom, class element and class molecule kept in parts their output stream, was they print to file.
• make check runs fine
• MISSING: Verbosity is not fixed for everything (i.e. if no endl; is present and next has Verbose(0) ...)

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

File:

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

molecuilder/src/molecule_graph.cpp

@@ -14 +14 @@
 #include "linkedcell.hpp"
 #include "lists.hpp"
+#include "log.hpp"
 #include "memoryallocator.hpp"
 #include "molecule.hpp"
@@ -49 +50 @@
  * We obtain an outside file with the indices of atoms which are bondmembers.
  */
-void molecule::CreateAdjacencyListFromDbondFile(ofstream *out, ifstream *input)
+void molecule::CreateAdjacencyListFromDbondFile(ifstream *input)
 {
 
@@ -57 +58 @@
 
   if (!input) {
-    cout << Verbose(1) << "Opening silica failed \n";
+    Log() << Verbose(1) << "Opening silica failed \n";
   };
 
   *input >> ws >> atom1;
   *input >> ws >> atom2;
-  cout << Verbose(1) << "Scanning file\n";
+  Log() << Verbose(1) << "Scanning file\n";
   while (!input->eof()) // Check whether we read everything already
   {
@@ -96 +97 @@
  * \param *BG BondGraph with the member function above or NULL, if just standard covalent should be used.
  */
-void molecule::CreateAdjacencyList(ofstream *out, double bonddistance, bool IsAngstroem, void (BondGraph::*minmaxdistance)(BondedParticle * const , BondedParticle * const , double &, double &, bool), BondGraph *BG)
+void molecule::CreateAdjacencyList(double bonddistance, bool IsAngstroem, void (BondGraph::*minmaxdistance)(BondedParticle * const , BondedParticle * const , double &, double &, bool), BondGraph *BG)
 {
   atom *Walker = NULL;
@@ -112 +113 @@
 
   BondDistance = bonddistance; // * ((IsAngstroem) ? 1. : 1./AtomicLengthToAngstroem);
-  *out << Verbose(0) << "Begin of CreateAdjacencyList." << endl;
+  Log() << Verbose(0) << "Begin of CreateAdjacencyList." << endl;
   // remove every bond from the list
   bond *Binder = NULL;
@@ -124 +125 @@
 
   // count atoms in molecule = dimension of matrix (also give each unique name and continuous numbering)
-  CountAtoms(out);
-  *out << Verbose(1) << "AtomCount " << AtomCount << " and bonddistance is " << bonddistance << "." << endl;
+  CountAtoms();
+  Log() << Verbose(1) << "AtomCount " << AtomCount << " and bonddistance is " << bonddistance << "." << endl;
 
   if ((AtomCount > 1) && (bonddistance > 1.)) {
-    *out << Verbose(2) << "Creating Linked Cell structure ... " << endl;
+    Log() << Verbose(2) << "Creating Linked Cell structure ... " << endl;
     LC = new LinkedCell(this, bonddistance);
 
     // create a list to map Tesselpoint::nr to atom *
-    *out << Verbose(2) << "Creating TesselPoint to atom map ... " << endl;
+    Log() << Verbose(2) << "Creating TesselPoint to atom map ... " << endl;
     AtomMap = Calloc<atom *> (AtomCount, "molecule::CreateAdjacencyList - **AtomCount");
     Walker = start;
@@ -141 +142 @@
 
     // 3a. go through every cell
-    *out << Verbose(2) << "Celling ... " << endl;
+    Log() << Verbose(2) << "Celling ... " << endl;
     for (LC->n[0] = 0; LC->n[0] < LC->N[0]; LC->n[0]++)
       for (LC->n[1] = 0; LC->n[1] < LC->N[1]; LC->n[1]++)
         for (LC->n[2] = 0; LC->n[2] < LC->N[2]; LC->n[2]++) {
           const LinkedNodes *List = LC->GetCurrentCell();
-          //*out << Verbose(2) << "Current cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << " containing " << List->size() << " points." << endl;
+          //Log() << Verbose(2) << "Current cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << " containing " << List->size() << " points." << endl;
           if (List != NULL) {
             for (LinkedNodes::const_iterator Runner = List->begin(); Runner != List->end(); Runner++) {
               Walker = AtomMap[(*Runner)->nr];
-              //*out << Verbose(0) << "Current Atom is " << *Walker << "." << endl;
+              //Log() << Verbose(0) << "Current Atom is " << *Walker << "." << endl;
               // 3c. check for possible bond between each atom in this and every one in the 27 cells
               for (n[0] = -1; n[0] <= 1; n[0]++)
@@ -156 +157 @@
                   for (n[2] = -1; n[2] <= 1; n[2]++) {
                     const LinkedNodes *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;
+                    //Log() << Verbose(2) << "Current relative cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << " containing " << List->size() << " points." << endl;
                     if (OtherList != NULL) {
                       for (LinkedNodes::const_iterator OtherRunner = OtherList->begin(); OtherRunner != OtherList->end(); OtherRunner++) {
                         if ((*OtherRunner)->nr > Walker->nr) {
                           OtherWalker = AtomMap[(*OtherRunner)->nr];
-                          //*out << Verbose(1) << "Checking distance " << OtherWalker->x.PeriodicDistanceSquared(&(Walker->x), cell_size) << " against typical bond length of " << bonddistance*bonddistance << "." << endl;
+                          //Log() << Verbose(1) << "Checking distance " << OtherWalker->x.PeriodicDistanceSquared(&(Walker->x), cell_size) << " against typical bond length of " << bonddistance*bonddistance << "." << endl;
                           (BG->*minmaxdistance)(Walker, OtherWalker, MinDistance, MaxDistance, IsAngstroem);
                           const double distance = OtherWalker->x.PeriodicDistanceSquared(&(Walker->x), cell_size);
                           const bool status = (distance <= MaxDistance * MaxDistance) && (distance >= MinDistance * MinDistance);
                           if ((OtherWalker->father->nr > Walker->father->nr) && (status)) { // create bond if distance is smaller
-                            //*out << Verbose(1) << "Adding Bond between " << *Walker << " and " << *OtherWalker << " in distance " << sqrt(distance) << "." << endl;
+                            //Log() << Verbose(1) << "Adding Bond between " << *Walker << " and " << *OtherWalker << " in distance " << sqrt(distance) << "." << endl;
                             AddBond(Walker->father, OtherWalker->father, 1); // also increases molecule::BondCount
                           } else {
-                            //*out << Verbose(1) << "Not Adding: Wrong label order or distance too great." << endl;
+                            //Log() << Verbose(1) << "Not Adding: Wrong label order or distance too great." << endl;
                           }
                         }
@@ -180 +181 @@
     Free(&AtomMap);
     delete (LC);
-    *out << Verbose(1) << "I detected " << BondCount << " bonds in the molecule with distance " << BondDistance << "." << endl;
+    Log() << Verbose(1) << "I detected " << BondCount << " bonds in the molecule with distance " << BondDistance << "." << endl;
 
     // correct bond degree by comparing valence and bond degree
-    *out << Verbose(2) << "Correcting bond degree ... " << endl;
-    CorrectBondDegree(out);
+    Log() << Verbose(2) << "Correcting bond degree ... " << endl;
+    CorrectBondDegree();
 
     // output bonds for debugging (if bond chain list was correctly installed)
-    ActOnAllAtoms(&atom::OutputBondOfAtom, out);
+    ActOnAllAtoms( &atom::OutputBondOfAtom );
   } else
-    *out << Verbose(1) << "AtomCount is " << AtomCount << ", thus no bonds, no connections!." << endl;
-  *out << Verbose(0) << "End of CreateAdjacencyList." << endl;
+    Log() << Verbose(1) << "AtomCount is " << AtomCount << ", thus no bonds, no connections!." << endl;
+  Log() << Verbose(0) << "End of CreateAdjacencyList." << endl;
   if (free_BG)
     delete(BG);
@@ -199 +200 @@
  * \param output stream
  */
-void molecule::OutputBondsList(ofstream *out) const
-{
-  *out << Verbose(1) << endl << "From contents of bond chain list:";
+void molecule::OutputBondsList() const
+{
+  Log() << Verbose(1) << endl << "From contents of bond chain list:";
   bond *Binder = first;
   while (Binder->next != last) {
     Binder = Binder->next;
-    *out << *Binder << "\t" << endl;
-  }
-  *out << endl;
+    Log() << Verbose(0) << *Binder << "\t" << endl;
+  }
+  Log() << Verbose(0) << endl;
 }
 ;
@@ -219 +220 @@
  * \return number of bonds that could not be corrected
  */
-int molecule::CorrectBondDegree(ofstream *out) const
+int molecule::CorrectBondDegree() const
 {
   int No = 0, OldNo = -1;
 
   if (BondCount != 0) {
-    *out << Verbose(1) << "Correcting Bond degree of each bond ... " << endl;
+    Log() << Verbose(1) << "Correcting Bond degree of each bond ... " << endl;
     do {
       OldNo = No;
-      No = SumPerAtom(&atom::CorrectBondDegree, out);
+      No = SumPerAtom( &atom::CorrectBondDegree );
     } while (OldNo != No);
-    *out << " done." << endl;
+    Log() << Verbose(0) << " done." << endl;
   } else {
-    *out << Verbose(1) << "BondCount is " << BondCount << ", no bonds between any of the " << AtomCount << " atoms." << endl;
-  }
-  *out << No << " bonds could not be corrected." << endl;
+    Log() << Verbose(1) << "BondCount is " << BondCount << ", no bonds between any of the " << AtomCount << " atoms." << endl;
+  }
+  Log() << Verbose(0) << No << " bonds could not be corrected." << endl;
 
   return (No);
@@ -244 +245 @@
  * \return number opf cyclic bonds
  */
-int molecule::CountCyclicBonds(ofstream *out)
+int molecule::CountCyclicBonds()
 {
   NoCyclicBonds = 0;
@@ -252 +253 @@
   bond *Binder = first;
   if ((Binder->next != last) && (Binder->next->Type == Undetermined)) {
-    *out << Verbose(0) << "No Depth-First-Search analysis performed so far, calling ..." << endl;
-    Subgraphs = DepthFirstSearchAnalysis(out, BackEdgeStack);
+    Log() << Verbose(0) << "No Depth-First-Search analysis performed so far, calling ..." << endl;
+    Subgraphs = DepthFirstSearchAnalysis(BackEdgeStack);
     while (Subgraphs->next != NULL) {
       Subgraphs = Subgraphs->next;
@@ -302 +303 @@
  * \param &BFS structure with accounting data for BFS
  */
-void DepthFirstSearchAnalysis_SetWalkersGraphNr(ofstream *out, atom *&Walker, struct DFSAccounting &DFS)
+void DepthFirstSearchAnalysis_SetWalkersGraphNr(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;
+    Log() << Verbose(1) << "Setting Walker[" << Walker->Name << "]'s number to " << Walker->GraphNr << " with Lowpoint " << Walker->LowpointNr << "." << endl;
     DFS.AtomStack->Push(Walker);
     DFS.CurrentGraphNr++;
@@ -324 +325 @@
  * \param &DFS DFS accounting data
  */
-void DepthFirstSearchAnalysis_ProbeAlongUnusedBond(ofstream *out, const molecule * const mol, atom *&Walker, bond *&Binder, struct DFSAccounting &DFS)
+void DepthFirstSearchAnalysis_ProbeAlongUnusedBond(const molecule * const mol, atom *&Walker, bond *&Binder, struct DFSAccounting &DFS)
 {
   atom *OtherAtom = NULL;
@@ -334 +335 @@
     if (Binder == NULL)
       break;
-    *out << Verbose(2) << "Current Unused Bond is " << *Binder << "." << endl;
+    Log() << Verbose(2) << "Current Unused Bond is " << *Binder << "." << endl;
     // (4) Mark Binder used, ...
     Binder->MarkUsed(black);
     OtherAtom = Binder->GetOtherAtom(Walker);
-    *out << Verbose(2) << "(4) OtherAtom is " << OtherAtom->Name << "." << endl;
+    Log() << Verbose(2) << "(4) OtherAtom is " << OtherAtom->Name << "." << endl;
     if (OtherAtom->GraphNr != -1) {
       // (4a) ... if "other" atom has been visited (GraphNr != 0), set lowpoint to minimum of both, go to (3)
@@ -344 +345 @@
       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;
+      Log() << Verbose(3) << "(4a) Visited: Setting Lowpoint of Walker[" << Walker->Name << "] to " << Walker->LowpointNr << "." << endl;
     } else {
       // (4b) ... otherwise set OtherAtom as Ancestor of Walker and Walker as OtherAtom, go to (2)
@@ -350 +351 @@
       OtherAtom->Ancestor = Walker;
       Walker = OtherAtom;
-      *out << Verbose(3) << "(4b) Not Visited: OtherAtom[" << OtherAtom->Name << "]'s Ancestor is now " << OtherAtom->Ancestor->Name << ", Walker is OtherAtom " << OtherAtom->Name << "." << endl;
+      Log() << Verbose(3) << "(4b) Not Visited: OtherAtom[" << OtherAtom->Name << "]'s Ancestor is now " << OtherAtom->Ancestor->Name << ", Walker is OtherAtom " << OtherAtom->Name << "." << endl;
       break;
     }
@@ -367 +368 @@
  * \param &DFS DFS accounting data
  */
-void DepthFirstSearchAnalysis_CheckForaNewComponent(ofstream *out, const molecule * const mol, atom *&Walker, struct DFSAccounting &DFS, MoleculeLeafClass *&LeafWalker)
+void DepthFirstSearchAnalysis_CheckForaNewComponent(const molecule * const mol, atom *&Walker, struct DFSAccounting &DFS, MoleculeLeafClass *&LeafWalker)
 {
   atom *OtherAtom = NULL;
 
   // (5) if Ancestor of Walker is ...
-  *out << Verbose(1) << "(5) Number of Walker[" << Walker->Name << "]'s Ancestor[" << Walker->Ancestor->Name << "] is " << Walker->Ancestor->GraphNr << "." << endl;
+  Log() << Verbose(1) << "(5) Number of Walker[" << Walker->Name << "]'s Ancestor[" << Walker->Ancestor->Name << "] is " << Walker->Ancestor->GraphNr << "." << endl;
 
   if (Walker->Ancestor->GraphNr != DFS.Root->GraphNr) {
@@ -379 +380 @@
       // (6a) set Ancestor's Lowpoint number to minimum of of its Ancestor and itself, go to Step(8)
       Walker->Ancestor->LowpointNr = (Walker->Ancestor->LowpointNr < Walker->LowpointNr) ? Walker->Ancestor->LowpointNr : Walker->LowpointNr;
-      *out << Verbose(2) << "(6) Setting Walker[" << Walker->Name << "]'s Ancestor[" << Walker->Ancestor->Name << "]'s Lowpoint to " << Walker->Ancestor->LowpointNr << "." << endl;
+      Log() << Verbose(2) << "(6) Setting Walker[" << Walker->Name << "]'s Ancestor[" << Walker->Ancestor->Name << "]'s Lowpoint to " << Walker->Ancestor->LowpointNr << "." << endl;
     } else {
       // (7) (Ancestor of Walker is a separating vertex, remove all from stack till Walker (including), these and Ancestor form a component
       Walker->Ancestor->SeparationVertex = true;
-      *out << Verbose(2) << "(7) Walker[" << Walker->Name << "]'s Ancestor[" << Walker->Ancestor->Name << "]'s is a separating vertex, creating component." << endl;
+      Log() << Verbose(2) << "(7) Walker[" << Walker->Name << "]'s Ancestor[" << Walker->Ancestor->Name << "]'s is a separating vertex, creating component." << endl;
       mol->SetNextComponentNumber(Walker->Ancestor, DFS.ComponentNumber);
-      *out << Verbose(3) << "(7) Walker[" << Walker->Name << "]'s Ancestor's Compont is " << DFS.ComponentNumber << "." << endl;
+      Log() << 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;
+      Log() << Verbose(3) << "(7) Walker[" << Walker->Name << "]'s Compont is " << DFS.ComponentNumber << "." << endl;
       do {
         OtherAtom = DFS.AtomStack->PopLast();
         LeafWalker->Leaf->AddCopyAtom(OtherAtom);
         mol->SetNextComponentNumber(OtherAtom, DFS.ComponentNumber);
-        *out << Verbose(3) << "(7) Other[" << OtherAtom->Name << "]'s Compont is " << DFS.ComponentNumber << "." << endl;
+        Log() << Verbose(3) << "(7) Other[" << OtherAtom->Name << "]'s Compont is " << DFS.ComponentNumber << "." << endl;
       } while (OtherAtom != Walker);
       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;
+    Log() << Verbose(2) << "(8) Walker[" << Walker->Name << "] is now its Ancestor " << Walker->Ancestor->Name << ", backstepping. " << endl;
     Walker = Walker->Ancestor;
     DFS.BackStepping = true;
@@ -413 +414 @@
  * \param &DFS DFS accounting data
  */
-void DepthFirstSearchAnalysis_CleanRootStackDownTillWalker(ofstream *out, const molecule * const mol, atom *&Walker, bond *&Binder, struct DFSAccounting &DFS, MoleculeLeafClass *&LeafWalker)
+void DepthFirstSearchAnalysis_CleanRootStackDownTillWalker(const molecule * const mol, atom *&Walker, bond *&Binder, struct DFSAccounting &DFS, MoleculeLeafClass *&LeafWalker)
 {
   atom *OtherAtom = NULL;
@@ -421 +422 @@
     //DFS.AtomStack->Output(out);
     mol->SetNextComponentNumber(DFS.Root, DFS.ComponentNumber);
-    *out << Verbose(3) << "(9) Root[" << DFS.Root->Name << "]'s Component is " << DFS.ComponentNumber << "." << endl;
+    Log() << 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;
+    Log() << Verbose(3) << "(9) Walker[" << Walker->Name << "]'s Component is " << DFS.ComponentNumber << "." << endl;
     do {
       OtherAtom = DFS.AtomStack->PopLast();
       LeafWalker->Leaf->AddCopyAtom(OtherAtom);
       mol->SetNextComponentNumber(OtherAtom, DFS.ComponentNumber);
-      *out << Verbose(3) << "(7) Other[" << OtherAtom->Name << "]'s Compont is " << DFS.ComponentNumber << "." << endl;
+      Log() << Verbose(3) << "(7) Other[" << OtherAtom->Name << "]'s Compont is " << DFS.ComponentNumber << "." << endl;
     } while (OtherAtom != Walker);
     DFS.ComponentNumber++;
@@ -435 +436 @@
     Walker = DFS.Root;
     Binder = mol->FindNextUnused(Walker);
-    *out << Verbose(1) << "(10) Walker is Root[" << DFS.Root->Name << "], next Unused Bond is " << Binder << "." << endl;
+    Log() << 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;
+      Log() << Verbose(1) << "(11) Root is a separation vertex." << endl;
       Walker->SeparationVertex = true;
     }
@@ -449 +450 @@
  * \param *mol molecule with AtomCount, BondCount and all atoms
  */
-void DepthFirstSearchAnalysis_Init(ofstream *out, struct DFSAccounting &DFS, const molecule * const mol)
+void DepthFirstSearchAnalysis_Init(struct DFSAccounting &DFS, const molecule * const mol)
 {
   DFS.AtomStack = new StackClass<atom *> (mol->AtomCount);
@@ -466 +467 @@
  * \param &DFS accounting structure to free
  */
-void DepthFirstSearchAnalysis_Finalize(ofstream *out, struct DFSAccounting &DFS)
+void DepthFirstSearchAnalysis_Finalize(struct DFSAccounting &DFS)
 {
   delete (DFS.AtomStack);
@@ -481 +482 @@
  * \return list of each disconnected subgraph as an individual molecule class structure
  */
-MoleculeLeafClass * molecule::DepthFirstSearchAnalysis(ofstream *out, class StackClass<bond *> *&BackEdgeStack) const
+MoleculeLeafClass * molecule::DepthFirstSearchAnalysis(class StackClass<bond *> *&BackEdgeStack) const
 {
   struct DFSAccounting DFS;
@@ -492 +493 @@
   bond *Binder = NULL;
 
-  *out << Verbose(0) << "Begin of DepthFirstSearchAnalysis" << endl;
-  DepthFirstSearchAnalysis_Init(out, DFS, this);
+  Log() << Verbose(0) << "Begin of DepthFirstSearchAnalysis" << endl;
+  DepthFirstSearchAnalysis_Init(DFS, this);
 
   DFS.Root = start->next;
@@ -509 +510 @@
     do { // (10)
       do { // (2) set number and Lowpoint of Atom to i, increase i, push current atom
-        DepthFirstSearchAnalysis_SetWalkersGraphNr(out, Walker, DFS);
-
-        DepthFirstSearchAnalysis_ProbeAlongUnusedBond(out, this, Walker, Binder, DFS);
+        DepthFirstSearchAnalysis_SetWalkersGraphNr(Walker, DFS);
+
+        DepthFirstSearchAnalysis_ProbeAlongUnusedBond(this, Walker, Binder, DFS);
 
         if (Binder == NULL) {
-          *out << Verbose(2) << "No more Unused Bonds." << endl;
+          Log() << Verbose(2) << "No more Unused Bonds." << endl;
           break;
         } else
@@ -524 +525 @@
         break;
 
-      DepthFirstSearchAnalysis_CheckForaNewComponent(out, this, Walker, DFS, LeafWalker);
-
-      DepthFirstSearchAnalysis_CleanRootStackDownTillWalker(out, this, Walker, Binder, DFS, LeafWalker);
+      DepthFirstSearchAnalysis_CheckForaNewComponent(this, Walker, DFS, LeafWalker);
+
+      DepthFirstSearchAnalysis_CleanRootStackDownTillWalker(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 " << DFS.CurrentGraphNr << "." << endl;
-    LeafWalker->Leaf->Output(out);
-    *out << endl;
+    Log() << Verbose(0) << "Disconnected subgraph ranges from " << OldGraphNr << " to " << DFS.CurrentGraphNr << "." << endl;
+    LeafWalker->Leaf->Output((ofstream *)&cout);
+    Log() << Verbose(0) << endl;
 
     // step on to next root
     while ((DFS.Root != end) && (DFS.Root->GraphNr != -1)) {
-      //*out << Verbose(1) << "Current next subgraph root candidate is " << Root->Name << "." << endl;
+      //Log() << Verbose(1) << "Current next subgraph root candidate is " << Root->Name << "." << endl;
       if (DFS.Root->GraphNr != -1) // if already discovered, step on
         DFS.Root = DFS.Root->next;
@@ -545 +546 @@
   CyclicBondAnalysis();
 
-  OutputGraphInfoPerAtom(out);
-
-  OutputGraphInfoPerBond(out);
+  OutputGraphInfoPerAtom();
+
+  OutputGraphInfoPerBond();
 
   // free all and exit
-  DepthFirstSearchAnalysis_Finalize(out, DFS);
-  *out << Verbose(0) << "End of DepthFirstSearchAnalysis" << endl;
+  DepthFirstSearchAnalysis_Finalize(DFS);
+  Log() << Verbose(0) << "End of DepthFirstSearchAnalysis" << endl;
   return SubGraphs;
 }
@@ -575 +576 @@
  * \param *out output stream
  */
-void molecule::OutputGraphInfoPerAtom(ofstream *out) const
-{
-  *out << Verbose(1) << "Final graph info for each atom is:" << endl;
-  ActOnAllAtoms(&atom::OutputGraphInfo, out);
+void molecule::OutputGraphInfoPerAtom() const
+{
+  Log() << Verbose(1) << "Final graph info for each atom is:" << endl;
+  ActOnAllAtoms( &atom::OutputGraphInfo );
 }
 ;
@@ -585 +586 @@
  * \param *out output stream
  */
-void molecule::OutputGraphInfoPerBond(ofstream *out) const
-{
-  *out << Verbose(1) << "Final graph info for each bond is:" << endl;
+void molecule::OutputGraphInfoPerBond() const
+{
+  Log() << Verbose(1) << "Final graph info for each bond is:" << endl;
   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.";
-    Binder->leftatom->OutputComponentNumber(out);
-    *out << " ===  ";
-    *out << ((Binder->rightatom->SeparationVertex) ? "SP," : "") << "L" << Binder->rightatom->LowpointNr << " G" << Binder->rightatom->GraphNr << " Comp.";
-    Binder->rightatom->OutputComponentNumber(out);
-    *out << ">." << endl;
+    Log() << Verbose(2) << ((Binder->Type == TreeEdge) ? "TreeEdge " : "BackEdge ") << *Binder << ": <";
+    Log() << Verbose(0) << ((Binder->leftatom->SeparationVertex) ? "SP," : "") << "L" << Binder->leftatom->LowpointNr << " G" << Binder->leftatom->GraphNr << " Comp.";
+    Binder->leftatom->OutputComponentNumber();
+    Log() << Verbose(0) << " ===  ";
+    Log() << Verbose(0) << ((Binder->rightatom->SeparationVertex) ? "SP," : "") << "L" << Binder->rightatom->LowpointNr << " G" << Binder->rightatom->GraphNr << " Comp.";
+    Binder->rightatom->OutputComponentNumber();
+    Log() << Verbose(0) << ">." << endl;
     if (Binder->Cyclic) // cyclic ??
-      *out << Verbose(3) << "Lowpoint at each side are equal: CYCLIC!" << endl;
+      Log() << Verbose(3) << "Lowpoint at each side are equal: CYCLIC!" << endl;
   }
 }
@@ -609 +610 @@
  * \param AtomCount number of entries in the array to allocate
  */
-void InitializeBFSAccounting(ofstream *out, struct BFSAccounting &BFS, int AtomCount)
+void InitializeBFSAccounting(struct BFSAccounting &BFS, int AtomCount)
 {
   BFS.AtomCount = AtomCount;
@@ -625 +626 @@
  * \param &BFS accounting structure
  */
-void FinalizeBFSAccounting(ofstream *out, struct BFSAccounting &BFS)
+void FinalizeBFSAccounting(struct BFSAccounting &BFS)
 {
   Free(&BFS.PredecessorList);
@@ -638 +639 @@
  * \param &BFS accounting structure
  */
-void CleanBFSAccounting(ofstream *out, struct BFSAccounting &BFS)
+void CleanBFSAccounting(struct BFSAccounting &BFS)
 {
   atom *Walker = NULL;
@@ -654 +655 @@
  * \param &BFS accounting structure
  */
-void ResetBFSAccounting(ofstream *out, atom *&Walker, struct BFSAccounting &BFS)
+void ResetBFSAccounting(atom *&Walker, struct BFSAccounting &BFS)
 {
   BFS.ShortestPathList[Walker->nr] = 0;
@@ -667 +668 @@
  * \param &BFS accounting structure
  */
-void CyclicStructureAnalysis_CyclicBFSFromRootToRoot(ofstream *out, bond *&BackEdge, struct BFSAccounting &BFS)
+void CyclicStructureAnalysis_CyclicBFSFromRootToRoot(bond *&BackEdge, struct BFSAccounting &BFS)
 {
   atom *Walker = NULL;
@@ -673 +674 @@
   do { // look for Root
     Walker = BFS.BFSStack->PopFirst();
-    *out << Verbose(2) << "Current Walker is " << *Walker << ", we look for SP to Root " << *BFS.Root << "." << endl;
+    Log() << 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)
@@ -680 +681 @@
         if (OtherAtom->type->Z != 1) {
 #endif
-        *out << Verbose(2) << "Current OtherAtom is: " << OtherAtom->Name << " for bond " << *(*Runner) << "." << endl;
+        Log() << Verbose(2) << "Current OtherAtom is: " << OtherAtom->Name << " for bond " << *(*Runner) << "." << endl;
         if (BFS.ColorList[OtherAtom->nr] == white) {
           BFS.TouchedStack->Push(OtherAtom);
@@ -686 +687 @@
           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;
+          Log() << 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;
+          Log() << Verbose(3) << "Putting OtherAtom into queue." << endl;
           BFS.BFSStack->Push(OtherAtom);
           //}
         } else {
-          *out << Verbose(3) << "Not Adding, has already been visited." << endl;
+          Log() << Verbose(3) << "Not Adding, has already been visited." << endl;
         }
         if (OtherAtom == BFS.Root)
@@ -698 +699 @@
 #ifdef ADDHYDROGEN
       } else {
-        *out << Verbose(2) << "Skipping hydrogen atom " << *OtherAtom << "." << endl;
+        Log() << 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;
+        Log() << Verbose(2) << "Bond " << *(*Runner) << " not Visiting, is the back edge." << endl;
       }
     }
     BFS.ColorList[Walker->nr] = black;
-    *out << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl;
+    Log() << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl;
     if (OtherAtom == BFS.Root) { // if we have found the root, check whether this cycle wasn't already found beforehand
       // step through predecessor list
@@ -717 +718 @@
       }
       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;
+        Log() << Verbose(3) << "This cycle was already found before, skipping and removing seeker from search." << endl;
         do {
           OtherAtom = BFS.TouchedStack->PopLast();
           if (BFS.PredecessorList[OtherAtom->nr] == Walker) {
-            *out << Verbose(4) << "Removing " << *OtherAtom << " from lists and stacks." << endl;
+            Log() << Verbose(4) << "Removing " << *OtherAtom << " from lists and stacks." << endl;
             BFS.PredecessorList[OtherAtom->nr] = NULL;
             BFS.ShortestPathList[OtherAtom->nr] = -1;
@@ -744 +745 @@
  * \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)
+void CyclicStructureAnalysis_RetrieveCycleMembers(atom *&OtherAtom, bond *&BackEdge, struct BFSAccounting &BFS, int *&MinimumRingSize, int &MinRingSize)
 {
   atom *Walker = NULL;
@@ -755 +756 @@
     RingSize = 1;
     BFS.Root->GetTrueFather()->IsCyclic = true;
-    *out << Verbose(1) << "Found ring contains: ";
+    Log() << Verbose(1) << "Found ring contains: ";
     Walker = BFS.Root;
     while (Walker != BackEdge->rightatom) {
-      *out << Walker->Name << " <-> ";
+      Log() << Verbose(0) << Walker->Name << " <-> ";
       Walker = BFS.PredecessorList[Walker->nr];
       Walker->GetTrueFather()->IsCyclic = true;
       RingSize++;
     }
-    *out << Walker->Name << "  with a length of " << RingSize << "." << endl << endl;
+    Log() << Verbose(0) << Walker->Name << "  with a length of " << RingSize << "." << endl << endl;
     // walk through all and set MinimumRingSize
     Walker = BFS.Root;
@@ -775 +776 @@
       MinRingSize = RingSize;
   } else {
-    *out << Verbose(1) << "No ring containing " << *BFS.Root << " with length equal to or smaller than " << MinimumRingSize[Walker->GetTrueFather()->nr] << " found." << endl;
+    Log() << Verbose(1) << "No ring containing " << *BFS.Root << " with length equal to or smaller than " << MinimumRingSize[Walker->GetTrueFather()->nr] << " found." << endl;
   }
 };
@@ -785 +786 @@
  * \param AtomCount number of nodes in graph
  */
-void CyclicStructureAnalysis_BFSToNextCycle(ofstream *out, atom *&Root, atom *&Walker, int *&MinimumRingSize, int AtomCount)
+void CyclicStructureAnalysis_BFSToNextCycle(atom *&Root, atom *&Walker, int *&MinimumRingSize, int AtomCount)
 {
   struct BFSAccounting BFS;
   atom *OtherAtom = Walker;
 
-  InitializeBFSAccounting(out, BFS, AtomCount);
-
-  ResetBFSAccounting(out, Walker, BFS);
+  InitializeBFSAccounting(BFS, AtomCount);
+
+  ResetBFSAccounting(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;
+    //Log() << 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)) {
       // "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;
+        //Log() << Verbose(2) << "Current OtherAtom is: " << OtherAtom->Name << " for bond " << *Binder << "." << endl;
         if (BFS.ColorList[OtherAtom->nr] == white) {
           BFS.TouchedStack->Push(OtherAtom);
@@ -806 +807 @@
           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;
+          //Log() << 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] = BFS.ShortestPathList[OtherAtom->nr] + MinimumRingSize[OtherAtom->GetTrueFather()->nr];
@@ -814 +815 @@
             BFS.BFSStack->Push(OtherAtom);
         } else {
-          //*out << Verbose(3) << "Not Adding, has already been visited." << endl;
+          //Log() << Verbose(3) << "Not Adding, has already been visited." << endl;
         }
       } else {
-        //*out << Verbose(3) << "Not Visiting, is a back edge." << endl;
+        //Log() << Verbose(3) << "Not Visiting, is a back edge." << endl;
       }
     }
     BFS.ColorList[Walker->nr] = black;
-    //*out << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl;
+    //Log() << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl;
   }
   //CleanAccountingLists(TouchedStack, PredecessorList, ShortestPathList, ColorList);
 
-  FinalizeBFSAccounting(out, BFS);
+  FinalizeBFSAccounting(BFS);
 }
 ;
@@ -836 +837 @@
  * \param *mol molecule with atoms
  */
-void CyclicStructureAnalysis_AssignRingSizetoNonCycleMembers(ofstream *out, int *&MinimumRingSize, int &MinRingSize, int &NumCycles, const molecule * const mol)
+void CyclicStructureAnalysis_AssignRingSizetoNonCycleMembers(int *&MinimumRingSize, int &MinRingSize, int &NumCycles, const molecule * const mol)
 {
   atom *Root = NULL;
@@ -849 +850 @@
         Walker = Root;
 
-        //*out << Verbose(1) << "---------------------------------------------------------------------------------------------------------" << endl;
-        CyclicStructureAnalysis_BFSToNextCycle(out, Root, Walker, MinimumRingSize, mol->AtomCount);
+        //Log() << Verbose(1) << "---------------------------------------------------------------------------------------------------------" << endl;
+        CyclicStructureAnalysis_BFSToNextCycle(Root, Walker, MinimumRingSize, mol->AtomCount);
 
       }
-      *out << Verbose(1) << "Minimum ring size of " << *Root << " is " << MinimumRingSize[Root->GetTrueFather()->nr] << "." << endl;
-    }
-    *out << Verbose(1) << "Minimum ring size is " << MinRingSize << ", over " << NumCycles << " cycles total." << endl;
+      Log() << Verbose(1) << "Minimum ring size of " << *Root << " is " << MinimumRingSize[Root->GetTrueFather()->nr] << "." << endl;
+    }
+    Log() << Verbose(1) << "Minimum ring size is " << MinRingSize << ", over " << NumCycles << " cycles total." << endl;
   } else
-    *out << Verbose(1) << "No rings were detected in the molecular structure." << endl;
+    Log() << Verbose(1) << "No rings were detected in the molecular structure." << endl;
 }
 ;
@@ -871 +872 @@
  * \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) const
+void molecule::CyclicStructureAnalysis(class StackClass<bond *> * BackEdgeStack, int *&MinimumRingSize) const
 {
   struct BFSAccounting BFS;
@@ -880 +881 @@
   int MinRingSize = -1;
 
-  InitializeBFSAccounting(out, BFS, AtomCount);
-
-  //*out << Verbose(1) << "Back edge list - ";
+  InitializeBFSAccounting(BFS, AtomCount);
+
+  //Log() << Verbose(1) << "Back edge list - ";
   //BackEdgeStack->Output(out);
 
-  *out << Verbose(1) << "Analysing cycles ... " << endl;
+  Log() << Verbose(1) << "Analysing cycles ... " << endl;
   NumCycles = 0;
   while (!BackEdgeStack->IsEmpty()) {
@@ -894 +895 @@
     Walker = BackEdge->rightatom;
 
-    ResetBFSAccounting(out, Walker, BFS);
-
-    *out << Verbose(1) << "---------------------------------------------------------------------------------------------------------" << endl;
+    ResetBFSAccounting(Walker, BFS);
+
+    Log() << Verbose(1) << "---------------------------------------------------------------------------------------------------------" << endl;
     OtherAtom = NULL;
-    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);
+    CyclicStructureAnalysis_CyclicBFSFromRootToRoot(BackEdge, BFS);
+
+    CyclicStructureAnalysis_RetrieveCycleMembers(OtherAtom, BackEdge, BFS, MinimumRingSize, MinRingSize);
+
+    CleanBFSAccounting(BFS);
+  }
+  FinalizeBFSAccounting(BFS);
+
+  CyclicStructureAnalysis_AssignRingSizetoNonCycleMembers(MinimumRingSize, MinRingSize, NumCycles, this);
 };
 
@@ -926 +927 @@
     }
     if (i == vertex->ListOfBonds.size())
-      cerr << "Error: All Component entries are already occupied!" << endl;
+      eLog() << Verbose(0) << "Error: All Component entries are already occupied!" << endl;
   } else
-    cerr << "Error: Given vertex is NULL!" << endl;
+    eLog() << Verbose(0) << "Error: Given vertex is NULL!" << endl;
 }
 ;
@@ -962 +963 @@
  * \param *list
  */
-void OutputAlreadyVisited(ofstream *out, int *list)
-{
-  *out << Verbose(4) << "Already Visited Bonds:\t";
+void OutputAlreadyVisited(int *list)
+{
+  Log() << Verbose(4) << "Already Visited Bonds:\t";
   for (int i = 1; i <= list[0]; i++)
-    *out << Verbose(0) << list[i] << "  ";
-  *out << endl;
+    Log() << Verbose(0) << list[i] << "  ";
+  Log() << Verbose(0) << endl;
 }
 ;
@@ -977 +978 @@
  * \return true - file written successfully, false - writing failed
  */
-bool molecule::StoreAdjacencyToFile(ofstream *out, char *path)
+bool molecule::StoreAdjacencyToFile(char *path)
 {
   ofstream AdjacencyFile;
@@ -985 +986 @@
   line << path << "/" << FRAGMENTPREFIX << ADJACENCYFILE;
   AdjacencyFile.open(line.str().c_str(), ios::out);
-  *out << Verbose(1) << "Saving adjacency list ... ";
+  Log() << Verbose(1) << "Saving adjacency list ... ";
   if (AdjacencyFile != NULL) {
     ActOnAllAtoms(&atom::OutputAdjacency, &AdjacencyFile);
     AdjacencyFile.close();
-    *out << Verbose(1) << "done." << endl;
+    Log() << Verbose(1) << "done." << endl;
   } else {
-    *out << Verbose(1) << "failed to open file " << line.str() << "." << endl;
+    Log() << Verbose(1) << "failed to open file " << line.str() << "." << endl;
     status = false;
   }
@@ -999 +1000 @@
 ;
 
-bool CheckAdjacencyFileAgainstMolecule_Init(ofstream *out, char *path, ifstream &File, int *&CurrentBonds)
+bool CheckAdjacencyFileAgainstMolecule_Init(char *path, ifstream &File, int *&CurrentBonds)
 {
   stringstream filename;
   filename << path << "/" << FRAGMENTPREFIX << ADJACENCYFILE;
   File.open(filename.str().c_str(), ios::out);
-  *out << Verbose(1) << "Looking at bond structure stored in adjacency file and comparing to present one ... ";
+  Log() << Verbose(1) << "Looking at bond structure stored in adjacency file and comparing to present one ... ";
   if (File == NULL)
     return false;
@@ -1014 +1015 @@
 ;
 
-void CheckAdjacencyFileAgainstMolecule_Finalize(ofstream *out, ifstream &File, int *&CurrentBonds)
+void CheckAdjacencyFileAgainstMolecule_Finalize(ifstream &File, int *&CurrentBonds)
 {
   File.close();
@@ -1022 +1023 @@
 ;
 
-void CheckAdjacencyFileAgainstMolecule_CompareBonds(ofstream *out, bool &status, int &NonMatchNumber, atom *&Walker, size_t &CurrentBondsOfAtom, int AtomNr, int *&CurrentBonds, atom **ListOfAtoms)
+void CheckAdjacencyFileAgainstMolecule_CompareBonds(bool &status, int &NonMatchNumber, atom *&Walker, size_t &CurrentBondsOfAtom, int AtomNr, int *&CurrentBonds, atom **ListOfAtoms)
 {
   size_t j = 0;
   int id = -1;
 
-  //*out << Verbose(2) << "Walker is " << *Walker << ", bond partners: ";
+  //Log() << Verbose(2) << "Walker is " << *Walker << ", bond partners: ";
   if (CurrentBondsOfAtom == Walker->ListOfBonds.size()) {
     for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
@@ -1038 +1039 @@
         NonMatchNumber++;
         status = false;
-        //*out << "[" << id << "]\t";
+        //Log() << Verbose(0) << "[" << id << "]\t";
       } else {
-        //*out << id << "\t";
+        //Log() << Verbose(0) << id << "\t";
       }
     }
-    //*out << endl;
+    //Log() << Verbose(0) << endl;
   } else {
-    *out << "Number of bonds for Atom " << *Walker << " does not match, parsed " << CurrentBondsOfAtom << " against " << Walker->ListOfBonds.size() << "." << endl;
+    Log() << Verbose(0) << "Number of bonds for Atom " << *Walker << " does not match, parsed " << CurrentBondsOfAtom << " against " << Walker->ListOfBonds.size() << "." << endl;
     status = false;
   }
@@ -1057 +1058 @@
  * \return true - structure is equal, false - not equivalence
  */
-bool molecule::CheckAdjacencyFileAgainstMolecule(ofstream *out, char *path, atom **ListOfAtoms)
+bool molecule::CheckAdjacencyFileAgainstMolecule(char *path, atom **ListOfAtoms)
 {
   ifstream File;
@@ -1067 +1068 @@
   size_t CurrentBondsOfAtom = -1;
 
-  if (!CheckAdjacencyFileAgainstMolecule_Init(out, path, File, CurrentBonds)) {
-    *out << Verbose(1) << "Adjacency file not found." << endl;
+  if (!CheckAdjacencyFileAgainstMolecule_Init(path, File, CurrentBonds)) {
+    Log() << Verbose(1) << "Adjacency file not found." << endl;
     return true;
   }
@@ -1087 +1088 @@
         line >> CurrentBonds[++CurrentBondsOfAtom];
       // compare against present bonds
-      CheckAdjacencyFileAgainstMolecule_CompareBonds(out, status, NonMatchNumber, Walker, CurrentBondsOfAtom, AtomNr, CurrentBonds, ListOfAtoms);
+      CheckAdjacencyFileAgainstMolecule_CompareBonds(status, NonMatchNumber, Walker, CurrentBondsOfAtom, AtomNr, CurrentBonds, ListOfAtoms);
     }
   }
   Free(&buffer);
-  CheckAdjacencyFileAgainstMolecule_Finalize(out, File, CurrentBonds);
+  CheckAdjacencyFileAgainstMolecule_Finalize(File, CurrentBonds);
 
   if (status) { // if equal we parse the KeySetFile
-    *out << Verbose(1) << "done: Equal." << endl;
+    Log() << Verbose(1) << "done: Equal." << endl;
   } else
-    *out << Verbose(1) << "done: Not equal by " << NonMatchNumber << " atoms." << endl;
+    Log() << Verbose(1) << "done: Not equal by " << NonMatchNumber << " atoms." << endl;
   return status;
 }
@@ -1108 +1109 @@
  * \return true - everything ok, false - ReferenceStack was empty
  */
-bool molecule::PickLocalBackEdges(ofstream *out, atom **ListOfLocalAtoms, class StackClass<bond *> *&ReferenceStack, class StackClass<bond *> *&LocalStack) const
+bool molecule::PickLocalBackEdges(atom **ListOfLocalAtoms, class StackClass<bond *> *&ReferenceStack, class StackClass<bond *> *&LocalStack) const
 {
   bool status = true;
   if (ReferenceStack->IsEmpty()) {
-    cerr << "ReferenceStack is empty!" << endl;
+    eLog() << Verbose(0) << "ReferenceStack is empty!" << endl;
     return false;
   }
@@ -1127 +1128 @@
         if (OtherAtom == ListOfLocalAtoms[(*Runner)->rightatom->nr]) { // found the bond
           LocalStack->Push((*Runner));
-          *out << Verbose(3) << "Found local edge " << *(*Runner) << "." << endl;
+          Log() << Verbose(3) << "Found local edge " << *(*Runner) << "." << endl;
           break;
         }
       }
     Binder = ReferenceStack->PopFirst(); // loop the stack for next item
-    *out << Verbose(3) << "Current candidate edge " << Binder << "." << endl;
+    Log() << Verbose(3) << "Current candidate edge " << Binder << "." << endl;
     ReferenceStack->Push(Binder);
   } while (FirstBond != Binder);
@@ -1175 +1176 @@
 ;
 
-void BreadthFirstSearchAdd_UnvisitedNode(ofstream *out, molecule *Mol, struct BFSAccounting &BFS, atom *&Walker, atom *&OtherAtom, bond *&Binder, bond *&Bond, atom **&AddedAtomList, bond **&AddedBondList, bool IsAngstroem)
+void BreadthFirstSearchAdd_UnvisitedNode(molecule *Mol, struct BFSAccounting &BFS, atom *&Walker, atom *&OtherAtom, bond *&Binder, bond *&Bond, atom **&AddedAtomList, bond **&AddedBondList, bool IsAngstroem)
 {
   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)
@@ -1181 +1182 @@
   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;
+  Log() << 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
-    *out << Verbose(3);
+    Log() << 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;
+      Log() << Verbose(0) << "Added OtherAtom " << OtherAtom->Name;
       AddedBondList[Binder->nr] = Mol->CopyBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder);
-      *out << " and bond " << *(AddedBondList[Binder->nr]) << ", ";
+      Log() << Verbose(0) << " 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)
-      *out << "Not adding OtherAtom " << OtherAtom->Name;
+      Log() << Verbose(0) << "Not adding OtherAtom " << OtherAtom->Name;
       if (AddedBondList[Binder->nr] == NULL) {
         AddedBondList[Binder->nr] = Mol->CopyBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder);
-        *out << ", added Bond " << *(AddedBondList[Binder->nr]);
+        Log() << Verbose(0) << ", added Bond " << *(AddedBondList[Binder->nr]);
       } else
-        *out << ", not added Bond ";
-    }
-    *out << ", putting OtherAtom into queue." << endl;
+        Log() << Verbose(0) << ", not added Bond ";
+    }
+    Log() << Verbose(0) << ", putting OtherAtom into queue." << endl;
     BFS.BFSStack->Push(OtherAtom);
   } else { // out of bond order, then replace
@@ -1203 +1204 @@
       BFS.ColorList[OtherAtom->nr] = white; // unmark if it has not been queued/added, to make it available via its other bonds (cyclic)
     if (Binder == Bond)
-      *out << Verbose(3) << "Not Queueing, is the Root bond";
+      Log() << Verbose(3) << "Not Queueing, is the Root bond";
     else if (BFS.ShortestPathList[OtherAtom->nr] >= BFS.BondOrder)
-      *out << Verbose(3) << "Not Queueing, is out of Bond Count of " << BFS.BondOrder;
+      Log() << Verbose(3) << "Not Queueing, is out of Bond Count of " << BFS.BondOrder;
     if (!Binder->Cyclic)
-      *out << ", is not part of a cyclic bond, saturating bond with Hydrogen." << endl;
+      Log() << Verbose(0) << ", is not part of a cyclic bond, saturating bond with Hydrogen." << endl;
     if (AddedBondList[Binder->nr] == NULL) {
       if ((AddedAtomList[OtherAtom->nr] != NULL)) { // .. whether we add or saturate
@@ -1213 +1214 @@
       } else {
 #ifdef ADDHYDROGEN
-        if (!Mol->AddHydrogenReplacementAtom(out, Binder, AddedAtomList[Walker->nr], Walker, OtherAtom, IsAngstroem))
+        if (!Mol->AddHydrogenReplacementAtom(Binder, AddedAtomList[Walker->nr], Walker, OtherAtom, IsAngstroem))
         exit(1);
 #endif
@@ -1222 +1223 @@
 ;
 
-void BreadthFirstSearchAdd_VisitedNode(ofstream *out, molecule *Mol, struct BFSAccounting &BFS, atom *&Walker, atom *&OtherAtom, bond *&Binder, bond *&Bond, atom **&AddedAtomList, bond **&AddedBondList, bool IsAngstroem)
-{
-  *out << Verbose(3) << "Not Adding, has already been visited." << endl;
+void BreadthFirstSearchAdd_VisitedNode(molecule *Mol, struct BFSAccounting &BFS, atom *&Walker, atom *&OtherAtom, bond *&Binder, bond *&Bond, atom **&AddedAtomList, bond **&AddedBondList, bool IsAngstroem)
+{
+  Log() << 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) {
@@ -1231 +1232 @@
     } 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, IsAngstroem))
+      if(!Mol->AddHydrogenReplacementAtom(Binder, AddedAtomList[Walker->nr], Walker, OtherAtom, IsAngstroem))
       exit(1);
 #endif
@@ -1251 +1252 @@
  * \param IsAngstroem lengths are in angstroem or bohrradii
  */
-void molecule::BreadthFirstSearchAdd(ofstream *out, molecule *Mol, atom **&AddedAtomList, bond **&AddedBondList, atom *Root, bond *Bond, int BondOrder, bool IsAngstroem)
+void molecule::BreadthFirstSearchAdd(molecule *Mol, atom **&AddedAtomList, bond **&AddedBondList, atom *Root, bond *Bond, int BondOrder, bool IsAngstroem)
 {
   struct BFSAccounting BFS;
@@ -1270 +1271 @@
     // followed by n+1 till top of stack.
     Walker = BFS.BFSStack->PopFirst(); // pop oldest added
-    *out << Verbose(1) << "Current Walker is: " << Walker->Name << ", and has " << Walker->ListOfBonds.size() << " bonds." << endl;
+    Log() << 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
         Binder = (*Runner);
         OtherAtom = (*Runner)->GetOtherAtom(Walker);
-        *out << Verbose(2) << "Current OtherAtom is: " << OtherAtom->Name << " for bond " << *(*Runner) << "." << endl;
+        Log() << Verbose(2) << "Current OtherAtom is: " << OtherAtom->Name << " for bond " << *(*Runner) << "." << endl;
         if (BFS.ColorList[OtherAtom->nr] == white) {
-          BreadthFirstSearchAdd_UnvisitedNode(out, Mol, BFS, Walker, OtherAtom, Binder, Bond, AddedAtomList, AddedBondList, IsAngstroem);
+          BreadthFirstSearchAdd_UnvisitedNode(Mol, BFS, Walker, OtherAtom, Binder, Bond, AddedAtomList, AddedBondList, IsAngstroem);
         } else {
-          BreadthFirstSearchAdd_VisitedNode(out, Mol, BFS, Walker, OtherAtom, Binder, Bond, AddedAtomList, AddedBondList, IsAngstroem);
+          BreadthFirstSearchAdd_VisitedNode(Mol, BFS, Walker, OtherAtom, Binder, Bond, AddedAtomList, AddedBondList, IsAngstroem);
         }
       }
     }
     BFS.ColorList[Walker->nr] = black;
-    *out << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl;
+    Log() << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl;
   }
   BreadthFirstSearchAdd_Free(BFS);
@@ -1305 +1306 @@
 ;
 
-void BuildInducedSubgraph_Init(ofstream *out, atom **&ParentList, int AtomCount)
+void BuildInducedSubgraph_Init(atom **&ParentList, int AtomCount)
 {
   // reset parent list
   ParentList = Calloc<atom*> (AtomCount, "molecule::BuildInducedSubgraph_Init: **ParentList");
-  *out << Verbose(3) << "Resetting ParentList." << endl;
-}
-;
-
-void BuildInducedSubgraph_FillParentList(ofstream *out, const molecule *mol, const molecule *Father, atom **&ParentList)
+  Log() << Verbose(3) << "Resetting ParentList." << endl;
+}
+;
+
+void BuildInducedSubgraph_FillParentList(const molecule *mol, const molecule *Father, atom **&ParentList)
 {
   // fill parent list with sons
-  *out << Verbose(3) << "Filling Parent List." << endl;
+  Log() << Verbose(3) << "Filling Parent List." << endl;
   atom *Walker = mol->start;
   while (Walker->next != mol->end) {
@@ -1322 +1323 @@
     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;
-  }
-
-}
-;
-
-void BuildInducedSubgraph_Finalize(ofstream *out, atom **&ParentList)
+    Log() << Verbose(4) << "Son[" << Walker->father->nr << "] of " << Walker->father << " is " << ParentList[Walker->father->nr] << "." << endl;
+  }
+
+}
+;
+
+void BuildInducedSubgraph_Finalize(atom **&ParentList)
 {
   Free(&ParentList);
@@ -1334 +1335 @@
 ;
 
-bool BuildInducedSubgraph_CreateBondsFromParent(ofstream *out, molecule *mol, const molecule *Father, atom **&ParentList)
+bool BuildInducedSubgraph_CreateBondsFromParent(molecule *mol, const molecule *Father, atom **&ParentList)
 {
   bool status = true;
@@ -1340 +1341 @@
   atom *OtherAtom = NULL;
   // check each entry of parent list and if ok (one-to-and-onto matching) create bonds
-  *out << Verbose(3) << "Creating bonds." << endl;
+  Log() << Verbose(3) << "Creating bonds." << endl;
   Walker = Father->start;
   while (Walker->next != Father->end) {
@@ -1351 +1352 @@
           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 " << (*Runner) << " are both present: " << ParentList[Walker->nr]->Name << " and " << ParentList[OtherAtom->nr]->Name << "." << endl;
+            Log() << Verbose(4) << "Endpoints of Bond " << (*Runner) << " are both present: " << ParentList[Walker->nr]->Name << " and " << ParentList[OtherAtom->nr]->Name << "." << endl;
             mol->AddBond(ParentList[Walker->nr], ParentList[OtherAtom->nr], (*Runner)->BondDegree);
           }
@@ -1371 +1372 @@
  * \todo not checked, not fully working probably
  */
-bool molecule::BuildInducedSubgraph(ofstream *out, const molecule *Father)
+bool molecule::BuildInducedSubgraph(const molecule *Father)
 {
   bool status = true;
   atom **ParentList = NULL;
 
-  *out << Verbose(2) << "Begin of BuildInducedSubgraph." << endl;
-  BuildInducedSubgraph_Init(out, ParentList, Father->AtomCount);
-  BuildInducedSubgraph_FillParentList(out, this, Father, ParentList);
-  status = BuildInducedSubgraph_CreateBondsFromParent(out, this, Father, ParentList);
-  BuildInducedSubgraph_Finalize(out, ParentList);
-  *out << Verbose(2) << "End of BuildInducedSubgraph." << endl;
+  Log() << Verbose(2) << "Begin of BuildInducedSubgraph." << endl;
+  BuildInducedSubgraph_Init(ParentList, Father->AtomCount);
+  BuildInducedSubgraph_FillParentList(this, Father, ParentList);
+  status = BuildInducedSubgraph_CreateBondsFromParent(this, Father, ParentList);
+  BuildInducedSubgraph_Finalize(ParentList);
+  Log() << Verbose(2) << "End of BuildInducedSubgraph." << endl;
   return status;
 }
@@ -1392 +1393 @@
  * \note this is O(n^2) for it's just a bug checker not meant for permanent use!
  */
-bool molecule::CheckForConnectedSubgraph(ofstream *out, KeySet *Fragment)
+bool molecule::CheckForConnectedSubgraph(KeySet *Fragment)
 {
   atom *Walker = NULL, *Walker2 = NULL;
@@ -1398 +1399 @@
   int size;
 
-  *out << Verbose(1) << "Begin of CheckForConnectedSubgraph" << endl;
-  *out << Verbose(2) << "Disconnected atom: ";
+  Log() << Verbose(1) << "Begin of CheckForConnectedSubgraph" << endl;
+  Log() << Verbose(2) << "Disconnected atom: ";
 
   // count number of atoms in graph
@@ -1421 +1422 @@
       }
       if (!BondStatus) {
-        *out << (*Walker) << endl;
+        Log() << Verbose(0) << (*Walker) << endl;
         return false;
       }
     }
   else {
-    *out << "none." << endl;
+    Log() << Verbose(0) << "none." << endl;
     return true;
   }
-  *out << "none." << endl;
-
-  *out << Verbose(1) << "End of CheckForConnectedSubgraph" << endl;
+  Log() << Verbose(0) << "none." << endl;
+
+  Log() << Verbose(1) << "End of CheckForConnectedSubgraph" << endl;
 
   return true;