# | Line 1 | Line 1 | |
---|---|---|
1 | < | #include <cstdlib> |
2 | < | #include <cstring> |
3 | < | #include <cmath> |
1 | > | #include <stdlib.h> |
2 | > | #include <string.h> |
3 | > | #include <math.h> |
4 | ||
5 | #include <iostream> | |
6 | using namespace std; | |
# | Line 12 | Line 12 | using namespace std; | |
12 | ||
13 | #include "fortranWrappers.hpp" | |
14 | ||
15 | + | #include "MatVec3.h" |
16 | + | |
17 | #ifdef IS_MPI | |
18 | #include "mpiSimulation.hpp" | |
19 | #endif | |
# | Line 20 | Line 22 | inline double roundMe( double x ){ | |
22 | return ( x >= 0 ) ? floor( x + 0.5 ) : ceil( x - 0.5 ); | |
23 | } | |
24 | ||
25 | + | inline double min( double a, double b ){ |
26 | + | return (a < b ) ? a : b; |
27 | + | } |
28 | ||
29 | SimInfo* currentInfo; | |
30 | ||
31 | SimInfo::SimInfo(){ | |
32 | < | excludes = NULL; |
32 | > | |
33 | n_constraints = 0; | |
34 | nZconstraints = 0; | |
35 | n_oriented = 0; | |
# | Line 37 | Line 42 | SimInfo::SimInfo(){ | |
42 | thermalTime = 0.0; | |
43 | currentTime = 0.0; | |
44 | rCut = 0.0; | |
45 | < | origRcut = -1.0; |
41 | < | ecr = 0.0; |
42 | < | origEcr = -1.0; |
43 | < | est = 0.0; |
44 | < | oldEcr = 0.0; |
45 | < | oldRcut = 0.0; |
45 | > | rSw = 0.0; |
46 | ||
47 | < | haveOrigRcut = 0; |
48 | < | haveOrigEcr = 0; |
47 | > | haveRcut = 0; |
48 | > | haveRsw = 0; |
49 | boxIsInit = 0; | |
50 | ||
51 | < | |
51 | > | resetTime = 1e99; |
52 | ||
53 | + | orthoRhombic = 0; |
54 | + | orthoTolerance = 1E-6; |
55 | + | useInitXSstate = true; |
56 | + | |
57 | usePBC = 0; | |
58 | useLJ = 0; | |
59 | useSticky = 0; | |
60 | < | useDipole = 0; |
60 | > | useCharges = 0; |
61 | > | useDipoles = 0; |
62 | useReactionField = 0; | |
63 | useGB = 0; | |
64 | useEAM = 0; | |
65 | + | useSolidThermInt = 0; |
66 | + | useLiquidThermInt = 0; |
67 | ||
68 | + | haveCutoffGroups = false; |
69 | + | |
70 | + | excludes = Exclude::Instance(); |
71 | + | |
72 | myConfiguration = new SimState(); | |
73 | ||
74 | + | has_minimizer = false; |
75 | + | the_minimizer =NULL; |
76 | + | |
77 | + | ngroup = 0; |
78 | + | |
79 | wrapMeSimInfo( this ); | |
80 | } | |
81 | ||
# | Line 72 | Line 88 | SimInfo::~SimInfo(){ | |
88 | ||
89 | for(i = properties.begin(); i != properties.end(); i++) | |
90 | delete (*i).second; | |
91 | < | |
91 | > | |
92 | } | |
93 | ||
94 | void SimInfo::setBox(double newBox[3]) { | |
# | Line 93 | Line 109 | void SimInfo::setBoxM( double theBox[3][3] ){ | |
109 | ||
110 | void SimInfo::setBoxM( double theBox[3][3] ){ | |
111 | ||
112 | < | int i, j, status; |
97 | < | double smallestBoxL, maxCutoff; |
112 | > | int i, j; |
113 | double FortranHmat[9]; // to preserve compatibility with Fortran the | |
114 | // ordering in the array is as follows: | |
115 | // [ 0 3 6 ] | |
# | Line 102 | Line 117 | void SimInfo::setBoxM( double theBox[3][3] ){ | |
117 | // [ 2 5 8 ] | |
118 | double FortranHmatInv[9]; // the inverted Hmat (for Fortran); | |
119 | ||
105 | – | |
120 | if( !boxIsInit ) boxIsInit = 1; | |
121 | ||
122 | for(i=0; i < 3; i++) | |
# | Line 146 | Line 160 | void SimInfo::calcHmatInv( void ) { | |
160 | ||
161 | void SimInfo::calcHmatInv( void ) { | |
162 | ||
163 | + | int oldOrtho; |
164 | int i,j; | |
165 | double smallDiag; | |
166 | double tol; | |
# | Line 153 | Line 168 | void SimInfo::calcHmatInv( void ) { | |
168 | ||
169 | invertMat3( Hmat, HmatInv ); | |
170 | ||
156 | – | // Check the inverse to make sure it is sane: |
157 | – | |
158 | – | matMul3( Hmat, HmatInv, sanity ); |
159 | – | |
171 | // check to see if Hmat is orthorhombic | |
172 | ||
173 | < | smallDiag = Hmat[0][0]; |
163 | < | if(smallDiag > Hmat[1][1]) smallDiag = Hmat[1][1]; |
164 | < | if(smallDiag > Hmat[2][2]) smallDiag = Hmat[2][2]; |
165 | < | tol = smallDiag * 1E-6; |
173 | > | oldOrtho = orthoRhombic; |
174 | ||
175 | + | smallDiag = fabs(Hmat[0][0]); |
176 | + | if(smallDiag > fabs(Hmat[1][1])) smallDiag = fabs(Hmat[1][1]); |
177 | + | if(smallDiag > fabs(Hmat[2][2])) smallDiag = fabs(Hmat[2][2]); |
178 | + | tol = smallDiag * orthoTolerance; |
179 | + | |
180 | orthoRhombic = 1; | |
181 | ||
182 | for (i = 0; i < 3; i++ ) { | |
183 | for (j = 0 ; j < 3; j++) { | |
184 | if (i != j) { | |
185 | if (orthoRhombic) { | |
186 | < | if (Hmat[i][j] >= tol) orthoRhombic = 0; |
186 | > | if ( fabs(Hmat[i][j]) >= tol) orthoRhombic = 0; |
187 | } | |
188 | } | |
189 | } | |
190 | } | |
178 | – | } |
191 | ||
192 | < | double SimInfo::matDet3(double a[3][3]) { |
193 | < | int i, j, k; |
194 | < | double determinant; |
195 | < | |
196 | < | determinant = 0.0; |
197 | < | |
198 | < | for(i = 0; i < 3; i++) { |
199 | < | j = (i+1)%3; |
200 | < | k = (i+2)%3; |
201 | < | |
202 | < | determinant += a[0][i] * (a[1][j]*a[2][k] - a[1][k]*a[2][j]); |
203 | < | } |
192 | < | |
193 | < | return determinant; |
194 | < | } |
195 | < | |
196 | < | void SimInfo::invertMat3(double a[3][3], double b[3][3]) { |
197 | < | |
198 | < | int i, j, k, l, m, n; |
199 | < | double determinant; |
200 | < | |
201 | < | determinant = matDet3( a ); |
202 | < | |
203 | < | if (determinant == 0.0) { |
204 | < | sprintf( painCave.errMsg, |
205 | < | "Can't invert a matrix with a zero determinant!\n"); |
206 | < | painCave.isFatal = 1; |
207 | < | simError(); |
208 | < | } |
209 | < | |
210 | < | for (i=0; i < 3; i++) { |
211 | < | j = (i+1)%3; |
212 | < | k = (i+2)%3; |
213 | < | for(l = 0; l < 3; l++) { |
214 | < | m = (l+1)%3; |
215 | < | n = (l+2)%3; |
216 | < | |
217 | < | b[l][i] = (a[j][m]*a[k][n] - a[j][n]*a[k][m]) / determinant; |
192 | > | if( oldOrtho != orthoRhombic ){ |
193 | > | |
194 | > | if( orthoRhombic ) { |
195 | > | sprintf( painCave.errMsg, |
196 | > | "\n\tOOPSE is switching from the default Non-Orthorhombic\n" |
197 | > | "\tto the faster Orthorhombic periodic boundary computations.\n" |
198 | > | "\tThis is usually a good thing, but if you wan't the\n" |
199 | > | "\tNon-Orthorhombic computations, make the orthoBoxTolerance\n" |
200 | > | "\tvariable ( currently set to %G ) smaller.\n", |
201 | > | orthoTolerance); |
202 | > | painCave.severity = OOPSE_INFO; |
203 | > | simError(); |
204 | } | |
205 | < | } |
206 | < | } |
207 | < | |
208 | < | void SimInfo::matMul3(double a[3][3], double b[3][3], double c[3][3]) { |
209 | < | double r00, r01, r02, r10, r11, r12, r20, r21, r22; |
210 | < | |
211 | < | r00 = a[0][0]*b[0][0] + a[0][1]*b[1][0] + a[0][2]*b[2][0]; |
212 | < | r01 = a[0][0]*b[0][1] + a[0][1]*b[1][1] + a[0][2]*b[2][1]; |
213 | < | r02 = a[0][0]*b[0][2] + a[0][1]*b[1][2] + a[0][2]*b[2][2]; |
214 | < | |
215 | < | r10 = a[1][0]*b[0][0] + a[1][1]*b[1][0] + a[1][2]*b[2][0]; |
230 | < | r11 = a[1][0]*b[0][1] + a[1][1]*b[1][1] + a[1][2]*b[2][1]; |
231 | < | r12 = a[1][0]*b[0][2] + a[1][1]*b[1][2] + a[1][2]*b[2][2]; |
232 | < | |
233 | < | r20 = a[2][0]*b[0][0] + a[2][1]*b[1][0] + a[2][2]*b[2][0]; |
234 | < | r21 = a[2][0]*b[0][1] + a[2][1]*b[1][1] + a[2][2]*b[2][1]; |
235 | < | r22 = a[2][0]*b[0][2] + a[2][1]*b[1][2] + a[2][2]*b[2][2]; |
236 | < | |
237 | < | c[0][0] = r00; c[0][1] = r01; c[0][2] = r02; |
238 | < | c[1][0] = r10; c[1][1] = r11; c[1][2] = r12; |
239 | < | c[2][0] = r20; c[2][1] = r21; c[2][2] = r22; |
240 | < | } |
241 | < | |
242 | < | void SimInfo::matVecMul3(double m[3][3], double inVec[3], double outVec[3]) { |
243 | < | double a0, a1, a2; |
244 | < | |
245 | < | a0 = inVec[0]; a1 = inVec[1]; a2 = inVec[2]; |
246 | < | |
247 | < | outVec[0] = m[0][0]*a0 + m[0][1]*a1 + m[0][2]*a2; |
248 | < | outVec[1] = m[1][0]*a0 + m[1][1]*a1 + m[1][2]*a2; |
249 | < | outVec[2] = m[2][0]*a0 + m[2][1]*a1 + m[2][2]*a2; |
250 | < | } |
251 | < | |
252 | < | void SimInfo::transposeMat3(double in[3][3], double out[3][3]) { |
253 | < | double temp[3][3]; |
254 | < | int i, j; |
255 | < | |
256 | < | for (i = 0; i < 3; i++) { |
257 | < | for (j = 0; j < 3; j++) { |
258 | < | temp[j][i] = in[i][j]; |
205 | > | else { |
206 | > | sprintf( painCave.errMsg, |
207 | > | "\n\tOOPSE is switching from the faster Orthorhombic to the more\n" |
208 | > | "\tflexible Non-Orthorhombic periodic boundary computations.\n" |
209 | > | "\tThis is usually because the box has deformed under\n" |
210 | > | "\tNPTf integration. If you wan't to live on the edge with\n" |
211 | > | "\tthe Orthorhombic computations, make the orthoBoxTolerance\n" |
212 | > | "\tvariable ( currently set to %G ) larger.\n", |
213 | > | orthoTolerance); |
214 | > | painCave.severity = OOPSE_WARNING; |
215 | > | simError(); |
216 | } | |
217 | } | |
261 | – | for (i = 0; i < 3; i++) { |
262 | – | for (j = 0; j < 3; j++) { |
263 | – | out[i][j] = temp[i][j]; |
264 | – | } |
265 | – | } |
218 | } | |
267 | – | |
268 | – | void SimInfo::printMat3(double A[3][3] ){ |
219 | ||
270 | – | std::cerr |
271 | – | << "[ " << A[0][0] << ", " << A[0][1] << ", " << A[0][2] << " ]\n" |
272 | – | << "[ " << A[1][0] << ", " << A[1][1] << ", " << A[1][2] << " ]\n" |
273 | – | << "[ " << A[2][0] << ", " << A[2][1] << ", " << A[2][2] << " ]\n"; |
274 | – | } |
275 | – | |
276 | – | void SimInfo::printMat9(double A[9] ){ |
277 | – | |
278 | – | std::cerr |
279 | – | << "[ " << A[0] << ", " << A[1] << ", " << A[2] << " ]\n" |
280 | – | << "[ " << A[3] << ", " << A[4] << ", " << A[5] << " ]\n" |
281 | – | << "[ " << A[6] << ", " << A[7] << ", " << A[8] << " ]\n"; |
282 | – | } |
283 | – | |
220 | void SimInfo::calcBoxL( void ){ | |
221 | ||
222 | double dx, dy, dz, dsq; | |
287 | – | int i; |
223 | ||
224 | // boxVol = Determinant of Hmat | |
225 | ||
# | Line 295 | Line 230 | void SimInfo::calcBoxL( void ){ | |
230 | dx = Hmat[0][0]; dy = Hmat[1][0]; dz = Hmat[2][0]; | |
231 | dsq = dx*dx + dy*dy + dz*dz; | |
232 | boxL[0] = sqrt( dsq ); | |
233 | < | maxCutoff = 0.5 * boxL[0]; |
233 | > | //maxCutoff = 0.5 * boxL[0]; |
234 | ||
235 | // boxLy | |
236 | ||
237 | dx = Hmat[0][1]; dy = Hmat[1][1]; dz = Hmat[2][1]; | |
238 | dsq = dx*dx + dy*dy + dz*dz; | |
239 | boxL[1] = sqrt( dsq ); | |
240 | < | if( (0.5 * boxL[1]) < maxCutoff ) maxCutoff = 0.5 * boxL[1]; |
240 | > | //if( (0.5 * boxL[1]) < maxCutoff ) maxCutoff = 0.5 * boxL[1]; |
241 | ||
242 | + | |
243 | // boxLz | |
244 | ||
245 | dx = Hmat[0][2]; dy = Hmat[1][2]; dz = Hmat[2][2]; | |
246 | dsq = dx*dx + dy*dy + dz*dz; | |
247 | boxL[2] = sqrt( dsq ); | |
248 | < | if( (0.5 * boxL[2]) < maxCutoff ) maxCutoff = 0.5 * boxL[2]; |
248 | > | //if( (0.5 * boxL[2]) < maxCutoff ) maxCutoff = 0.5 * boxL[2]; |
249 | > | |
250 | > | //calculate the max cutoff |
251 | > | maxCutoff = calcMaxCutOff(); |
252 | ||
253 | checkCutOffs(); | |
254 | ||
255 | } | |
256 | ||
257 | ||
258 | + | double SimInfo::calcMaxCutOff(){ |
259 | + | |
260 | + | double ri[3], rj[3], rk[3]; |
261 | + | double rij[3], rjk[3], rki[3]; |
262 | + | double minDist; |
263 | + | |
264 | + | ri[0] = Hmat[0][0]; |
265 | + | ri[1] = Hmat[1][0]; |
266 | + | ri[2] = Hmat[2][0]; |
267 | + | |
268 | + | rj[0] = Hmat[0][1]; |
269 | + | rj[1] = Hmat[1][1]; |
270 | + | rj[2] = Hmat[2][1]; |
271 | + | |
272 | + | rk[0] = Hmat[0][2]; |
273 | + | rk[1] = Hmat[1][2]; |
274 | + | rk[2] = Hmat[2][2]; |
275 | + | |
276 | + | crossProduct3(ri, rj, rij); |
277 | + | distXY = dotProduct3(rk,rij) / norm3(rij); |
278 | + | |
279 | + | crossProduct3(rj,rk, rjk); |
280 | + | distYZ = dotProduct3(ri,rjk) / norm3(rjk); |
281 | + | |
282 | + | crossProduct3(rk,ri, rki); |
283 | + | distZX = dotProduct3(rj,rki) / norm3(rki); |
284 | + | |
285 | + | minDist = min(min(distXY, distYZ), distZX); |
286 | + | return minDist/2; |
287 | + | |
288 | + | } |
289 | + | |
290 | void SimInfo::wrapVector( double thePos[3] ){ | |
291 | ||
292 | < | int i, j, k; |
292 | > | int i; |
293 | double scaled[3]; | |
294 | ||
295 | if( !orthoRhombic ){ | |
# | Line 356 | Line 327 | int SimInfo::getNDF(){ | |
327 | ||
328 | ||
329 | int SimInfo::getNDF(){ | |
330 | < | int ndf_local, ndf; |
330 | > | int ndf_local; |
331 | > | |
332 | > | ndf_local = 0; |
333 | ||
334 | < | ndf_local = 3 * n_atoms + 3 * n_oriented - n_constraints; |
334 | > | for(int i = 0; i < integrableObjects.size(); i++){ |
335 | > | ndf_local += 3; |
336 | > | if (integrableObjects[i]->isDirectional()) { |
337 | > | if (integrableObjects[i]->isLinear()) |
338 | > | ndf_local += 2; |
339 | > | else |
340 | > | ndf_local += 3; |
341 | > | } |
342 | > | } |
343 | ||
344 | + | // n_constraints is local, so subtract them on each processor: |
345 | + | |
346 | + | ndf_local -= n_constraints; |
347 | + | |
348 | #ifdef IS_MPI | |
349 | MPI_Allreduce(&ndf_local,&ndf,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD); | |
350 | #else | |
351 | ndf = ndf_local; | |
352 | #endif | |
353 | ||
354 | + | // nZconstraints is global, as are the 3 COM translations for the |
355 | + | // entire system: |
356 | + | |
357 | ndf = ndf - 3 - nZconstraints; | |
358 | ||
359 | return ndf; | |
360 | } | |
361 | ||
362 | int SimInfo::getNDFraw() { | |
363 | < | int ndfRaw_local, ndfRaw; |
363 | > | int ndfRaw_local; |
364 | ||
365 | // Raw degrees of freedom that we have to set | |
366 | < | ndfRaw_local = 3 * n_atoms + 3 * n_oriented; |
367 | < | |
366 | > | ndfRaw_local = 0; |
367 | > | |
368 | > | for(int i = 0; i < integrableObjects.size(); i++){ |
369 | > | ndfRaw_local += 3; |
370 | > | if (integrableObjects[i]->isDirectional()) { |
371 | > | if (integrableObjects[i]->isLinear()) |
372 | > | ndfRaw_local += 2; |
373 | > | else |
374 | > | ndfRaw_local += 3; |
375 | > | } |
376 | > | } |
377 | > | |
378 | #ifdef IS_MPI | |
379 | MPI_Allreduce(&ndfRaw_local,&ndfRaw,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD); | |
380 | #else | |
# | Line 387 | Line 385 | int SimInfo::getNDFtranslational() { | |
385 | } | |
386 | ||
387 | int SimInfo::getNDFtranslational() { | |
388 | < | int ndfTrans_local, ndfTrans; |
388 | > | int ndfTrans_local; |
389 | ||
390 | < | ndfTrans_local = 3 * n_atoms - n_constraints; |
390 | > | ndfTrans_local = 3 * integrableObjects.size() - n_constraints; |
391 | ||
392 | + | |
393 | #ifdef IS_MPI | |
394 | MPI_Allreduce(&ndfTrans_local,&ndfTrans,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD); | |
395 | #else | |
# | Line 402 | Line 401 | int SimInfo::getNDFtranslational() { | |
401 | return ndfTrans; | |
402 | } | |
403 | ||
404 | + | int SimInfo::getTotIntegrableObjects() { |
405 | + | int nObjs_local; |
406 | + | int nObjs; |
407 | + | |
408 | + | nObjs_local = integrableObjects.size(); |
409 | + | |
410 | + | |
411 | + | #ifdef IS_MPI |
412 | + | MPI_Allreduce(&nObjs_local,&nObjs,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD); |
413 | + | #else |
414 | + | nObjs = nObjs_local; |
415 | + | #endif |
416 | + | |
417 | + | |
418 | + | return nObjs; |
419 | + | } |
420 | + | |
421 | void SimInfo::refreshSim(){ | |
422 | ||
423 | simtype fInfo; | |
# | Line 411 | Line 427 | void SimInfo::refreshSim(){ | |
427 | ||
428 | fInfo.dielect = 0.0; | |
429 | ||
430 | < | if( useDipole ){ |
430 | > | if( useDipoles ){ |
431 | if( useReactionField )fInfo.dielect = dielectric; | |
432 | } | |
433 | ||
# | Line 420 | Line 436 | void SimInfo::refreshSim(){ | |
436 | fInfo.SIM_uses_LJ = useLJ; | |
437 | fInfo.SIM_uses_sticky = useSticky; | |
438 | //fInfo.SIM_uses_sticky = 0; | |
439 | < | fInfo.SIM_uses_dipoles = useDipole; |
439 | > | fInfo.SIM_uses_charges = useCharges; |
440 | > | fInfo.SIM_uses_dipoles = useDipoles; |
441 | //fInfo.SIM_uses_dipoles = 0; | |
442 | < | //fInfo.SIM_uses_RF = useReactionField; |
443 | < | fInfo.SIM_uses_RF = 0; |
442 | > | fInfo.SIM_uses_RF = useReactionField; |
443 | > | //fInfo.SIM_uses_RF = 0; |
444 | fInfo.SIM_uses_GB = useGB; | |
445 | fInfo.SIM_uses_EAM = useEAM; | |
446 | ||
447 | < | excl = Exclude::getArray(); |
448 | < | |
447 | > | n_exclude = excludes->getSize(); |
448 | > | excl = excludes->getFortranArray(); |
449 | > | |
450 | #ifdef IS_MPI | |
451 | < | n_global = mpiSim->getTotAtoms(); |
451 | > | n_global = mpiSim->getNAtomsGlobal(); |
452 | #else | |
453 | n_global = n_atoms; | |
454 | #endif | |
455 | < | |
455 | > | |
456 | isError = 0; | |
457 | < | |
457 | > | |
458 | > | getFortranGroupArrays(this, FglobalGroupMembership, mfact); |
459 | > | //it may not be a good idea to pass the address of first element in vector |
460 | > | //since c++ standard does not require vector to be stored continuously in meomory |
461 | > | //Most of the compilers will organize the memory of vector continuously |
462 | setFsimulation( &fInfo, &n_global, &n_atoms, identArray, &n_exclude, excl, | |
463 | < | &nGlobalExcludes, globalExcludes, molMembershipArray, |
464 | < | &isError ); |
463 | > | &nGlobalExcludes, globalExcludes, molMembershipArray, |
464 | > | &mfact[0], &ngroup, &FglobalGroupMembership[0], &isError); |
465 | ||
466 | if( isError ){ | |
467 | < | |
467 | > | |
468 | sprintf( painCave.errMsg, | |
469 | < | "There was an error setting the simulation information in fortran.\n" ); |
469 | > | "There was an error setting the simulation information in fortran.\n" ); |
470 | painCave.isFatal = 1; | |
471 | simError(); | |
472 | } | |
473 | < | |
473 | > | |
474 | #ifdef IS_MPI | |
475 | sprintf( checkPointMsg, | |
476 | "succesfully sent the simulation information to fortran.\n"); | |
477 | MPIcheckPoint(); | |
478 | #endif // is_mpi | |
479 | < | |
479 | > | |
480 | this->ndf = this->getNDF(); | |
481 | this->ndfRaw = this->getNDFraw(); | |
482 | this->ndfTrans = this->getNDFtranslational(); | |
483 | } | |
484 | ||
485 | < | |
486 | < | void SimInfo::setRcut( double theRcut ){ |
487 | < | |
466 | < | if( !haveOrigRcut ){ |
467 | < | haveOrigRcut = 1; |
468 | < | origRcut = theRcut; |
469 | < | } |
470 | < | |
485 | > | void SimInfo::setDefaultRcut( double theRcut ){ |
486 | > | |
487 | > | haveRcut = 1; |
488 | rCut = theRcut; | |
489 | < | checkCutOffs(); |
489 | > | rList = rCut + 1.0; |
490 | > | |
491 | > | notifyFortranCutOffs( &rCut, &rSw, &rList ); |
492 | } | |
493 | ||
494 | < | void SimInfo::setEcr( double theEcr ){ |
494 | > | void SimInfo::setDefaultRcut( double theRcut, double theRsw ){ |
495 | ||
496 | < | if( !haveOrigEcr ){ |
497 | < | haveOrigEcr = 1; |
479 | < | origEcr = theEcr; |
480 | < | } |
481 | < | |
482 | < | ecr = theEcr; |
483 | < | checkCutOffs(); |
496 | > | rSw = theRsw; |
497 | > | setDefaultRcut( theRcut ); |
498 | } | |
499 | ||
486 | – | void SimInfo::setEcr( double theEcr, double theEst ){ |
500 | ||
488 | – | est = theEst; |
489 | – | setEcr( theEcr ); |
490 | – | } |
491 | – | |
492 | – | |
501 | void SimInfo::checkCutOffs( void ){ | |
494 | – | |
495 | – | int cutChanged = 0; |
502 | ||
503 | if( boxIsInit ){ | |
504 | ||
505 | //we need to check cutOffs against the box | |
506 | ||
507 | < | if(( maxCutoff > rCut )&&(usePBC)){ |
502 | < | if( rCut < origRcut ){ |
503 | < | rCut = origRcut; |
504 | < | if (rCut > maxCutoff) rCut = maxCutoff; |
505 | < | |
506 | < | sprintf( painCave.errMsg, |
507 | < | "New Box size is setting the long range cutoff radius " |
508 | < | "to %lf at time %lf\n", |
509 | < | rCut, currentTime ); |
510 | < | painCave.isFatal = 0; |
511 | < | simError(); |
512 | < | } |
513 | < | } |
514 | < | |
515 | < | if( maxCutoff > ecr ){ |
516 | < | if( ecr < origEcr ){ |
517 | < | ecr = origEcr; |
518 | < | if (ecr > maxCutoff) ecr = maxCutoff; |
519 | < | |
520 | < | sprintf( painCave.errMsg, |
521 | < | "New Box size is setting the electrostaticCutoffRadius " |
522 | < | "to %lf at time %lf\n", |
523 | < | ecr, currentTime ); |
524 | < | painCave.isFatal = 0; |
525 | < | simError(); |
526 | < | } |
527 | < | } |
528 | < | |
529 | < | |
530 | < | if ((rCut > maxCutoff)&&(usePBC)) { |
507 | > | if( rCut > maxCutoff ){ |
508 | sprintf( painCave.errMsg, | |
509 | < | "New Box size is setting the long range cutoff radius " |
510 | < | "to %lf at time %lf\n", |
511 | < | maxCutoff, currentTime ); |
512 | < | painCave.isFatal = 0; |
509 | > | "\n\tcutoffRadius is too large for the current periodic box.\n" |
510 | > | "\tCurrent Value of cutoffRadius = %G at time %G\n " |
511 | > | "\tThis is larger than half of at least one of the\n" |
512 | > | "\tperiodic box vectors. Right now, the Box matrix is:\n" |
513 | > | "\n" |
514 | > | "\t[ %G %G %G ]\n" |
515 | > | "\t[ %G %G %G ]\n" |
516 | > | "\t[ %G %G %G ]\n", |
517 | > | rCut, currentTime, |
518 | > | Hmat[0][0], Hmat[0][1], Hmat[0][2], |
519 | > | Hmat[1][0], Hmat[1][1], Hmat[1][2], |
520 | > | Hmat[2][0], Hmat[2][1], Hmat[2][2]); |
521 | > | painCave.severity = OOPSE_ERROR; |
522 | > | painCave.isFatal = 1; |
523 | simError(); | |
524 | < | rCut = maxCutoff; |
538 | < | } |
539 | < | |
540 | < | if( ecr > maxCutoff){ |
541 | < | sprintf( painCave.errMsg, |
542 | < | "New Box size is setting the electrostaticCutoffRadius " |
543 | < | "to %lf at time %lf\n", |
544 | < | maxCutoff, currentTime ); |
545 | < | painCave.isFatal = 0; |
546 | < | simError(); |
547 | < | ecr = maxCutoff; |
548 | < | } |
549 | < | |
550 | < | if( (oldEcr != ecr) || ( oldRcut != rCut ) ) cutChanged = 1; |
551 | < | |
552 | < | // rlist is the 1.0 plus max( rcut, ecr ) |
553 | < | |
554 | < | ( rCut > ecr )? rList = rCut + 1.0: rList = ecr + 1.0; |
555 | < | |
556 | < | if( cutChanged ){ |
557 | < | |
558 | < | notifyFortranCutOffs( &rCut, &rList, &ecr, &est ); |
559 | < | } |
560 | < | |
561 | < | oldEcr = ecr; |
562 | < | oldRcut = rCut; |
563 | < | |
524 | > | } |
525 | } else { | |
526 | // initialize this stuff before using it, OK? | |
527 | sprintf( painCave.errMsg, | |
528 | < | "Trying to check cutoffs without a box. Be smarter.\n" ); |
528 | > | "\n\tTrying to check cutoffs without a box.\n" |
529 | > | "\tOOPSE should have better programmers than that.\n" ); |
530 | > | painCave.severity = OOPSE_ERROR; |
531 | painCave.isFatal = 1; | |
532 | simError(); | |
533 | } | |
# | Line 607 | Line 570 | GenericData* SimInfo::getProperty(const string& propNa | |
570 | return NULL; | |
571 | } | |
572 | ||
610 | – | vector<GenericData*> SimInfo::getProperties(){ |
573 | ||
574 | < | vector<GenericData*> result; |
575 | < | map<string, GenericData*>::iterator i; |
574 | > | void SimInfo::getFortranGroupArrays(SimInfo* info, |
575 | > | vector<int>& FglobalGroupMembership, |
576 | > | vector<double>& mfact){ |
577 | ||
578 | < | for(i = properties.begin(); i != properties.end(); i++) |
579 | < | result.push_back((*i).second); |
580 | < | |
581 | < | return result; |
582 | < | } |
578 | > | Molecule* myMols; |
579 | > | Atom** myAtoms; |
580 | > | int numAtom; |
581 | > | double mtot; |
582 | > | int numMol; |
583 | > | int numCutoffGroups; |
584 | > | CutoffGroup* myCutoffGroup; |
585 | > | vector<CutoffGroup*>::iterator iterCutoff; |
586 | > | Atom* cutoffAtom; |
587 | > | vector<Atom*>::iterator iterAtom; |
588 | > | int atomIndex; |
589 | > | double totalMass; |
590 | > | |
591 | > | mfact.clear(); |
592 | > | FglobalGroupMembership.clear(); |
593 | > | |
594 | ||
595 | < | double SimInfo::matTrace3(double m[3][3]){ |
596 | < | double trace; |
597 | < | trace = m[0][0] + m[1][1] + m[2][2]; |
595 | > | // Fix the silly fortran indexing problem |
596 | > | #ifdef IS_MPI |
597 | > | numAtom = mpiSim->getNAtomsGlobal(); |
598 | > | #else |
599 | > | numAtom = n_atoms; |
600 | > | #endif |
601 | > | for (int i = 0; i < numAtom; i++) |
602 | > | FglobalGroupMembership.push_back(globalGroupMembership[i] + 1); |
603 | > | |
604 | ||
605 | < | return trace; |
605 | > | myMols = info->molecules; |
606 | > | numMol = info->n_mol; |
607 | > | for(int i = 0; i < numMol; i++){ |
608 | > | numCutoffGroups = myMols[i].getNCutoffGroups(); |
609 | > | for(myCutoffGroup =myMols[i].beginCutoffGroup(iterCutoff); |
610 | > | myCutoffGroup != NULL; |
611 | > | myCutoffGroup =myMols[i].nextCutoffGroup(iterCutoff)){ |
612 | > | |
613 | > | totalMass = myCutoffGroup->getMass(); |
614 | > | |
615 | > | for(cutoffAtom = myCutoffGroup->beginAtom(iterAtom); |
616 | > | cutoffAtom != NULL; |
617 | > | cutoffAtom = myCutoffGroup->nextAtom(iterAtom)){ |
618 | > | mfact.push_back(cutoffAtom->getMass()/totalMass); |
619 | > | } |
620 | > | } |
621 | > | } |
622 | > | |
623 | } |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |