ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE_old/src/mdtools/libmdCode/Atom.hpp
(Generate patch)

Comparing trunk/OOPSE_old/src/mdtools/libmdCode/Atom.hpp (file contents):
Revision 270 by mmeineke, Fri Feb 14 17:08:46 2003 UTC vs.
Revision 370 by mmeineke, Thu Mar 20 17:10:43 2003 UTC

# Line 2 | Line 2
2   #define _ATOM_H_
3  
4   #include <cstring>
5 + #include <cstdlib>
6   #include <iostream>
7  
8   class Atom{
# Line 11 | Line 12 | class Atom{ (public)
12      has_dipole = 0;
13      is_VDW = 0;
14      is_LJ = 0;
15 +
16      index = theIndex;
17      offset = 3 * index;
18      offsetX = offset;
19      offsetY = offset+1;
20      offsetZ = offset+2;
21 +
22 +    Axx = index*9;
23 +    Axy = Axx+1;
24 +    Axz = Axx+2;
25 +    
26 +    Ayx = Axx+3;
27 +    Ayy = Axx+4;
28 +    Ayz = Axx+5;
29 +
30 +    Azx = Axx+6;
31 +    Azy = Axx+7;
32 +    Azz = Axx+8;
33    }
34    virtual ~Atom() {}
35  
36    static void createArrays (int nElements) {
37 +    int i;
38 +    
39      pos = new double[nElements*3];
40      vel = new double[nElements*3];
41      frc = new double[nElements*3];
42      trq = new double[nElements*3];
43 +    Amat = new double[nElements*9];
44 +    mu = new double[nElements];
45 +    ul = new double[nElements*3];
46 +
47 +    // init directional values to zero
48 +    
49 +    for( i=0; i<nElements; i++){
50 +      trq[i] = 0.0;
51 +      trq[i+1] = 0.0;
52 +      trq[i+2] = 0.0;
53 +      
54 +      Amat[i] = 1.0;
55 +      Amat[i+1] = 0.0;
56 +      Amat[i+2] = 0.0;
57 +      
58 +      Amat[i+3] = 0.0;
59 +      Amat[i+4] = 1.0;
60 +      Amat[i+5] = 0.0;
61 +      
62 +      Amat[i+6] = 0.0;
63 +      Amat[i+7] = 0.0;
64 +      Amat[i+8] = 1.0;
65 +      
66 +      mu[i] = 0.0;    
67 +      
68 +      ul[i] = 0.0;
69 +      ul[i+1] = 0.0;
70 +      ul[i+2] = 0.0;
71 +    }
72    }
73    static void destroyArrays(void) {
74      delete[] pos;
75      delete[] vel;
76      delete[] frc;
77      delete[] trq;
78 +    delete[] Amat;
79 +    delete[] mu;
80    }
81  
82    static double* getPosArray( void ) { return pos; }
83    static double* getVelArray( void ) { return vel; }
84    static double* getFrcArray( void ) { return frc; }
85    static double* getTrqArray( void ) { return trq; }
86 +  static double* getAmatArray( void ) { return Amat; }
87 +  static double* getMuArray( void ) { return mu; }
88 +  static double* getUlArray( void ) { return ul; }
89    
40 –  
90    double getX() const {return pos[offsetX];}
91    double getY() const {return pos[offsetY];}
92    double getZ() const {return pos[offsetZ];}
# Line 48 | Line 97 | class Atom{ (public)
97    double get_vx() const  {return vel[offsetX];}
98    double get_vy() const  {return vel[offsetY];}
99    double get_vz() const  {return vel[offsetZ];}
100 <  void set_vx(double vx) {vel[offsetX]   = vx;}
100 >  void set_vx(double vx) {vel[offsetX] = vx;}
101    void set_vy(double vy) {vel[offsetY] = vy;}
102    void set_vz(double vz) {vel[offsetZ] = vz;}
103    
104    double getFx() const   {return frc[offsetX];}
105    double getFy() const   {return frc[offsetY];}
106    double getFz() const   {return frc[offsetZ];}
107 <  void addFx(double add) {frc[offsetX]   += add;}
107 >  void addFx(double add) {frc[offsetX] += add;}
108    void addFy(double add) {frc[offsetY] += add;}
109    void addFz(double add) {frc[offsetZ] += add;}
110    virtual void zeroForces() = 0;
# Line 79 | Line 128 | class Atom{ (public)
128      offsetX = offset;
129      offsetY = offset+1;
130      offsetZ = offset+2;
131 +
132 +    Axx = index*9;
133 +    Axy = Axx+1;
134 +    Axz = Axx+2;
135 +    
136 +    Ayx = Axx+3;
137 +    Ayy = Axx+4;
138 +    Ayz = Axx+5;
139 +
140 +    Azx = Axx+6;
141 +    Azy = Axx+7;
142 +    Azz = Axx+8;
143    }
144  
145    char *getType() {return c_name;}
# Line 110 | Line 171 | class Atom{ (public)
171    static double* vel; // the velocity array
172    static double* frc; // the forc array
173    static double* trq; // the torque vector  ( space fixed )
174 +  static double* Amat; // the rotation matrix
175 +  static double* mu; // the dipole moment array
176 +  static double* ul; // the lab frame unit directional vector
177  
178   protected:
179    
# Line 122 | Line 186 | class Atom{ (public)
186    int offset; // the atom's offset in the storage array
187    int offsetX, offsetY, offsetZ;
188  
189 +  int Axx, Axy, Axz; // the rotational matrix indices
190 +  int Ayx, Ayy, Ayz;
191 +  int Azx, Azy, Azz;
192 +
193    char c_name[100]; /* it's name */
194    int ident;  // it's unique numeric identity.
195  
# Line 147 | Line 215 | class GeneralAtom : public Atom{ (public)
215  
216    int isDirectional( void ){ return 0; }
217    void zeroForces() {
218 <    frc[offsetX]   = 0.0;
218 >    frc[offsetX] = 0.0;
219      frc[offsetY] = 0.0;
220      frc[offsetZ] = 0.0;
221    }
# Line 159 | Line 227 | class DirectionalAtom : public Atom { (public)
227    DirectionalAtom(int theIndex) : Atom(theIndex)
228    {
229      ssdIdentity = 0;
230 +    sux = 0.0;
231 +    suy = 0.0;
232 +    suz = 0.0;
233    }
234    virtual ~DirectionalAtom() {}
235  
165 –  static void createDArrays(int nElements){
166 –    trq = new double[nElements*3];
167 –  }
168 –  static void destroyDArrays(void){
169 –    delete[] trq;
170 –  }
171 –
236    int isDirectional(void) { return 1; }
237    
238    void setSSD( int value) { ssdIdentity = value; }
# Line 190 | Line 254 | class DirectionalAtom : public Atom { (public)
254    void setJy( double the_jy ) { jy = the_jy; }
255    void setJz( double the_jz ) { jz = the_jz; }
256      
257 <  void addTx( double the_tx ) { trq[offsetX]   += the_tx;}
257 >  void addTx( double the_tx ) { trq[offsetX] += the_tx;}
258    void addTy( double the_ty ) { trq[offsetY] += the_ty;}
259    void addTz( double the_tz ) { trq[offsetZ] += the_tz;}
260  
197 –  void setMu( double the_mu ) { mu = the_mu; }
198 –
261    void zeroForces() {
262 <    frc[offsetX]   = 0.0;
262 >    frc[offsetX] = 0.0;
263      frc[offsetY] = 0.0;
264      frc[offsetZ] = 0.0;
265  
266 <    trq[offsetX]   = 0.0;
266 >    trq[offsetX] = 0.0;
267      trq[offsetY] = 0.0;
268      trq[offsetZ] = 0.0;
269    }
270  
271 <  double getAxx( void ) { return Axx; }
272 <  double getAxy( void ) { return Axy; }
273 <  double getAxz( void ) { return Axz; }
271 >  double getAxx( void ) { return Amat[Axx]; }
272 >  double getAxy( void ) { return Amat[Axy]; }
273 >  double getAxz( void ) { return Amat[Axz]; }
274    
275 <  double getAyx( void ) { return Ayx; }
276 <  double getAyy( void ) { return Ayy; }
277 <  double getAyz( void ) { return Ayz; }
275 >  double getAyx( void ) { return Amat[Ayx]; }
276 >  double getAyy( void ) { return Amat[Ayy]; }
277 >  double getAyz( void ) { return Amat[Ayz]; }
278    
279 <  double getAzx( void ) { return Azx; }
280 <  double getAzy( void ) { return Azy; }
281 <  double getAzz( void ) { return Azz; }
279 >  double getAzx( void ) { return Amat[Azx]; }
280 >  double getAzy( void ) { return Amat[Azy]; }
281 >  double getAzz( void ) { return Amat[Azz]; }
282  
283    void getA( double the_A[3][3] ); // get the full rotation matrix
284  
# Line 224 | Line 286 | class DirectionalAtom : public Atom { (public)
286    double getSUy( void ) { return suy; }
287    double getSUz( void ) { return suz; }
288  
289 <  void getU( double the_u[3] ); // get the unit vector
289 >  void getU( double the_u[3] ); // get the unit vetor
290    void getQ( double the_q[4] ); // get the quanternions
291  
292    double getJx( void ) { return jx; }
# Line 247 | Line 309 | class DirectionalAtom : public Atom { (public)
309    double getIzy( void ) { return Izy; }
310    double getIzz( void ) { return Izz; }
311  
312 <  double getMu( void ) { return mu; }
312 >  double getMu( void ) { return mu[index]; }
313 >  void setMu( double the_mu ) { mu[index] = the_mu; }
314  
315    void lab2Body( double r[3] );
316    void body2Lab( double r[3] );
317 +  void updateU( void );
318  
319   private:
320    int dIndex;
321  
258 –  double Axx, Axy, Axz; // the rotational matrix
259 –  double Ayx, Ayy, Ayz;
260 –  double Azx, Azy, Azz;
261 –
322    double sux, suy, suz; // the standard unit vector    ( body fixed )
323    double jx, jy, jz;    // the angular momentum vector ( body fixed )
324    
# Line 266 | Line 326 | class DirectionalAtom : public Atom { (public)
326    double Iyx, Iyy, Iyz;
327    double Izx, Izy, Izz;
328  
269 –  double mu; // the magnitude of the dipole moment
270 –  
329    int ssdIdentity; // boolean of whether atom is ssd
330  
331   };

Diff Legend

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