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

Comparing trunk/OOPSE/libmdtools/Atom.cpp (file contents):
Revision 599 by mmeineke, Mon Jul 14 21:48:43 2003 UTC vs.
Revision 999 by chrisfen, Fri Jan 30 15:01:09 2004 UTC

# Line 2 | Line 2 | using namespace std;
2  
3   using namespace std;
4  
5 + #include "simError.h"
6   #include "Atom.hpp"
7  
8 < double* Atom::pos; // the position array
9 < double* Atom::vel; // the velocity array
10 < double* Atom::frc; // the forc array
11 < double* Atom::trq; // the torque vector  ( space fixed )
11 < double* Atom::Amat; // the rotation matrix
12 < double* Atom::mu;   // the array of dipole moments
13 < double* Atom::ul;   // the lab frame unit directional vector
14 < int Atom::nElements;
8 > Atom::Atom(int theIndex, SimState* theConfig) {
9 >  
10 >  myConfig = theConfig;
11 >  hasCoords = false;
12  
16 – Atom::Atom(int theIndex) {
13    c_n_hyd = 0;
14    has_dipole = 0;
15    is_VDW = 0;
16    is_LJ = 0;
17 +  is_charged = 0;
18    
19    index = theIndex;
20 <  offset = 3 * index;
20 >  offset = 0;
21    offsetX = offset;
22    offsetY = offset+1;
23    offsetZ = offset+2;
24    
25 <  Axx = index*9;
25 >  Axx = 0;
26    Axy = Axx+1;
27    Axz = Axx+2;
28    
# Line 38 | Line 35 | void Atom::createArrays (int the_nElements) {
35    Azz = Axx+8;
36   }
37  
41 – void Atom::createArrays (int the_nElements) {
42 –  int i;
43 –  
44 –  nElements = the_nElements;
45 –
46 –  pos = new double[nElements*3];
47 –  vel = new double[nElements*3];
48 –  frc = new double[nElements*3];
49 –  trq = new double[nElements*3];
50 –  Amat = new double[nElements*9];
51 –  mu = new double[nElements];
52 –  ul = new double[nElements*3];
53 –  
54 –  // init directional values to zero
55 –  
56 –  for( i=0; i<nElements; i++){
57 –    trq[i] = 0.0;
58 –    trq[i+1] = 0.0;
59 –    trq[i+2] = 0.0;
60 –    
61 –    Amat[i] = 1.0;
62 –    Amat[i+1] = 0.0;
63 –    Amat[i+2] = 0.0;
64 –    
65 –    Amat[i+3] = 0.0;
66 –    Amat[i+4] = 1.0;
67 –    Amat[i+5] = 0.0;
68 –    
69 –    Amat[i+6] = 0.0;
70 –    Amat[i+7] = 0.0;
71 –    Amat[i+8] = 1.0;
72 –    
73 –    mu[i] = 0.0;    
74 –    
75 –    ul[i] = 1.0;
76 –    ul[i+1] = 0.0;
77 –    ul[i+2] = 0.0;
78 –  }
79 – }
80 –
81 – void Atom::destroyArrays(void) {
82 –  delete[] pos;
83 –  delete[] vel;
84 –  delete[] frc;
85 –  delete[] trq;
86 –  delete[] Amat;
87 –  delete[] mu;
88 – }
89 –
38   void Atom::setIndex(int theIndex) {
39    index = theIndex;
92 –  offset = index*3;
93 –  offsetX = offset;
94 –  offsetY = offset+1;
95 –  offsetZ = offset+2;
96 –  
97 –  Axx = index*9;
98 –  Axy = Axx+1;
99 –  Axz = Axx+2;
100 –  
101 –  Ayx = Axx+3;
102 –  Ayy = Axx+4;
103 –  Ayz = Axx+5;
104 –  
105 –  Azx = Axx+6;
106 –  Azy = Axx+7;
107 –  Azz = Axx+8;
40   }
41  
42 < void Atom::addAtoms(int nAdded, double* Apos, double* Avel, double* Afrc,
111 <                   double* Atrq, double* AAmat, double* Amu,
112 <                   double* Aul) {
42 > void Atom::setCoords(void){
43  
44 <  int nNew = nElements+nAdded;
44 >  if( myConfig->isAllocated() ){
45  
116 –  double* new_pos = new double[nNew*3];
117 –  double* new_vel = new double[nNew*3];
118 –  double* new_frc = new double[nNew*3];
119 –  double* new_trq = new double[nNew*3];
120 –  double* new_Amat = new double[nNew*9];
121 –  double* new_mu = new double[nNew];
122 –  double* new_ul = new double[nNew*3];
123 –  int i, j;
124 –  
125 –  for (i = 0; i < 3*nElements; i++) {
126 –    new_pos[i] = pos[i];
127 –    new_vel[i] = vel[i];
128 –    new_frc[i] = frc[i];
129 –    new_trq[i] = trq[i];
130 –    new_ul[i] = ul[i];
131 –  }
46  
47 <  for(i = 0; i < 3*nAdded; i++) {
48 <    j = i + 3*nElements;
49 <    new_pos[j] = Apos[i];
50 <    new_vel[j] = Avel[i];
51 <    new_frc[j] = Afrc[i];
52 <    new_trq[j] = Atrq[i];
53 <    new_ul[j] = Aul[i];
47 >    myConfig->getAtomPointers( index,
48 >                     &pos,
49 >                     &vel,
50 >                     &frc,
51 >                     &trq,
52 >                     &Amat,
53 >                     &mu,  
54 >                     &ul );
55    }
56 <
57 <  for (i = 0; i < 9*nElements; i++) {
58 <    new_Amat[i] = Amat[i];
56 >  else{
57 >    sprintf( painCave.errMsg,
58 >             "Attempted to set Atom %d  coordinates with an unallocated "
59 >             "SimState object.\n", index );
60 >    painCave.isFatal = 1;
61 >    simError();
62    }
63  
64 <  for(i = 0; i < 9*nAdded; i++) {
147 <    j = i + 9*nElements;
148 <    new_Amat[j] = AAmat[i];
149 <  }
64 >  hasCoords = true;
65  
151 –  for (i = 0; i < nElements; i++) {
152 –    new_mu[i] = mu[i];
153 –  }
154 –
155 –  for(i = 0; i < nAdded; i++) {
156 –    j = i + nElements;
157 –    new_mu[j] = Amu[i];
158 –  }
159 –
160 –  delete[] pos;
161 –  delete[] vel;
162 –  delete[] frc;
163 –  delete[] trq;
164 –  delete[] Amat;
165 –  delete[] mu;
166 –
167 –  pos = new_pos;
168 –  vel = new_vel;
169 –  frc = new_frc;
170 –  trq = new_trq;
171 –  ul = new_ul;
172 –  Amat = new_Amat;
173 –  mu = new_mu;
174 –
175 –  nElements = nNew;
66   }
67  
68 < void Atom::deleteAtom(int theIndex) {
69 <  deleteRange(theIndex, theIndex);
70 < }
68 > // void Atom::addAtoms(int nAdded, double* Apos, double* Avel, double* Afrc,
69 > //                    double* Atrq, double* AAmat, double* Amu,
70 > //                    double* Aul) {
71  
72 < void Atom::deleteRange(int startIndex, int stopIndex) {
183 <
184 <  int nNew = nElements-(stopIndex-startIndex+1);
72 > //   int nNew = nElements+nAdded;
73  
74 <  double* new_pos = new double[nNew*3];
75 <  double* new_vel = new double[nNew*3];
76 <  double* new_frc = new double[nNew*3];
77 <  double* new_trq = new double[nNew*3];
78 <  double* new_Amat = new double[nNew*9];
79 <  double* new_mu = new double[nNew];
80 <  double* new_ul = new double[nNew*3];
81 <  int i, j;
74 > //   double* new_pos = new double[nNew*3];
75 > //   double* new_vel = new double[nNew*3];
76 > //   double* new_frc = new double[nNew*3];
77 > //   double* new_trq = new double[nNew*3];
78 > //   double* new_Amat = new double[nNew*9];
79 > //   double* new_mu = new double[nNew];
80 > //   double* new_ul = new double[nNew*3];
81 > //   int i, j;
82    
83 <  for (i = 0; i < 3*startIndex; i++) {
84 <    new_pos[i] = pos[i];
85 <    new_vel[i] = vel[i];
86 <    new_frc[i] = frc[i];
87 <    new_trq[i] = trq[i];
88 <    new_ul[i] = ul[i];
89 <  }
83 > //   for (i = 0; i < 3*nElements; i++) {
84 > //     new_pos[i] = pos[i];
85 > //     new_vel[i] = vel[i];
86 > //     new_frc[i] = frc[i];
87 > //     new_trq[i] = trq[i];
88 > //     new_ul[i] = ul[i];
89 > //   }
90  
91 <  for(i = 3*(stopIndex + 1); i < 3*nElements; i++) {
92 <    j = i - 3*startIndex + 1;
93 <    new_pos[j] = pos[i];
94 <    new_vel[j] = vel[i];
95 <    new_frc[j] = frc[i];
96 <    new_trq[j] = trq[i];
97 <    new_ul[j] = ul[i];
98 <  }
91 > //   for(i = 0; i < 3*nAdded; i++) {
92 > //     j = i + 3*nElements;
93 > //     new_pos[j] = Apos[i];
94 > //     new_vel[j] = Avel[i];
95 > //     new_frc[j] = Afrc[i];
96 > //     new_trq[j] = Atrq[i];
97 > //     new_ul[j] = Aul[i];
98 > //   }
99  
100 <  for (i = 0; i < 9*startIndex; i++) {
101 <    new_Amat[i] = Amat[i];
102 <  }
100 > //   for (i = 0; i < 9*nElements; i++) {
101 > //     new_Amat[i] = Amat[i];
102 > //   }
103  
104 <  for(i = 9*(stopIndex + 1); i < 9*nElements; i++) {
105 <    j = i - 9*startIndex + 1;
106 <    new_Amat[j] = Amat[i];
107 <  }
104 > //   for(i = 0; i < 9*nAdded; i++) {
105 > //     j = i + 9*nElements;
106 > //     new_Amat[j] = AAmat[i];
107 > //   }
108  
109 <  for (i = 0; i < startIndex; i++) {
110 <    new_mu[i] = mu[i];
111 <  }
109 > //   for (i = 0; i < nElements; i++) {
110 > //     new_mu[i] = mu[i];
111 > //   }
112  
113 <  for(i = (stopIndex+1); i < nElements; i++) {
114 <    j = i - startIndex + 1;
115 <    new_mu[j] = mu[i];
116 <  }
113 > //   for(i = 0; i < nAdded; i++) {
114 > //     j = i + nElements;
115 > //     new_mu[j] = Amu[i];
116 > //   }
117  
118 <  delete[] pos;
119 <  delete[] vel;
120 <  delete[] frc;
121 <  delete[] trq;
122 <  delete[] Amat;
123 <  delete[] mu;
118 > //   delete[] pos;
119 > //   delete[] vel;
120 > //   delete[] frc;
121 > //   delete[] trq;
122 > //   delete[] Amat;
123 > //   delete[] mu;
124  
125 <  pos = new_pos;
126 <  vel = new_vel;
127 <  frc = new_frc;
128 <  trq = new_trq;
129 <  ul = new_ul;
130 <  Amat = new_Amat;
131 <  mu = new_mu;
125 > //   pos = new_pos;
126 > //   vel = new_vel;
127 > //   frc = new_frc;
128 > //   trq = new_trq;
129 > //   ul = new_ul;
130 > //   Amat = new_Amat;
131 > //   mu = new_mu;
132  
133 <  nElements = nNew;
134 < }
133 > //   nElements = nNew;
134 > // }
135  
136 + // void Atom::deleteAtom(int theIndex) {
137 + //   deleteRange(theIndex, theIndex);
138 + // }
139  
140 + // void Atom::deleteRange(int startIndex, int stopIndex) {
141 +
142 + //   int nNew = nElements-(stopIndex-startIndex+1);
143 +
144 + //   double* new_pos = new double[nNew*3];
145 + //   double* new_vel = new double[nNew*3];
146 + //   double* new_frc = new double[nNew*3];
147 + //   double* new_trq = new double[nNew*3];
148 + //   double* new_Amat = new double[nNew*9];
149 + //   double* new_mu = new double[nNew];
150 + //   double* new_ul = new double[nNew*3];
151 + //   int i, j;
152 +  
153 + //   for (i = 0; i < 3*startIndex; i++) {
154 + //     new_pos[i] = pos[i];
155 + //     new_vel[i] = vel[i];
156 + //     new_frc[i] = frc[i];
157 + //     new_trq[i] = trq[i];
158 + //     new_ul[i] = ul[i];
159 + //   }
160 +
161 + //   for(i = 3*(stopIndex + 1); i < 3*nElements; i++) {
162 + //     j = i - 3*startIndex + 1;
163 + //     new_pos[j] = pos[i];
164 + //     new_vel[j] = vel[i];
165 + //     new_frc[j] = frc[i];
166 + //     new_trq[j] = trq[i];
167 + //     new_ul[j] = ul[i];
168 + //   }
169 +
170 + //   for (i = 0; i < 9*startIndex; i++) {
171 + //     new_Amat[i] = Amat[i];
172 + //   }
173 +
174 + //   for(i = 9*(stopIndex + 1); i < 9*nElements; i++) {
175 + //     j = i - 9*startIndex + 1;
176 + //     new_Amat[j] = Amat[i];
177 + //   }
178 +
179 + //   for (i = 0; i < startIndex; i++) {
180 + //     new_mu[i] = mu[i];
181 + //   }
182 +
183 + //   for(i = (stopIndex+1); i < nElements; i++) {
184 + //     j = i - startIndex + 1;
185 + //     new_mu[j] = mu[i];
186 + //   }
187 +
188 + //   delete[] pos;
189 + //   delete[] vel;
190 + //   delete[] frc;
191 + //   delete[] trq;
192 + //   delete[] Amat;
193 + //   delete[] mu;
194 +
195 + //   pos = new_pos;
196 + //   vel = new_vel;
197 + //   frc = new_frc;
198 + //   trq = new_trq;
199 + //   ul = new_ul;
200 + //   Amat = new_Amat;
201 + //   mu = new_mu;
202 +
203 + //   nElements = nNew;
204 + // }
205 +
206 +
207   void Atom::getPos( double theP[3] ){
208    
209 <  theP[0] = pos[offsetX];
210 <  theP[1] = pos[offsetY];
211 <  theP[2] = pos[offsetZ];
209 >  if( hasCoords ){
210 >    theP[0] = pos[offsetX];
211 >    theP[1] = pos[offsetY];
212 >    theP[2] = pos[offsetZ];
213 >  }
214 >  else{
215 >
216 >    sprintf( painCave.errMsg,
217 >             "Attempt to get Pos for atom %d before coords set.\n",
218 >             index );
219 >    painCave.isFatal = 1;
220 >    simError();
221 >  }
222   }
223  
224   void Atom::setPos( double theP[3] ){
225    
226 <  pos[offsetX] = theP[0];
227 <  pos[offsetY] = theP[1];
228 <  pos[offsetZ] = theP[2];
226 >  if( hasCoords ){
227 >    pos[offsetX] = theP[0];
228 >    pos[offsetY] = theP[1];
229 >    pos[offsetZ] = theP[2];
230 >  }
231 >  else{
232 >
233 >    sprintf( painCave.errMsg,
234 >             "Attempt to set Pos for atom %d before coords set.\n",
235 >             index );
236 >    painCave.isFatal = 1;
237 >    simError();
238 >  }
239   }
240  
241   void Atom::getVel( double theV[3] ){
242    
243 <  theV[0] = vel[offsetX];
244 <  theV[1] = vel[offsetY];
245 <  theV[2] = vel[offsetZ];
243 >  if( hasCoords ){
244 >    theV[0] = vel[offsetX];
245 >    theV[1] = vel[offsetY];
246 >    theV[2] = vel[offsetZ];
247 >  }
248 >  else{
249 >    
250 >    sprintf( painCave.errMsg,
251 >             "Attempt to get vel for atom %d before coords set.\n",
252 >             index );
253 >    painCave.isFatal = 1;
254 >    simError();
255 >  }
256 >
257   }
258  
259   void Atom::setVel( double theV[3] ){
260    
261 <  vel[offsetX] = theV[0];
262 <  vel[offsetY] = theV[1];
263 <  vel[offsetZ] = theV[2];
261 >  if( hasCoords ){
262 >    vel[offsetX] = theV[0];
263 >    vel[offsetY] = theV[1];
264 >    vel[offsetZ] = theV[2];
265 >  }
266 >  else{
267 >    
268 >    sprintf( painCave.errMsg,
269 >             "Attempt to set vel for atom %d before coords set.\n",
270 >             index );
271 >    painCave.isFatal = 1;
272 >    simError();
273 >  }
274   }
275  
276   void Atom::getFrc( double theF[3] ){
277    
278 <  theF[0] = frc[offsetX];
279 <  theF[1] = frc[offsetY];
280 <  theF[2] = frc[offsetZ];
278 >  if( hasCoords ){
279 >    theF[0] = frc[offsetX];
280 >    theF[1] = frc[offsetY];
281 >    theF[2] = frc[offsetZ];
282 >  }
283 >  else{
284 >    
285 >    sprintf( painCave.errMsg,
286 >             "Attempt to get frc for atom %d before coords set.\n",
287 >             index );
288 >    painCave.isFatal = 1;
289 >    simError();
290 >  }
291   }
292  
293   void Atom::addFrc( double theF[3] ){
294    
295 <  frc[offsetX] += theF[0];
296 <  frc[offsetY] += theF[1];
297 <  frc[offsetZ] += theF[2];
295 >  if( hasCoords ){
296 >    frc[offsetX] += theF[0];
297 >    frc[offsetY] += theF[1];
298 >    frc[offsetZ] += theF[2];
299 >  }
300 >  else{
301 >    
302 >    sprintf( painCave.errMsg,
303 >             "Attempt to add frc for atom %d before coords set.\n",
304 >             index );
305 >    painCave.isFatal = 1;
306 >    simError();
307 >  }
308   }
309 +
310 +
311 + void GeneralAtom::zeroForces( void ){
312 +  
313 +  
314 +  if( hasCoords ){
315 +    frc[offsetX] = 0.0;
316 +    frc[offsetY] = 0.0;
317 +    frc[offsetZ] = 0.0;
318 +  }
319 +  else{
320 +    
321 +    sprintf( painCave.errMsg,
322 +             "Attempt to zero frc for atom %d before coords set.\n",
323 +             index );
324 +    painCave.isFatal = 1;
325 +    simError();
326 +  }
327 + }

Diff Legend

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