# | 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; | |
40 | – | origRcut = -1.0; |
45 | ecr = 0.0; | |
42 | – | origEcr = -1.0; |
46 | est = 0.0; | |
44 | – | oldEcr = 0.0; |
45 | – | oldRcut = 0.0; |
47 | ||
48 | < | haveOrigRcut = 0; |
49 | < | haveOrigEcr = 0; |
48 | > | haveRcut = 0; |
49 | > | haveEcr = 0; |
50 | boxIsInit = 0; | |
51 | ||
52 | resetTime = 1e99; | |
52 | – | |
53 | ||
54 | + | orthoRhombic = 0; |
55 | + | orthoTolerance = 1E-6; |
56 | + | useInitXSstate = true; |
57 | + | |
58 | usePBC = 0; | |
59 | useLJ = 0; | |
60 | useSticky = 0; | |
61 | < | useDipole = 0; |
61 | > | useCharges = 0; |
62 | > | useDipoles = 0; |
63 | useReactionField = 0; | |
64 | useGB = 0; | |
65 | useEAM = 0; | |
66 | + | useMolecularCutoffs = 0; |
67 | ||
68 | + | excludes = Exclude::Instance(); |
69 | + | |
70 | myConfiguration = new SimState(); | |
71 | ||
72 | + | has_minimizer = false; |
73 | + | the_minimizer =NULL; |
74 | + | |
75 | + | ngroup = 0; |
76 | + | |
77 | wrapMeSimInfo( this ); | |
78 | } | |
79 | ||
# | Line 73 | Line 86 | SimInfo::~SimInfo(){ | |
86 | ||
87 | for(i = properties.begin(); i != properties.end(); i++) | |
88 | delete (*i).second; | |
89 | < | |
89 | > | |
90 | } | |
91 | ||
92 | void SimInfo::setBox(double newBox[3]) { | |
# | Line 102 | Line 115 | void SimInfo::setBoxM( double theBox[3][3] ){ | |
115 | // [ 2 5 8 ] | |
116 | double FortranHmatInv[9]; // the inverted Hmat (for Fortran); | |
117 | ||
105 | – | |
118 | if( !boxIsInit ) boxIsInit = 1; | |
119 | ||
120 | for(i=0; i < 3; i++) | |
# | Line 161 | Line 173 | void SimInfo::calcHmatInv( void ) { | |
173 | smallDiag = fabs(Hmat[0][0]); | |
174 | if(smallDiag > fabs(Hmat[1][1])) smallDiag = fabs(Hmat[1][1]); | |
175 | if(smallDiag > fabs(Hmat[2][2])) smallDiag = fabs(Hmat[2][2]); | |
176 | < | tol = smallDiag * 1E-6; |
176 | > | tol = smallDiag * orthoTolerance; |
177 | ||
178 | orthoRhombic = 1; | |
179 | ||
# | Line 179 | Line 191 | void SimInfo::calcHmatInv( void ) { | |
191 | ||
192 | if( orthoRhombic ){ | |
193 | sprintf( painCave.errMsg, | |
194 | < | "Hmat is switching from Non-Orthorhombic to OrthoRhombic\n" |
195 | < | " If this is a bad thing change the ortho tolerance in SimInfo.\n" ); |
194 | > | "OOPSE is switching from the default Non-Orthorhombic\n" |
195 | > | "\tto the faster Orthorhombic periodic boundary computations.\n" |
196 | > | "\tThis is usually a good thing, but if you wan't the\n" |
197 | > | "\tNon-Orthorhombic computations, make the orthoBoxTolerance\n" |
198 | > | "\tvariable ( currently set to %G ) smaller.\n", |
199 | > | orthoTolerance); |
200 | simError(); | |
201 | } | |
202 | else { | |
203 | sprintf( painCave.errMsg, | |
204 | < | "Hmat is switching from Orthorhombic to Non-OrthoRhombic\n" |
205 | < | " If this is a bad thing change the ortho tolerance in SimInfo.\n" ); |
204 | > | "OOPSE is switching from the faster Orthorhombic to the more\n" |
205 | > | "\tflexible Non-Orthorhombic periodic boundary computations.\n" |
206 | > | "\tThis is usually because the box has deformed under\n" |
207 | > | "\tNPTf integration. If you wan't to live on the edge with\n" |
208 | > | "\tthe Orthorhombic computations, make the orthoBoxTolerance\n" |
209 | > | "\tvariable ( currently set to %G ) larger.\n", |
210 | > | orthoTolerance); |
211 | simError(); | |
191 | – | } |
192 | – | } |
193 | – | } |
194 | – | |
195 | – | double SimInfo::matDet3(double a[3][3]) { |
196 | – | int i, j, k; |
197 | – | double determinant; |
198 | – | |
199 | – | determinant = 0.0; |
200 | – | |
201 | – | for(i = 0; i < 3; i++) { |
202 | – | j = (i+1)%3; |
203 | – | k = (i+2)%3; |
204 | – | |
205 | – | determinant += a[0][i] * (a[1][j]*a[2][k] - a[1][k]*a[2][j]); |
206 | – | } |
207 | – | |
208 | – | return determinant; |
209 | – | } |
210 | – | |
211 | – | void SimInfo::invertMat3(double a[3][3], double b[3][3]) { |
212 | – | |
213 | – | int i, j, k, l, m, n; |
214 | – | double determinant; |
215 | – | |
216 | – | determinant = matDet3( a ); |
217 | – | |
218 | – | if (determinant == 0.0) { |
219 | – | sprintf( painCave.errMsg, |
220 | – | "Can't invert a matrix with a zero determinant!\n"); |
221 | – | painCave.isFatal = 1; |
222 | – | simError(); |
223 | – | } |
224 | – | |
225 | – | for (i=0; i < 3; i++) { |
226 | – | j = (i+1)%3; |
227 | – | k = (i+2)%3; |
228 | – | for(l = 0; l < 3; l++) { |
229 | – | m = (l+1)%3; |
230 | – | n = (l+2)%3; |
231 | – | |
232 | – | b[l][i] = (a[j][m]*a[k][n] - a[j][n]*a[k][m]) / determinant; |
233 | – | } |
234 | – | } |
235 | – | } |
236 | – | |
237 | – | void SimInfo::matMul3(double a[3][3], double b[3][3], double c[3][3]) { |
238 | – | double r00, r01, r02, r10, r11, r12, r20, r21, r22; |
239 | – | |
240 | – | r00 = a[0][0]*b[0][0] + a[0][1]*b[1][0] + a[0][2]*b[2][0]; |
241 | – | r01 = a[0][0]*b[0][1] + a[0][1]*b[1][1] + a[0][2]*b[2][1]; |
242 | – | r02 = a[0][0]*b[0][2] + a[0][1]*b[1][2] + a[0][2]*b[2][2]; |
243 | – | |
244 | – | r10 = a[1][0]*b[0][0] + a[1][1]*b[1][0] + a[1][2]*b[2][0]; |
245 | – | r11 = a[1][0]*b[0][1] + a[1][1]*b[1][1] + a[1][2]*b[2][1]; |
246 | – | r12 = a[1][0]*b[0][2] + a[1][1]*b[1][2] + a[1][2]*b[2][2]; |
247 | – | |
248 | – | r20 = a[2][0]*b[0][0] + a[2][1]*b[1][0] + a[2][2]*b[2][0]; |
249 | – | r21 = a[2][0]*b[0][1] + a[2][1]*b[1][1] + a[2][2]*b[2][1]; |
250 | – | r22 = a[2][0]*b[0][2] + a[2][1]*b[1][2] + a[2][2]*b[2][2]; |
251 | – | |
252 | – | c[0][0] = r00; c[0][1] = r01; c[0][2] = r02; |
253 | – | c[1][0] = r10; c[1][1] = r11; c[1][2] = r12; |
254 | – | c[2][0] = r20; c[2][1] = r21; c[2][2] = r22; |
255 | – | } |
256 | – | |
257 | – | void SimInfo::matVecMul3(double m[3][3], double inVec[3], double outVec[3]) { |
258 | – | double a0, a1, a2; |
259 | – | |
260 | – | a0 = inVec[0]; a1 = inVec[1]; a2 = inVec[2]; |
261 | – | |
262 | – | outVec[0] = m[0][0]*a0 + m[0][1]*a1 + m[0][2]*a2; |
263 | – | outVec[1] = m[1][0]*a0 + m[1][1]*a1 + m[1][2]*a2; |
264 | – | outVec[2] = m[2][0]*a0 + m[2][1]*a1 + m[2][2]*a2; |
265 | – | } |
266 | – | |
267 | – | void SimInfo::transposeMat3(double in[3][3], double out[3][3]) { |
268 | – | double temp[3][3]; |
269 | – | int i, j; |
270 | – | |
271 | – | for (i = 0; i < 3; i++) { |
272 | – | for (j = 0; j < 3; j++) { |
273 | – | temp[j][i] = in[i][j]; |
212 | } | |
213 | } | |
276 | – | for (i = 0; i < 3; i++) { |
277 | – | for (j = 0; j < 3; j++) { |
278 | – | out[i][j] = temp[i][j]; |
279 | – | } |
280 | – | } |
214 | } | |
282 | – | |
283 | – | void SimInfo::printMat3(double A[3][3] ){ |
215 | ||
285 | – | std::cerr |
286 | – | << "[ " << A[0][0] << ", " << A[0][1] << ", " << A[0][2] << " ]\n" |
287 | – | << "[ " << A[1][0] << ", " << A[1][1] << ", " << A[1][2] << " ]\n" |
288 | – | << "[ " << A[2][0] << ", " << A[2][1] << ", " << A[2][2] << " ]\n"; |
289 | – | } |
290 | – | |
291 | – | void SimInfo::printMat9(double A[9] ){ |
292 | – | |
293 | – | std::cerr |
294 | – | << "[ " << A[0] << ", " << A[1] << ", " << A[2] << " ]\n" |
295 | – | << "[ " << A[3] << ", " << A[4] << ", " << A[5] << " ]\n" |
296 | – | << "[ " << A[6] << ", " << A[7] << ", " << A[8] << " ]\n"; |
297 | – | } |
298 | – | |
299 | – | |
300 | – | void SimInfo::crossProduct3(double a[3],double b[3], double out[3]){ |
301 | – | |
302 | – | out[0] = a[1] * b[2] - a[2] * b[1]; |
303 | – | out[1] = a[2] * b[0] - a[0] * b[2] ; |
304 | – | out[2] = a[0] * b[1] - a[1] * b[0]; |
305 | – | |
306 | – | } |
307 | – | |
308 | – | double SimInfo::dotProduct3(double a[3], double b[3]){ |
309 | – | return a[0]*b[0] + a[1]*b[1]+ a[2]*b[2]; |
310 | – | } |
311 | – | |
312 | – | double SimInfo::length3(double a[3]){ |
313 | – | return sqrt(a[0]*a[0] + a[1]*a[1] + a[2]*a[2]); |
314 | – | } |
315 | – | |
216 | void SimInfo::calcBoxL( void ){ | |
217 | ||
218 | double dx, dy, dz, dsq; | |
# | Line 368 | Line 268 | double SimInfo::calcMaxCutOff(){ | |
268 | rk[0] = Hmat[0][2]; | |
269 | rk[1] = Hmat[1][2]; | |
270 | rk[2] = Hmat[2][2]; | |
271 | < | |
272 | < | crossProduct3(ri,rj, rij); |
273 | < | distXY = dotProduct3(rk,rij) / length3(rij); |
271 | > | |
272 | > | crossProduct3(ri, rj, rij); |
273 | > | distXY = dotProduct3(rk,rij) / norm3(rij); |
274 | ||
275 | crossProduct3(rj,rk, rjk); | |
276 | < | distYZ = dotProduct3(ri,rjk) / length3(rjk); |
276 | > | distYZ = dotProduct3(ri,rjk) / norm3(rjk); |
277 | ||
278 | crossProduct3(rk,ri, rki); | |
279 | < | distZX = dotProduct3(rj,rki) / length3(rki); |
279 | > | distZX = dotProduct3(rj,rki) / norm3(rki); |
280 | ||
281 | minDist = min(min(distXY, distYZ), distZX); | |
282 | return minDist/2; | |
# | Line 424 | Line 324 | int SimInfo::getNDF(){ | |
324 | ||
325 | int SimInfo::getNDF(){ | |
326 | int ndf_local; | |
327 | + | |
328 | + | ndf_local = 0; |
329 | ||
330 | < | ndf_local = 3 * n_atoms + 3 * n_oriented - n_constraints; |
330 | > | for(int i = 0; i < integrableObjects.size(); i++){ |
331 | > | ndf_local += 3; |
332 | > | if (integrableObjects[i]->isDirectional()) { |
333 | > | if (integrableObjects[i]->isLinear()) |
334 | > | ndf_local += 2; |
335 | > | else |
336 | > | ndf_local += 3; |
337 | > | } |
338 | > | } |
339 | ||
340 | + | // n_constraints is local, so subtract them on each processor: |
341 | + | |
342 | + | ndf_local -= n_constraints; |
343 | + | |
344 | #ifdef IS_MPI | |
345 | MPI_Allreduce(&ndf_local,&ndf,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD); | |
346 | #else | |
347 | ndf = ndf_local; | |
348 | #endif | |
349 | ||
350 | + | // nZconstraints is global, as are the 3 COM translations for the |
351 | + | // entire system: |
352 | + | |
353 | ndf = ndf - 3 - nZconstraints; | |
354 | ||
355 | return ndf; | |
# | Line 442 | Line 359 | int SimInfo::getNDFraw() { | |
359 | int ndfRaw_local; | |
360 | ||
361 | // Raw degrees of freedom that we have to set | |
362 | < | ndfRaw_local = 3 * n_atoms + 3 * n_oriented; |
363 | < | |
362 | > | ndfRaw_local = 0; |
363 | > | |
364 | > | for(int i = 0; i < integrableObjects.size(); i++){ |
365 | > | ndfRaw_local += 3; |
366 | > | if (integrableObjects[i]->isDirectional()) { |
367 | > | if (integrableObjects[i]->isLinear()) |
368 | > | ndfRaw_local += 2; |
369 | > | else |
370 | > | ndfRaw_local += 3; |
371 | > | } |
372 | > | } |
373 | > | |
374 | #ifdef IS_MPI | |
375 | MPI_Allreduce(&ndfRaw_local,&ndfRaw,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD); | |
376 | #else | |
# | Line 456 | Line 383 | int SimInfo::getNDFtranslational() { | |
383 | int SimInfo::getNDFtranslational() { | |
384 | int ndfTrans_local; | |
385 | ||
386 | < | ndfTrans_local = 3 * n_atoms - n_constraints; |
386 | > | ndfTrans_local = 3 * integrableObjects.size() - n_constraints; |
387 | ||
388 | + | |
389 | #ifdef IS_MPI | |
390 | MPI_Allreduce(&ndfTrans_local,&ndfTrans,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD); | |
391 | #else | |
# | Line 469 | Line 397 | int SimInfo::getNDFtranslational() { | |
397 | return ndfTrans; | |
398 | } | |
399 | ||
400 | + | int SimInfo::getTotIntegrableObjects() { |
401 | + | int nObjs_local; |
402 | + | int nObjs; |
403 | + | |
404 | + | nObjs_local = integrableObjects.size(); |
405 | + | |
406 | + | |
407 | + | #ifdef IS_MPI |
408 | + | MPI_Allreduce(&nObjs_local,&nObjs,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD); |
409 | + | #else |
410 | + | nObjs = nObjs_local; |
411 | + | #endif |
412 | + | |
413 | + | |
414 | + | return nObjs; |
415 | + | } |
416 | + | |
417 | void SimInfo::refreshSim(){ | |
418 | ||
419 | simtype fInfo; | |
# | Line 478 | Line 423 | void SimInfo::refreshSim(){ | |
423 | ||
424 | fInfo.dielect = 0.0; | |
425 | ||
426 | < | if( useDipole ){ |
426 | > | if( useDipoles ){ |
427 | if( useReactionField )fInfo.dielect = dielectric; | |
428 | } | |
429 | ||
# | Line 487 | Line 432 | void SimInfo::refreshSim(){ | |
432 | fInfo.SIM_uses_LJ = useLJ; | |
433 | fInfo.SIM_uses_sticky = useSticky; | |
434 | //fInfo.SIM_uses_sticky = 0; | |
435 | < | fInfo.SIM_uses_dipoles = useDipole; |
435 | > | fInfo.SIM_uses_charges = useCharges; |
436 | > | fInfo.SIM_uses_dipoles = useDipoles; |
437 | //fInfo.SIM_uses_dipoles = 0; | |
438 | < | //fInfo.SIM_uses_RF = useReactionField; |
439 | < | fInfo.SIM_uses_RF = 0; |
438 | > | fInfo.SIM_uses_RF = useReactionField; |
439 | > | //fInfo.SIM_uses_RF = 0; |
440 | fInfo.SIM_uses_GB = useGB; | |
441 | fInfo.SIM_uses_EAM = useEAM; | |
442 | ||
443 | < | excl = Exclude::getArray(); |
444 | < | |
443 | > | n_exclude = excludes->getSize(); |
444 | > | excl = excludes->getFortranArray(); |
445 | > | |
446 | #ifdef IS_MPI | |
447 | n_global = mpiSim->getTotAtoms(); | |
448 | #else | |
# | Line 504 | Line 451 | void SimInfo::refreshSim(){ | |
451 | ||
452 | isError = 0; | |
453 | ||
454 | + | getFortranGroupArray(this, mfact, ngroup, groupList, groupStart); |
455 | + | |
456 | setFsimulation( &fInfo, &n_global, &n_atoms, identArray, &n_exclude, excl, | |
457 | < | &nGlobalExcludes, globalExcludes, molMembershipArray, |
458 | < | &isError ); |
457 | > | &nGlobalExcludes, globalExcludes, molMembershipArray, |
458 | > | &mfact[0], &ngroup, &groupList[0], &groupStart[0], &isError ); |
459 | ||
460 | if( isError ){ | |
461 | ||
# | Line 527 | Line 476 | void SimInfo::refreshSim(){ | |
476 | this->ndfTrans = this->getNDFtranslational(); | |
477 | } | |
478 | ||
530 | – | |
531 | – | void SimInfo::setRcut( double theRcut ){ |
532 | – | |
533 | – | rCut = theRcut; |
534 | – | checkCutOffs(); |
535 | – | } |
536 | – | |
479 | void SimInfo::setDefaultRcut( double theRcut ){ | |
480 | ||
481 | < | haveOrigRcut = 1; |
540 | < | origRcut = theRcut; |
481 | > | haveRcut = 1; |
482 | rCut = theRcut; | |
483 | ||
484 | ( rCut > ecr )? rList = rCut + 1.0: rList = ecr + 1.0; | |
# | Line 545 | Line 486 | void SimInfo::setDefaultRcut( double theRcut ){ | |
486 | notifyFortranCutOffs( &rCut, &rList, &ecr, &est ); | |
487 | } | |
488 | ||
548 | – | void SimInfo::setEcr( double theEcr ){ |
549 | – | |
550 | – | ecr = theEcr; |
551 | – | checkCutOffs(); |
552 | – | } |
553 | – | |
489 | void SimInfo::setDefaultEcr( double theEcr ){ | |
490 | ||
491 | < | haveOrigEcr = 1; |
492 | < | origEcr = theEcr; |
491 | > | haveEcr = 1; |
492 | > | ecr = theEcr; |
493 | ||
494 | ( rCut > ecr )? rList = rCut + 1.0: rList = ecr + 1.0; | |
495 | ||
561 | – | ecr = theEcr; |
562 | – | |
496 | notifyFortranCutOffs( &rCut, &rList, &ecr, &est ); | |
497 | } | |
498 | ||
566 | – | void SimInfo::setEcr( double theEcr, double theEst ){ |
567 | – | |
568 | – | est = theEst; |
569 | – | setEcr( theEcr ); |
570 | – | } |
571 | – | |
499 | void SimInfo::setDefaultEcr( double theEcr, double theEst ){ | |
500 | ||
501 | est = theEst; | |
# | Line 577 | Line 504 | void SimInfo::checkCutOffs( void ){ | |
504 | ||
505 | ||
506 | void SimInfo::checkCutOffs( void ){ | |
580 | – | |
581 | – | int cutChanged = 0; |
507 | ||
508 | if( boxIsInit ){ | |
509 | ||
510 | //we need to check cutOffs against the box | |
511 | < | |
512 | < | //detect the change of rCut |
588 | < | if(( maxCutoff > rCut )&&(usePBC)){ |
589 | < | if( rCut < origRcut ){ |
590 | < | rCut = origRcut; |
591 | < | |
592 | < | if (rCut > maxCutoff) |
593 | < | rCut = maxCutoff; |
594 | < | |
595 | < | sprintf( painCave.errMsg, |
596 | < | "New Box size is setting the long range cutoff radius " |
597 | < | "to %lf at time %lf\n", |
598 | < | rCut, currentTime ); |
599 | < | painCave.isFatal = 0; |
600 | < | simError(); |
601 | < | } |
602 | < | } |
603 | < | else if ((rCut > maxCutoff)&&(usePBC)) { |
511 | > | |
512 | > | if( rCut > maxCutoff ){ |
513 | sprintf( painCave.errMsg, | |
514 | < | "New Box size is setting the long range cutoff radius " |
515 | < | "to %lf at time %lf\n", |
516 | < | maxCutoff, currentTime ); |
517 | < | painCave.isFatal = 0; |
514 | > | "LJrcut is too large for the current periodic box.\n" |
515 | > | "\tCurrent Value of LJrcut = %G at time %G\n " |
516 | > | "\tThis is larger than half of at least one of the\n" |
517 | > | "\tperiodic box vectors. Right now, the Box matrix is:\n" |
518 | > | "\n" |
519 | > | "\t[ %G %G %G ]\n" |
520 | > | "\t[ %G %G %G ]\n" |
521 | > | "\t[ %G %G %G ]\n", |
522 | > | rCut, currentTime, |
523 | > | Hmat[0][0], Hmat[0][1], Hmat[0][2], |
524 | > | Hmat[1][0], Hmat[1][1], Hmat[1][2], |
525 | > | Hmat[2][0], Hmat[2][1], Hmat[2][2]); |
526 | > | painCave.isFatal = 1; |
527 | simError(); | |
610 | – | rCut = maxCutoff; |
528 | } | |
529 | < | |
530 | < | |
531 | < | //detect the change of ecr |
532 | < | if( maxCutoff > ecr ){ |
533 | < | if( ecr < origEcr ){ |
534 | < | ecr = origEcr; |
535 | < | if (ecr > maxCutoff) ecr = maxCutoff; |
536 | < | |
537 | < | sprintf( painCave.errMsg, |
538 | < | "New Box size is setting the electrostaticCutoffRadius " |
539 | < | "to %lf at time %lf\n", |
540 | < | ecr, currentTime ); |
541 | < | painCave.isFatal = 0; |
542 | < | simError(); |
529 | > | |
530 | > | if( haveEcr ){ |
531 | > | if( ecr > maxCutoff ){ |
532 | > | sprintf( painCave.errMsg, |
533 | > | "electrostaticCutoffRadius is too large for the current\n" |
534 | > | "\tperiodic box.\n\n" |
535 | > | "\tCurrent Value of ECR = %G at time %G\n " |
536 | > | "\tThis is larger than half of at least one of the\n" |
537 | > | "\tperiodic box vectors. Right now, the Box matrix is:\n" |
538 | > | "\n" |
539 | > | "\t[ %G %G %G ]\n" |
540 | > | "\t[ %G %G %G ]\n" |
541 | > | "\t[ %G %G %G ]\n", |
542 | > | ecr, currentTime, |
543 | > | Hmat[0][0], Hmat[0][1], Hmat[0][2], |
544 | > | Hmat[1][0], Hmat[1][1], Hmat[1][2], |
545 | > | Hmat[2][0], Hmat[2][1], Hmat[2][2]); |
546 | > | painCave.isFatal = 1; |
547 | > | simError(); |
548 | } | |
549 | } | |
628 | – | else if( ecr > maxCutoff){ |
629 | – | sprintf( painCave.errMsg, |
630 | – | "New Box size is setting the electrostaticCutoffRadius " |
631 | – | "to %lf at time %lf\n", |
632 | – | maxCutoff, currentTime ); |
633 | – | painCave.isFatal = 0; |
634 | – | simError(); |
635 | – | ecr = maxCutoff; |
636 | – | } |
637 | – | |
638 | – | if( (oldEcr != ecr) || ( oldRcut != rCut ) ) cutChanged = 1; |
639 | – | |
640 | – | // rlist is the 1.0 plus max( rcut, ecr ) |
641 | – | |
642 | – | ( rCut > ecr )? rList = rCut + 1.0: rList = ecr + 1.0; |
643 | – | |
644 | – | if( cutChanged ){ |
645 | – | notifyFortranCutOffs( &rCut, &rList, &ecr, &est ); |
646 | – | } |
647 | – | |
648 | – | oldEcr = ecr; |
649 | – | oldRcut = rCut; |
650 | – | |
550 | } else { | |
551 | // initialize this stuff before using it, OK? | |
552 | sprintf( painCave.errMsg, | |
553 | < | "Trying to check cutoffs without a box. Be smarter.\n" ); |
553 | > | "Trying to check cutoffs without a box.\n" |
554 | > | "\tOOPSE should have better programmers than that.\n" ); |
555 | painCave.isFatal = 1; | |
556 | simError(); | |
557 | } | |
# | Line 694 | Line 594 | GenericData* SimInfo::getProperty(const string& propNa | |
594 | return NULL; | |
595 | } | |
596 | ||
697 | – | vector<GenericData*> SimInfo::getProperties(){ |
597 | ||
598 | < | vector<GenericData*> result; |
599 | < | map<string, GenericData*>::iterator i; |
600 | < | |
601 | < | for(i = properties.begin(); i != properties.end(); i++) |
602 | < | result.push_back((*i).second); |
598 | > | void getFortranGroupArray(SimInfo* info, vector<double>& mfact, int& ngroup, |
599 | > | vector<int>& groupList, vector<int>& groupStart){ |
600 | > | Molecule* mol; |
601 | > | int numAtom; |
602 | > | int curIndex; |
603 | > | |
604 | > | mfact.clear(); |
605 | > | groupList.clear(); |
606 | > | groupStart.clear(); |
607 | > | |
608 | > | //Be careful, fortran array begin at 1 |
609 | > | curIndex = 1; |
610 | ||
611 | < | return result; |
612 | < | } |
611 | > | if(info->useMolecularCutoffs){ |
612 | > | //if using molecular cutoff |
613 | > | ngroup = info->n_mol; |
614 | ||
615 | < | double SimInfo::matTrace3(double m[3][3]){ |
616 | < | double trace; |
617 | < | trace = m[0][0] + m[1][1] + m[2][2]; |
615 | > | for(int i = 0; i < ngroup; i ++){ |
616 | > | mol = &(info->molecules[i]); |
617 | > | numAtom = mol->getNAtoms(); |
618 | > | |
619 | > | for(int j=0; j < numAtom; j++){ |
620 | > | #ifdef IS_MPI |
621 | > | groupList.push_back((info->atoms[i])->getGlobalIndex() + 1); |
622 | > | #else |
623 | > | groupList.push_back((info->atoms[i])->getIndex() + 1); |
624 | > | #endif |
625 | > | }//for(int j=0; j < numAtom; j++) |
626 | > | |
627 | > | groupStart.push_back(curIndex); |
628 | > | curIndex += numAtom; |
629 | > | |
630 | > | }//end for(int i =0 ; i < ngroup; i++) |
631 | > | } |
632 | > | else{ |
633 | > | //using atomic cutoff, every single atom is just a group |
634 | > | ngroup = info->n_atoms; |
635 | > | for(int i =0 ; i < ngroup; i++){ |
636 | > | groupStart.push_back(curIndex++); |
637 | ||
638 | < | return trace; |
638 | > | #ifdef IS_MPI |
639 | > | groupList.push_back((info->atoms[i])->getGlobalIndex() + 1); |
640 | > | #else |
641 | > | groupList.push_back((info->atoms[i])->getIndex() + 1); |
642 | > | #endif |
643 | > | |
644 | > | }//end for(int i =0 ; i < ngroup; i++) |
645 | > | |
646 | > | }//end if (info->useMolecularCutoffs) |
647 | > | |
648 | } |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |