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

Comparing trunk/src/brains/DataStorage.cpp (file contents):
Revision 1782 by gezelter, Wed Aug 22 02:28:28 2012 UTC vs.
Revision 1993 by gezelter, Tue Apr 29 17:32:31 2014 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  
# Line 73 | Line 72 | namespace OpenMD {
72        cerr << "size does not match"<< endl;        
73      }
74  
75 +    if (storageLayout_ & dslForce && force.size() != size_) {
76 +      //error
77 +      cerr << "size does not match"<< endl;        
78 +    }
79 +
80      if (storageLayout_ & dslAmat && aMat.size() != size_) {
81        //error
82        cerr << "size does not match"<< endl;        
# Line 83 | Line 87 | namespace OpenMD {
87        cerr << "size does not match"<< endl;        
88      }
89  
90 <    if (storageLayout_ & dslElectroFrame && electroFrame.size() != size_) {
90 >    if (storageLayout_ & dslTorque && torque.size() != size_) {
91        //error
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        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        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        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        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        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        cerr << "size does not match"<< endl;        
123      }
# Line 142 | Line 146 | namespace OpenMD {
146        //error
147        cerr << "size does not match"<< endl;        
148      }
149 +
150 +    if (storageLayout_ & dslSitePotential && sitePotential.size() != size_) {
151 +      //error
152 +      cerr << "size does not match"<< endl;        
153 +    }
154      
155      return size_;
156  
# Line 157 | Line 166 | namespace OpenMD {
166        internalResize(velocity, newSize);
167      }
168  
169 +    if (storageLayout_ & dslForce) {
170 +      internalResize(force, newSize);
171 +    }
172 +
173      if (storageLayout_ & dslAmat) {
174        internalResize(aMat, newSize);
175      }
# Line 164 | Line 177 | namespace OpenMD {
177      if (storageLayout_ & dslAngularMomentum) {
178        internalResize(angularMomentum, newSize);
179      }
167 –
168 –    if (storageLayout_ & dslElectroFrame) {
169 –      internalResize(electroFrame, newSize);
170 –    }
180      
172 –    if (storageLayout_ & dslForce) {
173 –      internalResize(force, newSize);
174 –    }
175 –
181      if (storageLayout_ & dslTorque) {
182        internalResize(torque, newSize);
183      }
# Line 193 | Line 198 | namespace OpenMD {
198        internalResize(functionalDerivative, newSize);
199      }
200  
201 +    if (storageLayout_ & dslDipole) {
202 +      internalResize(dipole, newSize);
203 +    }
204 +
205 +    if (storageLayout_ & dslQuadrupole) {
206 +      internalResize(quadrupole, newSize);
207 +    }
208 +
209      if (storageLayout_ & dslElectricField) {
210        internalResize(electricField, newSize);
211      }
# Line 213 | Line 226 | namespace OpenMD {
226        internalResize(flucQFrc, newSize);
227      }
228  
229 +    if (storageLayout_ & dslSitePotential) {
230 +      internalResize(sitePotential, newSize);
231 +    }
232 +
233      size_ = newSize;
234    }
235  
# Line 225 | Line 242 | namespace OpenMD {
242        velocity.reserve(size);
243      }
244  
245 +    if (storageLayout_ & dslForce) {
246 +      force.reserve(size);
247 +    }
248 +
249      if (storageLayout_ & dslAmat) {
250        aMat.reserve(size);
251      }
# Line 233 | Line 254 | namespace OpenMD {
254        angularMomentum.reserve(size);
255      }
256  
236 –    if (storageLayout_ & dslElectroFrame) {
237 –      electroFrame.reserve(size);
238 –    }
239 –    
240 –    if (storageLayout_ & dslForce) {
241 –      force.reserve(size);
242 –    }
243 –
257      if (storageLayout_ & dslTorque) {
258        torque.reserve(size);
259      }
# Line 261 | Line 274 | namespace OpenMD {
274        functionalDerivative.reserve(size);
275      }
276  
277 +    if (storageLayout_ & dslDipole) {
278 +      dipole.reserve(size);
279 +    }
280 +
281 +    if (storageLayout_ & dslQuadrupole) {
282 +      quadrupole.reserve(size);
283 +    }
284 +
285      if (storageLayout_ & dslElectricField) {
286        electricField.reserve(size);
287      }
# Line 280 | Line 301 | namespace OpenMD {
301      if (storageLayout_ & dslFlucQForce) {
302        flucQFrc.reserve(size);
303      }
304 +
305 +    if (storageLayout_ & dslSitePotential) {
306 +      sitePotential.reserve(size);
307 +    }
308    }
309  
310    void DataStorage::copy(int source, int num, int target) {
# Line 295 | Line 320 | namespace OpenMD {
320        internalCopy(velocity, source, num, target);
321      }
322  
323 +    if (storageLayout_ & dslForce) {
324 +      internalCopy(force, source, num, target);
325 +    }
326 +
327      if (storageLayout_ & dslAmat) {
328        internalCopy(aMat, source, num, target);
329      }
330  
331      if (storageLayout_ & dslAngularMomentum) {
332        internalCopy(angularMomentum, source, num, target);
304 –    }
305 –
306 –    if (storageLayout_ & dslElectroFrame) {
307 –      internalCopy(electroFrame, source, num, target);
308 –    }
309 –    
310 –    if (storageLayout_ & dslForce) {
311 –      internalCopy(force, source, num, target);
333      }
334  
335      if (storageLayout_ & dslTorque) {
# Line 331 | Line 352 | namespace OpenMD {
352        internalCopy(functionalDerivative, source, num, target);
353      }
354  
355 +    if (storageLayout_ & dslDipole) {
356 +      internalCopy(dipole, source, num, target);
357 +    }
358 +
359 +    if (storageLayout_ & dslQuadrupole) {
360 +      internalCopy(quadrupole, source, num, target);
361 +    }
362 +
363      if (storageLayout_ & dslElectricField) {
364        internalCopy(electricField, source, num, target);
365      }
# Line 349 | Line 378 | namespace OpenMD {
378      if (storageLayout_ & dslFlucQForce) {
379        internalCopy(flucQFrc, source, num, target);
380      }
381 +
382 +    if (storageLayout_ & dslSitePotential) {
383 +      internalCopy(sitePotential, source, num, target);
384 +    }
385    }
386  
387    int DataStorage::getStorageLayout() {
# Line 365 | Line 398 | namespace OpenMD {
398      switch (whichArray) {
399      case dslPosition:
400        return internalGetArrayPointer(position);
368 –      break;
401              
402      case dslVelocity:
403        return internalGetArrayPointer(velocity);
372 –      break;
404              
405 +    case dslForce:
406 +      return internalGetArrayPointer(force);
407 +
408      case dslAmat:
409        return internalGetArrayPointer(aMat);
376 –      break;            
410              
411      case dslAngularMomentum:
412        return internalGetArrayPointer(angularMomentum);
380 –      break;
413              
382 –    case dslElectroFrame:
383 –      return internalGetArrayPointer(electroFrame);
384 –      break;
385 –            
386 –    case dslForce:
387 –      return internalGetArrayPointer(force);
388 –      break;            
389 –
414      case dslTorque:
415        return internalGetArrayPointer(torque);
392 –      break;
416  
417      case dslParticlePot:
418        return internalGetArrayPointer(particlePot);
396 –      break;
419  
420      case dslDensity:
421        return internalGetArrayPointer(density);
400 –      break;
422  
423      case dslFunctional:
424        return internalGetArrayPointer(functional);
404 –      break;
425  
426      case dslFunctionalDerivative:
427        return internalGetArrayPointer(functionalDerivative);
408 –      break;
428  
429 +    case dslDipole:
430 +      return internalGetArrayPointer(dipole);
431 +
432 +    case dslQuadrupole:
433 +      return internalGetArrayPointer(quadrupole);
434 +
435      case dslElectricField:
436        return internalGetArrayPointer(electricField);
412 –      break;
437  
438      case dslSkippedCharge:
439        return internalGetArrayPointer(skippedCharge);
416 –      break;
440  
441      case dslFlucQPosition:
442        return internalGetArrayPointer(flucQPos);
420 –      break;
443  
444      case dslFlucQVelocity:
445        return internalGetArrayPointer(flucQVel);
424 –      break;
446            
447      case dslFlucQForce:
448        return internalGetArrayPointer(flucQFrc);
428 –      break;
449            
450 +    case dslSitePotential:
451 +      return internalGetArrayPointer(sitePotential);
452 +          
453      default:
454        //error message
455        return NULL;
433 –
456      }
457    }    
458  
459    RealType* DataStorage::internalGetArrayPointer(std::vector<Vector3d>& v) {
460 <    if (v.size() == 0) {
460 >    if (v.empty()) {
461        return NULL;
462      } else {
463        return v[0].getArrayPointer();
464      }
465    }
466  
467 <  RealType* DataStorage::internalGetArrayPointer(std::vector<RotMat3x3d>& v) {
468 <    if (v.size() == 0) {
467 >  RealType* DataStorage::internalGetArrayPointer(std::vector<Mat3x3d>& v) {
468 >    if (v.empty()) {
469        return NULL;
470      } else {
471        return v[0].getArrayPointer();
# Line 452 | Line 474 | namespace OpenMD {
474    }
475  
476    RealType* DataStorage::internalGetArrayPointer(std::vector<RealType>& v) {
477 <    if (v.size() == 0) {
477 >    if (v.empty()) {
478        return NULL;
479      } else {
480        return &(v[0]);
# Line 502 | Line 524 | namespace OpenMD {
524      if (layout & dslVelocity) {
525        bytes += sizeof(Vector3d);
526      }
527 +    if (layout & dslForce) {
528 +      bytes += sizeof(Vector3d);
529 +    }
530      if (layout & dslAmat) {
531        bytes += sizeof(RotMat3x3d);    
532      }
533      if (layout & dslAngularMomentum) {
534        bytes += sizeof(Vector3d);
535      }
511 –    if (layout & dslElectroFrame) {
512 –      bytes += sizeof(Mat3x3d);
513 –    }
514 –    if (layout & dslForce) {
515 –      bytes += sizeof(Vector3d);
516 –    }
536      if (layout & dslTorque) {
537        bytes += sizeof(Vector3d);
538      }
# Line 529 | Line 548 | namespace OpenMD {
548      if (layout & dslFunctionalDerivative) {
549        bytes += sizeof(RealType);
550      }
551 +    if (layout & dslDipole) {
552 +      bytes += sizeof(Vector3d);
553 +    }
554 +    if (layout & dslQuadrupole) {
555 +      bytes += sizeof(Mat3x3d);
556 +    }
557      if (layout & dslElectricField) {
558        bytes += sizeof(Vector3d);
559      }
# Line 544 | Line 569 | namespace OpenMD {
569      if (layout & dslFlucQForce) {
570        bytes += sizeof(RealType);
571      }
572 +    if (layout & dslSitePotential) {
573 +      bytes += sizeof(RealType);
574 +    }
575  
576      return bytes;
577    }

Diff Legend

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