Changeset 543ce4 for molecuilder/src/molecule_dynamics.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_dynamics.cpp (modified) (36 diffs)

molecuilder/src/molecule_dynamics.cpp

@@ -9 +9 @@
 #include "config.hpp"
 #include "element.hpp"
+#include "log.hpp"
 #include "memoryallocator.hpp"
 #include "molecule.hpp"
@@ -63 +64 @@
       tmp = trajectory2.Norm();  // remaining norm is distance
     } else if ((fabs(trajectory1.ScalarProduct(&trajectory2)/Norm1/Norm2) - 1.) < MYEPSILON) { // check whether they're linear dependent
-  //        *out << Verbose(3) << "Both trajectories of " << *Walker << " and " << *Runner << " are linear dependent: ";
-  //        *out << trajectory1;
-  //        *out << " and ";
-  //        *out << trajectory2;
+  //        Log() << Verbose(3) << "Both trajectories of " << *Walker << " and " << *Runner << " are linear dependent: ";
+  //        Log() << Verbose(0) << trajectory1;
+  //        Log() << Verbose(0) << " and ";
+  //        Log() << Verbose(0) << trajectory2;
       tmp = Walker->Trajectory.R.at(Params.startstep).Distance(&Runner->Trajectory.R.at(Params.startstep));
-  //        *out << " with distance " << tmp << "." << endl;
+  //        Log() << Verbose(0) << " with distance " << tmp << "." << endl;
     } else { // determine distance by finding minimum distance
-  //        *out << Verbose(3) << "Both trajectories of " << *Walker << " and " << *Runner << " are linear independent ";
-  //        *out << endl;
-  //        *out << "First Trajectory: ";
-  //        *out << trajectory1 << endl;
-  //        *out << "Second Trajectory: ";
-  //        *out << trajectory2 << endl;
+  //        Log() << Verbose(3) << "Both trajectories of " << *Walker << " and " << *Runner << " are linear independent ";
+  //        Log() << Verbose(0) << endl;
+  //        Log() << Verbose(0) << "First Trajectory: ";
+  //        Log() << Verbose(0) << trajectory1 << endl;
+  //        Log() << Verbose(0) << "Second Trajectory: ";
+  //        Log() << Verbose(0) << trajectory2 << endl;
       // determine normal vector for both
       normal.MakeNormalVector(&trajectory1, &trajectory2);
       // print all vectors for debugging
-  //        *out << "Normal vector in between: ";
-  //        *out << normal << endl;
+  //        Log() << Verbose(0) << "Normal vector in between: ";
+  //        Log() << Verbose(0) << normal << endl;
       // setup matrix
       for (int i=NDIM;i--;) {
@@ -92 +93 @@
       // distance from last component
       tmp = gsl_vector_get(x,2);
-  //        *out << " with distance " << tmp << "." << endl;
+  //        Log() << Verbose(0) << " with distance " << tmp << "." << endl;
       // test whether we really have the intersection (by checking on c_1 and c_2)
       TestVector.CopyVector(&Runner->Trajectory.R.at(Params.startstep));
@@ -103 +104 @@
       TestVector.SubtractVector(&trajectory1);
       if (TestVector.Norm() < MYEPSILON) {
-  //          *out << Verbose(2) << "Test: ok.\tDistance of " << tmp << " is correct." << endl;
+  //          Log() << Verbose(2) << "Test: ok.\tDistance of " << tmp << " is correct." << endl;
       } else {
-  //          *out << Verbose(2) << "Test: failed.\tIntersection is off by ";
-  //          *out << TestVector;
-  //          *out << "." << endl;
+  //          Log() << Verbose(2) << "Test: failed.\tIntersection is off by ";
+  //          Log() << Verbose(0) << TestVector;
+  //          Log() << Verbose(0) << "." << endl;
       }
     }
@@ -114 +115 @@
     if (fabs(tmp) > MYEPSILON) {
       result += Params.PenaltyConstants[1] * 1./tmp;
-      //*out << Verbose(4) << "Adding " << 1./tmp*constants[1] << "." << endl;
+      //Log() << Verbose(4) << "Adding " << 1./tmp*constants[1] << "." << endl;
     }
   }
