Index: src/Fragmentation/AdaptivityMap.cpp
===================================================================
--- src/Fragmentation/AdaptivityMap.cpp	(revision 07a47e0c167bba50906b5cc3e9289ec6e7f1c6db)
+++ src/Fragmentation/AdaptivityMap.cpp	(revision 47d0416c5a62d6d7eb14391e14c7f3f576fb1673)
@@ -68,13 +68,13 @@
         (*PresentItem).second.first = fabs(Value);
         (*PresentItem).second.second = FragOrder;
-        DoLog(2) && (Log() << Verbose(2) << "Updated element (" <<  (*PresentItem).first << ",[" << (*PresentItem).second.first << "," << (*PresentItem).second.second << "])." << endl);
+        LOG(2, "Updated element (" <<  (*PresentItem).first << ",[" << (*PresentItem).second.first << "," << (*PresentItem).second.second << "]).");
       } else {
-        DoLog(2) && (Log() << Verbose(2) << "Did not update element " <<  (*PresentItem).first << " as " << FragOrder << " is less than or equal to " << (*PresentItem).second.second << "." << endl);
+        LOG(2, "Did not update element " <<  (*PresentItem).first << " as " << FragOrder << " is less than or equal to " << (*PresentItem).second.second << ".");
       }
     } else {
-      DoLog(2) && (Log() << Verbose(2) << "Inserted element (" <<  (*PresentItem).first << ",[" << (*PresentItem).second.first << "," << (*PresentItem).second.second << "])." << endl);
+      LOG(2, "Inserted element (" <<  (*PresentItem).first << ",[" << (*PresentItem).second.first << "," << (*PresentItem).second.second << "]).");
     }
   } else {
-    DoLog(1) && (Log() << Verbose(1) << "No Fragment under No. " << No << "found." << endl);
+    LOG(1, "No Fragment under No. " << No << "found.");
   }
 };
@@ -93,5 +93,5 @@
 
   if (InputFile.fail()) {
-    DoeLog(1) && (eLog() << Verbose(1) << "Cannot find file " << filename << "." << endl);
+    ELOG(1, "Cannot find file " << filename << ".");
     return;
   }
@@ -104,5 +104,5 @@
       InputFile.getline(buffer, MAXSTRINGSIZE);
       if (strlen(buffer) > 2) {
-        //Log() << Verbose(2) << "Scanning: " << buffer << endl;
+        //LOG(2, "Scanning: " << buffer);
         stringstream line(buffer);
         line >> FragOrder;
@@ -111,5 +111,5 @@
         line >> ws >> Value;
         No -= 1;  // indices start at 1 in file, not 0
-        //Log() << Verbose(2) << " - yields (" << No << "," << Value << ", " << FragOrder << ")" << endl;
+        //LOG(2, " - yields (" << No << "," << Value << ", " << FragOrder << ")");
 
         // clean the list of those entries that have been superceded by higher order terms already
@@ -134,5 +134,5 @@
       "AdaptivityMap::ReMapAdaptiveCriteriaListToValue() - AdaptiveCriteriaList is not allocated yet.");
   FinalRootCandidates = new AdaptiveCriteriaValueMap;
-  DoLog(1) && (Log() << Verbose(1) << "Root candidate list is: " << endl);
+  LOG(1, "Root candidate list is: ");
   for(AdaptiveCriteriaIndexMap::const_iterator runner = AdaptiveCriteriaList->begin(); runner != AdaptiveCriteriaList->end(); runner++) {
     Walker = mol->FindAtom((*runner).first);
@@ -140,11 +140,11 @@
       //if ((*runner).second.second >= Walker->AdaptiveOrder) { // only insert if this is an "active" root site for the current order
       if (!Walker->MaxOrder) {
-        DoLog(2) && (Log() << Verbose(2) << "(" << (*runner).first << ",[" << (*runner).second.first << "," << (*runner).second.second << "])" << endl);
+        LOG(2, "(" << (*runner).first << ",[" << (*runner).second.first << "," << (*runner).second.second << "])");
         FinalRootCandidates->insert( make_pair( (*runner).second.first, pair<int,int>((*runner).first, (*runner).second.second) ) );
       } else {
-        DoLog(2) && (Log() << Verbose(2) << "Excluding (" << *Walker << ", " << (*runner).first << ",[" << (*runner).second.first << "," << (*runner).second.second << "]), as it has reached its maximum order." << endl);
+        LOG(2, "Excluding (" << *Walker << ", " << (*runner).first << ",[" << (*runner).second.first << "," << (*runner).second.second << "]), as it has reached its maximum order.");
       }
     } else {
-      DoeLog(0) && (eLog()<< Verbose(0) << "Atom No. " << (*runner).second.first << " was not found in this molecule." << endl);
+      ELOG(0, "Atom No. " << (*runner).second.first << " was not found in this molecule.");
       performCriticalExit();
     }
@@ -192,9 +192,9 @@
     Walker = mol->FindAtom(No);
     //if (Walker->AdaptiveOrder < MinimumRingSize[Walker->getNr()]) {
-      DoLog(2) && (Log() << Verbose(2) << "Root " << No << " is still above threshold (10^{" << Order <<"}: " << runner->first << ", setting entry " << No << " of Atom mask to true." << endl);
+      LOG(2, "Root " << No << " is still above threshold (10^{" << Order <<"}: " << runner->first << ", setting entry " << No << " of Atom mask to true.");
       AtomMask[No] = true;
       status = true;
     //} else
-      //Log() << Verbose(2) << "Root " << No << " is still above threshold (10^{" << Order <<"}: " << runner->first << ", however MinimumRingSize of " << MinimumRingSize[Walker->getNr()] << " does not allow further adaptive increase." << endl;
+      //LOG(2, "Root " << No << " is still above threshold (10^{" << Order <<"}: " << runner->first << ", however MinimumRingSize of " << MinimumRingSize[Walker->getNr()] << " does not allow further adaptive increase.");
   }
   return status;
Index: src/Fragmentation/BondsPerShortestPath.cpp
===================================================================
--- src/Fragmentation/BondsPerShortestPath.cpp	(revision 07a47e0c167bba50906b5cc3e9289ec6e7f1c6db)
+++ src/Fragmentation/BondsPerShortestPath.cpp	(revision 47d0416c5a62d6d7eb14391e14c7f3f576fb1673)
@@ -21,4 +21,6 @@
 
 #include "BondsPerShortestPath.hpp"
+
+#include <sstream>
 
 #include "CodePatterns/Log.hpp"
@@ -82,7 +84,8 @@
 void BondsPerShortestPath::ResetSPList()
 {
-  DoLog(0) && (Log() << Verbose(0) << "Free'ing all found lists. and resetting index lists" << endl);
+  LOG(0, "Free'ing all found lists. and resetting index lists");
+  std::stringstream output;
   for(int i=Order;i--;) {
-    DoLog(1) && (Log() << Verbose(1) << "Current SP level is " << i << ": ");
+    output << "Current SP level is " << i << ": ";
     // delete added bonds
     for (BondsPerSP::iterator iter = BondsPerSPList[i].begin();
@@ -93,6 +96,7 @@
     BondsPerSPList[i].clear();
     // also start and end node
-    DoLog(0) && (Log() << Verbose(0) << "cleaned." << endl);
-  }
+    output << "cleaned.";
+  }
+  LOG(1, output.str());
 };
 
@@ -120,12 +124,16 @@
   int SP = -1;
 
-  DoLog(0) && (Log() << Verbose(0) << "Starting BFS analysis ..." << endl);
+  LOG(0, "Starting BFS analysis ...");
   for (SP = 0; SP < (Order-1); SP++) {
-    DoLog(1) && (Log() << Verbose(1) << "New SP level reached: " << SP << ", creating new SP list with " << BondsPerSPCount[SP] << " item(s)");
-    if (SP > 0) {
-      DoLog(0) && (Log() << Verbose(0) << ", old level closed with " << BondsPerSPCount[SP-1] << " item(s)." << endl);
-      BondsPerSPCount[SP] = 0;
-    } else
-      DoLog(0) && (Log() << Verbose(0) << "." << endl);
+    {
+      std::stringstream output;
+      output << "New SP level reached: " << SP << ", creating new SP list with " << BondsPerSPCount[SP] << " item(s)";
+      if (SP > 0) {
+        output << ", old level closed with " << BondsPerSPCount[SP-1] << " item(s).";
+        BondsPerSPCount[SP] = 0;
+      } else
+        output << ".";
+      LOG(1, output.str());
+    }
 
     RemainingWalkers = BondsPerSPCount[SP];
@@ -137,8 +145,8 @@
       Predecessor = (*CurrentEdge)->leftatom;    // ... and leftatom is predecessor
       AtomKeyNr = Walker->getNr();
-      DoLog(0) && (Log() << Verbose(0) << "Current Walker is: " << *Walker << " with nr " << Walker->getNr() << " and SP of " << SP << ", with " << RemainingWalkers << " remaining walkers on this level." << endl);
+      LOG(0, "Current Walker is: " << *Walker << " with nr " << Walker->getNr() << " and SP of " << SP << ", with " << RemainingWalkers << " remaining walkers on this level.");
       // check for new sp level
       // go through all its bonds
-      DoLog(1) && (Log() << Verbose(1) << "Going through all bonds of Walker." << endl);
+      LOG(1, "Going through all bonds of Walker.");
       const BondList& ListOfBonds = Walker->getListOfBonds();
       for (BondList::const_iterator Runner = ListOfBonds.begin();
@@ -149,5 +157,5 @@
             // skip hydrogens if desired and restrict to fragment
             && ((saturation == DontSaturate) || (OtherWalker->getType()->getAtomicNumber() != 1))) {
-          DoLog(2) && (Log() << Verbose(2) << "Current partner is " << *OtherWalker << " with nr " << OtherWalker->getNr() << " in bond " << *(*Runner) << "." << endl);
+          LOG(2, "Current partner is " << *OtherWalker << " with nr " << OtherWalker->getNr() << " in bond " << *(*Runner) << ".");
           // set the label if not set (and push on root stack as well)
           if ((OtherWalker != Predecessor) && (OtherWalker->GetTrueFather()->getNr() > RootKeyNr)) { // only pass through those with label bigger than Root's
@@ -156,12 +164,12 @@
             BondsPerSPList[SP+1].push_back(Binder);
             BondsPerSPCount[SP+1]++;
-            DoLog(3) && (Log() << Verbose(3) << "Added its bond to SP list, having now " << BondsPerSPCount[SP+1] << " item(s)." << endl);
+            LOG(3, "Added its bond to SP list, having now " << BondsPerSPCount[SP+1] << " item(s).");
           } else {
             if (OtherWalker != Predecessor)
-              DoLog(3) && (Log() << Verbose(3) << "Not passing on, as index of " << *OtherWalker << " " << OtherWalker->GetTrueFather()->getNr() << " is smaller than that of Root " << RootKeyNr << "." << endl);
+              LOG(3, "Not passing on, as index of " << *OtherWalker << " " << OtherWalker->GetTrueFather()->getNr() << " is smaller than that of Root " << RootKeyNr << ".");
             else
-              DoLog(3) && (Log() << Verbose(3) << "This is my predecessor " << *Predecessor << "." << endl);
+              LOG(3, "This is my predecessor " << *Predecessor << ".");
           }
-        } else Log() << Verbose(2) << "Is not in the restricted keyset or skipping hydrogen " << *OtherWalker << "." << endl;
+        } else LOG(2, "Is not in the restricted keyset or skipping hydrogen " << *OtherWalker << ".");
       }
     }
