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 376 by tim, Thu Feb 24 20:55:07 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 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 <
70 <    // remove center of mass drift velocity (in case we passed in a configuration
71 <    // that was drifting
69 >    
70 >    // remove center of mass drift velocity (in case we passed in a
71 >    // configuration that was drifting)
72      velocitizer_->removeComDrift();
73 <
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  
76 >    
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
80 >      rattle->constraintA();
81 >      calcForce(true, true);
82 >      rattle->constraintB();      
83 >      //copy the current snapshot to previous snapshot
84 >      info_->getSnapshotManager()->advance();
85      }
86 <
86 >    
87      if (needVelocityScaling) {
88 <        velocitizer_->velocitize(targetScalingTemp);
88 >      velocitizer_->velocitize(targetScalingTemp);
89      }
90      
91      dumpWriter = createDumpWriter();
92 <
92 >    
93      statWriter = createStatWriter();
94 <
94 >
95      dumpWriter->writeDumpAndEor();
96 +
97 +    if (simParams->getUseSolidThermInt()) {
98 +      restWriter = createRestWriter();
99 +      restWriter->writeZAngFile();
100 +    }
101      
102      //save statistics, before writeStat,  we must save statistics
103      thermo.saveStat();
104      saveConservedQuantity();
105      statWriter->writeStat(currentSnapshot_->statData);
106 <
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 < }
107 <        
108 < void VelocityVerletIntegrator::doIntegrate() {
115 >    
116 >  }
117  
118 <
118 >  void VelocityVerletIntegrator::doIntegrate() {
119 >  
120 >  
121      initialize();
122 <
122 >  
123      while (currentSnapshot_->getTime() < runTime) {
124 <        
125 <        preStep();
126 <
127 <        integrateStep();
128 <        
129 <        postStep();
130 <
124 >    
125 >      preStep();
126 >    
127 >      integrateStep();
128 >    
129 >      postStep();
130 >    
131      }
132 <
132 >  
133      finalize();
134 <    
135 < }
134 >  
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;  
144 >    }
145 >  }
146  
147 <        if (difference > 0 || fabs(difference) < oopse::epsilon) {
132 <            needPotential = true;
133 <            needStress = true;  
134 <        }
147 >  void VelocityVerletIntegrator::postStep() {
148  
149 < }
149 >    //save snapshot
150 >    info_->getSnapshotManager()->advance();
151 >  
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 < void VelocityVerletIntegrator::postStep() {
162 >    if (currentSnapshot_->getTime() >= currSample) {
163 >      dumpWriter->writeDumpAndEor();
164  
165 <        //save snapshot
166 <        info_->getSnapshotManager()->advance();
165 >      if (simParams->getUseSolidThermInt())
166 >        restWriter->writeZAngFile();
167 >    
168 >      currSample += sampleTime;
169 >    }
170  
171 <        //increase time
172 <        currentSnapshot_->increaseTime(dt);        
173 <        
174 <        if (needVelocityScaling) {
175 <            if (currentSnapshot_->getTime() >= currThermal) {
176 <                velocitizer_->velocitize(targetScalingTemp);
177 <                currThermal += thermalTime;
178 <            }
179 <        }
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 >      needPotential = false;
178 >      needStress = false;
179 >      currStatus += statusTime;
180 >    }
181  
182 <        if (currentSnapshot_->getTime() >= currSample) {
183 <            dumpWriter->writeDumpAndEor();
184 <            currSample += sampleTime;
185 <        }
182 >      if (needReset && currentSnapshot_->getTime() >= currReset) {    
183 >        resetIntegrator();
184 >        currReset += resetTime;
185 >      }
186 >  
187 >  }
188  
158 –        if (currentSnapshot_->getTime() >= currStatus) {
159 –            //save statistics, before writeStat,  we must save statistics
160 –            thermo.saveStat();
161 –            saveConservedQuantity();
162 –            statWriter->writeStat(currentSnapshot_->statData);
189  
190 <            needPotential = false;
191 <            needStress = false;
192 <            currStatus += statusTime;
193 <        }
194 <
195 <        
196 < }
197 <
198 <
173 < void VelocityVerletIntegrator::finalize() {
174 <     dumpWriter->writeEor();
175 <
190 >  void VelocityVerletIntegrator::finalize() {
191 >    dumpWriter->writeEor();
192 >  
193 >    if (simParams->getUseSolidThermInt()) {
194 >      restWriter->writeZAngFile();
195 >      delete restWriter;
196 >      restWriter = NULL;
197 >    }
198 >  
199      delete dumpWriter;
200      delete statWriter;
201 <
201 >  
202      dumpWriter = NULL;
203      statWriter = NULL;
204 <    
205 < }
204 >  
205 >  }
206  
207 < void VelocityVerletIntegrator::integrateStep() {
208 <
207 >  void VelocityVerletIntegrator::integrateStep() {
208 >  
209      moveA();
210      calcForce(needPotential, needStress);
211      moveB();
212 < }
212 >  }
213  
214  
215 < void VelocityVerletIntegrator::calcForce(bool needPotential,
216 <                                         bool needStress) {
215 >  void VelocityVerletIntegrator::calcForce(bool needPotential,
216 >                                           bool needStress) {
217      forceMan_->calcForces(needPotential, needStress);
218 < }
218 >  }
219  
220 < DumpWriter* VelocityVerletIntegrator::createDumpWriter() {
220 >  DumpWriter* VelocityVerletIntegrator::createDumpWriter() {
221      return new DumpWriter(info_);
222 < }
222 >  }
223  
224 < StatWriter* VelocityVerletIntegrator::createStatWriter() {
202 <    return new StatWriter(info_->getStatFileName());
203 < }
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 +  }
250 +
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