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