ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libmdtools/Atom.hpp
(Generate patch)

Comparing:
branches/mmeineke/OOPSE/libmdtools/Atom.hpp (file contents), Revision 377 by mmeineke, Fri Mar 21 17:42:12 2003 UTC vs.
trunk/OOPSE/libmdtools/Atom.hpp (file contents), Revision 611 by gezelter, Tue Jul 15 17:10:50 2003 UTC

# Line 7 | Line 7 | class Atom{ (public)
7  
8   class Atom{
9   public:
10 –  Atom(int theIndex) {
11 –    c_n_hyd = 0;
12 –    has_dipole = 0;
13 –    is_VDW = 0;
14 –    is_LJ = 0;
10  
11 <    index = theIndex;
12 <    offset = 3 * index;
18 <    offsetX = offset;
19 <    offsetY = offset+1;
20 <    offsetZ = offset+2;
11 >  Atom(int theIndex);
12 >  virtual ~Atom() {}
13  
14 <    Axx = index*9;
15 <    Axy = Axx+1;
16 <    Axz = Axx+2;
17 <    
18 <    Ayx = Axx+3;
19 <    Ayy = Axx+4;
20 <    Ayz = Axx+5;
14 >  static double* pos; // the position array
15 >  static double* vel; // the velocity array
16 >  static double* frc; // the forc array
17 >  static double* trq; // the torque vector  ( space fixed )
18 >  static double* Amat; // the rotation matrix
19 >  static double* mu; // the dipole moment array
20 >  static double* ul; // the lab frame unit directional vector
21 >  static int nElements;
22  
23 <    Azx = Axx+6;
24 <    Azy = Axx+7;
25 <    Azz = Axx+8;
26 <  }
27 <  virtual ~Atom() {}
23 >  static void createArrays (int the_nElements);
24 >  static void destroyArrays(void);
25 >  void addAtoms(int nAdded, double* Apos, double* Avel, double* Afrc,
26 >                double* Atrq, double* AAmat, double* Amu,
27 >                double* Aul);
28 >  void deleteAtom(int theIndex);
29 >  void deleteRange(int startIndex, int stopIndex);
30  
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 –
31    static double* getPosArray( void ) { return pos; }
32    static double* getVelArray( void ) { return vel; }
33    static double* getFrcArray( void ) { return frc; }
# Line 87 | Line 36 | class Atom{ (public)
36    static double* getMuArray( void ) { return mu; }
37    static double* getUlArray( void ) { return ul; }
38    
39 +  void getPos( double theP[3] );
40 +  void setPos( double theP[3] );
41 +
42    double getX() const {return pos[offsetX];}
43    double getY() const {return pos[offsetY];}
44    double getZ() const {return pos[offsetZ];}
# Line 94 | Line 46 | class Atom{ (public)
46    void setY(double y) {pos[offsetY] = y;}
47    void setZ(double z) {pos[offsetZ] = z;}
48    
49 +  void getVel( double theV[3] );
50 +  void setVel( double theV[3] );
51 +
52    double get_vx() const  {return vel[offsetX];}
53    double get_vy() const  {return vel[offsetY];}
54    double get_vz() const  {return vel[offsetZ];}
# Line 101 | Line 56 | class Atom{ (public)
56    void set_vy(double vy) {vel[offsetY] = vy;}
57    void set_vz(double vz) {vel[offsetZ] = vz;}
58    
59 +
60 +  void getFrc( double theF[3] );
61 +  void addFrc( double theF[3] );
62 +
63    double getFx() const   {return frc[offsetX];}
64    double getFy() const   {return frc[offsetY];}
65    double getFz() const   {return frc[offsetZ];}
# Line 122 | Line 81 | class Atom{ (public)
81    void setCovalent(double covalent) {c_covalent = covalent;}
82    
83    int getIndex() const {return index;}
84 <  void setIndex(int theIndex) {
126 <    index = theIndex;
127 <    offset = index*3;
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 <
84 >  void setIndex(int theIndex);
85    char *getType() {return c_name;}
86    void setType(char * name) {strcpy(c_name,name);}
87    
# Line 167 | Line 107 | class Atom{ (public)
107  
108    virtual int isDirectional( void ) = 0;
109  
170 –  static double* pos; // the position array
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
110  
111   protected:
112    
# Line 205 | Line 138 | class Atom{ (public)
138    
139   };
140  
208 –
209 –
141   class GeneralAtom : public Atom{
142  
143   public:
# Line 233 | Line 164 | class DirectionalAtom : public Atom { (public)
164    }
165    virtual ~DirectionalAtom() {}
166  
167 +  void printAmatIndex( void );
168 +
169    int isDirectional(void) { return 1; }
170    
171    void setSSD( int value) { ssdIdentity = value; }
172    int isSSD(void) {return ssdIdentity; }
173  
241 –  void setA( double the_A[3][3] );
242 –
243 –  void setI( double the_I[3][3] );
244 –
245 –  void setQ( double the_q[4] );
174    
175    void setEuler( double phi, double theta, double psi );
176 +
177 +  double getSUx( void ) { return sux; }
178 +  double getSUy( void ) { return suy; }
179 +  double getSUz( void ) { return suz; }
180    
181    void setSUx( double the_sux ) { sux = the_sux; }
182    void setSUy( double the_suy ) { suy = the_suy; }
183    void setSUz( double the_suz ) { suz = the_suz; }
184  
253 –  void setJx( double the_jx ) { jx = the_jx; }
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;}
258 –  void addTy( double the_ty ) { trq[offsetY] += the_ty;}
259 –  void addTz( double the_tz ) { trq[offsetZ] += the_tz;}
260 –
185    void zeroForces() {
186      frc[offsetX] = 0.0;
187      frc[offsetY] = 0.0;
# Line 268 | Line 192 | class DirectionalAtom : public Atom { (public)
192      trq[offsetZ] = 0.0;
193    }
194  
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 Amat[Ayx]; }
276 –  double getAyy( void ) { return Amat[Ayy]; }
277 –  double getAyz( void ) { return Amat[Ayz]; }
278 –  
279 –  double getAzx( void ) { return Amat[Azx]; }
280 –  double getAzy( void ) { return Amat[Azy]; }
281 –  double getAzz( void ) { return Amat[Azz]; }
282 –
195    void getA( double the_A[3][3] ); // get the full rotation matrix
196 +  void setA( double the_A[3][3] );
197  
285 –  double getSUx( void ) { return sux; }
286 –  double getSUy( void ) { return suy; }
287 –  double getSUz( void ) { return suz; }
288 –
198    void getU( double the_u[3] ); // get the unit vetor
199 +  void updateU( void );
200 +
201    void getQ( double the_q[4] ); // get the quanternions
202 +  void setQ( double the_q[4] );
203  
204 +  void getJ( double theJ[3] );
205 +  void setJ( double theJ[3] );
206 +
207    double getJx( void ) { return jx; }
208    double getJy( void ) { return jy; }
209    double getJz( void ) { return jz; }
210  
211 <  double getTx( void ) { return trq[offsetX];}
212 <  double getTy( void ) { return trq[offsetY]; }
213 <  double getTz( void ) { return trq[offsetZ]; }
211 >  void setJx( double the_jx ) { jx = the_jx; }
212 >  void setJy( double the_jy ) { jy = the_jy; }
213 >  void setJz( double the_jz ) { jz = the_jz; }
214  
215 +  void getTrq( double theT[3] );
216 +  void addTrq( double theT[3] );
217 +
218 +  //  double getTx( void ) { return trq[offsetX];}
219 +  //  double getTy( void ) { return trq[offsetY]; }
220 +  //  double getTz( void ) { return trq[offsetZ]; }
221 +
222 +  void addTx( double the_tx ) { trq[offsetX] += the_tx;}
223 +  void addTy( double the_ty ) { trq[offsetY] += the_ty;}
224 +  void addTz( double the_tz ) { trq[offsetZ] += the_tz;}
225 +
226 +  void setI( double the_I[3][3] );
227 +  void getI( double the_I[3][3] );
228 +  
229    double getIxx( void ) { return Ixx; }
230    double getIxy( void ) { return Ixy; }
231    double getIxz( void ) { return Ixz; }
# Line 308 | Line 237 | class DirectionalAtom : public Atom { (public)
237    double getIzx( void ) { return Izx; }
238    double getIzy( void ) { return Izy; }
239    double getIzz( void ) { return Izz; }
240 +  
241  
242    double getMu( void ) { return mu[index]; }
243    void setMu( double the_mu ) { mu[index] = the_mu; }
244  
245    void lab2Body( double r[3] );
246    void body2Lab( double r[3] );
317 –  void updateU( void );
247  
248 +
249   private:
250    int dIndex;
251  

Diff Legend

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