@@ -134 +135 @@
     if ((Params.PermutationMap[Walker->nr] == Params.PermutationMap[Runner->nr]) && (Walker->nr < Runner->nr)) {
   //    atom *Sprinter = PermutationMap[Walker->nr];
-  //        *out << *Walker << " and " << *Runner << " are heading to the same target at ";
-  //        *out << Sprinter->Trajectory.R.at(endstep);
-  //        *out << ", penalting." << endl;
+  //        Log() << Verbose(0) << *Walker << " and " << *Runner << " are heading to the same target at ";
+  //        Log() << Verbose(0) << Sprinter->Trajectory.R.at(endstep);
+  //        Log() << Verbose(0) << ", penalting." << endl;
       result += Params.PenaltyConstants[2];
-      //*out << Verbose(4) << "Adding " << constants[2] << "." << endl;
+      //Log() << Verbose(4) << "Adding " << constants[2] << "." << endl;
     }
   }
@@ -159 +160 @@
  * \todo There's a bit double counting going on for the first time, bu nothing to worry really about.
  */
-double molecule::ConstrainedPotential(ofstream *out, struct EvaluatePotential &Params)
+double molecule::ConstrainedPotential(struct EvaluatePotential &Params)
 {
   double tmp, result;
@@ -173 +174 @@
     tmp *= Params.IsAngstroem ? 1. : 1./AtomicLengthToAngstroem;
     result += Params.PenaltyConstants[0] * tmp;
-    //*out << Verbose(4) << "Adding " << tmp*constants[0] << "." << endl;
+    //Log() << Verbose(4) << "Adding " << tmp*constants[0] << "." << endl;
 
     // second term: sum of distances to other trajectories
@@ -190 +191 @@
  * \param AtomCount number of atoms
  */
-void PrintPermutationMap(ofstream *out, int AtomCount, struct EvaluatePotential &Params)
+void PrintPermutationMap(int AtomCount, struct EvaluatePotential &Params)
 {
   stringstream zeile1, zeile2;
@@ -206 +207 @@
     doubles++;
   if (doubles >0)
-    *out << "Found " << doubles << " Doubles." << endl;
+    Log() << Verbose(2) << "Found " << doubles << " Doubles." << endl;
   Free(&DoubleList);
-//  *out << zeile1.str() << endl << zeile2.str() << endl;
+//  Log() << Verbose(2) << zeile1.str() << endl << zeile2.str() << endl;
 };
 
@@ -239 +240 @@
  * \param &Params constrained potential parameters
  */
-void CreateInitialLists(ofstream *out, molecule *mol, struct EvaluatePotential &Params)
+void CreateInitialLists(molecule *mol, struct EvaluatePotential &Params)
 {
   atom *Walker = mol->start;
@@ -248 +249 @@
     Params.DoubleList[Params.DistanceList[Walker->nr]->begin()->second->nr]++;            // increase this target's source count (>1? not injective)
     Params.DistanceIterators[Walker->nr] = Params.DistanceList[Walker->nr]->begin();    // and remember which one we picked
-    *out << *Walker << " starts with distance " << Params.DistanceList[Walker->nr]->begin()->first << "." << endl;
+    Log() << Verbose(2) << *Walker << " starts with distance " << Params.DistanceList[Walker->nr]->begin()->first << "." << endl;
   }
 };
@@ -259 +260 @@
  * \param &Params constrained potential parameters
  */
