ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/brains/DataStorage.cpp
(Generate patch)

Comparing branches/development/src/brains/DataStorage.cpp (file contents):
Revision 1665 by gezelter, Tue Nov 22 20:38:56 2011 UTC vs.
Revision 1850 by gezelter, Wed Feb 20 15:39:39 2013 UTC

# Line 35 | Line 35
35   *                                                                      
36   * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).            
37   * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
38 < * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).          
38 > * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (2008).          
39   * [4]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
40   * [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41   */
# Line 44 | Line 44
44   * @file DataStorage.cpp
45   * @author tlin
46   * @date 10/26/2004
47 – * @time 11:56am
47   * @version 1.0
48   */
49  
50   #include "brains/DataStorage.hpp"
51 <
51 > using namespace std;
52   namespace OpenMD {
53  
54    DataStorage::DataStorage() : size_(0), storageLayout_(0){
# Line 65 | Line 64 | namespace OpenMD {
64  
65      if (storageLayout_ & dslPosition && position.size() != size_) {
66        //error
67 <      std::cerr << "size does not match"<< std::endl;
67 >      cerr << "size does not match"<< endl;
68      }
69  
70      if (storageLayout_ & dslVelocity && velocity.size() != size_) {
71        //error
72 <      std::cerr << "size does not match"<< std::endl;        
72 >      cerr << "size does not match"<< endl;        
73      }
74  
75 <    if (storageLayout_ & dslAmat && aMat.size() != size_) {
75 >    if (storageLayout_ & dslForce && force.size() != size_) {
76        //error
77 <      std::cerr << "size does not match"<< std::endl;        
77 >      cerr << "size does not match"<< endl;        
78      }
79  
80 <    if (storageLayout_ & dslAngularMomentum && angularMomentum.size() != size_) {
80 >    if (storageLayout_ & dslAmat && aMat.size() != size_) {
81        //error
82 <      std::cerr << "size does not match"<< std::endl;        
82 >      cerr << "size does not match"<< endl;        
83      }
84  
85 <    if (storageLayout_ & dslElectroFrame && electroFrame.size() != size_) {
85 >    if (storageLayout_ & dslAngularMomentum && angularMomentum.size() != size_) {
86        //error
87 <      std::cerr << "size does not match"<< std::endl;        
87 >      cerr << "size does not match"<< endl;        
88      }
89  
90 <    if (storageLayout_ & dslZAngle && zAngle.size() != size_) {
90 >    if (storageLayout_ & dslTorque && torque.size() != size_) {
91        //error
92 <      std::cerr << "size does not match"<< std::endl;        
92 >      cerr << "size does not match"<< endl;        
93      }
94  
95 <    if (storageLayout_ & dslForce && force.size() != size_) {
95 >    if (storageLayout_ & dslParticlePot && particlePot.size() != size_) {
96        //error
97 <      std::cerr << "size does not match"<< std::endl;        
97 >      cerr << "size does not match"<< endl;        
98      }
99  
100 <    if (storageLayout_ & dslTorque && torque.size() != size_) {
100 >    if (storageLayout_ & dslDensity && density.size() != size_) {
101        //error
102 <      std::cerr << "size does not match"<< std::endl;        
102 >      cerr << "size does not match"<< endl;        
103      }
104  
105 <    if (storageLayout_ & dslParticlePot && particlePot.size() != size_) {
105 >    if (storageLayout_ & dslFunctional && functional.size() != size_) {
106        //error
107 <      std::cerr << "size does not match"<< std::endl;        
107 >      cerr << "size does not match"<< endl;        
108      }
109  
110 <    if (storageLayout_ & dslDensity && density.size() != size_) {
110 >    if (storageLayout_ & dslFunctionalDerivative && functionalDerivative.size() != size_) {
111        //error
112 <      std::cerr << "size does not match"<< std::endl;        
112 >      cerr << "size does not match"<< endl;        
113      }
114  
115 <    if (storageLayout_ & dslFunctional && functional.size() != size_) {
115 >    if (storageLayout_ & dslDipole && dipole.size() != size_) {
116        //error
117 <      std::cerr << "size does not match"<< std::endl;        
117 >      cerr << "size does not match"<< endl;        
118      }
119  
120 <    if (storageLayout_ & dslFunctionalDerivative && functionalDerivative.size() != size_) {
120 >    if (storageLayout_ & dslQuadrupole && quadrupole.size() != size_) {
121        //error
122 <      std::cerr << "size does not match"<< std::endl;        
122 >      cerr << "size does not match"<< endl;        
123      }
124  
125      if (storageLayout_ & dslElectricField && electricField.size() != size_) {
126        //error
127 <      std::cerr << "size does not match"<< std::endl;        
127 >      cerr << "size does not match"<< endl;        
128      }
129  
130      if (storageLayout_ & dslSkippedCharge && skippedCharge.size() != size_) {
131        //error
132 <      std::cerr << "size does not match"<< std::endl;        
132 >      cerr << "size does not match"<< endl;        
133      }
134 +
135 +    if (storageLayout_ & dslFlucQPosition && flucQPos.size() != size_) {
136 +      //error
137 +      cerr << "size does not match"<< endl;        
138 +    }
139 +
140 +    if (storageLayout_ & dslFlucQVelocity && flucQVel.size() != size_) {
141 +      //error
142 +      cerr << "size does not match"<< endl;        
143 +    }
144 +
145 +    if (storageLayout_ & dslFlucQForce && flucQFrc.size() != size_) {
146 +      //error
147 +      cerr << "size does not match"<< endl;        
148 +    }
149      
150      return size_;
151  
# Line 147 | Line 161 | namespace OpenMD {
161        internalResize(velocity, newSize);
162      }
163  
164 +    if (storageLayout_ & dslForce) {
165 +      internalResize(force, newSize);
166 +    }
167 +
168      if (storageLayout_ & dslAmat) {
169        internalResize(aMat, newSize);
170      }
# Line 154 | Line 172 | namespace OpenMD {
172      if (storageLayout_ & dslAngularMomentum) {
173        internalResize(angularMomentum, newSize);
174      }
157 –
158 –    if (storageLayout_ & dslElectroFrame) {
159 –      internalResize(electroFrame, newSize);
160 –    }
175      
162 –    if (storageLayout_ & dslZAngle) {
163 –      internalResize(zAngle, newSize);
164 –    }
165 –
166 –    if (storageLayout_ & dslForce) {
167 –      internalResize(force, newSize);
168 –    }
169 –
176      if (storageLayout_ & dslTorque) {
177        internalResize(torque, newSize);
178      }
# Line 187 | Line 193 | namespace OpenMD {
193        internalResize(functionalDerivative, newSize);
194      }
195  
196 +    if (storageLayout_ & dslDipole) {
197 +      internalResize(dipole, newSize);
198 +    }
199 +
200 +    if (storageLayout_ & dslQuadrupole) {
201 +      internalResize(quadrupole, newSize);
202 +    }
203 +
204      if (storageLayout_ & dslElectricField) {
205        internalResize(electricField, newSize);
206      }
# Line 195 | Line 209 | namespace OpenMD {
209        internalResize(skippedCharge, newSize);
210      }
211  
212 +    if (storageLayout_ & dslFlucQPosition) {
213 +      internalResize(flucQPos, newSize);
214 +    }
215 +
216 +    if (storageLayout_ & dslFlucQVelocity) {
217 +      internalResize(flucQVel, newSize);
218 +    }
219 +
220 +    if (storageLayout_ & dslFlucQForce) {
221 +      internalResize(flucQFrc, newSize);
222 +    }
223 +
224      size_ = newSize;
225    }
226  
# Line 207 | Line 233 | namespace OpenMD {
233        velocity.reserve(size);
234      }
235  
236 +    if (storageLayout_ & dslForce) {
237 +      force.reserve(size);
238 +    }
239 +
240      if (storageLayout_ & dslAmat) {
241        aMat.reserve(size);
242      }
# Line 215 | Line 245 | namespace OpenMD {
245        angularMomentum.reserve(size);
246      }
247  
218 –    if (storageLayout_ & dslElectroFrame) {
219 –      electroFrame.reserve(size);
220 –    }
221 –    
222 –    if (storageLayout_ & dslZAngle) {
223 –      zAngle.reserve(size);
224 –    }
225 –
226 –    if (storageLayout_ & dslForce) {
227 –      force.reserve(size);
228 –    }
229 –
248      if (storageLayout_ & dslTorque) {
249        torque.reserve(size);
250      }
# Line 247 | Line 265 | namespace OpenMD {
265        functionalDerivative.reserve(size);
266      }
267  
268 +    if (storageLayout_ & dslDipole) {
269 +      dipole.reserve(size);
270 +    }
271 +
272 +    if (storageLayout_ & dslQuadrupole) {
273 +      quadrupole.reserve(size);
274 +    }
275 +
276      if (storageLayout_ & dslElectricField) {
277        electricField.reserve(size);
278      }
# Line 255 | Line 281 | namespace OpenMD {
281        skippedCharge.reserve(size);
282      }
283  
284 +    if (storageLayout_ & dslFlucQPosition) {
285 +      flucQPos.reserve(size);
286 +    }
287 +
288 +    if (storageLayout_ & dslFlucQVelocity) {
289 +      flucQVel.reserve(size);
290 +    }
291 +
292 +    if (storageLayout_ & dslFlucQForce) {
293 +      flucQFrc.reserve(size);
294 +    }
295    }
296  
297    void DataStorage::copy(int source, int num, int target) {
# Line 270 | Line 307 | namespace OpenMD {
307        internalCopy(velocity, source, num, target);
308      }
309  
310 +    if (storageLayout_ & dslForce) {
311 +      internalCopy(force, source, num, target);
312 +    }
313 +
314      if (storageLayout_ & dslAmat) {
315        internalCopy(aMat, source, num, target);
316      }
# Line 278 | Line 319 | namespace OpenMD {
319        internalCopy(angularMomentum, source, num, target);
320      }
321  
281 –    if (storageLayout_ & dslElectroFrame) {
282 –      internalCopy(electroFrame, source, num, target);
283 –    }
284 –    
285 –    if (storageLayout_ & dslZAngle) {
286 –      internalCopy(zAngle, source, num, target);
287 –    }
288 –
289 –    if (storageLayout_ & dslForce) {
290 –      internalCopy(force, source, num, target);
291 –    }
292 –
322      if (storageLayout_ & dslTorque) {
323        internalCopy(torque, source, num, target);
324      }
# Line 310 | Line 339 | namespace OpenMD {
339        internalCopy(functionalDerivative, source, num, target);
340      }
341  
342 +    if (storageLayout_ & dslDipole) {
343 +      internalCopy(dipole, source, num, target);
344 +    }
345 +
346 +    if (storageLayout_ & dslQuadrupole) {
347 +      internalCopy(quadrupole, source, num, target);
348 +    }
349 +
350      if (storageLayout_ & dslElectricField) {
351        internalCopy(electricField, source, num, target);
352      }
# Line 317 | Line 354 | namespace OpenMD {
354      if (storageLayout_ & dslSkippedCharge) {
355        internalCopy(skippedCharge, source, num, target);
356      }
357 +
358 +    if (storageLayout_ & dslFlucQPosition) {
359 +      internalCopy(flucQPos, source, num, target);
360 +    }
361 +
362 +    if (storageLayout_ & dslFlucQVelocity) {
363 +      internalCopy(flucQVel, source, num, target);
364 +    }
365 +    if (storageLayout_ & dslFlucQForce) {
366 +      internalCopy(flucQFrc, source, num, target);
367 +    }
368    }
369  
370    int DataStorage::getStorageLayout() {
# Line 333 | Line 381 | namespace OpenMD {
381      switch (whichArray) {
382      case dslPosition:
383        return internalGetArrayPointer(position);
336 –      break;
384              
385      case dslVelocity:
386        return internalGetArrayPointer(velocity);
340 –      break;
387              
388 +    case dslForce:
389 +      return internalGetArrayPointer(force);
390 +
391      case dslAmat:
392        return internalGetArrayPointer(aMat);
344 –      break;            
393              
394      case dslAngularMomentum:
395        return internalGetArrayPointer(angularMomentum);
348 –      break;
396              
350 –    case dslElectroFrame:
351 –      return internalGetArrayPointer(electroFrame);
352 –      break;
353 –            
354 –    case dslZAngle:
355 –      return internalGetArrayPointer(zAngle);
356 –      break;
357 –
358 –    case dslForce:
359 –      return internalGetArrayPointer(force);
360 –      break;            
361 –
397      case dslTorque:
398        return internalGetArrayPointer(torque);
364 –      break;
399  
400      case dslParticlePot:
401        return internalGetArrayPointer(particlePot);
368 –      break;
402  
403      case dslDensity:
404        return internalGetArrayPointer(density);
372 –      break;
405  
406      case dslFunctional:
407        return internalGetArrayPointer(functional);
376 –      break;
408  
409      case dslFunctionalDerivative:
410        return internalGetArrayPointer(functionalDerivative);
380 –      break;
411  
412 +    case dslDipole:
413 +      return internalGetArrayPointer(dipole);
414 +
415 +    case dslQuadrupole:
416 +      return internalGetArrayPointer(quadrupole);
417 +
418      case dslElectricField:
419        return internalGetArrayPointer(electricField);
384 –      break;
420  
421      case dslSkippedCharge:
422        return internalGetArrayPointer(skippedCharge);
423 <      break;
423 >
424 >    case dslFlucQPosition:
425 >      return internalGetArrayPointer(flucQPos);
426 >
427 >    case dslFlucQVelocity:
428 >      return internalGetArrayPointer(flucQVel);
429            
430 +    case dslFlucQForce:
431 +      return internalGetArrayPointer(flucQFrc);
432 +          
433      default:
434        //error message
435        return NULL;
393 –
436      }
437    }    
438  
# Line 402 | Line 444 | namespace OpenMD {
444      }
445    }
446  
447 <  RealType* DataStorage::internalGetArrayPointer(std::vector<RotMat3x3d>& v) {
447 >  RealType* DataStorage::internalGetArrayPointer(std::vector<Mat3x3d>& v) {
448      if (v.size() == 0) {
449        return NULL;
450      } else {
# Line 462 | Line 504 | namespace OpenMD {
504      if (layout & dslVelocity) {
505        bytes += sizeof(Vector3d);
506      }
507 +    if (layout & dslForce) {
508 +      bytes += sizeof(Vector3d);
509 +    }
510      if (layout & dslAmat) {
511        bytes += sizeof(RotMat3x3d);    
512      }
513      if (layout & dslAngularMomentum) {
514        bytes += sizeof(Vector3d);
515      }
471 –    if (layout & dslElectroFrame) {
472 –      bytes += sizeof(Mat3x3d);
473 –    }
474 –    if (layout & dslZAngle) {
475 –      bytes += sizeof(RealType);
476 –    }
477 –    if (layout & dslForce) {
478 –      bytes += sizeof(Vector3d);
479 –    }
516      if (layout & dslTorque) {
517        bytes += sizeof(Vector3d);
518      }
# Line 492 | Line 528 | namespace OpenMD {
528      if (layout & dslFunctionalDerivative) {
529        bytes += sizeof(RealType);
530      }
531 +    if (layout & dslDipole) {
532 +      bytes += sizeof(Vector3d);
533 +    }
534 +    if (layout & dslQuadrupole) {
535 +      bytes += sizeof(Mat3x3d);
536 +    }
537      if (layout & dslElectricField) {
538        bytes += sizeof(Vector3d);
539      }
540      if (layout & dslSkippedCharge) {
541        bytes += sizeof(RealType);
542      }
543 +    if (layout & dslFlucQPosition) {
544 +      bytes += sizeof(RealType);
545 +    }
546 +    if (layout & dslFlucQVelocity) {
547 +      bytes += sizeof(RealType);
548 +    }
549 +    if (layout & dslFlucQForce) {
550 +      bytes += sizeof(RealType);
551 +    }
552  
553      return bytes;
554    }

Diff Legend

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