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 1583 by gezelter, Thu Jun 16 22:00:08 2011 UTC vs.
Revision 1711 by gezelter, Sat May 19 02:58:35 2012 UTC

# Line 36 | Line 36
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).          
39 < * [4]  Vardeman & Gezelter, in progress (2009).                        
39 > * [4]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
40 > * [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41   */
42  
43   /**
# Line 48 | Line 49
49   */
50  
51   #include "brains/DataStorage.hpp"
52 <
52 > using namespace std;
53   namespace OpenMD {
54  
55    DataStorage::DataStorage() : size_(0), storageLayout_(0){
# Line 64 | Line 65 | namespace OpenMD {
65  
66      if (storageLayout_ & dslPosition && position.size() != size_) {
67        //error
68 <      std::cerr << "size does not match"<< std::endl;
68 >      cerr << "size does not match"<< endl;
69      }
70  
71      if (storageLayout_ & dslVelocity && velocity.size() != size_) {
72        //error
73 <      std::cerr << "size does not match"<< std::endl;        
73 >      cerr << "size does not match"<< endl;        
74      }
75  
76      if (storageLayout_ & dslAmat && aMat.size() != size_) {
77        //error
78 <      std::cerr << "size does not match"<< std::endl;        
78 >      cerr << "size does not match"<< endl;        
79      }
80  
81      if (storageLayout_ & dslAngularMomentum && angularMomentum.size() != size_) {
82        //error
83 <      std::cerr << "size does not match"<< std::endl;        
83 >      cerr << "size does not match"<< endl;        
84      }
85  
86      if (storageLayout_ & dslElectroFrame && electroFrame.size() != size_) {
87        //error
88 <      std::cerr << "size does not match"<< std::endl;        
88 >      cerr << "size does not match"<< endl;        
89      }
90  
90 –    if (storageLayout_ & dslZAngle && zAngle.size() != size_) {
91 –      //error
92 –      std::cerr << "size does not match"<< std::endl;        
93 –    }
94 –
91      if (storageLayout_ & dslForce && force.size() != size_) {
92        //error
93 <      std::cerr << "size does not match"<< std::endl;        
93 >      cerr << "size does not match"<< endl;        
94      }
95  
96      if (storageLayout_ & dslTorque && torque.size() != size_) {
97        //error
98 <      std::cerr << "size does not match"<< std::endl;        
98 >      cerr << "size does not match"<< endl;        
99      }
100  
101      if (storageLayout_ & dslParticlePot && particlePot.size() != size_) {
102        //error
103 <      std::cerr << "size does not match"<< std::endl;        
103 >      cerr << "size does not match"<< endl;        
104      }
105  
106      if (storageLayout_ & dslDensity && density.size() != size_) {
107        //error
108 <      std::cerr << "size does not match"<< std::endl;        
108 >      cerr << "size does not match"<< endl;        
109      }
110  
111      if (storageLayout_ & dslFunctional && functional.size() != size_) {
112        //error
113 <      std::cerr << "size does not match"<< std::endl;        
113 >      cerr << "size does not match"<< endl;        
114      }
115  
116      if (storageLayout_ & dslFunctionalDerivative && functionalDerivative.size() != size_) {
117        //error
118 <      std::cerr << "size does not match"<< std::endl;        
118 >      cerr << "size does not match"<< endl;        
119      }
120  
121      if (storageLayout_ & dslElectricField && electricField.size() != size_) {
122        //error
123 <      std::cerr << "size does not match"<< std::endl;        
123 >      cerr << "size does not match"<< endl;        
124      }
125 +
126 +    if (storageLayout_ & dslSkippedCharge && skippedCharge.size() != size_) {
127 +      //error
128 +      cerr << "size does not match"<< endl;        
129 +    }
130 +
131 +    if (storageLayout_ & dslFlucQPosition && flucQPos.size() != size_) {
132 +      //error
133 +      cerr << "size does not match"<< endl;        
134 +    }
135 +
136 +    if (storageLayout_ & dslFlucQVelocity && flucQVel.size() != size_) {
137 +      //error
138 +      cerr << "size does not match"<< endl;        
139 +    }
140 +
141 +    if (storageLayout_ & dslFlucQForce && flucQFrc.size() != size_) {
142 +      //error
143 +      cerr << "size does not match"<< endl;        
144 +    }
145      
146      return size_;
147  
# Line 153 | Line 169 | namespace OpenMD {
169        internalResize(electroFrame, newSize);
170      }
171      
156 –    if (storageLayout_ & dslZAngle) {
157 –      internalResize(zAngle, newSize);
158 –    }
159 –
172      if (storageLayout_ & dslForce) {
173        internalResize(force, newSize);
174      }
# Line 185 | Line 197 | namespace OpenMD {
197        internalResize(electricField, newSize);
198      }
199  
200 +    if (storageLayout_ & dslSkippedCharge) {
201 +      internalResize(skippedCharge, newSize);
202 +    }
203 +
204 +    if (storageLayout_ & dslFlucQPosition) {
205 +      internalResize(flucQPos, newSize);
206 +    }
207 +
208 +    if (storageLayout_ & dslFlucQVelocity) {
209 +      internalResize(flucQVel, newSize);
210 +    }
211 +
212 +    if (storageLayout_ & dslFlucQForce) {
213 +      internalResize(flucQFrc, newSize);
214 +    }
215 +
216      size_ = newSize;
217    }
218  
# Line 209 | Line 237 | namespace OpenMD {
237        electroFrame.reserve(size);
238      }
239      
212 –    if (storageLayout_ & dslZAngle) {
213 –      zAngle.reserve(size);
214 –    }
215 –
240      if (storageLayout_ & dslForce) {
241        force.reserve(size);
242      }
# Line 241 | Line 265 | namespace OpenMD {
265        electricField.reserve(size);
266      }
267  
268 +    if (storageLayout_ & dslSkippedCharge) {
269 +      skippedCharge.reserve(size);
270 +    }
271 +
272 +    if (storageLayout_ & dslFlucQPosition) {
273 +      flucQPos.reserve(size);
274 +    }
275 +
276 +    if (storageLayout_ & dslFlucQVelocity) {
277 +      flucQVel.reserve(size);
278 +    }
279 +
280 +    if (storageLayout_ & dslFlucQForce) {
281 +      flucQFrc.reserve(size);
282 +    }
283    }
284  
285    void DataStorage::copy(int source, int num, int target) {
# Line 268 | Line 307 | namespace OpenMD {
307        internalCopy(electroFrame, source, num, target);
308      }
309      
271 –    if (storageLayout_ & dslZAngle) {
272 –      internalCopy(zAngle, source, num, target);
273 –    }
274 –
310      if (storageLayout_ & dslForce) {
311        internalCopy(force, source, num, target);
312      }
# Line 299 | Line 334 | namespace OpenMD {
334      if (storageLayout_ & dslElectricField) {
335        internalCopy(electricField, source, num, target);
336      }
337 +
338 +    if (storageLayout_ & dslSkippedCharge) {
339 +      internalCopy(skippedCharge, source, num, target);
340 +    }
341 +
342 +    if (storageLayout_ & dslFlucQPosition) {
343 +      internalCopy(flucQPos, source, num, target);
344 +    }
345 +
346 +    if (storageLayout_ & dslFlucQVelocity) {
347 +      internalCopy(flucQVel, source, num, target);
348 +    }
349 +    if (storageLayout_ & dslFlucQForce) {
350 +      internalCopy(flucQFrc, source, num, target);
351 +    }
352    }
353  
354    int DataStorage::getStorageLayout() {
# Line 333 | Line 383 | namespace OpenMD {
383        return internalGetArrayPointer(electroFrame);
384        break;
385              
336 –    case dslZAngle:
337 –      return internalGetArrayPointer(zAngle);
338 –      break;
339 –
386      case dslForce:
387        return internalGetArrayPointer(force);
388        break;            
# Line 364 | Line 410 | namespace OpenMD {
410      case dslElectricField:
411        return internalGetArrayPointer(electricField);
412        break;
413 +
414 +    case dslSkippedCharge:
415 +      return internalGetArrayPointer(skippedCharge);
416 +      break;
417 +
418 +    case dslFlucQPosition:
419 +      return internalGetArrayPointer(flucQPos);
420 +      break;
421 +
422 +    case dslFlucQVelocity:
423 +      return internalGetArrayPointer(flucQVel);
424 +      break;
425            
426 +    case dslFlucQForce:
427 +      return internalGetArrayPointer(flucQFrc);
428 +      break;
429 +          
430      default:
431        //error message
432        return NULL;
# Line 449 | Line 511 | namespace OpenMD {
511      if (layout & dslElectroFrame) {
512        bytes += sizeof(Mat3x3d);
513      }
452 –    if (layout & dslZAngle) {
453 –      bytes += sizeof(RealType);
454 –    }
514      if (layout & dslForce) {
515        bytes += sizeof(Vector3d);
516      }
# Line 473 | Line 532 | namespace OpenMD {
532      if (layout & dslElectricField) {
533        bytes += sizeof(Vector3d);
534      }
535 +    if (layout & dslSkippedCharge) {
536 +      bytes += sizeof(RealType);
537 +    }
538 +    if (layout & dslFlucQPosition) {
539 +      bytes += sizeof(RealType);
540 +    }
541 +    if (layout & dslFlucQVelocity) {
542 +      bytes += sizeof(RealType);
543 +    }
544 +    if (layout & dslFlucQForce) {
545 +      bytes += sizeof(RealType);
546 +    }
547  
548      return bytes;
549    }

Diff Legend

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