@@ -173,11 +181,11 @@
 void BondsPerShortestPath::OutputSPList()
 {
-  DoLog(0) && (Log() << Verbose(0) << "Printing all found lists." << endl);
+  LOG(0, "Printing all found lists.");
   for(int i=1;i<Order;i++) {    // skip the root edge in the printing
-    DoLog(1) && (Log() << Verbose(1) << "Current SP level is " << i << "." << endl);
+    LOG(1, "Current SP level is " << i << ".");
     for (BondsPerShortestPath::BondsPerSP::const_iterator Binder = BondsPerSPList[i].begin();
         Binder != BondsPerSPList[i].end();
         ++Binder) {
-      DoLog(2) && (Log() << Verbose(2) << *Binder << endl);
+      LOG(2, *Binder);
     }
   }
Index: src/Fragmentation/EnergyMatrix.cpp
===================================================================
--- src/Fragmentation/EnergyMatrix.cpp	(revision 07a47e0c167bba50906b5cc3e9289ec6e7f1c6db)
+++ src/Fragmentation/EnergyMatrix.cpp	(revision 47d0416c5a62d6d7eb14391e14c7f3f576fb1673)
@@ -34,5 +34,5 @@
 bool EnergyMatrix::ParseIndices()
 {
-  DoLog(0) && (Log() << Verbose(0) << "Parsing energy indices." << endl);
+  LOG(0, "Parsing energy indices.");
   Indices.resize(MatrixCounter + 1);
   for(int i=MatrixCounter+1;i--;) {
Index: src/Fragmentation/ForceMatrix.cpp
===================================================================
--- src/Fragmentation/ForceMatrix.cpp	(revision 07a47e0c167bba50906b5cc3e9289ec6e7f1c6db)
+++ src/Fragmentation/ForceMatrix.cpp	(revision 47d0416c5a62d6d7eb14391e14c7f3f576fb1673)
@@ -43,11 +43,11 @@
   stringstream line;
 
-  DoLog(0) && (Log() << Verbose(0) << "Parsing force indices for " << MatrixCounter << " matrices." << endl);
+  LOG(0, "Parsing force indices for " << MatrixCounter << " matrices.");
   Indices.resize(MatrixCounter + 1);
   line << name << FRAGMENTPREFIX << FORCESFILE;
   input.open(line.str().c_str(), ios::in);
-  //Log() << Verbose(0) << "Opening " << line.str() << " ... "  << input << endl;
+  //LOG(0, "Opening " << line.str() << " ... "  << input);
   if (input.fail()) {
-    DoLog(0) && (Log() << Verbose(0) << endl << "ForceMatrix::ParseIndices: Unable to open " << line.str() << ", is the directory correct?" << endl);
+    LOG(0, endl << "ForceMatrix::ParseIndices: Unable to open " << line.str() << ", is the directory correct?");
     return false;
   }
@@ -59,11 +59,12 @@
     Indices[i].resize(RowCounter[i]);
     FragmentNumber = FixedDigitNumber(MatrixCounter, i);
-    //Log() << Verbose(0) << FRAGMENTPREFIX << FragmentNumber << "[" << RowCounter[i] << "]:";
+    //std::stringstream output;
+    //output << FRAGMENTPREFIX << FragmentNumber << "[" << RowCounter[i] << "]:";
     delete[](FragmentNumber);
     for(int j=0;(j<RowCounter[i]) && (!line.eof());j++) {
       line >> Indices[i][j];
-      //Log() << Verbose(0) << " " << Indices[i][j];
+      //output << " " << Indices[i][j];
     }
-    //Log() << Verbose(0) << endl;
+    //LOG(0, output.str());
   }
   Indices[MatrixCounter].resize(RowCounter[MatrixCounter]);
@@ -92,10 +93,10 @@
       int j = Indices[ FragmentNr ][l];
       if (j > RowCounter[MatrixCounter]) {
-        DoeLog(0) && (eLog()<< Verbose(0) << "Current force index " << j << " is greater than " << RowCounter[MatrixCounter] << "!" << endl);
+        ELOG(0, "Current force index " << j << " is greater than " << RowCounter[MatrixCounter] << "!");
         performCriticalExit();
         return false;
       }
       if (j != -1) {
-        //if (j == 0) Log() << Verbose(0) << "Summing onto ion 0, type 0 from fragment " << FragmentNr << ", ion " << l << "." << endl;
+        //if (j == 0) LOG(0, "Summing onto ion 0, type 0 from fragment " << FragmentNr << ", ion " << l << ".");
         for(int k=2;k<ColumnCounter[MatrixCounter];k++)
           Matrix[MatrixCounter][j][k] += sign*Fragments.Matrix[ FragmentNr ][l][k];
@@ -128,5 +129,5 @@
     input.open(file.str().c_str(), ios::in);
     if (input.fail()) {
-      DoLog(0) && (Log() << Verbose(0) << endl << "ForceMatrix::ParseFragmentMatrix: Unable to open " << file.str() << ", is the directory correct?" << endl);
+      LOG(0, endl << "ForceMatrix::ParseFragmentMatrix: Unable to open " << file.str() << ", is the directory correct?");
       return false;
     }
@@ -137,5 +138,5 @@
       while (!zeile.eof()) {
         zeile >> nr;
-        //Log() << Verbose(0) << "Current index: " << getNr() << "." << endl;
+        //LOG(0, "Current index: " << getNr() << ".");
         if (nr > RowCounter[MatrixCounter])
           RowCounter[MatrixCounter] = nr;
Index: src/Fragmentation/Fragmentation.cpp
===================================================================
--- src/Fragmentation/Fragmentation.cpp	(revision 07a47e0c167bba50906b5cc3e9289ec6e7f1c6db)
+++ src/Fragmentation/Fragmentation.cpp	(revision 47d0416c5a62d6d7eb14391e14c7f3f576fb1673)
@@ -22,4 +22,5 @@
 
 #include "CodePatterns/Assert.hpp"
+#include "CodePatterns/Info.hpp"
 #include "CodePatterns/Log.hpp"
 
@@ -92,11 +93,11 @@
   bool *AtomMask = NULL;
 
-  DoLog(0) && (Log() << Verbose(0) << endl);
+  LOG(0, endl);
   switch (saturation) {
     case DoSaturate:
-      DoLog(0) && (Log() << Verbose(0) << "I will treat hydrogen special and saturate dangling bonds with it." << endl);
+      LOG(0, "I will treat hydrogen special and saturate dangling bonds with it.");
       break;
     case DontSaturate:
-      DoLog(0) && (Log() << Verbose(0) << "Hydrogen is treated just like the rest of the lot." << endl);
+      LOG(0, "Hydrogen is treated just like the rest of the lot.");
       break;
     default:
@@ -115,5 +116,5 @@
     filename = prefix + ADJACENCYFILE;
     File.open(filename.c_str(), ios::out);
-    DoLog(1) && (Log() << Verbose(1) << "Looking at bond structure stored in adjacency file and comparing to present one ... " << endl);
+    LOG(1, "Looking at bond structure stored in adjacency file and comparing to present one ... ");
 
     CheckAgainstAdjacencyFile FileChecker(World::getInstance().beginAtomSelection(), World::getInstance().endAtomSelection());
@@ -167,16 +168,16 @@
     while (MolecularWalker->next != NULL) {
       MolecularWalker = MolecularWalker->next;
-      DoLog(1) && (Log() << Verbose(1) << "Fragmenting subgraph " << MolecularWalker << "." << endl);
+      LOG(1, "Fragmenting subgraph " << MolecularWalker << ".");
       if (MolecularWalker->Leaf->hasBondStructure()) {
         // call BOSSANOVA method
-        DoLog(0) && (Log() << Verbose(0) << endl << " ========== BOND ENERGY of subgraph " << FragmentCounter << " ========================= " << endl);
+        LOG(0, endl << " ========== BOND ENERGY of subgraph " << FragmentCounter << " ========================= ");
         FragmentBOSSANOVA(MolecularWalker->Leaf, FragmentList[FragmentCounter], RootStack[FragmentCounter]);
       } else {
-        DoeLog(1) && (eLog()<< Verbose(1) << "Subgraph " << MolecularWalker << " has no atoms!" << endl);
+        ELOG(1, "Subgraph " << MolecularWalker << " has no atoms!");
       }
       FragmentCounter++;  // next fragment list
     }
   }
-  DoLog(2) && (Log() << Verbose(2) << "CheckOrder is " << CheckOrder << "." << endl);
+  LOG(2, "CheckOrder is " << CheckOrder << ".");
   delete[](RootStack);
   delete[](AtomMask);
@@ -202,5 +203,5 @@
   delete[](FragmentList);
 
-  DoLog(0) && (Log() << Verbose(0) << FragmentCounter << " subgraph fragments have been removed." << std::endl);
+  LOG(0, FragmentCounter << " subgraph fragments have been removed.");
 
   // ===== 8b. gather keyset lists (graphs) from all subgraphs and transform into MoleculeListClass =====
@@ -211,9 +212,9 @@
   for(Graph::iterator runner = TotalGraph.begin(); runner != TotalGraph.end(); runner++) {
     KeySet test = (*runner).first;
-    DoLog(0) && (Log() << Verbose(0) << "Fragment No." << (*runner).second.first << " with TEFactor " << (*runner).second.second << "." << endl);
+    LOG(0, "Fragment No." << (*runner).second.first << " with TEFactor " << (*runner).second.second << ".");
     BondFragments->insert(StoreFragmentFromKeySet(test, World::getInstance().getConfig()));
     k++;
   }
-  DoLog(0) && (Log() << Verbose(0) << k << "/" << BondFragments->ListOfMolecules.size() << " fragments generated from the keysets." << endl);
+  LOG(0, k << "/" << BondFragments->ListOfMolecules.size() << " fragments generated from the keysets.");
 
   // ===== 9. Save fragments' configuration and keyset files et al to disk ===
@@ -223,5 +224,5 @@
     CreateMappingLabelsToConfigSequence(SortIndex);
 
-    DoLog(1) && (Log() << Verbose(1) << "Writing " << BondFragments->ListOfMolecules.size() << " possible bond fragmentation configs" << endl);
+    LOG(1, "Writing " << BondFragments->ListOfMolecules.size() << " possible bond fragmentation configs");
     bool write_status = true;
     for (std::vector<std::string>::const_iterator iter = typelist.begin();
@@ -236,7 +237,7 @@
     }
     if (write_status)
-      DoLog(1) && (Log() << Verbose(1) << "All configs written." << endl);
+      LOG(1, "All configs written.");
     else
-      DoLog(1) && (Log() << Verbose(1) << "Some config writing failed." << endl);
+      LOG(1, "Some config writing failed.");
 
     // store force index reference file
@@ -262,8 +263,8 @@
 
     // free memory for bond part
-    DoLog(1) && (Log() << Verbose(1) << "Freeing bond memory" << endl);
+    LOG(1, "Freeing bond memory");
     delete[](SortIndex);
   } else {
-    DoLog(1) && (Log() << Verbose(1) << "FragmentList is zero on return, splitting failed." << endl);
+    LOG(1, "FragmentList is zero on return, splitting failed.");
   }
   // remove all create molecules again from the World including their atoms
@@ -278,5 +279,5 @@
   }
   delete(BondFragments);
-  DoLog(0) && (Log() << Verbose(0) << "End of bond fragmentation." << endl);
+  LOG(0, "End of bond fragmentation.");
 
   return ((int)(!FragmentationToDo)+1);    // 1 - continue, 2 - stop (no fragmentation occured)
@@ -314,5 +315,5 @@
   UniqueFragments FragmentSearch;
 
-  DoLog(0) && (Log() << Verbose(0) << "Begin of FragmentBOSSANOVA." << endl);
+  LOG(0, "Begin of FragmentBOSSANOVA.");
 
   // FragmentLowerOrdersList is a 2D-array of pointer to MoleculeListClass objects, one dimension represents the ANOVA expansion of a single order (i.e. 5)
@@ -345,5 +346,5 @@
     // check cyclic lengths
     //if ((MinimumRingSize[Walker->GetTrueFather()->getNr()] != -1) && (Walker->GetTrueFather()->AdaptiveOrder+1 > MinimumRingSize[Walker->GetTrueFather()->getNr()])) {
-    //  Log() << Verbose(0) << "Bond order " << Walker->GetTrueFather()->AdaptiveOrder << " of Root " << *Walker << " greater than or equal to Minimum Ring size of " << MinimumRingSize << " found is not allowed." << endl;
+    //  LOG(0, "Bond order " << Walker->GetTrueFather()->AdaptiveOrder << " of Root " << *Walker << " greater than or equal to Minimum Ring size of " << MinimumRingSize << " found is not allowed.");
     //} else
     {
@@ -362,6 +363,6 @@
 
       // create top order where nothing is reduced
-      DoLog(0) && (Log() << Verbose(0) << "==============================================================================================================" << endl);
-      DoLog(0) && (Log() << Verbose(0) << "Creating KeySets of Bond Order " << Order << " for " << *Walker << ", " << (RootStack.size()-RootNr) << " Roots remaining." << endl); // , NumLevels is " << NumLevels << "
+      LOG(0, "==============================================================================================================");
+      LOG(0, "Creating KeySets of Bond Order " << Order << " for " << *Walker << ", " << (RootStack.size()-RootNr) << " Roots remaining."); // , NumLevels is " << NumLevels << "
 
       // Create list of Graphs of current Bond Order (i.e. F_{ij})
@@ -371,5 +372,5 @@
 
       // output resulting number
-      DoLog(1) && (Log() << Verbose(1) << "Number of resulting KeySets is: " << NumMoleculesOfOrder[RootNr] << "." << endl);
+      LOG(1, "Number of resulting KeySets is: " << NumMoleculesOfOrder[RootNr] << ".");
       if (NumMoleculesOfOrder[RootNr] != 0) {
         NumMolecules = 0;
@@ -380,12 +381,12 @@
       //NumMoleculesOfOrder[Walker->AdaptiveOrder-1] = NumMolecules;
       TotalNumMolecules += NumMoleculesOfOrder[RootNr];
-//      Log() << Verbose(1) << "Number of resulting molecules for Order " << (int)Walker->GetTrueFather()->AdaptiveOrder << " is: " << NumMoleculesOfOrder[RootNr] << "." << endl;
+//      LOG(1, "Number of resulting molecules for Order " << (int)Walker->GetTrueFather()->AdaptiveOrder << " is: " << NumMoleculesOfOrder[RootNr] << ".");
       RootStack.push_back(RootKeyNr); // put back on stack
       RootNr++;
     }
   }
-  DoLog(0) && (Log() << Verbose(0) << "==============================================================================================================" << endl);
-  DoLog(1) && (Log() << Verbose(1) << "Total number of resulting molecules is: " << TotalNumMolecules << "." << endl);
-  DoLog(0) && (Log() << Verbose(0) << "==============================================================================================================" << endl);
+  LOG(0, "==============================================================================================================");
+  LOG(1, "Total number of resulting molecules is: " << TotalNumMolecules << ".");
+  LOG(0, "==============================================================================================================");
 
   // cleanup FragmentSearch structure
@@ -404,5 +405,5 @@
   delete[](NumMoleculesOfOrder);
 
-  DoLog(0) && (Log() << Verbose(0) << "End of FragmentBOSSANOVA." << endl);
+  LOG(0, "End of FragmentBOSSANOVA.");
 };
 
@@ -417,4 +418,5 @@
 molecule * Fragmentation::StoreFragmentFromKeySet(KeySet &Leaflet, bool IsAngstroem)
 {
+  Info info(__func__);
   atom **SonList = new atom*[mol->getAtomCount()];
   molecule *Leaf = World::getInstance().createMolecule();
@@ -423,13 +425,11 @@
     SonList[i] = NULL;
 
-//  Log() << Verbose(1) << "Begin of StoreFragmentFromKeyset." << endl;
   StoreFragmentFromKeySet_Init(mol, Leaf, Leaflet, SonList);
   // create the bonds between all: Make it an induced subgraph and add hydrogen
-//  Log() << Verbose(2) << "Creating bonds from father graph (i.e. induced subgraph creation)." << endl;
+//  LOG(2, "Creating bonds from father graph (i.e. induced subgraph creation).");
   CreateInducedSubgraphOfFragment(mol, Leaf, SonList, IsAngstroem);
 
   //Leaflet->Leaf->ScanForPeriodicCorrection(out);
   delete[](SonList);
-//  Log() << Verbose(1) << "End of StoreFragmentFromKeyset." << endl;
   return Leaf;
 };
@@ -456,5 +456,5 @@
   }
   FragmentCount = mol->NoNonHydrogen*(1 << (c*order));
