OOPSE/libmdtools/Atom.cpp

#include <iostream>

using namespace std;

#include "simError.h"
#include "Atom.hpp"

Atom::Atom(int theIndex, SimState* theConfig) {
  
  myConfig = theConfig;
  hasCoords = false;
  
  c_n_hyd = 0; 
  has_dipole = 0;
  is_VDW = 0;
  is_LJ = 0;
  
  index = theIndex;
  offset = 0;
  offsetX = offset;
  offsetY = offset+1;
  offsetZ = offset+2;
  
  Axx = 0;
  Axy = Axx+1;
  Axz = Axx+2;
  
  Ayx = Axx+3;
  Ayy = Axx+4;
  Ayz = Axx+5;
  
  Azx = Axx+6;
  Azy = Axx+7;
  Azz = Axx+8;
}

void Atom::setIndex(int theIndex) {
  index = theIndex; 
}

void Atom::setCoords(void){

  if( myConfig->isAllocated() ){

    myConfig->getAtomPointers( index,
                     &pos, 
                     &vel, 
                     &frc, 
                     &trq, 
                     &Amat,
                     &mu,  
                     &ul );
  }
  else{
    sprintf( painCave.errMsg,
             "Attempted to set Atom %d  coordinates with an unallocated "
             "SimState object.\n" );
    painCave.isFatal = 1;
    simError();
  }

  hasCoords = true;

}

// void Atom::addAtoms(int nAdded, double* Apos, double* Avel, double* Afrc, 
//                    double* Atrq, double* AAmat, double* Amu, 
//                    double* Aul) {

//   int nNew = nElements+nAdded;

//   double* new_pos = new double[nNew*3];
//   double* new_vel = new double[nNew*3];
//   double* new_frc = new double[nNew*3];
//   double* new_trq = new double[nNew*3];
//   double* new_Amat = new double[nNew*9];
//   double* new_mu = new double[nNew];
//   double* new_ul = new double[nNew*3];
//   int i, j;
  
//   for (i = 0; i < 3*nElements; i++) {
//     new_pos[i] = pos[i];
//     new_vel[i] = vel[i];
//     new_frc[i] = frc[i];
//     new_trq[i] = trq[i];
//     new_ul[i] = ul[i];
//   }

//   for(i = 0; i < 3*nAdded; i++) {
//     j = i + 3*nElements;
//     new_pos[j] = Apos[i];
//     new_vel[j] = Avel[i];
//     new_frc[j] = Afrc[i];
//     new_trq[j] = Atrq[i];
//     new_ul[j] = Aul[i]; 
//   }

//   for (i = 0; i < 9*nElements; i++) {
//     new_Amat[i] = Amat[i];
//   }

//   for(i = 0; i < 9*nAdded; i++) {
//     j = i + 9*nElements;
//     new_Amat[j] = AAmat[i];
//   }

//   for (i = 0; i < nElements; i++) {
//     new_mu[i] = mu[i];
//   }

//   for(i = 0; i < nAdded; i++) {
//     j = i + nElements;
//     new_mu[j] = Amu[i];
//   }

//   delete[] pos;
//   delete[] vel;
//   delete[] frc;
//   delete[] trq;
//   delete[] Amat;
//   delete[] mu;

//   pos = new_pos;
//   vel = new_vel;
//   frc = new_frc;
//   trq = new_trq;
//   ul = new_ul;
//   Amat = new_Amat;
//   mu = new_mu;

//   nElements = nNew;
// }

// void Atom::deleteAtom(int theIndex) {
//   deleteRange(theIndex, theIndex);
// }

// void Atom::deleteRange(int startIndex, int stopIndex) {
 
//   int nNew = nElements-(stopIndex-startIndex+1);

//   double* new_pos = new double[nNew*3];
//   double* new_vel = new double[nNew*3];
//   double* new_frc = new double[nNew*3];
//   double* new_trq = new double[nNew*3];
//   double* new_Amat = new double[nNew*9];
//   double* new_mu = new double[nNew];
//   double* new_ul = new double[nNew*3];
//   int i, j;
  
//   for (i = 0; i < 3*startIndex; i++) {
//     new_pos[i] = pos[i];
//     new_vel[i] = vel[i];
//     new_frc[i] = frc[i];
//     new_trq[i] = trq[i];
//     new_ul[i] = ul[i];
//   }

//   for(i = 3*(stopIndex + 1); i < 3*nElements; i++) {
//     j = i - 3*startIndex + 1;
//     new_pos[j] = pos[i];
//     new_vel[j] = vel[i];
//     new_frc[j] = frc[i];
//     new_trq[j] = trq[i];
//     new_ul[j] = ul[i]; 
//   }

//   for (i = 0; i < 9*startIndex; i++) {
//     new_Amat[i] = Amat[i];
//   }

//   for(i = 9*(stopIndex + 1); i < 9*nElements; i++) {
//     j = i - 9*startIndex + 1;
//     new_Amat[j] = Amat[i];
//   }

//   for (i = 0; i < startIndex; i++) {
//     new_mu[i] = mu[i];
//   }

//   for(i = (stopIndex+1); i < nElements; i++) {
//     j = i - startIndex + 1;
//     new_mu[j] = mu[i];
//   }

//   delete[] pos;
//   delete[] vel;
//   delete[] frc;
//   delete[] trq;
//   delete[] Amat;
//   delete[] mu;

//   pos = new_pos;
//   vel = new_vel;
//   frc = new_frc;
//   trq = new_trq;
//   ul = new_ul;
//   Amat = new_Amat;
//   mu = new_mu;

//   nElements = nNew;
// }


void Atom::getPos( double theP[3] ){
  
  if( hasCoords ){
    theP[0] = pos[offsetX];
    theP[1] = pos[offsetY];
    theP[2] = pos[offsetZ];
  }
  else{

    sprintf( painCave.errMsg,
             "Attempt to get Pos for atom %d before coords set.\n",
             index );
    painCave.isFatal = 1;
    simError();
  }
}

void Atom::setPos( double theP[3] ){
  
  if( hasCoords ){
    pos[offsetX] = theP[0];
    pos[offsetY] = theP[1];
    pos[offsetZ] = theP[2];
  }
  else{

    sprintf( painCave.errMsg,
             "Attempt to set Pos for atom %d before coords set.\n",
             index );
    painCave.isFatal = 1;
    simError();
  }
}

void Atom::getVel( double theV[3] ){
  
  if( hasCoords ){
    theV[0] = vel[offsetX];
    theV[1] = vel[offsetY];
    theV[2] = vel[offsetZ];
  }
  else{
    
    sprintf( painCave.errMsg,
             "Attempt to get vel for atom %d before coords set.\n",
             index );
    painCave.isFatal = 1;
    simError();
  }

}

void Atom::setVel( double theV[3] ){
  
  if( hasCoords ){
    vel[offsetX] = theV[0];
    vel[offsetY] = theV[1];
    vel[offsetZ] = theV[2];
  }
  else{
    
    sprintf( painCave.errMsg,
             "Attempt to set vel for atom %d before coords set.\n",
             index );
    painCave.isFatal = 1;
    simError();
  }
}

void Atom::getFrc( double theF[3] ){
  
  if( hasCoords ){
    theF[0] = frc[offsetX];
    theF[1] = frc[offsetY];
    theF[2] = frc[offsetZ];
  }
  else{
    
    sprintf( painCave.errMsg,
             "Attempt to get frc for atom %d before coords set.\n",
             index );
    painCave.isFatal = 1;
    simError();
  }
}

void Atom::addFrc( double theF[3] ){
  
  if( hasCoords ){
    frc[offsetX] += theF[0];
    frc[offsetY] += theF[1];
    frc[offsetZ] += theF[2];
  }
  else{
    
    sprintf( painCave.errMsg,
             "Attempt to add frc for atom %d before coords set.\n",
             index );
    painCave.isFatal = 1;
    simError();
  }
}


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