ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/branches/no-template-branch/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 669 by chuckv, Thu Aug 7 00:47:33 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 111 | Line 70 | class Atom{ (public)
70  
71    double getMass() const {return c_mass;}
72    void setMass(double mass) {c_mass = mass;}
73 +
74 +  double getEamRcut() const {return myEamRcut;}
75 +  void setEamRcut(double eamRcut) {myEamRcut = eamRcut;}
76    
77    double getSigma() const {return c_sigma;}
78    void setSigma(double sigma) {c_sigma = sigma;}
# Line 122 | Line 84 | class Atom{ (public)
84    void setCovalent(double covalent) {c_covalent = covalent;}
85    
86    int getIndex() const {return index;}
87 <  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 <
87 >  void setIndex(int theIndex);
88    char *getType() {return c_name;}
89    void setType(char * name) {strcpy(c_name,name);}
90    
# Line 165 | Line 108 | class Atom{ (public)
108    void seVDW( void )        { is_VDW = 1; is_LJ = 0; }
109    int isVDW( void )    { return is_VDW; }
110  
111 +  void setEAM( void ) { is_EAM = 1; }
112 +  int  isEAM( void ) { return is_EAM; }
113 +
114    virtual int isDirectional( void ) = 0;
115  
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
116  
117   protected:
118    
# Line 182 | Line 121 | class Atom{ (public)
121    double c_epslon; /* the esplon parameter for VDW interactions */
122    double c_covalent; // The covalent radius of the atom.
123  
124 +  double myEamRcut; // Atom rcut for eam defined by the forcefield.
125 +
126    int index; /* set the atom's index */
127    int offset; // the atom's offset in the storage array
128    int offsetX, offsetY, offsetZ;
# Line 198 | Line 139 | class Atom{ (public)
139    int has_dipole; // dipole boolean
140    int is_VDW;    // VDW boolean
141    int is_LJ;    // LJ boolean
142 +  int is_EAM; //EAM boolean
143  
144   #ifdef IS_MPI
145    int myGlobalIndex;
# Line 205 | Line 147 | class Atom{ (public)
147    
148   };
149  
208 –
209 –
150   class GeneralAtom : public Atom{
151  
152   public:
# Line 233 | Line 173 | class DirectionalAtom : public Atom { (public)
173    }
174    virtual ~DirectionalAtom() {}
175  
176 +  void printAmatIndex( void );
177 +
178    int isDirectional(void) { return 1; }
179    
180    void setSSD( int value) { ssdIdentity = value; }
181    int isSSD(void) {return ssdIdentity; }
182  
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] );
183    
184    void setEuler( double phi, double theta, double psi );
185 +
186 +  double getSUx( void ) { return sux; }
187 +  double getSUy( void ) { return suy; }
188 +  double getSUz( void ) { return suz; }
189    
190    void setSUx( double the_sux ) { sux = the_sux; }
191    void setSUy( double the_suy ) { suy = the_suy; }
192    void setSUz( double the_suz ) { suz = the_suz; }
193  
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 –
194    void zeroForces() {
195      frc[offsetX] = 0.0;
196      frc[offsetY] = 0.0;
# Line 268 | Line 201 | class DirectionalAtom : public Atom { (public)
201      trq[offsetZ] = 0.0;
202    }
203  
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 –
204    void getA( double the_A[3][3] ); // get the full rotation matrix
205 +  void setA( double the_A[3][3] );
206  
285 –  double getSUx( void ) { return sux; }
286 –  double getSUy( void ) { return suy; }
287 –  double getSUz( void ) { return suz; }
288 –
207    void getU( double the_u[3] ); // get the unit vetor
208 +  void updateU( void );
209 +
210    void getQ( double the_q[4] ); // get the quanternions
211 +  void setQ( double the_q[4] );
212  
213 +  void getJ( double theJ[3] );
214 +  void setJ( double theJ[3] );
215 +
216    double getJx( void ) { return jx; }
217    double getJy( void ) { return jy; }
218    double getJz( void ) { return jz; }
219  
220 <  double getTx( void ) { return trq[offsetX];}
221 <  double getTy( void ) { return trq[offsetY]; }
222 <  double getTz( void ) { return trq[offsetZ]; }
220 >  void setJx( double the_jx ) { jx = the_jx; }
221 >  void setJy( double the_jy ) { jy = the_jy; }
222 >  void setJz( double the_jz ) { jz = the_jz; }
223  
224 +  void getTrq( double theT[3] );
225 +  void addTrq( double theT[3] );
226 +
227 +  //  double getTx( void ) { return trq[offsetX];}
228 +  //  double getTy( void ) { return trq[offsetY]; }
229 +  //  double getTz( void ) { return trq[offsetZ]; }
230 +
231 +  void addTx( double the_tx ) { trq[offsetX] += the_tx;}
232 +  void addTy( double the_ty ) { trq[offsetY] += the_ty;}
233 +  void addTz( double the_tz ) { trq[offsetZ] += the_tz;}
234 +
235 +  void setI( double the_I[3][3] );
236 +  void getI( double the_I[3][3] );
237 +  
238    double getIxx( void ) { return Ixx; }
239    double getIxy( void ) { return Ixy; }
240    double getIxz( void ) { return Ixz; }
# Line 308 | Line 246 | class DirectionalAtom : public Atom { (public)
246    double getIzx( void ) { return Izx; }
247    double getIzy( void ) { return Izy; }
248    double getIzz( void ) { return Izz; }
249 +  
250  
251    double getMu( void ) { return mu[index]; }
252    void setMu( double the_mu ) { mu[index] = the_mu; }
253  
254    void lab2Body( double r[3] );
255    void body2Lab( double r[3] );
317 –  void updateU( void );
256  
257 +
258   private:
259    int dIndex;
260  

Diff Legend

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