-  DoLog(1) && (Log() << Verbose(1) << "Upper limit for this subgraph is " << FragmentCount << " for " << mol->NoNonHydrogen << " non-H atoms with maximum bond degree of " << c << "." << endl);
+  LOG(1, "Upper limit for this subgraph is " << FragmentCount << " for " << mol->NoNonHydrogen << " non-H atoms with maximum bond degree of " << c << ".");
   return FragmentCount;
 };
@@ -482,5 +482,5 @@
     // transmorph graph keyset list into indexed KeySetList
     if (GlobalKeySetList == NULL) {
-      DoeLog(1) && (eLog()<< Verbose(1) << "Given global key set list (graph) is NULL!" << endl);
+      ELOG(1, "Given global key set list (graph) is NULL!");
       return false;
     }
@@ -494,5 +494,5 @@
     // pick the ones still below threshold and mark as to be adaptively updated
     if (IndexKeySetList->IsAdaptiveCriteriaListEmpty()) {
-      DoeLog(2) && (eLog()<< Verbose(2) << "Unable to parse file, incrementing all." << endl);
+      ELOG(2, "Unable to parse file, incrementing all.");
       for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
         if ((saturation == DontSaturate) || ((*iter)->getType()->getAtomicNumber() != 1)) // skip hydrogen
@@ -521,7 +521,7 @@
     if (!status) {
       if (Order == 0)
-        DoLog(1) && (Log() << Verbose(1) << "Single stepping done." << endl);
+        LOG(1, "Single stepping done.");
       else
-        DoLog(1) && (Log() << Verbose(1) << "Order at every site is already equal or above desired order " << Order << "." << endl);
+        LOG(1, "Order at every site is already equal or above desired order " << Order << ".");
     }
   }
@@ -544,12 +544,12 @@
   line = path + ORDERATSITEFILE;
   file.open(line.c_str());
-  DoLog(1) && (Log() << Verbose(1) << "Writing OrderAtSite " << ORDERATSITEFILE << " ... " << endl);
+  LOG(1, "Writing OrderAtSite " << ORDERATSITEFILE << " ... ");
   if (file.good()) {
     for_each(mol->begin(),mol->end(),bind2nd(mem_fun(&atom::OutputOrder), &file));
     file.close();
-    DoLog(1) && (Log() << Verbose(1) << "done." << endl);
+    LOG(1, "done.");
     return true;
   } else {
-    DoLog(1) && (Log() << Verbose(1) << "failed to open file " << line << "." << endl);
+    LOG(1, "failed to open file " << line << ".");
     return false;
   }
@@ -577,5 +577,5 @@
   }
 
-  DoLog(1) && (Log() << Verbose(1) << "Begin of ParseOrderAtSiteFromFile" << endl);
+  LOG(1, "Begin of ParseOrderAtSiteFromFile");
   line = path + ORDERATSITEFILE;
   file.open(line.c_str());
@@ -589,5 +589,5 @@
         file >> value;
         MaxArray[AtomNr] = value;
-        //Log() << Verbose(2) << "AtomNr " << AtomNr << " with order " << (int)OrderArray[AtomNr] << " and max order set to " << (int)MaxArray[AtomNr] << "." << endl;
+        //LOG(2, "AtomNr " << AtomNr << " with order " << (int)OrderArray[AtomNr] << " and max order set to " << (int)MaxArray[AtomNr] << ".");
       }
     }
@@ -602,8 +602,8 @@
     //SetAtomValueToIndexedArray( MaxArray, &atom::getNr(), &atom::MaxOrder );
 
-    DoLog(1) && (Log() << Verbose(1) << "\t ... done." << endl);
+    LOG(1, "\t ... done.");
     status = true;
   } else {
-    DoLog(1) && (Log() << Verbose(1) << "\t ... failed to open file " << line << "." << endl);
+    LOG(1, "\t ... failed to open file " << line << ".");
     status = false;
   }
@@ -611,5 +611,5 @@
   delete[](MaxArray);
 
-  DoLog(1) && (Log() << Verbose(1) << "End of ParseOrderAtSiteFromFile" << endl);
+  LOG(1, "End of ParseOrderAtSiteFromFile");
   return status;
 };
@@ -623,5 +623,5 @@
 {
   if (SortIndex != NULL) {
-    DoLog(1) && (Log() << Verbose(1) << "SortIndex is " << SortIndex << " and not NULL as expected." << endl);
+    LOG(1, "SortIndex is " << SortIndex << " and not NULL as expected.");
     return false;
   }
@@ -687,31 +687,34 @@
           ++BondRunner) {
         OtherFather = (*BondRunner)->GetOtherAtom(FatherOfRunner);
-//        Log() << Verbose(2) << "Father " << *FatherOfRunner << " of son " << *SonList[FatherOfRunner->getNr()] << " is bound to " << *OtherFather;
         if (SonList[OtherFather->getNr()] != NULL) {
-//          Log() << Verbose(0) << ", whose son is " << *SonList[OtherFather->getNr()] << "." << endl;
+//          LOG(2, "INFO: Father " << *FatherOfRunner << " of son " << *SonList[FatherOfRunner->getNr()]
+//              << " is bound to " << *OtherFather << ", whose son is "
+//              << *SonList[OtherFather->getNr()] << ".");
           if (OtherFather->getNr() > FatherOfRunner->getNr()) { // add bond (Nr check is for adding only one of both variants: ab, ba)
-//            Log() << Verbose(3) << "Adding Bond: ";
-//            Log() << Verbose(0) <<
-            Leaf->AddBond((*iter), SonList[OtherFather->getNr()], (*BondRunner)->BondDegree);
-//            Log() << Verbose(0) << "." << endl;
+            std::stringstream output;
+//            output << "ACCEPT: Adding Bond: "
+            output << Leaf->AddBond((*iter), SonList[OtherFather->getNr()], (*BondRunner)->BondDegree);
+//            LOG(3, output.str());
             //NumBonds[(*iter)->getNr()]++;
           } else {
-//            Log() << Verbose(3) << "Not adding bond, labels in wrong order." << endl;
+//            LOG(3, "REJECY: Not adding bond, labels in wrong order.");
           }
           LonelyFlag = false;
         } else {
-//          Log() << Verbose(0) << ", who has no son in this fragment molecule." << endl;
-          //Log() << Verbose(3) << "Adding Hydrogen to " << (*iter)->Name << " and a bond in between." << endl;
-          if (saturation == DoSaturate)
+//          LOG(2, "INFO: Father " << *FatherOfRunner << " of son " << *SonList[FatherOfRunner->getNr()]
+//              << " is bound to " << *OtherFather << ", who has no son in this fragment molecule.");
+          if (saturation == DoSaturate) {
+//          LOG(3, "ACCEPT: Adding Hydrogen to " << (*iter)->Name << " and a bond in between.");
             if (!Leaf->AddHydrogenReplacementAtom((*BondRunner), (*iter), FatherOfRunner, OtherFather, IsAngstroem))
               exit(1);
+          }
           //NumBonds[(*iter)->getNr()] += Binder->BondDegree;
         }
       }
     } else {
-    DoeLog(1) && (eLog()<< Verbose(1) << "Son " << (*iter)->getName() << " has father " << FatherOfRunner->getName() << " but its entry in SonList is " << SonList[FatherOfRunner->getNr()] << "!" << endl);
+    ELOG(1, "Son " << (*iter)->getName() << " has father " << FatherOfRunner->getName() << " but its entry in SonList is " << SonList[FatherOfRunner->getNr()] << "!");
     }
     if ((LonelyFlag) && (Leaf->getAtomCount() > 1)) {
-      DoLog(0) && (Log() << Verbose(0) << **iter << "has got bonds only to hydrogens!" << endl);
+      LOG(0, **iter << "has got bonds only to hydrogens!");
     }
     ++iter;
Index: src/Fragmentation/HessianMatrix.cpp
===================================================================
--- src/Fragmentation/HessianMatrix.cpp	(revision 07a47e0c167bba50906b5cc3e9289ec6e7f1c6db)
+++ src/Fragmentation/HessianMatrix.cpp	(revision 47d0416c5a62d6d7eb14391e14c7f3f576fb1673)
@@ -43,11 +43,11 @@
   stringstream line;
 
-  DoLog(0) && (Log() << Verbose(0) << "Parsing hessian indices for " << MatrixCounter << " matrices." << endl);
+  LOG(0, "Parsing hessian indices for " << MatrixCounter << " matrices.");
   Indices.resize(MatrixCounter + 1);
   line << name << FRAGMENTPREFIX << FORCESFILE;
   input.open(line.str().c_str(), ios::in);
-  //Log() << Verbose(0) << "Opening " << line.str() << " ... "  << input << endl;
+  //LOG(0, "Opening " << line.str() << " ... "  << input);
   if (input.fail()) {
-    DoLog(0) && (Log() << Verbose(0) << endl << "HessianMatrix::ParseIndices: Unable to open " << line.str() << ", is the directory correct?" << endl);
+    LOG(0, endl << "HessianMatrix::ParseIndices: Unable to open " << line.str() << ", is the directory correct?");
     return false;
   }
@@ -59,11 +59,12 @@
     Indices[i].resize(RowCounter[i]);
     FragmentNumber = FixedDigitNumber(MatrixCounter, i);
