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 542 by chuckv, Sun May 22 21:36:21 2005 UTC vs.
Revision 1338 by skuang, Thu Apr 23 18:22:30 2009 UTC

# 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      
# Line 132 | Line 139 | namespace oopse {
139  
140  
141    void VelocityVerletIntegrator::preStep() {
142 <    double difference = currentSnapshot_->getTime() + dt - currStatus;
142 >    RealType difference = currentSnapshot_->getTime() + dt - currStatus;
143    
144      if (difference > 0 || fabs(difference) < oopse::epsilon) {
145        needPotential = true;
146        needStress = true;  
147      }
141 –  
148    }
149  
150    void VelocityVerletIntegrator::postStep() {
151 <  
151 >
152      //save snapshot
153      info_->getSnapshotManager()->advance();
154    
155      //increase time
156      currentSnapshot_->increaseTime(dt);        
157 <  
157 >  
158      if (needVelocityScaling) {
159        if (currentSnapshot_->getTime() >= currThermal) {
160          velocitizer_->velocitize(targetScalingTemp);
161          currThermal += thermalTime;
162        }
163      }
164 <  
164 >    if (useRNEMD) {
165 >      if (currentSnapshot_->getTime() >= currRNEMD) {
166 >        rnemd_->doSwap();
167 >        currRNEMD += RNEMD_swapTime;
168 >      }
169 >    }
170 >    
171      if (currentSnapshot_->getTime() >= currSample) {
172        dumpWriter->writeDumpAndEor();
173 <    
173 >      
174        if (simParams->getUseSolidThermInt())
175 <        restWriter->writeZangle();
176 <    
175 >        restWriter->writeZAngFile();
176 >      
177        currSample += sampleTime;
178      }
179 <  
179 >    
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 <    
185 >      if (simParams->getUseRNEMD())
186 >        rnemd_->getStatus();
187 >      
188        needPotential = false;
189        needStress = false;
190        currStatus += statusTime;
191      }
192 <  
193 <  
192 >    
193 >    if (needReset && currentSnapshot_->getTime() >= currReset) {    
194 >      resetIntegrator();
195 >      currReset += resetTime;
196 >    }        
197    }
198  
199  
# Line 184 | Line 201 | namespace oopse {
201      dumpWriter->writeEor();
202    
203      if (simParams->getUseSolidThermInt()) {
204 <      restWriter->writeZangle();
204 >      restWriter->writeZAngFile();
205        delete restWriter;
206        restWriter = NULL;
207      }
# Line 215 | Line 232 | namespace oopse {
232    }
233  
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()){
220 –      StatsBitSet mask;
221 –      mask.set(Stats::TIME);
222 –      mask.set(Stats::TOTAL_ENERGY);
223 –      mask.set(Stats::POTENTIAL_ENERGY);
224 –      mask.set(Stats::KINETIC_ENERGY);
225 –      mask.set(Stats::TEMPERATURE);
226 –      mask.set(Stats::PRESSURE);
227 –      mask.set(Stats::VOLUME);
228 –      mask.set(Stats::CONSERVED_QUANTITY);
241        mask.set(Stats::VRAW);
242        mask.set(Stats::VHARM);
231 –      return new StatWriter(info_->getStatFileName(), mask);
243      }
244  
245 <    if (simParams->havePrintPressureTensor() && simParams->getPrintPressureTensor()){
246 <       StatsBitSet mask;
247 <        mask.set(Stats::TIME);
248 <        mask.set(Stats::TOTAL_ENERGY);
249 <        mask.set(Stats::POTENTIAL_ENERGY);
250 <        mask.set(Stats::KINETIC_ENERGY);
251 <        mask.set(Stats::TEMPERATURE);
252 <        mask.set(Stats::PRESSURE);
253 <        mask.set(Stats::VOLUME);
254 <        mask.set(Stats::CONSERVED_QUANTITY);
255 <        mask.set(Stats::PRESSURE_TENSOR_X);
245 <        mask.set(Stats::PRESSURE_TENSOR_Y);
246 <        mask.set(Stats::PRESSURE_TENSOR_Z);
247 <        return new StatWriter(info_->getStatFileName(), mask);
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 <    return new StatWriter(info_->getStatFileName());
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    }
277  
278    RestWriter* VelocityVerletIntegrator::createRestWriter(){

Diff Legend

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