ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/integrators/VelocityVerletIntegrator.cpp
(Generate patch)

Comparing trunk/src/integrators/VelocityVerletIntegrator.cpp (file contents):
Revision 276 by tim, Wed Jan 26 15:26:47 2005 UTC vs.
Revision 963 by tim, Wed May 17 21:51:42 2006 UTC

# Line 1 | Line 1
1 < /*
1 > /*
2   * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3   *
4   * The University of Notre Dame grants you ("Licensee") a
# Line 52 | Line 52 | namespace oopse {
52   #include "utils/StringUtils.hpp"
53  
54   namespace oopse {
55 < VelocityVerletIntegrator::VelocityVerletIntegrator(SimInfo *info) : Integrator(info), rotAlgo(NULL) {
55 >  VelocityVerletIntegrator::VelocityVerletIntegrator(SimInfo *info) : Integrator(info), rotAlgo(NULL) {
56      dt2 = 0.5 * dt;
57      rotAlgo = new DLM();
58      rattle = new Rattle(info);
59 < }
60 <
61 < VelocityVerletIntegrator::~VelocityVerletIntegrator() {
59 >  }
60 >  
61 >  VelocityVerletIntegrator::~VelocityVerletIntegrator() {
62      delete rotAlgo;
63      delete rattle;
64 < }
65 <
66 < void VelocityVerletIntegrator::initialize(){
67 <
64 >  }
65 >  
66 >  void VelocityVerletIntegrator::initialize(){
67 >    
68      forceMan_->init();
69 <
69 >    
70      // remove center of mass drift velocity (in case we passed in a configuration
71      // that was drifting
72      velocitizer_->removeComDrift();
73 <
73 >    
74      // initialize the forces before the first step
75      calcForce(true, true);
76 <
76 >    
77      //execute constraint algorithm to make sure at the very beginning the system is constrained  
78      if (info_->getNGlobalConstraints() > 0) {
79 <        rattle->constraintA();
80 <        calcForce(true, true);
81 <        rattle->constraintB();        
82 <        info_->getSnapshotManager()->advance();//copy the current snapshot to previous snapshot
79 >      rattle->constraintA();
80 >      calcForce(true, true);
81 >      rattle->constraintB();        
82 >      info_->getSnapshotManager()->advance();//copy the current snapshot to previous snapshot
83      }
84 <
84 >    
85      if (needVelocityScaling) {
86 <        velocitizer_->velocitize(targetScalingTemp);
86 >      velocitizer_->velocitize(targetScalingTemp);
87      }
88      
89      dumpWriter = createDumpWriter();
90 <    eorWriter = createEorWriter();
90 >    
91      statWriter = createStatWriter();
92 –
93 –    dumpWriter->writeDump();
94 –    eorWriter->writeDump();
92      
93 +    if (simParams->getUseSolidThermInt()) {
94 +      restWriter = createRestWriter();
95 +      restWriter->writeZangle();
96 +    }
97 +    
98 +    dumpWriter->writeDumpAndEor();
99 +    
100 +    
101      //save statistics, before writeStat,  we must save statistics
102      thermo.saveStat();
103      saveConservedQuantity();
104      statWriter->writeStat(currentSnapshot_->statData);
105 <
105 >    
106      currSample = sampleTime + currentSnapshot_->getTime();
107      currStatus =  statusTime + currentSnapshot_->getTime();;
108 <    currThermal = thermalTime +  + currentSnapshot_->getTime();
108 >    currThermal = thermalTime + currentSnapshot_->getTime();
109 >    if (needReset) {
110 >      currReset = resetTime + currentSnapshot_->getTime();
111 >    }
112      needPotential = false;
113      needStress = false;      
114 <  
115 < }
108 <        
109 < void VelocityVerletIntegrator::doIntegrate() {
114 >    
115 >  }
116  
117 <
117 >  void VelocityVerletIntegrator::doIntegrate() {
118 >  
119 >  
120      initialize();
121 <
121 >  
122      while (currentSnapshot_->getTime() < runTime) {
123 <        
124 <        preStep();
125 <
126 <        integrateStep();
127 <        
128 <        postStep();
129 <
123 >    
124 >      preStep();
125 >    
126 >      integrateStep();
127 >    
128 >      postStep();
129 >    
130      }
131 <
131 >  
132      finalize();
133 <    
134 < }
133 >  
134 >  }
135  
136  
137 < void VelocityVerletIntegrator::preStep() {
138 <        double difference = currentSnapshot_->getTime() + dt - currStatus;
137 >  void VelocityVerletIntegrator::preStep() {
138 >    RealType difference = currentSnapshot_->getTime() + dt - currStatus;
139 >  
140 >    if (difference > 0 || fabs(difference) < oopse::epsilon) {
141 >      needPotential = true;
142 >      needStress = true;  
143 >    }
144 >  }
145  
146 <        if (difference > 0 || fabs(difference) < oopse::epsilon) {
133 <            needPotential = true;
134 <            needStress = true;  
135 <        }
146 >  void VelocityVerletIntegrator::postStep() {
147  
148 < }
148 >    //save snapshot
149 >    info_->getSnapshotManager()->advance();
150 >  
151 >    //increase time
152 >    currentSnapshot_->increaseTime(dt);        
153 >  
154 >    if (needVelocityScaling) {
155 >      if (currentSnapshot_->getTime() >= currThermal) {
156 >        velocitizer_->velocitize(targetScalingTemp);
157 >        currThermal += thermalTime;
158 >      }
159 >    }
160 >  
161 >    if (currentSnapshot_->getTime() >= currSample) {
162 >      dumpWriter->writeDumpAndEor();
163 >    
164 >      if (simParams->getUseSolidThermInt())
165 >        restWriter->writeZangle();
166 >    
167 >      currSample += sampleTime;
168 >    }
169 >  
170 >    if (currentSnapshot_->getTime() >= currStatus) {
171 >      //save statistics, before writeStat,  we must save statistics
172 >      thermo.saveStat();
173 >      saveConservedQuantity();
174 >      statWriter->writeStat(currentSnapshot_->statData);
175 >    
176 >      needPotential = false;
177 >      needStress = false;
178 >      currStatus += statusTime;
179 >    }
180  
181 < void VelocityVerletIntegrator::postStep() {
181 >      if (needReset && currentSnapshot_->getTime() >= currReset) {    
182 >        resetIntegrator();
183 >        currReset += resetTime;
184 >      }
185 >  
186 >  }
187  
141 –        //save snapshot
142 –        info_->getSnapshotManager()->advance();
188  
189 <        //increase time
190 <        currentSnapshot_->increaseTime(dt);        
191 <        
192 <        if (needVelocityScaling) {
193 <            if (currentSnapshot_->getTime() >= currThermal) {
194 <                velocitizer_->velocitize(targetScalingTemp);
195 <                currThermal += thermalTime;
196 <            }
197 <        }
153 <
154 <        if (currentSnapshot_->getTime() >= currSample) {
155 <            dumpWriter->writeDump();
156 <            eorWriter->writeDump();
157 <            currSample += sampleTime;
158 <        }
159 <
160 <        if (currentSnapshot_->getTime() >= currStatus) {
161 <            //save statistics, before writeStat,  we must save statistics
162 <            thermo.saveStat();
163 <            saveConservedQuantity();
164 <            statWriter->writeStat(currentSnapshot_->statData);
165 <
166 <            needPotential = false;
167 <            needStress = false;
168 <            currStatus += statusTime;
169 <        }
170 <
171 <        
172 < }
173 <
174 <
175 < void VelocityVerletIntegrator::finalize() {
176 <
177 <    dumpWriter->writeDump();
178 <    eorWriter->writeDump();
179 <
189 >  void VelocityVerletIntegrator::finalize() {
190 >    dumpWriter->writeEor();
191 >  
192 >    if (simParams->getUseSolidThermInt()) {
193 >      restWriter->writeZangle();
194 >      delete restWriter;
195 >      restWriter = NULL;
196 >    }
197 >  
198      delete dumpWriter;
181 –    delete eorWriter;
199      delete statWriter;
200 <
200 >  
201      dumpWriter = NULL;
185 –    eorWriter = NULL;
202      statWriter = NULL;
203 <    
204 < }
203 >  
204 >  }
205  
206 < void VelocityVerletIntegrator::integrateStep() {
207 <
206 >  void VelocityVerletIntegrator::integrateStep() {
207 >  
208      moveA();
209      calcForce(needPotential, needStress);
210      moveB();
211 < }
211 >  }
212  
213  
214 < void VelocityVerletIntegrator::calcForce(bool needPotential,
215 <                                         bool needStress) {
214 >  void VelocityVerletIntegrator::calcForce(bool needPotential,
215 >                                           bool needStress) {
216      forceMan_->calcForces(needPotential, needStress);
217 < }
217 >  }
218  
219 < DumpWriter* VelocityVerletIntegrator::createDumpWriter() {
220 <    return new DumpWriter(info_, info_->getDumpFileName());
221 < }
219 >  DumpWriter* VelocityVerletIntegrator::createDumpWriter() {
220 >    return new DumpWriter(info_);
221 >  }
222  
223 < DumpWriter* VelocityVerletIntegrator::createEorWriter() {
208 <    return new DumpWriter(info_, getPrefix(info_->getDumpFileName()) + ".eor");
209 < }
223 >  StatWriter* VelocityVerletIntegrator::createStatWriter() {
224  
225 < StatWriter* VelocityVerletIntegrator::createStatWriter() {
226 <    return new StatWriter(info_->getStatFileName());
227 < }
225 >    std::string statFileFormatString = simParams->getStatFileFormat();
226 >    StatsBitSet mask = parseStatFileFormat(statFileFormatString);
227 >    
228 >    // if solidThermInt is true, add extra information to the statfile
229 >    if (simParams->getUseSolidThermInt()){
230 >      mask.set(Stats::VRAW);
231 >      mask.set(Stats::VHARM);
232 >    }
233  
234 +    if (simParams->havePrintPressureTensor() && simParams->getPrintPressureTensor()){
235 +        mask.set(Stats::PRESSURE_TENSOR_X);
236 +        mask.set(Stats::PRESSURE_TENSOR_Y);
237 +        mask.set(Stats::PRESSURE_TENSOR_Z);
238 +    }
239 +    
240 +     return new StatWriter(info_->getStatFileName(), mask);
241 +  }
242  
243 +  RestWriter* VelocityVerletIntegrator::createRestWriter(){
244 +    return new RestWriter(info_);
245 +  }
246 +
247 +
248   } //end namespace oopse

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines