# | 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 27 | Line 29 | SimInfo::SimInfo(){ | |
29 | SimInfo* currentInfo; | |
30 | ||
31 | SimInfo::SimInfo(){ | |
32 | < | excludes = NULL; |
32 | > | |
33 | n_constraints = 0; | |
34 | nZconstraints = 0; | |
35 | n_oriented = 0; | |
# | Line 49 | Line 51 | SimInfo::SimInfo(){ | |
51 | ||
52 | resetTime = 1e99; | |
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 | ||
67 | + | excludes = Exclude::Instance(); |
68 | + | |
69 | myConfiguration = new SimState(); | |
70 | ||
71 | + | has_minimizer = false; |
72 | + | the_minimizer =NULL; |
73 | + | |
74 | wrapMeSimInfo( this ); | |
75 | } | |
76 | ||
# | Line 179 | Line 188 | void SimInfo::calcHmatInv( void ) { | |
188 | ||
189 | if( orthoRhombic ){ | |
190 | sprintf( painCave.errMsg, | |
191 | < | "Hmat is switching from Non-Orthorhombic to OrthoRhombic\n" |
192 | < | " If this is a bad thing, change the orthoBoxTolerance( currently %G ).\n", |
191 | > | "OOPSE is switching from the default Non-Orthorhombic\n" |
192 | > | "\tto the faster Orthorhombic periodic boundary computations.\n" |
193 | > | "\tThis is usually a good thing, but if you wan't the\n" |
194 | > | "\tNon-Orthorhombic computations, make the orthoBoxTolerance\n" |
195 | > | "\tvariable ( currently set to %G ) smaller.\n", |
196 | orthoTolerance); | |
197 | simError(); | |
198 | } | |
199 | else { | |
200 | sprintf( painCave.errMsg, | |
201 | < | "Hmat is switching from Orthorhombic to Non-OrthoRhombic\n" |
202 | < | " If this is a bad thing, change the orthoBoxTolerance( currently %G ).\n", |
201 | > | "OOPSE is switching from the faster Orthorhombic to the more\n" |
202 | > | "\tflexible Non-Orthorhombic periodic boundary computations.\n" |
203 | > | "\tThis is usually because the box has deformed under\n" |
204 | > | "\tNPTf integration. If you wan't to live on the edge with\n" |
205 | > | "\tthe Orthorhombic computations, make the orthoBoxTolerance\n" |
206 | > | "\tvariable ( currently set to %G ) larger.\n", |
207 | orthoTolerance); | |
208 | simError(); | |
193 | – | } |
194 | – | } |
195 | – | } |
196 | – | |
197 | – | double SimInfo::matDet3(double a[3][3]) { |
198 | – | int i, j, k; |
199 | – | double determinant; |
200 | – | |
201 | – | determinant = 0.0; |
202 | – | |
203 | – | for(i = 0; i < 3; i++) { |
204 | – | j = (i+1)%3; |
205 | – | k = (i+2)%3; |
206 | – | |
207 | – | determinant += a[0][i] * (a[1][j]*a[2][k] - a[1][k]*a[2][j]); |
208 | – | } |
209 | – | |
210 | – | return determinant; |
211 | – | } |
212 | – | |
213 | – | void SimInfo::invertMat3(double a[3][3], double b[3][3]) { |
214 | – | |
215 | – | int i, j, k, l, m, n; |
216 | – | double determinant; |
217 | – | |
218 | – | determinant = matDet3( a ); |
219 | – | |
220 | – | if (determinant == 0.0) { |
221 | – | sprintf( painCave.errMsg, |
222 | – | "Can't invert a matrix with a zero determinant!\n"); |
223 | – | painCave.isFatal = 1; |
224 | – | simError(); |
225 | – | } |
226 | – | |
227 | – | for (i=0; i < 3; i++) { |
228 | – | j = (i+1)%3; |
229 | – | k = (i+2)%3; |
230 | – | for(l = 0; l < 3; l++) { |
231 | – | m = (l+1)%3; |
232 | – | n = (l+2)%3; |
233 | – | |
234 | – | b[l][i] = (a[j][m]*a[k][n] - a[j][n]*a[k][m]) / determinant; |
209 | } | |
210 | } | |
211 | } | |
212 | ||
239 | – | void SimInfo::matMul3(double a[3][3], double b[3][3], double c[3][3]) { |
240 | – | double r00, r01, r02, r10, r11, r12, r20, r21, r22; |
241 | – | |
242 | – | r00 = a[0][0]*b[0][0] + a[0][1]*b[1][0] + a[0][2]*b[2][0]; |
243 | – | r01 = a[0][0]*b[0][1] + a[0][1]*b[1][1] + a[0][2]*b[2][1]; |
244 | – | r02 = a[0][0]*b[0][2] + a[0][1]*b[1][2] + a[0][2]*b[2][2]; |
245 | – | |
246 | – | r10 = a[1][0]*b[0][0] + a[1][1]*b[1][0] + a[1][2]*b[2][0]; |
247 | – | r11 = a[1][0]*b[0][1] + a[1][1]*b[1][1] + a[1][2]*b[2][1]; |
248 | – | r12 = a[1][0]*b[0][2] + a[1][1]*b[1][2] + a[1][2]*b[2][2]; |
249 | – | |
250 | – | r20 = a[2][0]*b[0][0] + a[2][1]*b[1][0] + a[2][2]*b[2][0]; |
251 | – | r21 = a[2][0]*b[0][1] + a[2][1]*b[1][1] + a[2][2]*b[2][1]; |
252 | – | r22 = a[2][0]*b[0][2] + a[2][1]*b[1][2] + a[2][2]*b[2][2]; |
253 | – | |
254 | – | c[0][0] = r00; c[0][1] = r01; c[0][2] = r02; |
255 | – | c[1][0] = r10; c[1][1] = r11; c[1][2] = r12; |
256 | – | c[2][0] = r20; c[2][1] = r21; c[2][2] = r22; |
257 | – | } |
258 | – | |
259 | – | void SimInfo::matVecMul3(double m[3][3], double inVec[3], double outVec[3]) { |
260 | – | double a0, a1, a2; |
261 | – | |
262 | – | a0 = inVec[0]; a1 = inVec[1]; a2 = inVec[2]; |
263 | – | |
264 | – | outVec[0] = m[0][0]*a0 + m[0][1]*a1 + m[0][2]*a2; |
265 | – | outVec[1] = m[1][0]*a0 + m[1][1]*a1 + m[1][2]*a2; |
266 | – | outVec[2] = m[2][0]*a0 + m[2][1]*a1 + m[2][2]*a2; |
267 | – | } |
268 | – | |
269 | – | void SimInfo::transposeMat3(double in[3][3], double out[3][3]) { |
270 | – | double temp[3][3]; |
271 | – | int i, j; |
272 | – | |
273 | – | for (i = 0; i < 3; i++) { |
274 | – | for (j = 0; j < 3; j++) { |
275 | – | temp[j][i] = in[i][j]; |
276 | – | } |
277 | – | } |
278 | – | for (i = 0; i < 3; i++) { |
279 | – | for (j = 0; j < 3; j++) { |
280 | – | out[i][j] = temp[i][j]; |
281 | – | } |
282 | – | } |
283 | – | } |
284 | – | |
285 | – | void SimInfo::printMat3(double A[3][3] ){ |
286 | – | |
287 | – | std::cerr |
288 | – | << "[ " << A[0][0] << ", " << A[0][1] << ", " << A[0][2] << " ]\n" |
289 | – | << "[ " << A[1][0] << ", " << A[1][1] << ", " << A[1][2] << " ]\n" |
290 | – | << "[ " << A[2][0] << ", " << A[2][1] << ", " << A[2][2] << " ]\n"; |
291 | – | } |
292 | – | |
293 | – | void SimInfo::printMat9(double A[9] ){ |
294 | – | |
295 | – | std::cerr |
296 | – | << "[ " << A[0] << ", " << A[1] << ", " << A[2] << " ]\n" |
297 | – | << "[ " << A[3] << ", " << A[4] << ", " << A[5] << " ]\n" |
298 | – | << "[ " << A[6] << ", " << A[7] << ", " << A[8] << " ]\n"; |
299 | – | } |
300 | – | |
301 | – | |
302 | – | void SimInfo::crossProduct3(double a[3],double b[3], double out[3]){ |
303 | – | |
304 | – | out[0] = a[1] * b[2] - a[2] * b[1]; |
305 | – | out[1] = a[2] * b[0] - a[0] * b[2] ; |
306 | – | out[2] = a[0] * b[1] - a[1] * b[0]; |
307 | – | |
308 | – | } |
309 | – | |
310 | – | double SimInfo::dotProduct3(double a[3], double b[3]){ |
311 | – | return a[0]*b[0] + a[1]*b[1]+ a[2]*b[2]; |
312 | – | } |
313 | – | |
314 | – | double SimInfo::length3(double a[3]){ |
315 | – | return sqrt(a[0]*a[0] + a[1]*a[1] + a[2]*a[2]); |
316 | – | } |
317 | – | |
213 | void SimInfo::calcBoxL( void ){ | |
214 | ||
215 | double dx, dy, dz, dsq; | |
# | Line 370 | Line 265 | double SimInfo::calcMaxCutOff(){ | |
265 | rk[0] = Hmat[0][2]; | |
266 | rk[1] = Hmat[1][2]; | |
267 | rk[2] = Hmat[2][2]; | |
268 | < | |
269 | < | crossProduct3(ri,rj, rij); |
270 | < | distXY = dotProduct3(rk,rij) / length3(rij); |
268 | > | |
269 | > | crossProduct3(ri, rj, rij); |
270 | > | distXY = dotProduct3(rk,rij) / norm3(rij); |
271 | ||
272 | crossProduct3(rj,rk, rjk); | |
273 | < | distYZ = dotProduct3(ri,rjk) / length3(rjk); |
273 | > | distYZ = dotProduct3(ri,rjk) / norm3(rjk); |
274 | ||
275 | crossProduct3(rk,ri, rki); | |
276 | < | distZX = dotProduct3(rj,rki) / length3(rki); |
276 | > | distZX = dotProduct3(rj,rki) / norm3(rki); |
277 | ||
278 | minDist = min(min(distXY, distYZ), distZX); | |
279 | return minDist/2; | |
# | Line 426 | Line 321 | int SimInfo::getNDF(){ | |
321 | ||
322 | int SimInfo::getNDF(){ | |
323 | int ndf_local; | |
324 | + | |
325 | + | ndf_local = 0; |
326 | ||
327 | < | ndf_local = 3 * n_atoms + 3 * n_oriented - n_constraints; |
327 | > | for(int i = 0; i < integrableObjects.size(); i++){ |
328 | > | ndf_local += 3; |
329 | > | if (integrableObjects[i]->isDirectional()) { |
330 | > | if (integrableObjects[i]->isLinear()) |
331 | > | ndf_local += 2; |
332 | > | else |
333 | > | ndf_local += 3; |
334 | > | } |
335 | > | } |
336 | ||
337 | + | // n_constraints is local, so subtract them on each processor: |
338 | + | |
339 | + | ndf_local -= n_constraints; |
340 | + | |
341 | #ifdef IS_MPI | |
342 | MPI_Allreduce(&ndf_local,&ndf,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD); | |
343 | #else | |
344 | ndf = ndf_local; | |
345 | #endif | |
346 | ||
347 | + | // nZconstraints is global, as are the 3 COM translations for the |
348 | + | // entire system: |
349 | + | |
350 | ndf = ndf - 3 - nZconstraints; | |
351 | ||
352 | + | std::cerr << "ndf = " << ndf; |
353 | + | |
354 | return ndf; | |
355 | } | |
356 | ||
# | Line 444 | Line 358 | int SimInfo::getNDFraw() { | |
358 | int ndfRaw_local; | |
359 | ||
360 | // Raw degrees of freedom that we have to set | |
361 | < | ndfRaw_local = 3 * n_atoms + 3 * n_oriented; |
362 | < | |
361 | > | ndfRaw_local = 0; |
362 | > | |
363 | > | for(int i = 0; i < integrableObjects.size(); i++){ |
364 | > | ndfRaw_local += 3; |
365 | > | if (integrableObjects[i]->isDirectional()) { |
366 | > | if (integrableObjects[i]->isLinear()) |
367 | > | ndfRaw_local += 2; |
368 | > | else |
369 | > | ndfRaw_local += 3; |
370 | > | } |
371 | > | } |
372 | > | |
373 | #ifdef IS_MPI | |
374 | MPI_Allreduce(&ndfRaw_local,&ndfRaw,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD); | |
375 | #else | |
# | Line 458 | Line 382 | int SimInfo::getNDFtranslational() { | |
382 | int SimInfo::getNDFtranslational() { | |
383 | int ndfTrans_local; | |
384 | ||
385 | < | ndfTrans_local = 3 * n_atoms - n_constraints; |
385 | > | ndfTrans_local = 3 * integrableObjects.size() - n_constraints; |
386 | ||
387 | + | |
388 | #ifdef IS_MPI | |
389 | MPI_Allreduce(&ndfTrans_local,&ndfTrans,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD); | |
390 | #else | |
# | Line 469 | Line 394 | int SimInfo::getNDFtranslational() { | |
394 | ndfTrans = ndfTrans - 3 - nZconstraints; | |
395 | ||
396 | return ndfTrans; | |
397 | + | } |
398 | + | |
399 | + | int SimInfo::getTotIntegrableObjects() { |
400 | + | int nObjs_local; |
401 | + | int nObjs; |
402 | + | |
403 | + | nObjs_local = integrableObjects.size(); |
404 | + | |
405 | + | |
406 | + | #ifdef IS_MPI |
407 | + | MPI_Allreduce(&nObjs_local,&nObjs,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD); |
408 | + | #else |
409 | + | nObjs = nObjs_local; |
410 | + | #endif |
411 | + | |
412 | + | |
413 | + | return nObjs; |
414 | } | |
415 | ||
416 | void SimInfo::refreshSim(){ | |
# | Line 480 | Line 422 | void SimInfo::refreshSim(){ | |
422 | ||
423 | fInfo.dielect = 0.0; | |
424 | ||
425 | < | if( useDipole ){ |
425 | > | if( useDipoles ){ |
426 | if( useReactionField )fInfo.dielect = dielectric; | |
427 | } | |
428 | ||
# | Line 489 | Line 431 | void SimInfo::refreshSim(){ | |
431 | fInfo.SIM_uses_LJ = useLJ; | |
432 | fInfo.SIM_uses_sticky = useSticky; | |
433 | //fInfo.SIM_uses_sticky = 0; | |
434 | < | fInfo.SIM_uses_dipoles = useDipole; |
434 | > | fInfo.SIM_uses_charges = useCharges; |
435 | > | fInfo.SIM_uses_dipoles = useDipoles; |
436 | //fInfo.SIM_uses_dipoles = 0; | |
437 | < | //fInfo.SIM_uses_RF = useReactionField; |
438 | < | fInfo.SIM_uses_RF = 0; |
437 | > | fInfo.SIM_uses_RF = useReactionField; |
438 | > | //fInfo.SIM_uses_RF = 0; |
439 | fInfo.SIM_uses_GB = useGB; | |
440 | fInfo.SIM_uses_EAM = useEAM; | |
441 | ||
442 | < | excl = Exclude::getArray(); |
442 | > | n_exclude = excludes->getSize(); |
443 | > | excl = excludes->getFortranArray(); |
444 | ||
445 | #ifdef IS_MPI | |
446 | n_global = mpiSim->getTotAtoms(); | |
# | Line 564 | Line 508 | void SimInfo::checkCutOffs( void ){ | |
508 | ||
509 | if( rCut > maxCutoff ){ | |
510 | sprintf( painCave.errMsg, | |
511 | < | "Box size is too small for the long range cutoff radius, " |
512 | < | "%G, at time %G\n" |
513 | < | " [ %G %G %G ]\n" |
514 | < | " [ %G %G %G ]\n" |
515 | < | " [ %G %G %G ]\n", |
516 | < | rCut, currentTime, |
511 | > | "LJrcut is too large for the current periodic box.\n" |
512 | > | "\tCurrent Value of LJrcut = %G at time %G\n " |
513 | > | "\tThis is larger than half of at least one of the\n" |
514 | > | "\tperiodic box vectors. Right now, the Box matrix is:\n" |
515 | > | "\n, %G" |
516 | > | "\t[ %G %G %G ]\n" |
517 | > | "\t[ %G %G %G ]\n" |
518 | > | "\t[ %G %G %G ]\n", |
519 | > | rCut, currentTime, maxCutoff, |
520 | Hmat[0][0], Hmat[0][1], Hmat[0][2], | |
521 | Hmat[1][0], Hmat[1][1], Hmat[1][2], | |
522 | Hmat[2][0], Hmat[2][1], Hmat[2][2]); | |
# | Line 580 | Line 527 | void SimInfo::checkCutOffs( void ){ | |
527 | if( haveEcr ){ | |
528 | if( ecr > maxCutoff ){ | |
529 | sprintf( painCave.errMsg, | |
530 | < | "Box size is too small for the electrostatic cutoff radius, " |
531 | < | "%G, at time %G\n" |
532 | < | " [ %G %G %G ]\n" |
533 | < | " [ %G %G %G ]\n" |
534 | < | " [ %G %G %G ]\n", |
530 | > | "electrostaticCutoffRadius is too large for the current\n" |
531 | > | "\tperiodic box.\n\n" |
532 | > | "\tCurrent Value of ECR = %G at time %G\n " |
533 | > | "\tThis is larger than half of at least one of the\n" |
534 | > | "\tperiodic box vectors. Right now, the Box matrix is:\n" |
535 | > | "\n" |
536 | > | "\t[ %G %G %G ]\n" |
537 | > | "\t[ %G %G %G ]\n" |
538 | > | "\t[ %G %G %G ]\n", |
539 | ecr, currentTime, | |
540 | Hmat[0][0], Hmat[0][1], Hmat[0][2], | |
541 | Hmat[1][0], Hmat[1][1], Hmat[1][2], | |
# | Line 596 | Line 547 | void SimInfo::checkCutOffs( void ){ | |
547 | } else { | |
548 | // initialize this stuff before using it, OK? | |
549 | sprintf( painCave.errMsg, | |
550 | < | "Trying to check cutoffs without a box. Be smarter.\n" ); |
550 | > | "Trying to check cutoffs without a box.\n" |
551 | > | "\tOOPSE should have better programmers than that.\n" ); |
552 | painCave.isFatal = 1; | |
553 | simError(); | |
554 | } | |
# | Line 639 | Line 591 | GenericData* SimInfo::getProperty(const string& propNa | |
591 | return NULL; | |
592 | } | |
593 | ||
642 | – | vector<GenericData*> SimInfo::getProperties(){ |
643 | – | |
644 | – | vector<GenericData*> result; |
645 | – | map<string, GenericData*>::iterator i; |
646 | – | |
647 | – | for(i = properties.begin(); i != properties.end(); i++) |
648 | – | result.push_back((*i).second); |
649 | – | |
650 | – | return result; |
651 | – | } |
652 | – | |
653 | – | double SimInfo::matTrace3(double m[3][3]){ |
654 | – | double trace; |
655 | – | trace = m[0][0] + m[1][1] + m[2][2]; |
656 | – | |
657 | – | return trace; |
658 | – | } |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |