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 1097 by gezelter, Mon Apr 12 20:32:20 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
8 < double* Atom::vel; // the velocity array
9 < double* Atom::frc; // the forc array
10 < 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 < Atom::Atom(int theIndex) {
11 <  c_n_hyd = 0;
10 >  objType = OT_ATOM;
11 >  myConfig = theConfig;
12 >  hasCoords = false;
13 >
14    has_dipole = 0;
19 –  is_VDW = 0;
20 –  is_LJ = 0;
15    
16    index = theIndex;
17 <  offset = 3 * index;
17 >  offset = 0;
18    offsetX = offset;
19    offsetY = offset+1;
20    offsetZ = offset+2;
21    
22 <  Axx = index*9;
22 >  Axx = 0;
23    Axy = Axx+1;
24    Axz = Axx+2;
25    
# Line 38 | Line 32 | Atom::Atom(int theIndex) {
32    Azz = Axx+8;
33   }
34  
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 –
35   void Atom::setIndex(int theIndex) {
36    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;
37   }
38  
39 < void Atom::addAtoms(int nAdded, double* Apos, double* Avel, double* Afrc,
111 <                   double* Atrq, double* AAmat, double* Amu,
112 <                   double* Aul) {
39 > void Atom::setCoords(void){
40  
41 <  int nNew = nElements+nAdded;
41 >  if( myConfig->isAllocated() ){
42  
43 <  double* new_pos = new double[nNew*3];
44 <  double* new_vel = new double[nNew*3];
45 <  double* new_frc = new double[nNew*3];
46 <  double* new_trq = new double[nNew*3];
47 <  double* new_Amat = new double[nNew*9];
48 <  double* new_mu = new double[nNew];
49 <  double* new_ul = new double[nNew*3];
50 <  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];
43 >    myConfig->getAtomPointers( index,
44 >                     &pos,
45 >                     &vel,
46 >                     &frc,
47 >                     &trq,
48 >                     &Amat,
49 >                     &mu,  
50 >                     &ul );
51    }
52 <
53 <  for(i = 0; i < 3*nAdded; i++) {
54 <    j = i + 3*nElements;
55 <    new_pos[j] = Apos[i];
56 <    new_vel[j] = Avel[i];
57 <    new_frc[j] = Afrc[i];
138 <    new_trq[j] = Atrq[i];
139 <    new_ul[j] = Aul[i];
52 >  else{
53 >    sprintf( painCave.errMsg,
54 >             "Attempted to set Atom %d  coordinates with an unallocated "
55 >             "SimState object.\n", index );
56 >    painCave.isFatal = 1;
57 >    simError();
58    }
59 <
60 <  for (i = 0; i < 9*nElements; i++) {
61 <    new_Amat[i] = Amat[i];
144 <  }
145 <
146 <  for(i = 0; i < 9*nAdded; i++) {
147 <    j = i + 9*nElements;
148 <    new_Amat[j] = AAmat[i];
149 <  }
150 <
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;
59 >  
60 >  hasCoords = true;
61 >  
62   }
63  
64 < void Atom::deleteAtom(int theIndex) {
179 <  deleteRange(theIndex, theIndex);
180 < }
181 <
182 < void Atom::deleteRange(int startIndex, int stopIndex) {
183 <
184 <  int nNew = nElements-(stopIndex-startIndex+1);
185 <
186 <  double* new_pos = new double[nNew*3];
187 <  double* new_vel = new double[nNew*3];
188 <  double* new_frc = new double[nNew*3];
189 <  double* new_trq = new double[nNew*3];
190 <  double* new_Amat = new double[nNew*9];
191 <  double* new_mu = new double[nNew];
192 <  double* new_ul = new double[nNew*3];
193 <  int i, j;
64 > void Atom::getPos( double theP[3] ){
65    
66 <  for (i = 0; i < 3*startIndex; i++) {
67 <    new_pos[i] = pos[i];
68 <    new_vel[i] = vel[i];
69 <    new_frc[i] = frc[i];
199 <    new_trq[i] = trq[i];
200 <    new_ul[i] = ul[i];
66 >  if( hasCoords ){
67 >    theP[0] = pos[offsetX];
68 >    theP[1] = pos[offsetY];
69 >    theP[2] = pos[offsetZ];
70    }
71 +  else{
72  
73 <  for(i = 3*(stopIndex + 1); i < 3*nElements; i++) {
74 <    j = i - 3*startIndex + 1;
75 <    new_pos[j] = pos[i];
76 <    new_vel[j] = vel[i];
77 <    new_frc[j] = frc[i];
208 <    new_trq[j] = trq[i];
209 <    new_ul[j] = ul[i];
73 >    sprintf( painCave.errMsg,
74 >             "Attempt to get Pos for atom %d before coords set.\n",
75 >             index );
76 >    painCave.isFatal = 1;
77 >    simError();
78    }
79 + }
80  
81 <  for (i = 0; i < 9*startIndex; i++) {
213 <    new_Amat[i] = Amat[i];
214 <  }
81 > void Atom::setPos( double theP[3] ){
82  
83 <  for(i = 9*(stopIndex + 1); i < 9*nElements; i++) {
84 <    j = i - 9*startIndex + 1;
85 <    new_Amat[j] = Amat[i];
83 >  if( hasCoords ){
84 >    pos[offsetX] = theP[0];
85 >    pos[offsetY] = theP[1];
86 >    pos[offsetZ] = theP[2];
87    }
88 +  else{
89  
90 <  for (i = 0; i < startIndex; i++) {
91 <    new_mu[i] = mu[i];
90 >    sprintf( painCave.errMsg,
91 >             "Attempt to set Pos for atom %d before coords set.\n",
92 >             index );
93 >    painCave.isFatal = 1;
94 >    simError();
95    }
224 –
225 –  for(i = (stopIndex+1); i < nElements; i++) {
226 –    j = i - startIndex + 1;
227 –    new_mu[j] = mu[i];
228 –  }
229 –
230 –  delete[] pos;
231 –  delete[] vel;
232 –  delete[] frc;
233 –  delete[] trq;
234 –  delete[] Amat;
235 –  delete[] mu;
236 –
237 –  pos = new_pos;
238 –  vel = new_vel;
239 –  frc = new_frc;
240 –  trq = new_trq;
241 –  ul = new_ul;
242 –  Amat = new_Amat;
243 –  mu = new_mu;
244 –
245 –  nElements = nNew;
96   }
97  
98 <
249 < void Atom::getPos( double theP[3] ){
98 > void Atom::getVel( double theV[3] ){
99    
100 <  theP[0] = pos[offsetX];
101 <  theP[1] = pos[offsetY];
102 <  theP[2] = pos[offsetZ];
103 < }
100 >  if( hasCoords ){
101 >    theV[0] = vel[offsetX];
102 >    theV[1] = vel[offsetY];
103 >    theV[2] = vel[offsetZ];
104 >  }
105 >  else{
106 >    
107 >    sprintf( painCave.errMsg,
108 >             "Attempt to get vel for atom %d before coords set.\n",
109 >             index );
110 >    painCave.isFatal = 1;
111 >    simError();
112 >  }
113  
256 – void Atom::setPos( double theP[3] ){
257 –  
258 –  pos[offsetX] = theP[0];
259 –  pos[offsetY] = theP[1];
260 –  pos[offsetZ] = theP[2];
114   }
115  
263 – void Atom::getVel( double theV[3] ){
264 –  
265 –  theV[0] = vel[offsetX];
266 –  theV[1] = vel[offsetY];
267 –  theV[2] = vel[offsetZ];
268 – }
269 –
116   void Atom::setVel( double theV[3] ){
117    
118 <  vel[offsetX] = theV[0];
119 <  vel[offsetY] = theV[1];
120 <  vel[offsetZ] = theV[2];
118 >  if( hasCoords ){
119 >    vel[offsetX] = theV[0];
120 >    vel[offsetY] = theV[1];
121 >    vel[offsetZ] = theV[2];
122 >  }
123 >  else{
124 >    
125 >    sprintf( painCave.errMsg,
126 >             "Attempt to set vel for atom %d before coords set.\n",
127 >             index );
128 >    painCave.isFatal = 1;
129 >    simError();
130 >  }
131   }
132  
133   void Atom::getFrc( double theF[3] ){
134    
135 <  theF[0] = frc[offsetX];
136 <  theF[1] = frc[offsetY];
137 <  theF[2] = frc[offsetZ];
135 >  if( hasCoords ){
136 >    theF[0] = frc[offsetX];
137 >    theF[1] = frc[offsetY];
138 >    theF[2] = frc[offsetZ];
139 >  }
140 >  else{
141 >    
142 >    sprintf( painCave.errMsg,
143 >             "Attempt to get frc for atom %d before coords set.\n",
144 >             index );
145 >    painCave.isFatal = 1;
146 >    simError();
147 >  }
148   }
149  
150   void Atom::addFrc( double theF[3] ){
151    
152 <  frc[offsetX] += theF[0];
153 <  frc[offsetY] += theF[1];
154 <  frc[offsetZ] += theF[2];
152 >  if( hasCoords ){
153 >    frc[offsetX] += theF[0];
154 >    frc[offsetY] += theF[1];
155 >    frc[offsetZ] += theF[2];
156 >  }
157 >  else{
158 >    
159 >    sprintf( painCave.errMsg,
160 >             "Attempt to add frc for atom %d before coords set.\n",
161 >             index );
162 >    painCave.isFatal = 1;
163 >    simError();
164 >  }
165   }
166 +
167 +
168 + void Atom::zeroForces( void ){
169 +  
170 +  if( hasCoords ){
171 +    frc[offsetX] = 0.0;
172 +    frc[offsetY] = 0.0;
173 +    frc[offsetZ] = 0.0;
174 +  }
175 +  else{
176 +    
177 +    sprintf( painCave.errMsg,
178 +             "Attempt to zero frc for atom %d before coords set.\n",
179 +             index );
180 +    painCave.isFatal = 1;
181 +    simError();
182 +  }
183 + }

Diff Legend

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