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 1584 by gezelter, Fri Jun 17 20:16:35 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 <      std::cerr << "size does not match"<< std::endl;        
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 158 | Line 169 | namespace OpenMD {
169        internalResize(electroFrame, newSize);
170      }
171      
161 –    if (storageLayout_ & dslZAngle) {
162 –      internalResize(zAngle, newSize);
163 –    }
164 –
172      if (storageLayout_ & dslForce) {
173        internalResize(force, newSize);
174      }
# Line 194 | Line 201 | namespace OpenMD {
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 218 | Line 237 | namespace OpenMD {
237        electroFrame.reserve(size);
238      }
239      
221 –    if (storageLayout_ & dslZAngle) {
222 –      zAngle.reserve(size);
223 –    }
224 –
240      if (storageLayout_ & dslForce) {
241        force.reserve(size);
242      }
# Line 254 | Line 269 | namespace OpenMD {
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 281 | Line 307 | namespace OpenMD {
307        internalCopy(electroFrame, source, num, target);
308      }
309      
284 –    if (storageLayout_ & dslZAngle) {
285 –      internalCopy(zAngle, source, num, target);
286 –    }
287 –
310      if (storageLayout_ & dslForce) {
311        internalCopy(force, source, num, target);
312      }
# Line 315 | Line 337 | namespace OpenMD {
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  
# Line 350 | Line 383 | namespace OpenMD {
383        return internalGetArrayPointer(electroFrame);
384        break;
385              
353 –    case dslZAngle:
354 –      return internalGetArrayPointer(zAngle);
355 –      break;
356 –
386      case dslForce:
387        return internalGetArrayPointer(force);
388        break;            
# Line 385 | Line 414 | namespace OpenMD {
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 470 | Line 511 | namespace OpenMD {
511      if (layout & dslElectroFrame) {
512        bytes += sizeof(Mat3x3d);
513      }
473 –    if (layout & dslZAngle) {
474 –      bytes += sizeof(RealType);
475 –    }
514      if (layout & dslForce) {
515        bytes += sizeof(Vector3d);
516      }
# Line 497 | Line 535 | namespace OpenMD {
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