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

Comparing branches/development/src/brains/DataStorage.hpp (file contents):
Revision 1665 by gezelter, Tue Nov 22 20:38:56 2011 UTC vs.
Revision 1787 by gezelter, Wed Aug 29 18:13:11 2012 UTC

# Line 54 | Line 54
54   #include <math/Vector3.hpp>
55   #include <math/SquareMatrix3.hpp>
56  
57 + using namespace std;
58   namespace OpenMD {
59    /**
60     * @class DataStorage
# Line 68 | Line 69 | namespace OpenMD {
69      enum{
70        dslPosition = 1,
71        dslVelocity = 2,
72 <      dslAmat = 4,
73 <      dslAngularMomentum = 8,
74 <      dslElectroFrame = 16,
75 <      dslZAngle = 32,
76 <      dslForce = 64,
77 <      dslTorque = 128,
78 <      dslParticlePot = 256,
79 <      dslDensity = 512,
80 <      dslFunctional = 1024,
81 <      dslFunctionalDerivative = 2048,
72 >      dslForce = 4,
73 >      dslAmat = 8,
74 >      dslAngularMomentum = 16,
75 >      dslTorque = 32,
76 >      dslParticlePot = 64,
77 >      dslDensity = 128,
78 >      dslFunctional = 256,
79 >      dslFunctionalDerivative = 512,
80 >      dslDipole = 1024,
81 >      dslQuadrupole = 2048,
82        dslElectricField = 4096,
83 <      dslSkippedCharge = 8192
83 >      dslSkippedCharge = 8192,
84 >      dslFlucQPosition = 16384,
85 >      dslFlucQVelocity = 32768,
86 >      dslFlucQForce = 65536
87      };
88  
89      DataStorage();
90 <    DataStorage(int size, int storageLayout = 16383);
90 >    DataStorage(int size, int storageLayout = 0);
91      /** return the size of this DataStorage. */
92      int getSize();
93      /**
# Line 103 | Line 107 | namespace OpenMD {
107      /**
108       * Copies data inside DataStorage class.
109       *
110 <     * Copy function actually call copy for every vector in
110 >     * Copy function actually calls copy for every vector in
111       * DataStorage class.  One Precondition of copy is that
112       * target is not within the range [source, soruce + num]
113       *
114 <     * @param souce
114 >     * @param source
115       * @param num number of element to be moved
116       * @param target
117       */
# Line 119 | Line 123 | namespace OpenMD {
123      /** Returns the pointer of internal array */
124      RealType *getArrayPointer(int whichArray);
125  
126 <    std::vector<Vector3d> position;        /** position array */
127 <    std::vector<Vector3d> velocity;        /** velocity array */
128 <    std::vector<RotMat3x3d> aMat;          /** rotation matrix array */
129 <    std::vector<Vector3d> angularMomentum; /** angular momentum array (body-fixed) */
130 <    std::vector<Mat3x3d> electroFrame;     /** the lab frame unit std::vector array*/
131 <    std::vector<RealType> zAngle;          /** z-angle array */        
132 <    std::vector<Vector3d> force;           /** force array */
133 <    std::vector<Vector3d> torque;          /** torque array */
134 <    std::vector<RealType> particlePot;     /** particle potential arrray */
135 <    std::vector<RealType> density;         /** electron density */
136 <    std::vector<RealType> functional;      /** density functional */
137 <    std::vector<RealType> functionalDerivative; /** derivative of functional */
138 <    std::vector<Vector3d> electricField;   /** local electric field */
139 <    std::vector<RealType> skippedCharge;   /** charge skipped during normal pairwise calculation */
126 >    vector<Vector3d> position;        /** position array */
127 >    vector<Vector3d> velocity;        /** velocity array */
128 >    vector<Vector3d> force;           /** force array */
129 >    vector<RotMat3x3d> aMat;          /** rotation matrix array */
130 >    vector<Vector3d> angularMomentum; /** angular momentum array (body-fixed) */
131 >    vector<Vector3d> torque;          /** torque array */
132 >    vector<RealType> particlePot;     /** particle potential arrray */
133 >    vector<RealType> density;         /** electron density */
134 >    vector<RealType> functional;      /** density functional */
135 >    vector<RealType> functionalDerivative; /** derivative of functional */
136 >    vector<Vector3d> dipole;          /** space-frame dipole vector */
137 >    vector<Mat3x3d>  quadrupole;      /** space-frame quadrupole tensor */
138 >    vector<Vector3d> electricField;   /** local electric field */
139 >    vector<RealType> skippedCharge;   /** charge skipped during normal pairwise calculation */
140 >    vector<RealType> flucQPos;        /** fluctuating charges */
141 >    vector<RealType> flucQVel;        /** fluctuating charge velocities */
142 >    vector<RealType> flucQFrc;        /** fluctuating charge forces */
143  
144      static int getBytesPerStuntDouble(int layout);
145  
146    private:
147  
148 <    RealType* internalGetArrayPointer(std::vector<Vector3d>& v);            
149 <    RealType* internalGetArrayPointer(std::vector<RotMat3x3d>& v);
150 <    RealType* internalGetArrayPointer(std::vector<RealType>& v);
144 <
148 >    RealType* internalGetArrayPointer(vector<Vector3d>& v);
149 >    RealType* internalGetArrayPointer(vector<Mat3x3d>& v);
150 >    RealType* internalGetArrayPointer(vector<RealType>& v);
151              
152      template<typename T>
153      void internalResize(std::vector<T>& v, int newSize);

Diff Legend

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