--- trunk/OOPSE-4/src/integrators/VelocityVerletIntegrator.cpp	2005/02/24 20:55:07	2060
+++ trunk/OOPSE-4/src/integrators/VelocityVerletIntegrator.cpp	2005/10/17 23:13:44	2380
@@ -1,4 +1,4 @@
- /*
+/*
  * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
  *
  * The University of Notre Dame grants you ("Licensee") a
@@ -52,155 +52,198 @@ VelocityVerletIntegrator::VelocityVerletIntegrator(Sim
 #include "utils/StringUtils.hpp"
 
 namespace oopse {
-VelocityVerletIntegrator::VelocityVerletIntegrator(SimInfo *info) : Integrator(info), rotAlgo(NULL) { 
+  VelocityVerletIntegrator::VelocityVerletIntegrator(SimInfo *info) : Integrator(info), rotAlgo(NULL) { 
     dt2 = 0.5 * dt;
     rotAlgo = new DLM();
     rattle = new Rattle(info);
-}
-
-VelocityVerletIntegrator::~VelocityVerletIntegrator() { 
+  }
+  
+  VelocityVerletIntegrator::~VelocityVerletIntegrator() { 
     delete rotAlgo;
     delete rattle;
-}
-
-void VelocityVerletIntegrator::initialize(){
-
+  }
+  
+  void VelocityVerletIntegrator::initialize(){
+    
     forceMan_->init();
-
+    
     // remove center of mass drift velocity (in case we passed in a configuration
     // that was drifting
     velocitizer_->removeComDrift();
-
+    
     // initialize the forces before the first step
     calcForce(true, true);
-
+    
     //execute constraint algorithm to make sure at the very beginning the system is constrained  
     if (info_->getNGlobalConstraints() > 0) {
-        rattle->constraintA();
-        calcForce(true, true);
-        rattle->constraintB();        
-        info_->getSnapshotManager()->advance();//copy the current snapshot to previous snapshot
+      rattle->constraintA();
+      calcForce(true, true);
+      rattle->constraintB();        
+      info_->getSnapshotManager()->advance();//copy the current snapshot to previous snapshot
     }
-
+    
     if (needVelocityScaling) {
-        velocitizer_->velocitize(targetScalingTemp);
+      velocitizer_->velocitize(targetScalingTemp);
     }
     
     dumpWriter = createDumpWriter();
-
+    
     statWriter = createStatWriter();
-
+    
+    if (simParams->getUseSolidThermInt()) {
+      restWriter = createRestWriter();
+      restWriter->writeZangle();
+    }
+    
     dumpWriter->writeDumpAndEor();
     
+    
     //save statistics, before writeStat,  we must save statistics
     thermo.saveStat();
     saveConservedQuantity();
     statWriter->writeStat(currentSnapshot_->statData);
-
+    
     currSample = sampleTime + currentSnapshot_->getTime();
     currStatus =  statusTime + currentSnapshot_->getTime();;
-    currThermal = thermalTime +  + currentSnapshot_->getTime();
+    currThermal = thermalTime + currentSnapshot_->getTime();
+    if (needReset) {
+      currReset = resetTime + currentSnapshot_->getTime();
+    }
     needPotential = false;
     needStress = false;       
-   
-}
-        
-void VelocityVerletIntegrator::doIntegrate() {
+    
+  }
 
-
+  void VelocityVerletIntegrator::doIntegrate() {
+  
+  
     initialize();
-
+  
     while (currentSnapshot_->getTime() < runTime) {
-        
-        preStep();
+    
+      preStep();
+    
+      integrateStep();
+    
+      postStep();
+    
+    }
+  
+    finalize();
+  
+  }
 
-        integrateStep();
-        
-        postStep();
 
+  void VelocityVerletIntegrator::preStep() {
+    double difference = currentSnapshot_->getTime() + dt - currStatus;
+  
+    if (difference > 0 || fabs(difference) < oopse::epsilon) {
+      needPotential = true;
+      needStress = true;   
     }
+  
+  }
 
-    finalize();
+  void VelocityVerletIntegrator::postStep() {
+  
+    //save snapshot
+    info_->getSnapshotManager()->advance();
+  
+    //increase time
+    currentSnapshot_->increaseTime(dt);        
+  
+    if (needVelocityScaling) {
+      if (currentSnapshot_->getTime() >= currThermal) {
+	velocitizer_->velocitize(targetScalingTemp);
+	currThermal += thermalTime;
+      }
+    }
+  
+    if (currentSnapshot_->getTime() >= currSample) {
+      dumpWriter->writeDumpAndEor();
     
-}
+      if (simParams->getUseSolidThermInt())
+	restWriter->writeZangle();
+    
+      currSample += sampleTime;
+    }
+  
+    if (currentSnapshot_->getTime() >= currStatus) {
+      //save statistics, before writeStat,  we must save statistics
+      thermo.saveStat();
+      saveConservedQuantity();
+      statWriter->writeStat(currentSnapshot_->statData);
+    
+      needPotential = false;
+      needStress = false;
+      currStatus += statusTime;
+    }
 
+      if (needReset && currentSnapshot_->getTime() >= currReset) {    
+        resetIntegrator();
+        currReset += resetTime;
+      }
+  
+  }
 
-void VelocityVerletIntegrator::preStep() {
-        double difference = currentSnapshot_->getTime() + dt - currStatus;
 
-        if (difference > 0 || fabs(difference) < oopse::epsilon) {
-            needPotential = true;
-            needStress = true;   
-        }
-
-}
-
-void VelocityVerletIntegrator::postStep() {
-
-        //save snapshot
-        info_->getSnapshotManager()->advance();
-
-        //increase time
-        currentSnapshot_->increaseTime(dt);        
-        
-        if (needVelocityScaling) {
-            if (currentSnapshot_->getTime() >= currThermal) {
-                velocitizer_->velocitize(targetScalingTemp);
-                currThermal += thermalTime;
-            }
-        }
-
-        if (currentSnapshot_->getTime() >= currSample) {
-            dumpWriter->writeDumpAndEor();
-            currSample += sampleTime;
-        }
-
-        if (currentSnapshot_->getTime() >= currStatus) {
-            //save statistics, before writeStat,  we must save statistics
-            thermo.saveStat();
-            saveConservedQuantity();
-            statWriter->writeStat(currentSnapshot_->statData);
-
-            needPotential = false;
-            needStress = false;
-            currStatus += statusTime;
-        }
-
-        
-}
-
-
-void VelocityVerletIntegrator::finalize() {
-     dumpWriter->writeEor();
-
+  void VelocityVerletIntegrator::finalize() {
+    dumpWriter->writeEor();
+  
+    if (simParams->getUseSolidThermInt()) {
+      restWriter->writeZangle();
+      delete restWriter;
+      restWriter = NULL;
+    }
+  
     delete dumpWriter;
     delete statWriter;
-
+  
     dumpWriter = NULL;
     statWriter = NULL;
-    
-}
+  
+  }
 
-void VelocityVerletIntegrator::integrateStep() { 
-
+  void VelocityVerletIntegrator::integrateStep() { 
+  
     moveA();
     calcForce(needPotential, needStress);
     moveB();
-}
+  }
 
 
-void VelocityVerletIntegrator::calcForce(bool needPotential,
-                                         bool needStress) { 
+  void VelocityVerletIntegrator::calcForce(bool needPotential,
+					   bool needStress) { 
     forceMan_->calcForces(needPotential, needStress);
-}
+  }
 
-DumpWriter* VelocityVerletIntegrator::createDumpWriter() {
+  DumpWriter* VelocityVerletIntegrator::createDumpWriter() {
     return new DumpWriter(info_);
-}
+  }
 
-StatWriter* VelocityVerletIntegrator::createStatWriter() {
-    return new StatWriter(info_->getStatFileName());
-}
+  StatWriter* VelocityVerletIntegrator::createStatWriter() {
 
+    std::string statFileFormatString = simParams->getStatFileFormat();
+    StatsBitSet mask = parseStatFileFormat(statFileFormatString);
+    
+    // if solidThermInt is true, add extra information to the statfile
+    if (simParams->getUseSolidThermInt()){
+      mask.set(Stats::VRAW);
+      mask.set(Stats::VHARM);
+    }
 
+    if (simParams->havePrintPressureTensor() && simParams->getPrintPressureTensor()){
+        mask.set(Stats::PRESSURE_TENSOR_X);
+        mask.set(Stats::PRESSURE_TENSOR_Y);
+        mask.set(Stats::PRESSURE_TENSOR_Z);
+    }
+    
+     return new StatWriter(info_->getStatFileName(), mask);
+  }
+
+  RestWriter* VelocityVerletIntegrator::createRestWriter(){
+    return new RestWriter(info_);
+  }
+
+
 } //end namespace oopse