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 1710 by gezelter, Fri May 18 21:44:02 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  
91      if (storageLayout_ & dslZAngle && zAngle.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_ & dslForce && force.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_ & dslTorque && torque.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_ & dslParticlePot && particlePot.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_ & dslDensity && density.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_ & dslFunctional && functional.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_ & dslFunctionalDerivative && functionalDerivative.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_ & dslElectricField && electricField.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_ & dslSkippedCharge && skippedCharge.size() != size_) {
132 +      //error
133 +      cerr << "size does not match"<< endl;        
134 +    }
135 +
136 +    if (storageLayout_ & dslFlucQPosition && flucQPos.size() != size_) {
137 +      //error
138 +      cerr << "size does not match"<< endl;        
139 +    }
140 +
141 +    if (storageLayout_ & dslFlucQVelocity && flucQVel.size() != size_) {
142 +      //error
143 +      cerr << "size does not match"<< endl;        
144 +    }
145 +
146 +    if (storageLayout_ & dslFlucQForce && flucQFrc.size() != size_) {
147 +      //error
148 +      cerr << "size does not match"<< endl;        
149 +    }
150      
151      return size_;
152  
# Line 185 | Line 206 | namespace OpenMD {
206        internalResize(electricField, newSize);
207      }
208  
209 +    if (storageLayout_ & dslSkippedCharge) {
210 +      internalResize(skippedCharge, newSize);
211 +    }
212 +
213 +    if (storageLayout_ & dslFlucQPosition) {
214 +      internalResize(flucQPos, newSize);
215 +    }
216 +
217 +    if (storageLayout_ & dslFlucQVelocity) {
218 +      internalResize(flucQVel, newSize);
219 +    }
220 +
221 +    if (storageLayout_ & dslFlucQForce) {
222 +      internalResize(flucQFrc, newSize);
223 +    }
224 +
225      size_ = newSize;
226    }
227  
# Line 241 | Line 278 | namespace OpenMD {
278        electricField.reserve(size);
279      }
280  
281 +    if (storageLayout_ & dslSkippedCharge) {
282 +      skippedCharge.reserve(size);
283 +    }
284 +
285 +    if (storageLayout_ & dslFlucQPosition) {
286 +      flucQPos.reserve(size);
287 +    }
288 +
289 +    if (storageLayout_ & dslFlucQVelocity) {
290 +      flucQVel.reserve(size);
291 +    }
292 +
293 +    if (storageLayout_ & dslFlucQForce) {
294 +      flucQFrc.reserve(size);
295 +    }
296    }
297  
298    void DataStorage::copy(int source, int num, int target) {
# Line 298 | Line 350 | namespace OpenMD {
350  
351      if (storageLayout_ & dslElectricField) {
352        internalCopy(electricField, source, num, target);
353 +    }
354 +
355 +    if (storageLayout_ & dslSkippedCharge) {
356 +      internalCopy(skippedCharge, source, num, target);
357 +    }
358 +
359 +    if (storageLayout_ & dslFlucQPosition) {
360 +      internalCopy(flucQPos, source, num, target);
361 +    }
362 +
363 +    if (storageLayout_ & dslFlucQVelocity) {
364 +      internalCopy(flucQVel, source, num, target);
365 +    }
366 +    if (storageLayout_ & dslFlucQForce) {
367 +      internalCopy(flucQFrc, source, num, target);
368      }
369    }
370  
# Line 364 | Line 431 | namespace OpenMD {
431      case dslElectricField:
432        return internalGetArrayPointer(electricField);
433        break;
434 +
435 +    case dslSkippedCharge:
436 +      return internalGetArrayPointer(skippedCharge);
437 +      break;
438 +
439 +    case dslFlucQPosition:
440 +      return internalGetArrayPointer(flucQPos);
441 +      break;
442 +
443 +    case dslFlucQVelocity:
444 +      return internalGetArrayPointer(flucQVel);
445 +      break;
446            
447 +    case dslFlucQForce:
448 +      return internalGetArrayPointer(flucQFrc);
449 +      break;
450 +          
451      default:
452        //error message
453        return NULL;
# Line 473 | Line 556 | namespace OpenMD {
556      if (layout & dslElectricField) {
557        bytes += sizeof(Vector3d);
558      }
559 +    if (layout & dslSkippedCharge) {
560 +      bytes += sizeof(RealType);
561 +    }
562 +    if (layout & dslFlucQPosition) {
563 +      bytes += sizeof(RealType);
564 +    }
565 +    if (layout & dslFlucQVelocity) {
566 +      bytes += sizeof(RealType);
567 +    }
568 +    if (layout & dslFlucQForce) {
569 +      bytes += sizeof(RealType);
570 +    }
571  
572      return bytes;
573    }

Diff Legend

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