-    //Log() << Verbose(0) << FRAGMENTPREFIX << FragmentNumber << "[" << RowCounter[i] << "]:";
+    //std::stringstream output;
+    //output << FRAGMENTPREFIX << FragmentNumber << "[" << RowCounter[i] << "]:";
     delete[](FragmentNumber);
     for(int j=0;(j<RowCounter[i]) && (!line.eof());j++) {
       line >> Indices[i][j];
-      //Log() << Verbose(0) << " " << Indices[i][j];
-    }
-    //Log() << Verbose(0) << endl;
+      //output << " " << Indices[i][j];
+    }
+    //LOG(0, output.str());
   }
   Indices[MatrixCounter].resize(RowCounter[MatrixCounter]);
@@ -92,5 +93,5 @@
       int j = Indices[ FragmentNr ][l];
       if (j > RowCounter[MatrixCounter]) {
-        DoeLog(0) && (eLog()<< Verbose(0) << "Current hessian index " << j << " is greater than " << RowCounter[MatrixCounter] << ", where i=" << i << ", Order=" << Order << ", l=" << l << " and FragmentNr=" << FragmentNr << "!" << endl);
+        ELOG(0, "Current hessian index " << j << " is greater than " << RowCounter[MatrixCounter] << ", where i=" << i << ", Order=" << Order << ", l=" << l << " and FragmentNr=" << FragmentNr << "!");
         performCriticalExit();
         return false;
@@ -100,10 +101,10 @@
           int k = Indices[ FragmentNr ][m];
           if (k > ColumnCounter[MatrixCounter]) {
-            DoeLog(0) && (eLog()<< Verbose(0) << "Current hessian index " << k << " is greater than " << ColumnCounter[MatrixCounter] << ", where m=" << m << ", j=" << j << ", i=" << i << ", Order=" << Order << ", l=" << l << " and FragmentNr=" << FragmentNr << "!" << endl);
+            ELOG(0, "Current hessian index " << k << " is greater than " << ColumnCounter[MatrixCounter] << ", where m=" << m << ", j=" << j << ", i=" << i << ", Order=" << Order << ", l=" << l << " and FragmentNr=" << FragmentNr << "!");
             performCriticalExit();
             return false;
           }
           if (k != -1) {
-            //Log() << Verbose(0) << "Adding " << sign*Fragments.Matrix[ FragmentNr ][l][m] << " from [" << l << "][" << m << "] onto [" << j << "][" << k << "]." << endl;
+            //LOG(0, "Adding " << sign*Fragments.Matrix[ FragmentNr ][l][m] << " from [" << l << "][" << m << "] onto [" << j << "][" << k << "].");
             Matrix[MatrixCounter][j][k] += sign*Fragments.Matrix[ FragmentNr ][l][m];
           }
@@ -133,17 +134,17 @@
   // go through each order
   for (int CurrentFragment=0;CurrentFragment<KeySets.FragmentsPerOrder[Order];CurrentFragment++) {
-    //Log() << Verbose(0) << "Current Fragment is " << CurrentFragment << "/" << KeySets.OrderSet[Order][CurrentFragment] << "." << endl;
+    //LOG(0, "Current Fragment is " << CurrentFragment << "/" << KeySets.OrderSet[Order][CurrentFragment] << ".");
     // then go per order through each suborder and pick together all the terms that contain this fragment
     for(int SubOrder=0;SubOrder<=Order;SubOrder++) { // go through all suborders up to the desired order
       for (int j=0;j<KeySets.FragmentsPerOrder[SubOrder];j++) { // go through all possible fragments of size suborder
         if (KeySets.Contains(KeySets.OrderSet[Order][CurrentFragment], KeySets.OrderSet[SubOrder][j])) {
-          //Log() << Verbose(0) << "Current other fragment is " << j << "/" << KeySets.OrderSet[SubOrder][j] << "." << endl;
+          //LOG(0, "Current other fragment is " << j << "/" << KeySets.OrderSet[SubOrder][j] << ".");
           // if the fragment's indices are all in the current fragment
           for(int k=0;k<RowCounter[ KeySets.OrderSet[SubOrder][j] ];k++) { // go through all atoms in this fragment
             int m = MatrixValues.Indices[ KeySets.OrderSet[SubOrder][j] ][k];
-            //Log() << Verbose(0) << "Current row index is " << k << "/" << m << "." << endl;
+            //LOG(0, "Current row index is " << k << "/" << m << ".");
             if (m != -1) { // if it's not an added hydrogen
               for (int l=0;l<RowCounter[ KeySets.OrderSet[Order][CurrentFragment] ];l++) { // look for the corresponding index in the current fragment
-                //Log() << Verbose(0) << "Comparing " << m << " with " << MatrixValues.Indices[ KeySets.OrderSet[Order][CurrentFragment] ][l] << "." << endl;
+                //LOG(0, "Comparing " << m << " with " << MatrixValues.Indices[ KeySets.OrderSet[Order][CurrentFragment] ][l] << ".");
                 if (m == MatrixValues.Indices[ KeySets.OrderSet[Order][CurrentFragment] ][l]) {
                   m = l;
@@ -151,7 +152,7 @@
                 }
               }
-              //Log() << Verbose(0) << "Corresponding row index for " << k << " in CurrentFragment is " << m << "." << endl;
+              //LOG(0, "Corresponding row index for " << k << " in CurrentFragment is " << m << ".");
               if (m > RowCounter[ KeySets.OrderSet[Order][CurrentFragment] ]) {
-                DoeLog(0) && (eLog()<< Verbose(0) << "In fragment No. " << KeySets.OrderSet[Order][CurrentFragment]   << " current row index " << m << " is greater than " << RowCounter[ KeySets.OrderSet[Order][CurrentFragment] ] << "!" << endl);
+                ELOG(0, "In fragment No. " << KeySets.OrderSet[Order][CurrentFragment]   << " current row index " << m << " is greater than " << RowCounter[ KeySets.OrderSet[Order][CurrentFragment] ] << "!");
                 performCriticalExit();
                 return false;
@@ -160,8 +161,8 @@
               for(int l=0;l<ColumnCounter[ KeySets.OrderSet[SubOrder][j] ];l++) {
                 int n = MatrixValues.Indices[ KeySets.OrderSet[SubOrder][j] ][l];
-                //Log() << Verbose(0) << "Current column index is " << l << "/" << n << "." << endl;
+                //LOG(0, "Current column index is " << l << "/" << n << ".");
                 if (n != -1) { // if it's not an added hydrogen
                   for (int p=0;p<ColumnCounter[ KeySets.OrderSet[Order][CurrentFragment] ];p++) { // look for the corresponding index in the current fragment
-                    //Log() << Verbose(0) << "Comparing " << n << " with " << MatrixValues.Indices[ KeySets.OrderSet[Order][CurrentFragment] ][p] << "." << endl;
+                    //LOG(0, "Comparing " << n << " with " << MatrixValues.Indices[ KeySets.OrderSet[Order][CurrentFragment] ][p] << ".");
                     if (n == MatrixValues.Indices[ KeySets.OrderSet[Order][CurrentFragment] ][p]) {
                       n = p;
@@ -169,15 +170,15 @@
                     }
                   }
-                  //Log() << Verbose(0) << "Corresponding column index for " << l << " in CurrentFragment is " << n << "." << endl;
+                  //LOG(0, "Corresponding column index for " << l << " in CurrentFragment is " << n << ".");
                   if (n > ColumnCounter[ KeySets.OrderSet[Order][CurrentFragment] ]) {
-                    DoeLog(0) && (eLog()<< Verbose(0) << "In fragment No. " << KeySets.OrderSet[Order][CurrentFragment]   << " current column index " << n << " is greater than " << ColumnCounter[ KeySets.OrderSet[Order][CurrentFragment] ] << "!" << endl);
+                    ELOG(0, "In fragment No. " << KeySets.OrderSet[Order][CurrentFragment]   << " current column index " << n << " is greater than " << ColumnCounter[ KeySets.OrderSet[Order][CurrentFragment] ] << "!");
                     performCriticalExit();
                     return false;
                   }
                   if (Order == SubOrder) { // equal order is always copy from Energies
-                    //Log() << Verbose(0) << "Adding " << MatrixValues.Matrix[ KeySets.OrderSet[SubOrder][j] ][k][l] << " from [" << k << "][" << l << "] onto [" << m << "][" << n << "]." << endl;
+                    //LOG(0, "Adding " << MatrixValues.Matrix[ KeySets.OrderSet[SubOrder][j] ][k][l] << " from [" << k << "][" << l << "] onto [" << m << "][" << n << "].");
                     Matrix[ KeySets.OrderSet[Order][CurrentFragment] ][m][n] += MatrixValues.Matrix[ KeySets.OrderSet[SubOrder][j] ][k][l];
                   } else {
-                    //Log() << Verbose(0) << "Subtracting " << Matrix[ KeySets.OrderSet[SubOrder][j] ][k][l] << " from [" << k << "][" << l << "] onto [" << m << "][" << n << "]." << endl;
+                    //LOG(0, "Subtracting " << Matrix[ KeySets.OrderSet[SubOrder][j] ][k][l] << " from [" << k << "][" << l << "] onto [" << m << "][" << n << "].");
                     Matrix[ KeySets.OrderSet[Order][CurrentFragment] ][m][n] -= Matrix[ KeySets.OrderSet[SubOrder][j] ][k][l];
                   }
@@ -186,12 +187,12 @@
             }
             //if ((ColumnCounter[ KeySets.OrderSet[SubOrder][j] ]>1) && (RowCounter[0]-1 >= 1))
-             //Log() << Verbose(0) << "Fragments[ KeySets.OrderSet[" << Order << "][" << CurrentFragment << "]=" << KeySets.OrderSet[Order][CurrentFragment] << " ][" << RowCounter[0]-1 << "][" << 1 << "] = " <<  Matrix[ KeySets.OrderSet[Order][CurrentFragment] ][RowCounter[0]-1][1] << endl;
+             //LOG(0, "Fragments[ KeySets.OrderSet[" << Order << "][" << CurrentFragment << "]=" << KeySets.OrderSet[Order][CurrentFragment] << " ][" << RowCounter[0]-1 << "][" << 1 << "] = " <<  Matrix[ KeySets.OrderSet[Order][CurrentFragment] ][RowCounter[0]-1][1]);
           }
         } else {
-          //Log() << Verbose(0) << "Fragment " << KeySets.OrderSet[SubOrder][j] << " is not contained in fragment " << KeySets.OrderSet[Order][CurrentFragment] << "." << endl;
+          //LOG(0, "Fragment " << KeySets.OrderSet[SubOrder][j] << " is not contained in fragment " << KeySets.OrderSet[Order][CurrentFragment] << ".");
         }
       }
     }
-   //Log() << Verbose(0) << "Final Fragments[ KeySets.OrderSet[" << Order << "][" << CurrentFragment << "]=" << KeySets.OrderSet[Order][CurrentFragment] << " ][" << KeySets.AtomCounter[0]-1 << "][" << 1 << "] = " <<  Matrix[ KeySets.OrderSet[Order][CurrentFragment] ][KeySets.AtomCounter[0]-1][1] << endl;
+   //LOG(0, "Final Fragments[ KeySets.OrderSet[" << Order << "][" << CurrentFragment << "]=" << KeySets.OrderSet[Order][CurrentFragment] << " ][" << KeySets.AtomCounter[0]-1 << "][" << 1 << "] = " <<  Matrix[ KeySets.OrderSet[Order][CurrentFragment] ][KeySets.AtomCounter[0]-1][1]);
   }
 
@@ -220,5 +221,5 @@
     input.open(file.str().c_str(), ios::in);
     if (input.fail()) {
-      DoLog(0) && (Log() << Verbose(0) << endl << "HessianMatrix::ParseFragmentMatrix: Unable to open " << file.str() << ", is the directory correct?" << endl);
+      LOG(0, endl << "HessianMatrix::ParseFragmentMatrix: Unable to open " << file.str() << ", is the directory correct?");
       return false;
     }
@@ -230,5 +231,5 @@
       while (!zeile.eof()) {
         zeile >> nr;
-        //Log() << Verbose(0) << "Current index: " << getNr() << "." << endl;
+        //LOG(0, "Current index: " << getNr() << ".");
         if (nr > RowCounter[MatrixCounter]) {
           RowCounter[MatrixCounter] = nr;
@@ -242,5 +243,5 @@
 
     // allocate last plus one matrix
-    DoLog(0) && (Log() << Verbose(0) << "Allocating last plus one matrix with " << (RowCounter[MatrixCounter]+1) << " rows and " << ColumnCounter[MatrixCounter] << " columns." << endl);
+    LOG(0, "Allocating last plus one matrix with " << (RowCounter[MatrixCounter]+1) << " rows and " << ColumnCounter[MatrixCounter] << " columns.");
     if (Matrix[MatrixCounter].size() <= RowCounter[MatrixCounter] + 2)
       Matrix[MatrixCounter].resize(RowCounter[MatrixCounter] + 1);
Index: src/Fragmentation/KeySet.cpp
===================================================================
--- src/Fragmentation/KeySet.cpp	(revision 07a47e0c167bba50906b5cc3e9289ec6e7f1c6db)
+++ src/Fragmentation/KeySet.cpp	(revision 47d0416c5a62d6d7eb14391e14c7f3f576fb1673)
@@ -48,5 +48,5 @@
 bool KeySet::operator<(const KeySet &a) const
 {
-  //Log() << Verbose(0) << "my check is used." << endl;
+  //LOG(0, "my check is used.");
   if (size() < a.size()) {
     return true;
Index: src/Fragmentation/KeySetsContainer.cpp
===================================================================
--- src/Fragmentation/KeySetsContainer.cpp	(revision 07a47e0c167bba50906b5cc3e9289ec6e7f1c6db)
+++ src/Fragmentation/KeySetsContainer.cpp	(revision 47d0416c5a62d6d7eb14391e14c7f3f576fb1673)
@@ -64,10 +64,10 @@
 
   FragmentCounter = FCounter;
-  DoLog(0) && (Log() << Verbose(0) << "Parsing key sets." << endl);
+  LOG(0, "Parsing key sets.");
   KeySets.resize(FragmentCounter);
   file << name << FRAGMENTPREFIX << KEYSETFILE;
   input.open(file.str().c_str(), ios::in);
   if (input.fail()) {
-    DoLog(0) && (Log() << Verbose(0) << endl << "KeySetsContainer::ParseKeySets: Unable to open " << file.str() << ", is the directory correct?" << endl);
+    LOG(0, endl << "KeySetsContainer::ParseKeySets: Unable to open " << file.str() << ", is the directory correct?");
     return false;
   }
@@ -82,5 +82,6 @@
       KeySets[i][j] = -1;
     FragmentNumber = FixedDigitNumber(FragmentCounter, i);
-    //Log() << Verbose(0) << FRAGMENTPREFIX << FragmentNumber << "[" << AtomCounter[i] << "]:";
+    //std::stringstream output;
+    //output << FRAGMENTPREFIX << FragmentNumber << "[" << AtomCounter[i] << "]:";
     delete[](FragmentNumber);
     input.getline(filename, 1023);
@@ -88,7 +89,7 @@
     for(int j=0;(j<AtomCounter[i]) && (!line.eof());j++) {
       line >> KeySets[i][j];
-      //Log() << Verbose(0) << " " << KeySets[i][j];
+      //output << " " << KeySets[i][j];
     }
-    //Log() << Verbose(0) << endl;
+    //LOG(0, output.str());
   }
   input.close();
@@ -103,5 +104,5 @@
   int Counter;
 
-  DoLog(0) && (Log() << Verbose(0) << "Creating Fragment terms." << endl);
+  LOG(0, "Creating Fragment terms.");
   // scan through all to determine maximum order
   Order=0;
@@ -114,5 +115,5 @@
       Order = Counter;
   }
-  DoLog(0) && (Log() << Verbose(0) << "Found Order is " << Order << "." << endl);
+  LOG(0, "Found Order is " << Order << ".");
 
   // scan through all to determine fragments per order
@@ -128,5 +129,5 @@
   }
   for(int i=0;i<Order;i++)
-    DoLog(0) && (Log() << Verbose(0) << "Found No. of Fragments of Order " << i+1 << " is " << FragmentsPerOrder[i] << "." << endl);
+    LOG(0, "Found No. of Fragments of Order " << i+1 << " is " << FragmentsPerOrder[i] << ".");
 
   // scan through all to gather indices to each order set
@@ -144,13 +145,13 @@
     FragmentsPerOrder[Counter-1]++;
   }
-  DoLog(0) && (Log() << Verbose(0) << "Printing OrderSet." << endl);
+  std::stringstream output;
+  output << "Printing OrderSet: " << std::endl;
   for(int i=0;i<Order;i++) {
     for (int j=0;j<FragmentsPerOrder[i];j++) {
-      DoLog(0) && (Log() << Verbose(0) << " " << OrderSet[i][j]);
+      output << " " << OrderSet[i][j];
     }
-    DoLog(0) && (Log() << Verbose(0) << endl);
-  }
-  DoLog(0) && (Log() << Verbose(0) << endl);
-
+    output << std::endl;
+  }
+  LOG(0, output.str());
 
   return true;
Index: src/Fragmentation/MatrixContainer.cpp
===================================================================
--- src/Fragmentation/MatrixContainer.cpp	(revision 07a47e0c167bba50906b5cc3e9289ec6e7f1c6db)
+++ src/Fragmentation/MatrixContainer.cpp	(revision 47d0416c5a62d6d7eb14391e14c7f3f576fb1673)
@@ -56,7 +56,6 @@
 bool MatrixContainer::InitialiseIndices(class MatrixContainer *_container)
 {
-  DoLog(0) && (Log() << Verbose(0) << "Initialising indices");
   if (_container == NULL) {
-    DoLog(0) && (Log() << Verbose(0) << " with trivial mapping." << endl);
+    LOG(0, "Initialising indices with trivial mapping.");
     Indices.resize(MatrixCounter + 1);
     for(int i=MatrixCounter+1;i--;) {
@@ -66,5 +65,5 @@
     }
   } else {
-    DoLog(0) && (Log() << Verbose(0) << " from other MatrixContainer." << endl);
+    std::stringstream output;
     if (MatrixCounter != _container->MatrixCounter)
       return false;
@@ -76,8 +75,8 @@
       for(int j=_container->RowCounter[i];j--;) {
         Indices[i][j] = _container->Indices[i][j];
-        //Log() << Verbose(0) << Indices[i][j] << "\t";
+        output << Indices[i][j] << "\t";
       }
-      //Log() << Verbose(0) << endl;
-    }
+    }
+    LOG(0, "Initialising indices from other MatrixContainer: " << output.str());
   }
   return true;
@@ -104,5 +103,5 @@
 
   if (input.fail()) {
-    DoeLog(1) && (eLog()<< Verbose(1) << endl << "MatrixContainer::ParseMatrix: Unable to parse istream." << endl);
+    ELOG(1, endl << "MatrixContainer::ParseMatrix: Unable to parse istream.");
     //performCriticalExit();
     return false;
@@ -119,5 +118,5 @@
   for(int k=skipcolumns;k--;)
     line >> Header[MatrixNr];
-  Log() << Verbose(0) << line.str() << endl;
+  LOG(0, line.str());
 
   // scan header for number of columns
@@ -129,8 +128,8 @@
       ColumnCounter[MatrixNr]++;
   }
-  Log() << Verbose(0) << line.str() << endl;
-  Log() << Verbose(1) << "ColumnCounter[" << MatrixNr << "]: " << ColumnCounter[MatrixNr] << "." << endl;
+  LOG(0, line.str());
+  LOG(1, "ColumnCounter[" << MatrixNr << "]: " << ColumnCounter[MatrixNr] << ".");
   if (ColumnCounter[MatrixNr] == 0) {
-    DoeLog(0) && (eLog()<< Verbose(0) << "ColumnCounter[" << MatrixNr << "]: " << ColumnCounter[MatrixNr] << " from ostream." << endl);
+    ELOG(0, "ColumnCounter[" << MatrixNr << "]: " << ColumnCounter[MatrixNr] << " from ostream.");
     performCriticalExit();
   }
@@ -142,5 +141,5 @@
   while (!input.eof()) {
     input.getline(filename, 1023);
-    Log() << Verbose(0) << "Comparing: " << strncmp(filename,"MeanForce",9) << endl;
+    LOG(0, "Comparing: " << strncmp(filename,"MeanForce",9));
     RowCounter[MatrixNr]++; // then line was not last MeanForce
     if (strncmp(filename,"MeanForce", 9) == 0) {
@@ -148,7 +147,7 @@
     }
   }
-  Log() << Verbose(1) << "RowCounter[" << MatrixNr << "]: " << RowCounter[MatrixNr] << " from input stream." << endl;
+  LOG(1, "RowCounter[" << MatrixNr << "]: " << RowCounter[MatrixNr] << " from input stream.");
   if (RowCounter[MatrixNr] == 0) {
-    DoeLog(0) && (eLog()<< Verbose(0) << "RowCounter[" << MatrixNr << "]: " << RowCounter[MatrixNr] << " from input stream." << endl);
+    ELOG(0, "RowCounter[" << MatrixNr << "]: " << RowCounter[MatrixNr] << " from input stream.");
     performCriticalExit();
   }
@@ -177,5 +176,5 @@
     input.getline(dummy, 1023);    // skip header
   line.str(dummy);
-  Log() << Verbose(0) << "Header: " << line.str() << endl;
+  LOG(0, "Header: " << line.str());
   for(int k=skipcolumns;k--;)  // skip columns in header too
     line >> filename;
@@ -183,12 +182,14 @@
   for(int j=0;j<RowCounter[MatrixNr];j++) {
     input.getline(filename, 1023);
-    stringstream lines(filename);
-    Log() << Verbose(2) << "Matrix at level " << j << ":";// << filename << endl;
+    std::stringstream lines(filename);
+    std::stringstream output;
+    output << "INFO: Matrix at level " << j << ":";// << filename << endl;
     for(int k=skipcolumns;k--;)
       lines >> filename;
     for(int k=0;(k<ColumnCounter[MatrixNr]) && (!lines.eof());k++) {
       lines >> Matrix[MatrixNr][j][k];
-      Log() << Verbose(1) << " " << std::setprecision(2) << Matrix[MatrixNr][j][k] << endl;
-    }
+      output << " " << std::setprecision(2) << Matrix[MatrixNr][j][k] << endl;
+    }
+    LOG(1, output.str());
   }
 
@@ -227,5 +228,5 @@
   input.open(file.str().c_str(), ios::in);
   if (input.bad()) {
-    DoLog(0) && (Log() << Verbose(0) << endl << "MatrixContainer::ParseFragmentMatrix: Unable to open " << file.str() << ", is the directory correct?" << endl);
+    LOG(0, endl << "MatrixContainer::ParseFragmentMatrix: Unable to open " << file.str() << ", is the directory correct?");
     return false;
   }
@@ -236,7 +237,7 @@
   }
   input.close();