-double TryNextNearestNeighbourForInjectivePermutation(ofstream *out, molecule *mol, atom *Walker, double &OldPotential, struct EvaluatePotential &Params)
+double TryNextNearestNeighbourForInjectivePermutation(molecule *mol, atom *Walker, double &OldPotential, struct EvaluatePotential &Params)
 {
   double Potential = 0;
@@ -268 +269 @@
   if (NewBase != Params.DistanceList[Walker->nr]->end()) {
     Params.PermutationMap[Walker->nr] = NewBase->second;
-    Potential = fabs(mol->ConstrainedPotential(out, Params));
+    Potential = fabs(mol->ConstrainedPotential(Params));
     if (Potential > OldPotential) { // undo
       Params.PermutationMap[Walker->nr] = Params.DistanceIterators[Walker->nr]->second;
@@ -276 +277 @@
       Params.DistanceIterators[Walker->nr] = NewBase;
       OldPotential = Potential;
-      *out << Verbose(3) << "Found a new permutation, new potential is " << OldPotential << "." << endl;
+      Log() << Verbose(3) << "Found a new permutation, new potential is " << OldPotential << "." << endl;
     }
   }
@@ -287 +288 @@
  * \param &Params constrained potential parameters
  */
-void MakeInjectivePermutation(ofstream *out, molecule *mol, struct EvaluatePotential &Params)
+void MakeInjectivePermutation(molecule *mol, struct EvaluatePotential &Params)
 {
   atom *Walker = mol->start;
   DistanceMap::iterator NewBase;
-  double Potential = fabs(mol->ConstrainedPotential(out, Params));
+  double Potential = fabs(mol->ConstrainedPotential(Params));
 
   while ((Potential) > Params.PenaltyConstants[2]) {
-    PrintPermutationMap(out, mol->AtomCount, Params);
+    PrintPermutationMap(mol->AtomCount, Params);
     Walker = Walker->next;
     if (Walker == mol->end) // round-robin at the end
@@ -301 +302 @@
       continue;
     // now, try finding a new one
-    Potential = TryNextNearestNeighbourForInjectivePermutation(out, mol, Walker, Potential, Params);
+    Potential = TryNextNearestNeighbourForInjectivePermutation(mol, Walker, Potential, Params);
   }
   for (int i=mol->AtomCount; i--;) // now each single entry in the DoubleList should be <=1
     if (Params.DoubleList[i] > 1) {
-      cerr << "Failed to create an injective PermutationMap!" << endl;
+      eLog() << Verbose(0) << "Failed to create an injective PermutationMap!" << endl;
       exit(1);
     }
-  *out << Verbose(1) << "done." << endl;
+  Log() << Verbose(1) << "done." << endl;
 };
 
@@ -338 +339 @@
  * \bug this all is not O(N log N) but O(N^2)
  */
-double molecule::MinimiseConstrainedPotential(ofstream *out, atom **&PermutationMap, int startstep, int endstep, bool IsAngstroem)
+double molecule::MinimiseConstrainedPotential(atom **&PermutationMap, int startstep, int endstep, bool IsAngstroem)
 {
   double Potential, OldPotential, OlderPotential;
@@ -357 +358 @@
   Params.PenaltyConstants[2] = 1e+7;    // just a huge penalty
   // generate the distance list
-  *out << Verbose(1) << "Allocating, initializting and filling the distance list ... " << endl;
+  Log() << Verbose(1) << "Allocating, initializting and filling the distance list ... " << endl;
   FillDistanceList(this, Params);
 
   // create the initial PermutationMap (source -> target)
-  CreateInitialLists(out, this, Params);
+  CreateInitialLists(this, Params);
 
   // make the PermutationMap injective by checking whether we have a non-zero constants[2] term in it
-  *out << Verbose(1) << "Making the PermutationMap injective ... " << endl;
-  MakeInjectivePermutation(out, this, Params);
+  Log() << Verbose(1) << "Making the PermutationMap injective ... " << endl;
+  MakeInjectivePermutation(this, Params);
   Free(&Params.DoubleList);
 
   // argument minimise the constrained potential in this injective PermutationMap
-  *out << Verbose(1) << "Argument minimising the PermutationMap, at current potential " << OldPotential << " ... " << endl;
+  Log() << Verbose(1) << "Argument minimising the PermutationMap, at current potential " << OldPotential << " ... " << endl;
   OldPotential = 1e+10;
   round = 0;
   do {
-    *out << "Starting round " << ++round << " ... " << endl;
+    Log() << Verbose(2) << "Starting round " << ++round << " ... " << endl;
     OlderPotential = OldPotential;
     do {
@@ -379 +380 @@
       while (Walker->next != end) { // pick one
         Walker = Walker->next;
-        PrintPermutationMap(out, AtomCount, Params);
+        PrintPermutationMap(AtomCount, Params);
         Sprinter = Params.DistanceIterators[Walker->nr]->second;   // store initial partner
         Strider = Params.DistanceIterators[Walker->nr];  //remember old iterator
@@ -387 +388 @@
           break;
         }
-        //*out << Verbose(2) << "Current Walker: " << *Walker << " with old/next candidate " << *Sprinter << "/" << *DistanceIterators[Walker->nr]->second << "." << endl;
+        //Log() << Verbose(2) << "Current Walker: " << *Walker << " with old/next candidate " << *Sprinter << "/" << *DistanceIterators[Walker->nr]->second << "." << endl;
         // find source of the new target
         Runner = start->next;
         while(Runner != end) { // find the source whose toes we might be stepping on (Walker's new target should be in use by another already)
           if (Params.PermutationMap[Runner->nr] == Params.DistanceIterators[Walker->nr]->second) {
-            //*out << Verbose(2) << "Found the corresponding owner " << *Runner << " to " << *PermutationMap[Runner->nr] << "." << endl;
+            //Log() << Verbose(2) << "Found the corresponding owner " << *Runner << " to " << *PermutationMap[Runner->nr] << "." << endl;
             break;
           }
@@ -404 +405 @@
               break;
           if (Rider != Params.DistanceList[Runner->nr]->end()) { // if we have found one
-            //*out << Verbose(2) << "Current Other: " << *Runner << " with old/next candidate " << *PermutationMap[Runner->nr] << "/" << *Rider->second << "." << endl;
+            //Log() << Verbose(2) << "Current Other: " << *Runner << " with old/next candidate " << *PermutationMap[Runner->nr] << "/" << *Rider->second << "." << endl;
             // exchange both
             Params.PermutationMap[Walker->nr] = Params.DistanceIterators[Walker->nr]->second; // put next farther distance into PermutationMap
             Params.PermutationMap[Runner->nr] = Sprinter;  // and hand the old target to its respective owner
-            PrintPermutationMap(out, AtomCount, Params);
+            PrintPermutationMap(AtomCount, Params);
             // calculate the new potential
-            //*out << Verbose(2) << "Checking new potential ..." << endl;
-            Potential = ConstrainedPotential(out, Params);
+            //Log() << Verbose(2) << "Checking new potential ..." << endl;
+            Potential = ConstrainedPotential(Params);
             if (Potential > OldPotential) { // we made everything worse! Undo ...
-              //*out << Verbose(3) << "Nay, made the potential worse: " << Potential << " vs. " << OldPotential << "!" << endl;
-              //*out << Verbose(3) << "Setting " << *Runner << "'s source to " << *Params.DistanceIterators[Runner->nr]->second << "." << endl;
+              //Log() << Verbose(3) << "Nay, made the potential worse: " << Potential << " vs. " << OldPotential << "!" << endl;
+              //Log() << Verbose(3) << "Setting " << *Runner << "'s source to " << *Params.DistanceIterators[Runner->nr]->second << "." << endl;
               // Undo for Runner (note, we haven't moved the iteration yet, we may use this)
               Params.PermutationMap[Runner->nr] = Params.DistanceIterators[Runner->nr]->second;
               // Undo for Walker
               Params.DistanceIterators[Walker->nr] = Strider;  // take next farther distance target
-              //*out << Verbose(3) << "Setting " << *Walker << "'s source to " << *Params.DistanceIterators[Walker->nr]->second << "." << endl;
+              //Log() << Verbose(3) << "Setting " << *Walker << "'s source to " << *Params.DistanceIterators[Walker->nr]->second << "." << endl;
               Params.PermutationMap[Walker->nr] = Params.DistanceIterators[Walker->nr]->second;
             } else {
               Params.DistanceIterators[Runner->nr] = Rider;  // if successful also move the pointer in the iterator list
-              *out << Verbose(3) << "Found a better permutation, new potential is " << Potential << " vs." << OldPotential << "." << endl;
+              Log() << Verbose(3) << "Found a better permutation, new potential is " << Potential << " vs." << OldPotential << "." << endl;
               OldPotential = Potential;
             }
             if (Potential > Params.PenaltyConstants[2]) {
-              cerr << "ERROR: The two-step permutation procedure did not maintain injectivity!" << endl;
+              eLog() << Verbose(0) << "ERROR: The two-step permutation procedure did not maintain injectivity!" << endl;
               exit(255);
             }
-            //*out << endl;
+            //Log() << Verbose(0) << endl;
           } else {
-            cerr << "ERROR: " << *Runner << " was not the owner of " << *Sprinter << "!" << endl;
+            eLog() << Verbose(0) << "ERROR: " << *Runner << " was not the owner of " << *Sprinter << "!" << endl;
             exit(255);
           }
@@ -442 +443 @@
     } while (Walker->next != end);
   } while ((OlderPotential - OldPotential) > 1e-3);
-  *out << Verbose(1) << "done." << endl;
+  Log() << Verbose(1) << "done." << endl;
 
 
@@ -450 +451 @@
   Free(&Params.DistanceList);
   Free(&Params.DistanceIterators);
-  return ConstrainedPotential(out, Params);
+  return ConstrainedPotential(Params);
 };
 
@@ -462 +463 @@
  * \todo the constant for the constrained potential distance part is hard-coded independently of the hard-coded value in MinimiseConstrainedPotential()
  */
-void molecule::EvaluateConstrainedForces(ofstream *out, int startstep, int endstep, atom **PermutationMap, ForceMatrix *Force)
+void molecule::EvaluateConstrainedForces(int startstep, int endstep, atom **PermutationMap, ForceMatrix *Force)
 {
   /// evaluate forces (only the distance to target dependent part) with the final PermutationMap
-  *out << Verbose(1) << "Calculating forces and adding onto ForceMatrix ... " << endl;
+  Log() << Verbose(1) << "Calculating forces and adding onto ForceMatrix ... " << endl;
   ActOnAllAtoms( &atom::EvaluateConstrainedForce, startstep, endstep, PermutationMap, Force );
-  *out << Verbose(1) << "done." << endl;
+  Log() << Verbose(1) << "done." << endl;
 };
 
@@ -479 +480 @@
  * \return true - success in writing step files, false - error writing files or only one step in molecule::Trajectories
  */
-bool molecule::LinearInterpolationBetweenConfiguration(ofstream *out, int startstep, int endstep, const char *prefix, config &configuration, bool MapByIdentity)
+bool molecule::LinearInterpolationBetweenConfiguration(int startstep, int endstep, const char *prefix, config &configuration, bool MapByIdentity)
 {
   molecule *mol = NULL;
@@ -489 +490 @@
   atom *Walker = NULL, *Sprinter = NULL;
   if (!MapByIdentity)
-    MinimiseConstrainedPotential(out, PermutationMap, startstep, endstep, configuration.GetIsAngstroem());
+    MinimiseConstrainedPotential(PermutationMap, startstep, endstep, configuration.GetIsAngstroem());
   else {
     PermutationMap = Malloc<atom *>(AtomCount, "molecule::LinearInterpolationBetweenConfiguration: **PermutationMap");
@@ -502 +503 @@
 
   // go through all steps and add the molecular configuration to the list and to the Trajectories of \a this molecule
-  *out << Verbose(1) << "Filling intermediate " << MaxSteps << " steps with MDSteps of " << MDSteps << "." << endl;
+  Log() << Verbose(1) << "Filling intermediate " << MaxSteps << " steps with MDSteps of " << MDSteps << "." << endl;
   for (int step = 0; step <= MaxSteps; step++) {
     mol = new molecule(elemente);
@@ -514 +515 @@
         Sprinter->x.x[n] = Walker->Trajectory.R.at(startstep).x[n] + (PermutationMap[Walker->nr]->Trajectory.R.at(endstep).x[n] - Walker->Trajectory.R.at(startstep).x[n])*((double)step/(double)MaxSteps);
         // add to Trajectories
-        //*out << Verbose(3) << step << ">=" << MDSteps-1 << endl;
+        //Log() << Verbose(3) << step << ">=" << MDSteps-1 << endl;
         if (step < MaxSteps) {
           Walker->Trajectory.R.at(step).x[n] = Walker->Trajectory.R.at(startstep).x[n] + (PermutationMap[Walker->nr]->Trajectory.R.at(endstep).x[n] - Walker->Trajectory.R.at(startstep).x[n])*((double)step/(double)MaxSteps);
@@ -529 +530 @@
   for (int i=AtomCount; i--; )
     SortIndex[i] = i;
-  status = MoleculePerStep->OutputConfigForListOfFragments(out, &configuration, SortIndex);
+  status = MoleculePerStep->OutputConfigForListOfFragments(&configuration, SortIndex);
 
   // free and return
@@ -550 +551 @@
  * \todo This is not yet checked if it is correctly working with DoConstrained set to true.
  */
-bool molecule::VerletForceIntegration(ofstream *out, char *file, config &configuration)
+bool molecule::VerletForceIntegration(char *file, config &configuration)
 {
   ifstream input(file);
@@ -567 +568 @@
     // parse file into ForceMatrix
     if (!Force.ParseMatrix(file, 0,0,0)) {
-      cerr << "Could not parse Force Matrix file " << file << "." << endl;
+      eLog() << Verbose(0) << "Could not parse Force Matrix file " << file << "." << endl;
       return false;
     }
     if (Force.RowCounter[0] != AtomCount) {
-      cerr << "Mismatch between number of atoms in file " << Force.RowCounter[0] << " and in molecule " << AtomCount << "." << endl;
+      eLog() << Verbose(0) << "Mismatch between number of atoms in file " << Force.RowCounter[0] << " and in molecule " << AtomCount << "." << endl;
       return false;
     }
@@ -588 +589 @@
       // calculate forces and potential
       atom **PermutationMap = NULL;
-      ConstrainedPotentialEnergy = MinimiseConstrainedPotential(out, PermutationMap,configuration.DoConstrainedMD, 0, configuration.GetIsAngstroem());
-      EvaluateConstrainedForces(out, configuration.DoConstrainedMD, 0, PermutationMap, &Force);
+      ConstrainedPotentialEnergy = MinimiseConstrainedPotential(PermutationMap,configuration.DoConstrainedMD, 0, configuration.GetIsAngstroem());
+      EvaluateConstrainedForces(configuration.DoConstrainedMD, 0, PermutationMap, &Force);
       Free(&PermutationMap);
     }
@@ -649 +650 @@
   switch(Thermostat) {
      case None:
-      cout << Verbose(2) <<  "Applying no thermostat..." << endl;
+      Log() << Verbose(2) <<  "Applying no thermostat..." << endl;
       break;
      case Woodcock:
       if ((configuration.ScaleTempStep > 0) && ((MDSteps-1) % configuration.ScaleTempStep == 0)) {
-        cout << Verbose(2) <<  "Applying Woodcock thermostat..." << endl;
+        Log() << Verbose(2) <<  "Applying Woodcock thermostat..." << endl;
         ActOnAllAtoms( &atom::Thermostat_Woodcock, sqrt(ScaleTempFactor), MDSteps, &ekin );
       }
       break;
      case Gaussian:
-      cout << Verbose(2) <<  "Applying Gaussian thermostat..." << endl;
+      Log() << Verbose(2) <<  "Applying Gaussian thermostat..." << endl;
       ActOnAllAtoms( &atom::Thermostat_Gaussian_init, MDSteps, &G, &E );
 
-      cout << Verbose(1) << "Gaussian Least Constraint constant is " << G/E << "." << endl;
+      Log() << Verbose(1) << "Gaussian Least Constraint constant is " << G/E << "." << endl;
       ActOnAllAtoms( &atom::Thermostat_Gaussian_least_constraint, MDSteps, G/E, &ekin, &configuration);
 
       break;
      case Langevin:
-      cout << Verbose(2) <<  "Applying Langevin thermostat..." << endl;
+      Log() << Verbose(2) <<  "Applying Langevin thermostat..." << endl;
       // init random number generator
       gsl_rng_env_setup();
@@ -676 +677 @@
 
      case Berendsen:
-      cout << Verbose(2) <<  "Applying Berendsen-VanGunsteren thermostat..." << endl;
+      Log() << Verbose(2) <<  "Applying Berendsen-VanGunsteren thermostat..." << endl;
       ActOnAllAtoms( &atom::Thermostat_Berendsen, MDSteps, ScaleTempFactor, &ekin, &configuration );
       break;
 
      case NoseHoover:
-      cout << Verbose(2) <<  "Applying Nose-Hoover thermostat..." << endl;
+      Log() << Verbose(2) <<  "Applying Nose-Hoover thermostat..." << endl;
       // dynamically evolve alpha (the additional degree of freedom)
       delta_alpha = 0.;
@@ -687 +688 @@
       delta_alpha = (delta_alpha - (3.*AtomCount+1.) * configuration.TargetTemp)/(configuration.HooverMass*Units2Electronmass);
       configuration.alpha += delta_alpha*configuration.Deltat;
-      cout << Verbose(3) << "alpha = " << delta_alpha << " * " << configuration.Deltat << " = " << configuration.alpha << "." << endl;
+      Log() << Verbose(3) << "alpha = " << delta_alpha << " * " << configuration.Deltat << " = " << configuration.alpha << "." << endl;
       // apply updated alpha as additional force
       ActOnAllAtoms( &atom::Thermostat_NoseHoover_scale, MDSteps, &ekin, &configuration );
       break;
   }
-  cout << Verbose(1) << "Kinetic energy is " << ekin << "." << endl;
-};
+  Log() << Verbose(1) << "Kinetic energy is " << ekin << "." << endl;
+};