ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-4/src/integrators/VelocityVerletIntegrator.cpp
(Generate patch)

Comparing trunk/OOPSE-4/src/integrators/VelocityVerletIntegrator.cpp (file contents):
Revision 1930 by gezelter, Wed Jan 12 22:41:40 2005 UTC vs.
Revision 2239 by chuckv, Sun May 22 21:36:21 2005 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 49 | Line 49
49  
50   #include "integrators/VelocityVerletIntegrator.hpp"
51   #include "integrators/DLM.hpp"
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 +    
91      statWriter = createStatWriter();
92 <
93 <    dumpWriter->writeDump();
94 <
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();
109      needPotential = false;
110      needStress = false;      
111 <  
112 < }
105 <        
106 < void VelocityVerletIntegrator::doIntegrate() {
111 >    
112 >  }
113  
114 <
114 >  void VelocityVerletIntegrator::doIntegrate() {
115 >  
116 >  
117      initialize();
118 <
118 >  
119      while (currentSnapshot_->getTime() < runTime) {
120 <        
121 <        preStep();
120 >    
121 >      preStep();
122 >    
123 >      integrateStep();
124 >    
125 >      postStep();
126 >    
127 >    }
128 >  
129 >    finalize();
130 >  
131 >  }
132  
115 –        integrateStep();
116 –        
117 –        postStep();
133  
134 +  void VelocityVerletIntegrator::preStep() {
135 +    double difference = currentSnapshot_->getTime() + dt - currStatus;
136 +  
137 +    if (difference > 0 || fabs(difference) < oopse::epsilon) {
138 +      needPotential = true;
139 +      needStress = true;  
140      }
141 +  
142 +  }
143  
144 <    finalize();
144 >  void VelocityVerletIntegrator::postStep() {
145 >  
146 >    //save snapshot
147 >    info_->getSnapshotManager()->advance();
148 >  
149 >    //increase time
150 >    currentSnapshot_->increaseTime(dt);        
151 >  
152 >    if (needVelocityScaling) {
153 >      if (currentSnapshot_->getTime() >= currThermal) {
154 >        velocitizer_->velocitize(targetScalingTemp);
155 >        currThermal += thermalTime;
156 >      }
157 >    }
158 >  
159 >    if (currentSnapshot_->getTime() >= currSample) {
160 >      dumpWriter->writeDumpAndEor();
161      
162 < }
162 >      if (simParams->getUseSolidThermInt())
163 >        restWriter->writeZangle();
164 >    
165 >      currSample += sampleTime;
166 >    }
167 >  
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;
177 >    }
178 >  
179 >  
180 >  }
181  
182  
183 < void VelocityVerletIntegrator::preStep() {
184 <        double difference = currentSnapshot_->getTime() + dt - currStatus;
185 <
186 <        if (difference > 0 || fabs(difference) < oopse::epsilon) {
187 <            needPotential = true;
188 <            needStress = true;  
189 <        }
190 <
191 < }
135 <
136 < void VelocityVerletIntegrator::postStep() {
137 <
138 <        //save snapshot
139 <        info_->getSnapshotManager()->advance();
140 <
141 <        //increase time
142 <        currentSnapshot_->increaseTime(dt);        
143 <        
144 <        if (needVelocityScaling) {
145 <            if (currentSnapshot_->getTime() >= currThermal) {
146 <                velocitizer_->velocitize(targetScalingTemp);
147 <                currThermal += thermalTime;
148 <            }
149 <        }
150 <
151 <        if (currentSnapshot_->getTime() >= currSample) {
152 <            dumpWriter->writeDump();
153 <            currSample += sampleTime;
154 <        }
155 <
156 <        if (currentSnapshot_->getTime() >= currStatus) {
157 <            //save statistics, before writeStat,  we must save statistics
158 <            thermo.saveStat();
159 <            saveConservedQuantity();
160 <            statWriter->writeStat(currentSnapshot_->statData);
161 <
162 <            needPotential = false;
163 <            needStress = false;
164 <            currStatus += statusTime;
165 <        }
166 <
167 <        
168 < }
169 <
170 <
171 < void VelocityVerletIntegrator::finalize() {
172 <
173 <    dumpWriter->writeDump();
174 <
183 >  void VelocityVerletIntegrator::finalize() {
184 >    dumpWriter->writeEor();
185 >  
186 >    if (simParams->getUseSolidThermInt()) {
187 >      restWriter->writeZangle();
188 >      delete restWriter;
189 >      restWriter = NULL;
190 >    }
191 >  
192      delete dumpWriter;
193      delete statWriter;
194 <
194 >  
195      dumpWriter = NULL;
196      statWriter = NULL;
197 <    
198 < }
197 >  
198 >  }
199  
200 < void VelocityVerletIntegrator::integrateStep() {
201 <
200 >  void VelocityVerletIntegrator::integrateStep() {
201 >  
202      moveA();
203      calcForce(needPotential, needStress);
204      moveB();
205 < }
205 >  }
206  
207  
208 < void VelocityVerletIntegrator::calcForce(bool needPotential,
209 <                                         bool needStress) {
208 >  void VelocityVerletIntegrator::calcForce(bool needPotential,
209 >                                           bool needStress) {
210      forceMan_->calcForces(needPotential, needStress);
211 < }
211 >  }
212  
213 < DumpWriter* VelocityVerletIntegrator::createDumpWriter() {
214 <    return new DumpWriter(info_, info_->getDumpFileName());
215 < }
213 >  DumpWriter* VelocityVerletIntegrator::createDumpWriter() {
214 >    return new DumpWriter(info_);
215 >  }
216  
217 < StatWriter* VelocityVerletIntegrator::createStatWriter() {
217 >  StatWriter* VelocityVerletIntegrator::createStatWriter() {
218 >    // if solidThermInt is true, add extra information to the statfile
219 >    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);
229 >      mask.set(Stats::VRAW);
230 >      mask.set(Stats::VHARM);
231 >      return new StatWriter(info_->getStatFileName(), mask);
232 >    }
233 >
234 >    if (simParams->havePrintPressureTensor() && simParams->getPrintPressureTensor()){
235 >       StatsBitSet mask;
236 >        mask.set(Stats::TIME);
237 >        mask.set(Stats::TOTAL_ENERGY);
238 >        mask.set(Stats::POTENTIAL_ENERGY);
239 >        mask.set(Stats::KINETIC_ENERGY);
240 >        mask.set(Stats::TEMPERATURE);
241 >        mask.set(Stats::PRESSURE);
242 >        mask.set(Stats::VOLUME);
243 >        mask.set(Stats::CONSERVED_QUANTITY);
244 >        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);
248 >    }
249 >    
250      return new StatWriter(info_->getStatFileName());
251 < }
251 >  }
252  
253 +  RestWriter* VelocityVerletIntegrator::createRestWriter(){
254 +    return new RestWriter(info_);
255 +  }
256  
257 +
258   } //end namespace oopse

Diff Legend

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