-  DoLog(0) && (Log() << Verbose(0) << "Determined " << MatrixCounter << " fragments." << endl);
-
-  DoLog(0) && (Log() << Verbose(0) << "Parsing through each fragment and retrieving " << prefix << suffix << "." << endl);
+  LOG(0, "Determined " << MatrixCounter << " fragments.");
+
+  LOG(0, "Parsing through each fragment and retrieving " << prefix << suffix << ".");
   Header.clear();
   Matrix.clear();
@@ -253,5 +254,5 @@
     file << name << FRAGMENTPREFIX << FragmentNumber << prefix << suffix;
     std::ifstream input(file.str().c_str());
-    DoLog(0) &&( Log() << Verbose(0) << "Opening " << file.str() << " ... " << endl);
+    LOG(1, "INFO: Opening " << file.str() << " ... ");
     if (!ParseMatrix(input, skiplines, skipcolumns, i)) {
       input.close();
@@ -373,17 +374,17 @@
   // go through each order
   for (int CurrentFragment=0;CurrentFragment<KeySets.FragmentsPerOrder[Order];CurrentFragment++) {
-    //Log() << Verbose(0) << "Current Fragment is " << CurrentFragment << "/" << KeySets.OrderSet[Order][CurrentFragment] << "." << endl;
+    //LOG(0, "Current Fragment is " << CurrentFragment << "/" << KeySets.OrderSet[Order][CurrentFragment] << ".");
     // then go per order through each suborder and pick together all the terms that contain this fragment
     for(int SubOrder=0;SubOrder<=Order;SubOrder++) { // go through all suborders up to the desired order
       for (int j=0;j<KeySets.FragmentsPerOrder[SubOrder];j++) { // go through all possible fragments of size suborder
         if (KeySets.Contains(KeySets.OrderSet[Order][CurrentFragment], KeySets.OrderSet[SubOrder][j])) {
-          //Log() << Verbose(0) << "Current other fragment is " << j << "/" << KeySets.OrderSet[SubOrder][j] << "." << endl;
+          //LOG(0, "Current other fragment is " << j << "/" << KeySets.OrderSet[SubOrder][j] << ".");
           // if the fragment's indices are all in the current fragment
           for(int k=0;k<RowCounter[ KeySets.OrderSet[SubOrder][j] ];k++) { // go through all atoms in this fragment
             int m = MatrixValues.Indices[ KeySets.OrderSet[SubOrder][j] ][k];
-            //Log() << Verbose(0) << "Current index is " << k << "/" << m << "." << endl;
+            //LOG(0, "Current index is " << k << "/" << m << ".");
             if (m != -1) { // if it's not an added hydrogen
               for (int l=0;l<RowCounter[ KeySets.OrderSet[Order][CurrentFragment] ];l++) { // look for the corresponding index in the current fragment
-                //Log() << Verbose(0) << "Comparing " << m << " with " << MatrixValues.Indices[ KeySets.OrderSet[Order][CurrentFragment] ][l] << "." << endl;
+                //LOG(0, "Comparing " << m << " with " << MatrixValues.Indices[ KeySets.OrderSet[Order][CurrentFragment] ][l] << ".");
                 if (m == MatrixValues.Indices[ KeySets.OrderSet[Order][CurrentFragment] ][l]) {
                   m = l;
@@ -391,7 +392,7 @@
                 }
               }
-              //Log() << Verbose(0) << "Corresponding index in CurrentFragment is " << m << "." << endl;
+              //LOG(0, "Corresponding index in CurrentFragment is " << m << ".");
               if (m > RowCounter[ KeySets.OrderSet[Order][CurrentFragment] ]) {
-                DoeLog(0) && (eLog()<< Verbose(0) << "In fragment No. " << KeySets.OrderSet[Order][CurrentFragment]   << " current force index " << m << " is greater than " << RowCounter[ KeySets.OrderSet[Order][CurrentFragment] ] << "!" << endl);
+                ELOG(0, "In fragment No. " << KeySets.OrderSet[Order][CurrentFragment]   << " current force index " << m << " is greater than " << RowCounter[ KeySets.OrderSet[Order][CurrentFragment] ] << "!");
                 performCriticalExit();
                 return false;
@@ -406,12 +407,12 @@
             }
             //if ((ColumnCounter[ KeySets.OrderSet[SubOrder][j] ]>1) && (RowCounter[0]-1 >= 1))
-             //Log() << Verbose(0) << "Fragments[ KeySets.OrderSet[" << Order << "][" << CurrentFragment << "]=" << KeySets.OrderSet[Order][CurrentFragment] << " ][" << RowCounter[0]-1 << "][" << 1 << "] = " <<  Matrix[ KeySets.OrderSet[Order][CurrentFragment] ][RowCounter[0]-1][1] << endl;
+             //LOG(0, "Fragments[ KeySets.OrderSet[" << Order << "][" << CurrentFragment << "]=" << KeySets.OrderSet[Order][CurrentFragment] << " ][" << RowCounter[0]-1 << "][" << 1 << "] = " <<  Matrix[ KeySets.OrderSet[Order][CurrentFragment] ][RowCounter[0]-1][1]);
           }
         } else {
-          //Log() << Verbose(0) << "Fragment " << KeySets.OrderSet[SubOrder][j] << " is not contained in fragment " << KeySets.OrderSet[Order][CurrentFragment] << "." << endl;
+          //LOG(0, "Fragment " << KeySets.OrderSet[SubOrder][j] << " is not contained in fragment " << KeySets.OrderSet[Order][CurrentFragment] << ".");
         }
       }
     }
-   //Log() << Verbose(0) << "Final Fragments[ KeySets.OrderSet[" << Order << "][" << CurrentFragment << "]=" << KeySets.OrderSet[Order][CurrentFragment] << " ][" << KeySets.AtomCounter[0]-1 << "][" << 1 << "] = " <<  Matrix[ KeySets.OrderSet[Order][CurrentFragment] ][KeySets.AtomCounter[0]-1][1] << endl;
+   //LOG(0, "Final Fragments[ KeySets.OrderSet[" << Order << "][" << CurrentFragment << "]=" << KeySets.OrderSet[Order][CurrentFragment] << " ][" << KeySets.AtomCounter[0]-1 << "][" << 1 << "] = " <<  Matrix[ KeySets.OrderSet[Order][CurrentFragment] ][KeySets.AtomCounter[0]-1][1]);
   }
 
@@ -429,5 +430,5 @@
   char *FragmentNumber = NULL;
 
-  DoLog(0) && (Log() << Verbose(0) << "Writing fragment files." << endl);
+  LOG(0, "Writing fragment files.");
   for(int i=0;i<MatrixCounter;i++) {
     stringstream line;
@@ -437,5 +438,5 @@
     output.open(line.str().c_str(), ios::out);
     if (output == NULL) {
-      DoeLog(0) && (eLog()<< Verbose(0) << "MatrixContainer::WriteTotalFragments: Unable to open output energy file " << line.str() << "!" << endl);
+      ELOG(0, "MatrixContainer::WriteTotalFragments: Unable to open output energy file " << line.str() << "!");
       performCriticalExit();
       return false;
@@ -463,9 +464,9 @@
   stringstream line;
 
-  DoLog(0) && (Log() << Verbose(0) << "Writing matrix values of " << suffix << "." << endl);
+  LOG(0, "Writing matrix values of " << suffix << ".");
   line << name << prefix << suffix;
   output.open(line.str().c_str(), ios::out);
   if (output == NULL) {
-    DoeLog(0) && (eLog()<< Verbose(0) << "MatrixContainer::WriteLastMatrix: Unable to open output matrix file " << line.str() << "!" << endl);
+    ELOG(0, "MatrixContainer::WriteLastMatrix: Unable to open output matrix file " << line.str() << "!");
     performCriticalExit();
     return false;
Index: src/Fragmentation/PowerSetGenerator.cpp
===================================================================
--- src/Fragmentation/PowerSetGenerator.cpp	(revision 07a47e0c167bba50906b5cc3e9289ec6e7f1c6db)
+++ src/Fragmentation/PowerSetGenerator.cpp	(revision 47d0416c5a62d6d7eb14391e14c7f3f576fb1673)
@@ -22,4 +22,7 @@
 #include "PowerSetGenerator.hpp"
 
+#include <sstream>
+
+#include "CodePatterns/Info.hpp"
 #include "CodePatterns/Log.hpp"
 
@@ -53,5 +56,5 @@
 void PowerSetGenerator::ClearingTouched(int verbosity, int *&TouchedList, int SubOrder, int &TouchedIndex)
 {
-  Log() << Verbose(1+verbosity) << "Clearing touched list." << endl;
+  LOG(1+verbosity, "Clearing touched list.");
   for (TouchedIndex=SubOrder+1;TouchedIndex--;)  // empty touched list
     TouchedList[TouchedIndex] = -1;
@@ -81,6 +84,6 @@
     if (bit) {  // if bit is set, we add this bond partner
       OtherWalker = BondsSet[j]->rightatom;  // rightatom is always the one more distant, i.e. the one to add
-      //Log() << Verbose(1+verbosity) << "Current Bond is " << BondsSet[j] << ", checking on " << *OtherWalker << "." << endl;
-      Log() << Verbose(2+verbosity) << "Adding " << *OtherWalker << " with nr " << OtherWalker->getNr() << "." << endl;
+      //LOG(1+verbosity, "Current Bond is " << BondsSet[j] << ", checking on " << *OtherWalker << ".");
+      LOG(2+verbosity, "Adding " << *OtherWalker << " with nr " << OtherWalker->getNr() << ".");
       TestKeySetInsert = FragmentSet->insert(OtherWalker->getNr());
       if (TestKeySetInsert.second) {
@@ -88,8 +91,8 @@
         Added++;
       } else {
-        Log() << Verbose(2+verbosity) << "This was item was already present in the keyset." << endl;
+        LOG(2+verbosity, "This was item was already present in the keyset.");
       }
     } else {
-      Log() << Verbose(2+verbosity) << "Not adding." << endl;
+      LOG(2+verbosity, "Not adding.");
     }
   }
@@ -151,12 +154,13 @@
   for(int j=0;j<TouchedIndex;j++) {
     Removal = TouchedList[j];
-    Log() << Verbose(2+verbosity) << "Removing item nr. " << Removal << " from snake stack." << endl;
+    LOG(2+verbosity, "Removing item nr. " << Removal << " from snake stack.");
     FragmentSet->erase(Removal);
     TouchedList[j] = -1;
   }
-  DoLog(2) && (Log() << Verbose(2) << "Remaining local nr.s on snake stack are: ");
+  std::stringstream output;
+  output << "Remaining local nr.s on snake stack are: ";
   for(KeySet::iterator runner = FragmentSet->begin(); runner != FragmentSet->end(); runner++)
-    DoLog(0) && (Log() << Verbose(0) << (*runner) << " ");
-  DoLog(0) && (Log() << Verbose(0) << endl);
+    output << (*runner) << " ";
+  LOG(2, output.str());
   TouchedIndex = 0; // set Index to 0 for list of atoms added on this level
 };
@@ -180,6 +184,6 @@
   int Counter = FragmentSearch->FragmentCounter; // mark current value of counter
 
-  DoLog(0) && (Log() << Verbose(0) << endl);
-  DoLog(0) && (Log() << Verbose(0) << "Begin of PowerSetGenerator with order " << BondsPerSPList.getOrder() << " at Root " << *FragmentSearch->getRoot() << "." << endl);
+  LOG(0, std::endl);
+  LOG(0, "Begin of PowerSetGenerator with order " << BondsPerSPList.getOrder() << " at Root " << *FragmentSearch->getRoot() << ".");
 
   BondsPerSPList.SetSPList(FragmentSearch->getRoot());
@@ -193,10 +197,10 @@
   // creating fragments with the found edge sets  (may be done in reverse order, faster)
   int SP = BondsPerSPList.CountNumbersInBondsList();
-  DoLog(0) && (Log() << Verbose(0) << "Total number of edges is " << SP << "." << endl);
+  LOG(0, "Total number of edges is " << SP << ".");
   if (SP >= (BondsPerSPList.getOrder()-1)) {
     // start with root (push on fragment stack)
-    DoLog(0) && (Log() << Verbose(0) << "Starting fragment generation with " << *FragmentSearch->getRoot() << ", local nr is " << FragmentSearch->getRoot()->getNr() << "." << endl);
+    LOG(0, "Starting fragment generation with " << *FragmentSearch->getRoot() << ", local nr is " << FragmentSearch->getRoot()->getNr() << ".");
     FragmentSearch->FragmentSet->clear();
-    DoLog(0) && (Log() << Verbose(0) << "Preparing subset for this root and calling generator." << endl);
+    LOG(0, "Preparing subset for this root and calling generator.");
 
     // prepare the subset and call the generator
@@ -209,10 +213,10 @@
     SPFragmentGenerator(0, BondsList, BondsPerSPList.BondsPerSPCount[0], BondsPerSPList.getOrder());
   } else {
-    DoLog(0) && (Log() << Verbose(0) << "Not enough total number of edges to build " << BondsPerSPList.getOrder() << "-body fragments." << endl);
+    LOG(0, "Not enough total number of edges to build " << BondsPerSPList.getOrder() << "-body fragments.");
   }
 
   // as FragmentSearch structure is used only once, we don't have to clean it anymore
   // remove root from stack
-  DoLog(0) && (Log() << Verbose(0) << "Removing root again from stack." << endl);
+  LOG(0, "Removing root again from stack.");
   FragmentSearch->FragmentSet->erase(FragmentSearch->getRoot()->getNr());
 
@@ -221,5 +225,5 @@
 
   // return list
-  DoLog(0) && (Log() << Verbose(0) << "End of PowerSetGenerator." << endl);
+  LOG(0, "End of PowerSetGenerator.");
   return (FragmentSearch->FragmentCounter - Counter);
 };
@@ -240,4 +244,5 @@
 void PowerSetGenerator::SPFragmentGenerator(int RootDistance, std::vector<bond *> &BondsSet, int SetDimension, int SubOrder)
 {
+  Info info(__func__);
   int verbosity = 0; //FragmentSearch->ANOVAOrder-SubOrder;
   int NumCombinations;
@@ -253,6 +258,5 @@
   // recursively for the next level
 
-  Log() << Verbose(1+verbosity) << "Begin of SPFragmentGenerator." << endl;
-  Log() << Verbose(1+verbosity) << "We are " << RootDistance << " away from Root, which is " << *FragmentSearch->getRoot() << ", SubOrder is " << SubOrder << ", SetDimension is " << SetDimension << " and this means " <<  NumCombinations-1 << " combination(s)." << endl;
+  LOG(1+verbosity, "We are " << RootDistance << " away from Root, which is " << *FragmentSearch->getRoot() << ", SubOrder is " << SubOrder << ", SetDimension is " << SetDimension << " and this means " <<  NumCombinations-1 << " combination(s).");
 
   // initialised touched list (stores added atoms on this level)
@@ -260,5 +264,5 @@
 
   // create every possible combination of the endpieces
-  Log() << Verbose(1+verbosity) << "Going through all combinations of the power set." << endl;
+  LOG(1+verbosity, "Going through all combinations of the power set.");
   for (int i=1;i<NumCombinations;i++) {  // sweep through all power set combinations (skip empty set!)
     // count the set bit of i
@@ -267,5 +271,5 @@
       bits += (i & (1 << j)) >> j;
 
-    Log() << Verbose(1+verbosity) << "Current set is " << Binary(i | (1 << SetDimension)) << ", number of bits is " << bits << "." << endl;
+    LOG(1+verbosity, "Current set is " << Binary(i | (1 << SetDimension)) << ", number of bits is " << bits << ".");
     if (bits <= SubOrder) { // if not greater than additional atoms allowed on stack, continue
       // --1-- add this set of the power set of bond partners to the snake stack
@@ -274,5 +278,5 @@
       SpaceLeft = SubOrder - Added ;// SubOrder - bits; // due to item's maybe being already present, this does not work anymore
       if (SpaceLeft > 0) {
-        Log() << Verbose(1+verbosity) << "There's still some space left on stack: " << SpaceLeft << "." << endl;
+        LOG(1+verbosity, "There's still some space left on stack: " << SpaceLeft << ".");
         if (SubOrder > 1) {    // Due to Added above we have to check extra whether we're not already reaching beyond the desired Order
           // --2-- look at all added end pieces of this combination, construct bond subsets and sweep through a power set of these by recursion
@@ -288,26 +292,29 @@
 
           // then iterate
-          Log() << Verbose(2+verbosity) << "Calling subset generator " << SP << " away from root " << *FragmentSearch->getRoot() << " with sub set dimension " << SubSetDimension << "." << endl;
+          LOG(2+verbosity, "Calling subset generator " << SP << " away from root " << *FragmentSearch->getRoot() << " with sub set dimension " << SubSetDimension << ".");
           SPFragmentGenerator(SP, BondsList, SubSetDimension, SubOrder-bits);
         }
       } else {
         // --2-- otherwise store the complete fragment
-        Log() << Verbose(1+verbosity) << "Enough items on stack for a fragment!" << endl;
+        LOG(1+verbosity, "Enough items on stack for a fragment!");
         // store fragment as a KeySet
-        DoLog(2) && (Log() << Verbose(2) << "Found a new fragment[" << FragmentSearch->FragmentCounter << "], local nr.s are: ");
-        for(KeySet::iterator runner = FragmentSearch->FragmentSet->begin(); runner != FragmentSearch->FragmentSet->end(); runner++)
-          DoLog(0) && (Log() << Verbose(0) << (*runner) << " ");
-        DoLog(0) && (Log() << Verbose(0) << endl);
+        if (DoLog(2)) {
+          std::stringstream output;
+          output << "Found a new fragment[" << FragmentSearch->FragmentCounter << "], local nr.s are: ";
+          for(KeySet::iterator runner = FragmentSearch->FragmentSet->begin(); runner != FragmentSearch->FragmentSet->end(); runner++)
+            output << (*runner) << " ";
+          LOG(2, output.str());
+        }
         FragmentSearch->InsertFragmentIntoGraph();
       }
 
       // --3-- remove all added items in this level from snake stack
-      Log() << Verbose(1+verbosity) << "Removing all items that were added on this SP level " << RootDistance << "." << endl;
+      LOG(1+verbosity, "Removing all items that were added on this SP level " << RootDistance << ".");
       RemoveAllTouchedFromSnakeStack(verbosity, FragmentSearch->FragmentSet, TouchedList, TouchedIndex);
     } else {
-      Log() << Verbose(2+verbosity) << "More atoms to add for this set (" << bits << ") than space left on stack " << SubOrder << ", skipping this set." << endl;
+      LOG(2+verbosity, "More atoms to add for this set (" << bits << ") than space left on stack " << SubOrder << ", skipping this set.");
     }
   }
   delete[](TouchedList);
-  Log() << Verbose(1+verbosity) << "End of SPFragmentGenerator, " << RootDistance << " away from Root " << *FragmentSearch->getRoot() << " and SubOrder is " << SubOrder << "." << endl;
-};
+  LOG(1+verbosity, "End of SPFragmentGenerator, " << RootDistance << " away from Root " << *FragmentSearch->getRoot() << " and SubOrder is " << SubOrder << ".");
+};
Index: src/Fragmentation/UniqueFragments.cpp
===================================================================
--- src/Fragmentation/UniqueFragments.cpp	(revision 07a47e0c167bba50906b5cc3e9289ec6e7f1c6db)
+++ src/Fragmentation/UniqueFragments.cpp	(revision 47d0416c5a62d6d7eb14391e14c7f3f576fb1673)
@@ -51,10 +51,10 @@
   testGraphInsert = Leaflet->insert(GraphPair (*FragmentSet,std::pair<int,double>(FragmentCounter,TEFactor)));  // store fragment number and current factor
   if (testGraphInsert.second) {
-    DoLog(2) && (Log() << Verbose(2) << "KeySet " << FragmentCounter << " successfully inserted." << endl);
+    LOG(2, "KeySet " << FragmentCounter << " successfully inserted.");
     FragmentCounter++;
   } else {
-    DoLog(2) && (Log() << Verbose(2) << "KeySet " << FragmentCounter << " failed to insert, present fragment is " << ((*(testGraphInsert.first)).second).first << endl);
+    LOG(2, "KeySet " << FragmentCounter << " failed to insert, present fragment is " << ((*(testGraphInsert.first)).second).first);
     ((*(testGraphInsert.first)).second).second += TEFactor;  // increase the "created" counter
-    DoLog(2) && (Log() << Verbose(2) << "New factor is " << ((*(testGraphInsert.first)).second).second << "." << endl);
+    LOG(2, "New factor is " << ((*(testGraphInsert.first)).second).second << ".");
   }
 };
Index: src/Fragmentation/analyzer.cpp
===================================================================
--- src/Fragmentation/analyzer.cpp	(revision 07a47e0c167bba50906b5cc3e9289ec6e7f1c6db)
+++ src/Fragmentation/analyzer.cpp	(revision 47d0416c5a62d6d7eb14391e14c7f3f576fb1673)
@@ -79,14 +79,14 @@
   int counter = 0;
 
-  DoLog(0) && (Log() << Verbose(0) << "ANOVA Analyzer" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "==============" << endl);
+  LOG(0, "ANOVA Analyzer");
+  LOG(0, "==============");
 
   // Get the command line options
   if (argc < 4) {
-    DoLog(0) && (Log() << Verbose(0) << "Usage: " << argv[0] << " <inputdir> <prefix> <outputdir> [elementsdb]" << endl);
-    DoLog(0) && (Log() << Verbose(0) << "<inputdir>\ttherein the output of a molecuilder fragmentation is expected, each fragment with a subdir containing an energy.all and a forces.all file." << endl);
-    DoLog(0) && (Log() << Verbose(0) << "<prefix>\tprefix of energy and forces file." << endl);
-    DoLog(0) && (Log() << Verbose(0) << "<outputdir>\tcreated plotfiles and datafiles are placed into this directory " << endl);
-    DoLog(0) && (Log() << Verbose(0) << "[elementsdb]\tpath to elements database, needed for shieldings." << endl);
+    LOG(0, "Usage: " << argv[0] << " <inputdir> <prefix> <outputdir> [elementsdb]");
+    LOG(0, "<inputdir>\ttherein the output of a molecuilder fragmentation is expected, each fragment with a subdir containing an energy.all and a forces.all file.");
+    LOG(0, "<prefix>\tprefix of energy and forces file.");
+    LOG(0, "<outputdir>\tcreated plotfiles and datafiles are placed into this directory ");
+    LOG(0, "[elementsdb]\tpath to elements database, needed for shieldings.");
     return 1;
   } else {
@@ -97,5 +97,5 @@
 
   if (argc > 4) {
-    DoLog(0) && (Log() << Verbose(0) << "Loading periodentafel." << endl);
+    LOG(0, "Loading periodentafel.");
     periode = new periodentafel;
     periode->LoadPeriodentafel(argv[4]);
@@ -112,5 +112,5 @@
   if (!Hcorrection.ParseFragmentMatrix(argv[1], "", HCORRECTIONSUFFIX,0,0)) {
     NoHCorrection = true;
-    DoeLog(2) && (eLog()<< Verbose(2) << "No HCorrection file found, skipping these." << endl);
+    ELOG(2, "No HCorrection file found, skipping these.");
   }
   
@@ -118,9 +118,9 @@
   if (!Hessian.ParseFragmentMatrix(argv[1], dir, HessianSuffix,0,0)) {
     NoHessian = true;
-    DoeLog(2) && (eLog()<< Verbose(2) << "No Hessian file found, skipping these." << endl);
+    ELOG(2, "No Hessian file found, skipping these.");
   }
   if (!Time.ParseFragmentMatrix(argv[1], dir, TimeSuffix, 10,1)) {
     NoTime = true;
-    DoeLog(2) && (eLog()<< Verbose(2) << "No speed file found, skipping these." << endl);
+    ELOG(2, "No speed file found, skipping these.");
   }
   if (periode != NULL) { // also look for PAS values
@@ -264,5 +264,5 @@
   // +++++++++++++++ ANALYZING ++++++++++++++++++++++++++++++
 
-  DoLog(0) && (Log() << Verbose(0) << "Analyzing ..." << endl);
+  LOG(0, "Analyzing ...");
 
   // ======================================= Creating the data files ==============================================================
@@ -575,5 +575,5 @@
   delete(periode);
   delete[](dir);
-  DoLog(0) && (Log() << Verbose(0) << "done." << endl);
+  LOG(0, "done.");
   return 0;
 };
Index: src/Fragmentation/datacreator.cpp
===================================================================
--- src/Fragmentation/datacreator.cpp	(revision 07a47e0c167bba50906b5cc3e9289ec6e7f1c6db)
+++ src/Fragmentation/datacreator.cpp	(revision 47d0416c5a62d6d7eb14391e14c7f3f576fb1673)
@@ -51,5 +51,5 @@
   output.open(name.str().c_str(), ios::out);
   if (output == NULL) {
-    DoLog(0) && (Log() << Verbose(0) << "Unable to open " << name.str() << " for writing, is directory correct?" << endl);
+    LOG(0, "Unable to open " << name.str() << " for writing, is directory correct?");
     return false;
   }
@@ -69,5 +69,5 @@
   output.open(name.str().c_str(), ios::app);
   if (output == NULL) {
-    DoLog(0) && (Log() << Verbose(0) << "Unable to open " << name.str() << " for writing, is directory correct?" << endl);
+    LOG(0, "Unable to open " << name.str() << " for writing, is directory correct?");
     return false;
   }
@@ -89,5 +89,5 @@
   filename << prefix << ".dat";
   if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
-  DoLog(0) && (Log() << Verbose(0) << msg << endl);
+  LOG(0, msg);
   output << "# " << msg << ", created on " << datum;
   output << "#Order\tFrag.No.\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
@@ -122,5 +122,5 @@
   filename << prefix << ".dat";
   if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
-  DoLog(0) && (Log() << Verbose(0) << msg << endl);
+  LOG(0, msg);
   output << "# " << msg << ", created on " << datum;
   output << "#Order\tFrag.No.\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
@@ -159,5 +159,5 @@
   filename << prefix << ".dat";
   if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
-  DoLog(0) && (Log() << Verbose(0) << msg << endl);
+  LOG(0, msg);
   output << "# " << msg << ", created on " << datum;
   output << "# Order\tFrag.No.\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
@@ -191,5 +191,5 @@
   filename << prefix << ".dat";
   if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
-  DoLog(0) && (Log() << Verbose(0) << msg << endl);
+  LOG(0, msg);
   output << "# " << msg << ", created on " << datum;
   output << "# Order\tFrag.No.\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
@@ -224,10 +224,10 @@
   filename << prefix << ".dat";
   if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
-  DoLog(0) && (Log() << Verbose(0) << msg << endl);
+  LOG(0, msg);
   output << "# " << msg << ", created on " << datum;
   output << "# AtomNo\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
   Fragments.SetLastMatrix(Force.Matrix[Force.MatrixCounter], 0);
   for (int BondOrder=0;BondOrder<KeySets.Order;BondOrder++) {
-    //Log() << Verbose(0) << "Current order is " << BondOrder << "." << endl;
+    //LOG(0, "Current order is " << BondOrder << ".");
     Fragments.SumSubForces(Fragments, KeySets, BondOrder, -1.);
     // errors per atom
@@ -270,9 +270,9 @@
   filename << prefix << ".dat";
   if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
-  DoLog(0) && (Log() << Verbose(0) << msg << endl);
+  LOG(0, msg);
   output << "# " << msg << ", created on " << datum;
   output << "# AtomNo\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
   for (int BondOrder=0;BondOrder<KeySets.Order;BondOrder++) {
-    //Log() << Verbose(0) << "Current order is " << BondOrder << "." << endl;
+    //LOG(0, "Current order is " << BondOrder << ".");
     Fragments.SumSubForces(Fragments, KeySets, BondOrder, 1.);
     // errors per atom
@@ -307,10 +307,10 @@
   filename << prefix << ".dat";
   if (!OpenOutputFile(output, dir, filename.str().c_str())) return false; 
-  DoLog(0) && (Log() << Verbose(0) << msg << endl);
+  LOG(0, msg);
   output << "# " << msg << ", created on " << datum;
   output << "# AtomNo\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
   Fragments.SetLastMatrix(Hessian.Matrix[Hessian.MatrixCounter], 0);
   for (int BondOrder=0;BondOrder<KeySets.Order;BondOrder++) {
-    //Log() << Verbose(0) << "Current order is " << BondOrder << "." << endl;
+    //LOG(0, "Current order is " << BondOrder << ".");
     Fragments.SumSubHessians(Fragments, KeySets, BondOrder, -1.);
     // errors per atom
@@ -347,5 +347,5 @@
   filename << prefix << ".dat";
   if (!OpenOutputFile(output, dir, filename.str().c_str())) return false; 
-  DoLog(0) && (Log() << Verbose(0) << msg << endl);
+  LOG(0, msg);
   output << "# " << msg << ", created on " << datum;
   output << "# AtomNo\t";
@@ -357,5 +357,5 @@
   output << Fragments.RowCounter[ Fragments.MatrixCounter ] << "\t";
   for (int BondOrder=0;BondOrder<KeySets.Order;BondOrder++) {
-    //Log() << Verbose(0) << "Current order is " << BondOrder << "." << endl;
+    //LOG(0, "Current order is " << BondOrder << ".");
     Fragments.SumSubHessians(Fragments, KeySets, BondOrder, -1.);
     // frobenius norm of errors per atom
@@ -389,10 +389,10 @@
   filename << prefix << ".dat";
   if (!OpenOutputFile(output, dir, filename.str().c_str())) return false; 
-  DoLog(0) && (Log() << Verbose(0) << msg << endl);
+  LOG(0, msg);
   output << "# " << msg << ", created on " << datum;
   output << "# AtomNo\t" << Fragments.Header[ Fragments.MatrixCounter ] << endl;
   Fragments.SetLastMatrix(0., 0);
   for (int BondOrder=0;BondOrder<KeySets.Order;BondOrder++) {
-    //Log() << Verbose(0) << "Current order is " << BondOrder << "." << endl;
+    //LOG(0, "Current order is " << BondOrder << ".");
     Fragments.SumSubHessians(Fragments, KeySets, BondOrder, 1.);
     // errors per atom
@@ -419,5 +419,5 @@
   filename << prefix << ".dat";
   if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
-  DoLog(0) && (Log() << Verbose(0) << msg << endl);
+  LOG(0, msg);
   output << "# " << msg << ", created on " << datum << endl;
   output << "#Order\tFrag.No.\t" << Fragment.Header[ Fragment.MatrixCounter ] << endl;
@@ -484,5 +484,5 @@
   filename << prefix << ".dat";
   if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
-  DoLog(0) && (Log() << Verbose(0) << msg << endl);
+  LOG(0, msg);
   output << "# " << msg << ", created on " << datum;
   output << "#Order\tFrag.No.\t" << Fragment.Header[ Fragment.MatrixCounter ] << endl;
Index: src/Fragmentation/fragmentation_helpers.cpp
===================================================================
--- src/Fragmentation/fragmentation_helpers.cpp	(revision 07a47e0c167bba50906b5cc3e9289ec6e7f1c6db)
+++ src/Fragmentation/fragmentation_helpers.cpp	(revision 47d0416c5a62d6d7eb14391e14c7f3f576fb1673)
@@ -45,12 +45,14 @@
 void PrintAtomMask(bool *AtomMask, int AtomCount)
 {
-  DoLog(2) && (Log() << Verbose(2) << "              ");
+  std::stringstream output;
+  output << "              ";
   for(int i=0;i<AtomCount;i++)
-    DoLog(0) && (Log() << Verbose(0) << (i % 10));
-  DoLog(0) && (Log() << Verbose(0) << endl);
-  DoLog(2) && (Log() << Verbose(2) << "Atom mask is: ");
+    output << (i % 10);
+  LOG(2, output.str());
+  output.clear();
+  output << "Atom mask is: ";
   for(int i=0;i<AtomCount;i++)
-    DoLog(0) && (Log() << Verbose(0) << (AtomMask[i] ? "t" : "f"));
-  DoLog(0) && (Log() << Verbose(0) << endl);
+    output << (AtomMask[i] ? "t" : "f");
+  LOG(2, output.str());
 };
 
@@ -71,5 +73,5 @@
   atom *Walker = NULL;
 
-  DoLog(0) && (Log() << Verbose(0) << "Combining the lists of all orders per order and finally into a single one." << endl);
+  LOG(0, "Combining the lists of all orders per order and finally into a single one.");
   if (FragmentList == NULL) {
     FragmentList = new Graph;
@@ -104,5 +106,5 @@
 void FreeAllOrdersList(Graph ***FragmentLowerOrdersList, KeyStack &RootStack, molecule *mol)
 {
-  DoLog(1) && (Log() << Verbose(1) << "Free'ing the lists of all orders per order." << endl);
+  LOG(1, "Free'ing the lists of all orders per order.");
   int RootNr = 0;
   int RootKeyNr = 0;
Index: src/Fragmentation/helpers.cpp
===================================================================
--- src/Fragmentation/helpers.cpp	(revision 07a47e0c167bba50906b5cc3e9289ec6e7f1c6db)
+++ src/Fragmentation/helpers.cpp	(revision 47d0416c5a62d6d7eb14391e14c7f3f576fb1673)
@@ -44,5 +44,5 @@
   if (input.fail()) {
     if (!test)
-      DoLog(0) && (Log() << Verbose(0) << endl << "FilePresent: Unable to open " << filename << ", is the directory correct?" << endl);
+      LOG(0, endl << "FilePresent: Unable to open " << filename << ", is the directory correct?");
     return false;
   }
@@ -78,5 +78,5 @@
     number = (int)floor(((double)number / 10.));
     order++;
-    //Log() << Verbose(0) << "Number is " << number << ", order is " << order << "." << std::endl;
+    //LOG(0, "Number is " << number << ", order is " << order << ".");
   }
   // allocate string
@@ -89,5 +89,5 @@
     number = (int)floor(((double)number / 10.));
   }
-  //Log() << Verbose(0) << returnstring << endl;
+  //LOG(0, returnstring);
   return returnstring;
 };
Index: src/Fragmentation/joiner.cpp
===================================================================
--- src/Fragmentation/joiner.cpp	(revision 07a47e0c167bba50906b5cc3e9289ec6e7f1c6db)
+++ src/Fragmentation/joiner.cpp	(revision 47d0416c5a62d6d7eb14391e14c7f3f576fb1673)
@@ -67,13 +67,13 @@
   bool NoHessian = false;
 
-  DoLog(0) && (Log() << Verbose(0) << "Joiner" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "======" << endl);
+  LOG(0, "Joiner");
+  LOG(0, "======");
 
   // Get the command line options
   if (argc < 3) {
-    DoLog(0) && (Log() << Verbose(0) << "Usage: " << argv[0] << " <inputdir> <prefix> [elementsdb]" << endl);
-    DoLog(0) && (Log() << Verbose(0) << "<inputdir>\ttherein the output of a molecuilder fragmentation is expected, each fragment with a subdir containing an energy.all and a forces.all file." << endl);
-    DoLog(0) && (Log() << Verbose(0) << "<prefix>\tprefix of energy and forces file." << endl);
-    DoLog(0) && (Log() << Verbose(0) << "[elementsdb]\tpath to elements database, needed for shieldings." << endl);
+    LOG(0, "Usage: " << argv[0] << " <inputdir> <prefix> [elementsdb]");
+    LOG(0, "<inputdir>\ttherein the output of a molecuilder fragmentation is expected, each fragment with a subdir containing an energy.all and a forces.all file.");
+    LOG(0, "<prefix>\tprefix of energy and forces file.");
+    LOG(0, "[elementsdb]\tpath to elements database, needed for shieldings.");
     return 1;
   } else {
@@ -97,10 +97,10 @@
   if (!Hcorrection.ParseFragmentMatrix(argv[1], "", HCORRECTIONSUFFIX, 0,0)) {
     NoHCorrection = true;
-    DoLog(0) && (Log() << Verbose(0) << "No HCorrection matrices found, skipping these." << endl);
+    LOG(0, "No HCorrection matrices found, skipping these.");
   }
   if (!Force.ParseFragmentMatrix(argv[1], dir, ForcesSuffix, 0,0)) return 1;
   if (!Hessian.ParseFragmentMatrix(argv[1], dir, HessianSuffix, 0,0)) {
     NoHessian = true;
-    DoLog(0) && (Log() << Verbose(0) << "No hessian matrices found, skipping these." << endl);
+    LOG(0, "No hessian matrices found, skipping these.");
   }
   if (periode != NULL) { // also look for PAS values
@@ -166,5 +166,5 @@
   for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
     // --------- sum up energy --------------------
-    DoLog(0) && (Log() << Verbose(0) << "Summing energy of order " << BondOrder+1 << " ..." << endl);
+    LOG(0, "Summing energy of order " << BondOrder+1 << " ...");
     if (!EnergyFragments.SumSubManyBodyTerms(Energy, KeySet, BondOrder)) return 1;
     if (!NoHCorrection) { 
@@ -175,15 +175,15 @@
       if (!Energy.SumSubEnergy(EnergyFragments, NULL, KeySet, BondOrder, 1.)) return 1;
     // --------- sum up Forces --------------------
-    DoLog(0) && (Log() << Verbose(0) << "Summing forces of order " << BondOrder+1 << " ..." << endl);
+    LOG(0, "Summing forces of order " << BondOrder+1 << " ...");
     if (!ForceFragments.SumSubManyBodyTerms(Force, KeySet, BondOrder)) return 1;
     if (!Force.SumSubForces(ForceFragments, KeySet, BondOrder, 1.)) return 1;
     // --------- sum up Hessian --------------------
     if (!NoHessian) {
-      DoLog(0) && (Log() << Verbose(0) << "Summing Hessian of order " << BondOrder+1 << " ..." << endl);
+      LOG(0, "Summing Hessian of order " << BondOrder+1 << " ...");
       if (!HessianFragments.SumSubManyBodyTerms(Hessian, KeySet, BondOrder)) return 1;
       if (!Hessian.SumSubHessians(HessianFragments, KeySet, BondOrder, 1.)) return 1;
     }
     if (periode != NULL) { // also look for PAS values
-      DoLog(0) && (Log() << Verbose(0) << "Summing shieldings and susceptibilities of order " << BondOrder+1 << " ..." << endl);
+      LOG(0, "Summing shieldings and susceptibilities of order " << BondOrder+1 << " ...");
       if (!ShieldingFragments.SumSubManyBodyTerms(Shielding, KeySet, BondOrder)) return 1;
       if (!Shielding.SumSubForces(ShieldingFragments, KeySet, BondOrder, 1.)) return 1;
@@ -199,5 +199,5 @@
     prefix.str(" ");
     prefix << dir << OrderSuffix << (BondOrder+1);
-    DoLog(0) && (Log() << Verbose(0) << "Writing files " << argv[1] << prefix.str() << ". ..." << endl);
+    LOG(0, "Writing files " << argv[1] << prefix.str() << ". ...");
     // energy
     if (!Energy.WriteLastMatrix(argv[1], (prefix.str()).c_str(), EnergySuffix)) return 1;
@@ -268,5 +268,5 @@
   delete(periode);
   delete[](dir);
-  DoLog(0) && (Log() << Verbose(0) << "done." << endl);
+  LOG(0, "done.");
   return 0;
 };
