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 1711 by gezelter, Sat May 19 02:58:35 2012 UTC vs.
Revision 1808 by gezelter, Mon Oct 22 20:42:10 2012 UTC

# 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 157 | 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 164 | Line 172 | namespace OpenMD {
172      if (storageLayout_ & dslAngularMomentum) {
173        internalResize(angularMomentum, newSize);
174      }
167 –
168 –    if (storageLayout_ & dslElectroFrame) {
169 –      internalResize(electroFrame, newSize);
170 –    }
175      
172 –    if (storageLayout_ & dslForce) {
173 –      internalResize(force, newSize);
174 –    }
175 –
176      if (storageLayout_ & dslTorque) {
177        internalResize(torque, newSize);
178      }
# Line 193 | 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 225 | 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 233 | Line 245 | namespace OpenMD {
245        angularMomentum.reserve(size);
246      }
247  
236 –    if (storageLayout_ & dslElectroFrame) {
237 –      electroFrame.reserve(size);
238 –    }
239 –    
240 –    if (storageLayout_ & dslForce) {
241 –      force.reserve(size);
242 –    }
243 –
248      if (storageLayout_ & dslTorque) {
249        torque.reserve(size);
250      }
# Line 261 | 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 295 | 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 303 | Line 319 | namespace OpenMD {
319        internalCopy(angularMomentum, source, num, target);
320      }
321  
306 –    if (storageLayout_ & dslElectroFrame) {
307 –      internalCopy(electroFrame, source, num, target);
308 –    }
309 –    
310 –    if (storageLayout_ & dslForce) {
311 –      internalCopy(force, source, num, target);
312 –    }
313 –
322      if (storageLayout_ & dslTorque) {
323        internalCopy(torque, source, num, target);
324      }
# Line 331 | 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 371 | Line 387 | namespace OpenMD {
387        return internalGetArrayPointer(velocity);
388        break;
389              
390 +    case dslForce:
391 +      return internalGetArrayPointer(force);
392 +      break;            
393 +
394      case dslAmat:
395        return internalGetArrayPointer(aMat);
396        break;            
397              
398      case dslAngularMomentum:
399        return internalGetArrayPointer(angularMomentum);
380 –      break;
381 –            
382 –    case dslElectroFrame:
383 –      return internalGetArrayPointer(electroFrame);
400        break;
401              
386 –    case dslForce:
387 –      return internalGetArrayPointer(force);
388 –      break;            
389 –
402      case dslTorque:
403        return internalGetArrayPointer(torque);
404        break;
# Line 407 | Line 419 | namespace OpenMD {
419        return internalGetArrayPointer(functionalDerivative);
420        break;
421  
422 +    case dslDipole:
423 +      return internalGetArrayPointer(dipole);
424 +      break;
425 +
426 +    case dslQuadrupole:
427 +      return internalGetArrayPointer(quadrupole);
428 +      break;
429 +
430      case dslElectricField:
431        return internalGetArrayPointer(electricField);
432        break;
# Line 442 | Line 462 | namespace OpenMD {
462      }
463    }
464  
465 <  RealType* DataStorage::internalGetArrayPointer(std::vector<RotMat3x3d>& v) {
465 >  RealType* DataStorage::internalGetArrayPointer(std::vector<Mat3x3d>& v) {
466      if (v.size() == 0) {
467        return NULL;
468      } else {
# Line 502 | Line 522 | namespace OpenMD {
522      if (layout & dslVelocity) {
523        bytes += sizeof(Vector3d);
524      }
525 +    if (layout & dslForce) {
526 +      bytes += sizeof(Vector3d);
527 +    }
528      if (layout & dslAmat) {
529        bytes += sizeof(RotMat3x3d);    
530      }
531      if (layout & dslAngularMomentum) {
532        bytes += sizeof(Vector3d);
533      }
511 –    if (layout & dslElectroFrame) {
512 –      bytes += sizeof(Mat3x3d);
513 –    }
514 –    if (layout & dslForce) {
515 –      bytes += sizeof(Vector3d);
516 –    }
534      if (layout & dslTorque) {
535        bytes += sizeof(Vector3d);
536      }
# Line 529 | Line 546 | namespace OpenMD {
546      if (layout & dslFunctionalDerivative) {
547        bytes += sizeof(RealType);
548      }
549 +    if (layout & dslDipole) {
550 +      bytes += sizeof(Vector3d);
551 +    }
552 +    if (layout & dslQuadrupole) {
553 +      bytes += sizeof(Mat3x3d);
554 +    }
555      if (layout & dslElectricField) {
556        bytes += sizeof(Vector3d);
557      }

Diff Legend

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