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 471 by chrisfen, Tue Apr 12 14:24:29 2005 UTC vs.
Revision 1338 by skuang, Thu Apr 23 18:22:30 2009 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 67 | Line 67 | namespace oopse {
67      
68      forceMan_->init();
69      
70 <    // remove center of mass drift velocity (in case we passed in a configuration
71 <    // that was drifting
70 >    // remove center of mass drift velocity (in case we passed in a
71 >    // configuration that was drifting)
72      velocitizer_->removeComDrift();
73      
74      // initialize the forces before the first step
75      calcForce(true, true);
76      
77 <    //execute constraint algorithm to make sure at the very beginning the system is constrained  
77 >    // execute the constraint algorithm to make sure that the system is
78 >    // constrained at the very beginning  
79      if (info_->getNGlobalConstraints() > 0) {
80        rattle->constraintA();
81        calcForce(true, true);
82 <      rattle->constraintB();        
83 <      info_->getSnapshotManager()->advance();//copy the current snapshot to previous snapshot
82 >      rattle->constraintB();      
83 >      //copy the current snapshot to previous snapshot
84 >      info_->getSnapshotManager()->advance();
85      }
86      
87      if (needVelocityScaling) {
# Line 89 | Line 91 | namespace oopse {
91      dumpWriter = createDumpWriter();
92      
93      statWriter = createStatWriter();
94 <    
94 >
95 >    dumpWriter->writeDumpAndEor();
96 >
97      if (simParams->getUseSolidThermInt()) {
98        restWriter = createRestWriter();
99 <      restWriter->writeZangle();
99 >      restWriter->writeZAngFile();
100      }
101      
98 –    dumpWriter->writeDumpAndEor();
99 –    
100 –    
102      //save statistics, before writeStat,  we must save statistics
103      thermo.saveStat();
104      saveConservedQuantity();
105      statWriter->writeStat(currentSnapshot_->statData);
106      
107      currSample = sampleTime + currentSnapshot_->getTime();
108 <    currStatus =  statusTime + currentSnapshot_->getTime();;
109 <    currThermal = thermalTime +  + currentSnapshot_->getTime();
108 >    currStatus =  statusTime + currentSnapshot_->getTime();
109 >    currThermal = thermalTime + currentSnapshot_->getTime();
110 >    if (needReset) {
111 >      currReset = resetTime + currentSnapshot_->getTime();
112 >    }
113 >    if (simParams->getUseRNEMD()){
114 >      currRNEMD = RNEMD_swapTime + currentSnapshot_->getTime();
115 >    }
116      needPotential = false;
117      needStress = false;      
118      
119 < }
119 >  }
120  
121 < void VelocityVerletIntegrator::doIntegrate() {
121 >  void VelocityVerletIntegrator::doIntegrate() {
122    
123    
124 <  initialize();
124 >    initialize();
125    
126 <  while (currentSnapshot_->getTime() < runTime) {
126 >    while (currentSnapshot_->getTime() < runTime) {
127      
128 <    preStep();
128 >      preStep();
129      
130 <    integrateStep();
130 >      integrateStep();
131      
132 <    postStep();
132 >      postStep();
133      
134 <  }
134 >    }
135    
136 <  finalize();
136 >    finalize();
137    
138 < }
138 >  }
139  
140  
141 < void VelocityVerletIntegrator::preStep() {
142 <  double difference = currentSnapshot_->getTime() + dt - currStatus;
141 >  void VelocityVerletIntegrator::preStep() {
142 >    RealType difference = currentSnapshot_->getTime() + dt - currStatus;
143    
144 <  if (difference > 0 || fabs(difference) < oopse::epsilon) {
145 <    needPotential = true;
146 <    needStress = true;  
144 >    if (difference > 0 || fabs(difference) < oopse::epsilon) {
145 >      needPotential = true;
146 >      needStress = true;  
147 >    }
148    }
141 –  
142 – }
149  
150 < void VelocityVerletIntegrator::postStep() {
150 >  void VelocityVerletIntegrator::postStep() {
151 >
152 >    //save snapshot
153 >    info_->getSnapshotManager()->advance();
154    
155 <  //save snapshot
156 <  info_->getSnapshotManager()->advance();
157 <  
158 <  //increase time
159 <  currentSnapshot_->increaseTime(dt);        
160 <  
161 <  if (needVelocityScaling) {
162 <    if (currentSnapshot_->getTime() >= currThermal) {
154 <      velocitizer_->velocitize(targetScalingTemp);
155 <      currThermal += thermalTime;
155 >    //increase time
156 >    currentSnapshot_->increaseTime(dt);        
157 >  
158 >    if (needVelocityScaling) {
159 >      if (currentSnapshot_->getTime() >= currThermal) {
160 >        velocitizer_->velocitize(targetScalingTemp);
161 >        currThermal += thermalTime;
162 >      }
163      }
164 <  }
165 <  
166 <  if (currentSnapshot_->getTime() >= currSample) {
167 <    dumpWriter->writeDumpAndEor();
164 >    if (useRNEMD) {
165 >      if (currentSnapshot_->getTime() >= currRNEMD) {
166 >        rnemd_->doSwap();
167 >        currRNEMD += RNEMD_swapTime;
168 >      }
169 >    }
170      
171 <    if (simParams->getUseSolidThermInt())
172 <      restWriter->writeZangle();
171 >    if (currentSnapshot_->getTime() >= currSample) {
172 >      dumpWriter->writeDumpAndEor();
173 >      
174 >      if (simParams->getUseSolidThermInt())
175 >        restWriter->writeZAngFile();
176 >      
177 >      currSample += sampleTime;
178 >    }
179      
180 <    currSample += sampleTime;
181 <  }
182 <  
183 <  if (currentSnapshot_->getTime() >= currStatus) {
184 <    //save statistics, before writeStat,  we must save statistics
185 <    thermo.saveStat();
186 <    saveConservedQuantity();
187 <    statWriter->writeStat(currentSnapshot_->statData);
180 >    if (currentSnapshot_->getTime() >= currStatus) {
181 >      //save statistics, before writeStat,  we must save statistics
182 >      thermo.saveStat();
183 >      saveConservedQuantity();
184 >      statWriter->writeStat(currentSnapshot_->statData);
185 >      if (simParams->getUseRNEMD())
186 >        rnemd_->getStatus();
187 >      
188 >      needPotential = false;
189 >      needStress = false;
190 >      currStatus += statusTime;
191 >    }
192      
193 <    needPotential = false;
194 <    needStress = false;
195 <    currStatus += statusTime;
193 >    if (needReset && currentSnapshot_->getTime() >= currReset) {    
194 >      resetIntegrator();
195 >      currReset += resetTime;
196 >    }        
197    }
198 +
199 +
200 +  void VelocityVerletIntegrator::finalize() {
201 +    dumpWriter->writeEor();
202    
203 +    if (simParams->getUseSolidThermInt()) {
204 +      restWriter->writeZAngFile();
205 +      delete restWriter;
206 +      restWriter = NULL;
207 +    }
208    
209 < }
210 <
182 <
183 < void VelocityVerletIntegrator::finalize() {
184 <  dumpWriter->writeEor();
209 >    delete dumpWriter;
210 >    delete statWriter;
211    
212 <  if (simParams->getUseSolidThermInt()) {
213 <    restWriter->writeZangle();
188 <    delete restWriter;
189 <    restWriter = NULL;
190 <  }
212 >    dumpWriter = NULL;
213 >    statWriter = NULL;
214    
215 <  delete dumpWriter;
193 <  delete statWriter;
194 <  
195 <  dumpWriter = NULL;
196 <  statWriter = NULL;
197 <  
198 < }
215 >  }
216  
217 < void VelocityVerletIntegrator::integrateStep() {
217 >  void VelocityVerletIntegrator::integrateStep() {
218    
219 <  moveA();
220 <  calcForce(needPotential, needStress);
221 <  moveB();
222 < }
219 >    moveA();
220 >    calcForce(needPotential, needStress);
221 >    moveB();
222 >  }
223  
224  
225 < void VelocityVerletIntegrator::calcForce(bool needPotential,
226 <                                         bool needStress) {
227 <  forceMan_->calcForces(needPotential, needStress);
228 < }
225 >  void VelocityVerletIntegrator::calcForce(bool needPotential,
226 >                                           bool needStress) {
227 >    forceMan_->calcForces(needPotential, needStress);
228 >  }
229  
230 < DumpWriter* VelocityVerletIntegrator::createDumpWriter() {
231 <  return new DumpWriter(info_);
232 < }
230 >  DumpWriter* VelocityVerletIntegrator::createDumpWriter() {
231 >    return new DumpWriter(info_);
232 >  }
233  
234 < StatWriter* VelocityVerletIntegrator::createStatWriter() {
235 <  // if solidThermInt is true, add extra information to the statfile
236 <  if (simParams->getUseSolidThermInt()){
237 <    StatsBitSet mask;
238 <    mask.set(Stats::TIME);
239 <    mask.set(Stats::TOTAL_ENERGY);
240 <    mask.set(Stats::POTENTIAL_ENERGY);
241 <    mask.set(Stats::KINETIC_ENERGY);
242 <    mask.set(Stats::TEMPERATURE);
243 <    mask.set(Stats::PRESSURE);
244 <    mask.set(Stats::VOLUME);
245 <    mask.set(Stats::CONSERVED_QUANTITY);
246 <    mask.set(Stats::VRAW);
247 <    mask.set(Stats::VHARM);
248 <    return new StatWriter(info_->getStatFileName(), mask);
234 >  StatWriter* VelocityVerletIntegrator::createStatWriter() {
235 >
236 >    std::string statFileFormatString = simParams->getStatFileFormat();
237 >    StatsBitSet mask = parseStatFileFormat(statFileFormatString);
238 >    
239 >    // if solidThermInt is true, add extra information to the statfile
240 >    if (simParams->getUseSolidThermInt()){
241 >      mask.set(Stats::VRAW);
242 >      mask.set(Stats::VHARM);
243 >    }
244 >
245 >    if (simParams->havePrintPressureTensor() &&
246 >        simParams->getPrintPressureTensor()){
247 >      mask.set(Stats::PRESSURE_TENSOR_XX);
248 >      mask.set(Stats::PRESSURE_TENSOR_XY);
249 >      mask.set(Stats::PRESSURE_TENSOR_XZ);
250 >      mask.set(Stats::PRESSURE_TENSOR_YX);
251 >      mask.set(Stats::PRESSURE_TENSOR_YY);
252 >      mask.set(Stats::PRESSURE_TENSOR_YZ);
253 >      mask.set(Stats::PRESSURE_TENSOR_ZX);
254 >      mask.set(Stats::PRESSURE_TENSOR_ZY);
255 >      mask.set(Stats::PRESSURE_TENSOR_ZZ);
256 >    }
257 >    
258 >    if (simParams->getAccumulateBoxDipole()) {
259 >      mask.set(Stats::BOX_DIPOLE_X);
260 >      mask.set(Stats::BOX_DIPOLE_Y);
261 >      mask.set(Stats::BOX_DIPOLE_Z);
262 >    }
263 >  
264 >    if (simParams->haveTaggedAtomPair() && simParams->havePrintTaggedPairDistance()) {
265 >      if (simParams->getPrintTaggedPairDistance()) {
266 >        mask.set(Stats::TAGGED_PAIR_DISTANCE);
267 >      }
268 >    }
269 >
270 >    if (simParams->getUseRNEMD()) {
271 >      mask.set(Stats::RNEMD_SWAP_TOTAL);
272 >    }
273 >      
274 >
275 >     return new StatWriter(info_->getStatFileName(), mask);
276    }
233 –  
234 –  return new StatWriter(info_->getStatFileName());
235 – }
277  
278 < RestWriter* VelocityVerletIntegrator::createRestWriter(){
279 <  return new RestWriter(info_);
280 < }
278 >  RestWriter* VelocityVerletIntegrator::createRestWriter(){
279 >    return new RestWriter(info_);
280 >  }
281  
282  
283   } //end namespace oopse

Diff Legend

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