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 1029 by chrisfen, Thu Aug 31 22:34:49 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 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();
# Line 105 | Line 106 | namespace oopse {
106      
107      currSample = sampleTime + currentSnapshot_->getTime();
108      currStatus =  statusTime + currentSnapshot_->getTime();;
109 <    currThermal = thermalTime +  + currentSnapshot_->getTime();
109 >    currThermal = thermalTime + currentSnapshot_->getTime();
110 >    if (needReset) {
111 >      currReset = resetTime + currentSnapshot_->getTime();
112 >    }
113      needPotential = false;
114      needStress = false;      
115      
116 < }
116 >  }
117  
118 < void VelocityVerletIntegrator::doIntegrate() {
118 >  void VelocityVerletIntegrator::doIntegrate() {
119    
120    
121 <  initialize();
121 >    initialize();
122    
123 <  while (currentSnapshot_->getTime() < runTime) {
123 >    while (currentSnapshot_->getTime() < runTime) {
124      
125 <    preStep();
125 >      preStep();
126      
127 <    integrateStep();
127 >      integrateStep();
128      
129 <    postStep();
129 >      postStep();
130      
131 <  }
131 >    }
132    
133 <  finalize();
133 >    finalize();
134    
135 < }
135 >  }
136  
137  
138 < void VelocityVerletIntegrator::preStep() {
139 <  double difference = currentSnapshot_->getTime() + dt - currStatus;
138 >  void VelocityVerletIntegrator::preStep() {
139 >    RealType difference = currentSnapshot_->getTime() + dt - currStatus;
140    
141 <  if (difference > 0 || fabs(difference) < oopse::epsilon) {
142 <    needPotential = true;
143 <    needStress = true;  
141 >    if (difference > 0 || fabs(difference) < oopse::epsilon) {
142 >      needPotential = true;
143 >      needStress = true;  
144 >    }
145    }
141 –  
142 – }
146  
147 < void VelocityVerletIntegrator::postStep() {
147 >  void VelocityVerletIntegrator::postStep() {
148 >
149 >    //save snapshot
150 >    info_->getSnapshotManager()->advance();
151    
152 <  //save snapshot
153 <  info_->getSnapshotManager()->advance();
154 <  
155 <  //increase time
156 <  currentSnapshot_->increaseTime(dt);        
157 <  
158 <  if (needVelocityScaling) {
159 <    if (currentSnapshot_->getTime() >= currThermal) {
154 <      velocitizer_->velocitize(targetScalingTemp);
155 <      currThermal += thermalTime;
152 >    //increase time
153 >    currentSnapshot_->increaseTime(dt);        
154 >  
155 >    if (needVelocityScaling) {
156 >      if (currentSnapshot_->getTime() >= currThermal) {
157 >        velocitizer_->velocitize(targetScalingTemp);
158 >        currThermal += thermalTime;
159 >      }
160      }
161 <  }
162 <  
163 <  if (currentSnapshot_->getTime() >= currSample) {
164 <    dumpWriter->writeDumpAndEor();
161 >
162 >    if (currentSnapshot_->getTime() >= currSample) {
163 >      dumpWriter->writeDumpAndEor();
164 >
165 >      if (simParams->getUseSolidThermInt())
166 >        restWriter->writeZAngFile();
167      
168 <    if (simParams->getUseSolidThermInt())
169 <      restWriter->writeZangle();
168 >      currSample += sampleTime;
169 >    }
170 >
171 >    if (currentSnapshot_->getTime() >= currStatus) {
172 >      //save statistics, before writeStat,  we must save statistics
173 >      thermo.saveStat();
174 >      saveConservedQuantity();
175 >      statWriter->writeStat(currentSnapshot_->statData);
176      
177 <    currSample += sampleTime;
178 <  }
177 >      needPotential = false;
178 >      needStress = false;
179 >      currStatus += statusTime;
180 >    }
181 >
182 >      if (needReset && currentSnapshot_->getTime() >= currReset) {    
183 >        resetIntegrator();
184 >        currReset += resetTime;
185 >      }
186    
168 –  if (currentSnapshot_->getTime() >= currStatus) {
169 –    //save statistics, before writeStat,  we must save statistics
170 –    thermo.saveStat();
171 –    saveConservedQuantity();
172 –    statWriter->writeStat(currentSnapshot_->statData);
173 –    
174 –    needPotential = false;
175 –    needStress = false;
176 –    currStatus += statusTime;
187    }
178 –  
179 –  
180 – }
188  
189  
190 < void VelocityVerletIntegrator::finalize() {
191 <  dumpWriter->writeEor();
190 >  void VelocityVerletIntegrator::finalize() {
191 >    dumpWriter->writeEor();
192    
193 <  if (simParams->getUseSolidThermInt()) {
194 <    restWriter->writeZangle();
195 <    delete restWriter;
196 <    restWriter = NULL;
197 <  }
193 >    if (simParams->getUseSolidThermInt()) {
194 >      restWriter->writeZAngFile();
195 >      delete restWriter;
196 >      restWriter = NULL;
197 >    }
198    
199 <  delete dumpWriter;
200 <  delete statWriter;
199 >    delete dumpWriter;
200 >    delete statWriter;
201    
202 <  dumpWriter = NULL;
203 <  statWriter = NULL;
202 >    dumpWriter = NULL;
203 >    statWriter = NULL;
204    
205 < }
205 >  }
206  
207 < void VelocityVerletIntegrator::integrateStep() {
207 >  void VelocityVerletIntegrator::integrateStep() {
208    
209 <  moveA();
210 <  calcForce(needPotential, needStress);
211 <  moveB();
212 < }
209 >    moveA();
210 >    calcForce(needPotential, needStress);
211 >    moveB();
212 >  }
213  
214  
215 < void VelocityVerletIntegrator::calcForce(bool needPotential,
216 <                                         bool needStress) {
217 <  forceMan_->calcForces(needPotential, needStress);
218 < }
215 >  void VelocityVerletIntegrator::calcForce(bool needPotential,
216 >                                           bool needStress) {
217 >    forceMan_->calcForces(needPotential, needStress);
218 >  }
219  
220 < DumpWriter* VelocityVerletIntegrator::createDumpWriter() {
221 <  return new DumpWriter(info_);
222 < }
220 >  DumpWriter* VelocityVerletIntegrator::createDumpWriter() {
221 >    return new DumpWriter(info_);
222 >  }
223  
224 < StatWriter* VelocityVerletIntegrator::createStatWriter() {
225 <  // if solidThermInt is true, add extra information to the statfile
226 <  if (simParams->getUseSolidThermInt()){
227 <    StatsBitSet mask;
228 <    mask.set(Stats::TIME);
229 <    mask.set(Stats::TOTAL_ENERGY);
230 <    mask.set(Stats::POTENTIAL_ENERGY);
231 <    mask.set(Stats::KINETIC_ENERGY);
232 <    mask.set(Stats::TEMPERATURE);
233 <    mask.set(Stats::PRESSURE);
234 <    mask.set(Stats::VOLUME);
235 <    mask.set(Stats::CONSERVED_QUANTITY);
236 <    mask.set(Stats::VRAW);
237 <    mask.set(Stats::VHARM);
238 <    return new StatWriter(info_->getStatFileName(), mask);
224 >  StatWriter* VelocityVerletIntegrator::createStatWriter() {
225 >
226 >    std::string statFileFormatString = simParams->getStatFileFormat();
227 >    StatsBitSet mask = parseStatFileFormat(statFileFormatString);
228 >    
229 >    // if solidThermInt is true, add extra information to the statfile
230 >    if (simParams->getUseSolidThermInt()){
231 >      mask.set(Stats::VRAW);
232 >      mask.set(Stats::VHARM);
233 >    }
234 >
235 >    if (simParams->havePrintPressureTensor() &&
236 >        simParams->getPrintPressureTensor()){
237 >        mask.set(Stats::PRESSURE_TENSOR_X);
238 >        mask.set(Stats::PRESSURE_TENSOR_Y);
239 >        mask.set(Stats::PRESSURE_TENSOR_Z);
240 >    }
241 >    
242 >    if (simParams->getAccumulateBoxDipole()) {
243 >      mask.set(Stats::BOX_DIPOLE_X);
244 >      mask.set(Stats::BOX_DIPOLE_Y);
245 >      mask.set(Stats::BOX_DIPOLE_Z);
246 >    }
247 >
248 >     return new StatWriter(info_->getStatFileName(), mask);
249    }
233 –  
234 –  return new StatWriter(info_->getStatFileName());
235 – }
250  
251 < RestWriter* VelocityVerletIntegrator::createRestWriter(){
252 <  return new RestWriter(info_);
253 < }
251 >  RestWriter* VelocityVerletIntegrator::createRestWriter(){
252 >    return new RestWriter(info_);
253 >  }
254  
255  
256   } //end namespace oopse

Diff Legend

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