# | 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 40 | Line 42 | SimInfo::SimInfo(){ | |
42 | thermalTime = 0.0; | |
43 | currentTime = 0.0; | |
44 | rCut = 0.0; | |
45 | < | ecr = 0.0; |
44 | < | est = 0.0; |
45 | > | rSw = 0.0; |
46 | ||
47 | haveRcut = 0; | |
48 | < | haveEcr = 0; |
48 | > | haveRsw = 0; |
49 | boxIsInit = 0; | |
50 | ||
51 | resetTime = 1e99; | |
52 | ||
53 | + | orthoRhombic = 0; |
54 | orthoTolerance = 1E-6; | |
55 | useInitXSstate = true; | |
56 | ||
# | Line 61 | Line 63 | SimInfo::SimInfo(){ | |
63 | useGB = 0; | |
64 | useEAM = 0; | |
65 | ||
66 | + | excludes = Exclude::Instance(); |
67 | + | |
68 | myConfiguration = new SimState(); | |
69 | ||
70 | has_minimizer = false; | |
71 | the_minimizer =NULL; | |
72 | ||
73 | + | ngroup = 0; |
74 | + | |
75 | wrapMeSimInfo( this ); | |
76 | } | |
77 | ||
# | Line 78 | Line 84 | SimInfo::~SimInfo(){ | |
84 | ||
85 | for(i = properties.begin(); i != properties.end(); i++) | |
86 | delete (*i).second; | |
87 | < | |
87 | > | |
88 | } | |
89 | ||
90 | void SimInfo::setBox(double newBox[3]) { | |
# | Line 183 | Line 189 | void SimInfo::calcHmatInv( void ) { | |
189 | ||
190 | if( orthoRhombic ){ | |
191 | sprintf( painCave.errMsg, | |
192 | < | "Hmat is switching from Non-Orthorhombic to Orthorhombic Box.\n" |
193 | < | "\tIf this is a bad thing, change the orthoBoxTolerance\n" |
194 | < | "\tvariable ( currently set to %G ).\n", |
192 | > | "OOPSE is switching from the default Non-Orthorhombic\n" |
193 | > | "\tto the faster Orthorhombic periodic boundary computations.\n" |
194 | > | "\tThis is usually a good thing, but if you wan't the\n" |
195 | > | "\tNon-Orthorhombic computations, make the orthoBoxTolerance\n" |
196 | > | "\tvariable ( currently set to %G ) smaller.\n", |
197 | orthoTolerance); | |
198 | simError(); | |
199 | } | |
200 | else { | |
201 | sprintf( painCave.errMsg, | |
202 | < | "Hmat is switching from Orthorhombic to Non-Orthorhombic Box.\n" |
203 | < | "\tIf this is a bad thing, change the orthoBoxTolerance\n" |
204 | < | "\tvariable ( currently set to %G ).\n", |
202 | > | "OOPSE is switching from the faster Orthorhombic to the more\n" |
203 | > | "\tflexible Non-Orthorhombic periodic boundary computations.\n" |
204 | > | "\tThis is usually because the box has deformed under\n" |
205 | > | "\tNPTf integration. If you wan't to live on the edge with\n" |
206 | > | "\tthe Orthorhombic computations, make the orthoBoxTolerance\n" |
207 | > | "\tvariable ( currently set to %G ) larger.\n", |
208 | orthoTolerance); | |
209 | simError(); | |
210 | } | |
211 | } | |
212 | } | |
213 | ||
203 | – | double SimInfo::matDet3(double a[3][3]) { |
204 | – | int i, j, k; |
205 | – | double determinant; |
206 | – | |
207 | – | determinant = 0.0; |
208 | – | |
209 | – | for(i = 0; i < 3; i++) { |
210 | – | j = (i+1)%3; |
211 | – | k = (i+2)%3; |
212 | – | |
213 | – | determinant += a[0][i] * (a[1][j]*a[2][k] - a[1][k]*a[2][j]); |
214 | – | } |
215 | – | |
216 | – | return determinant; |
217 | – | } |
218 | – | |
219 | – | void SimInfo::invertMat3(double a[3][3], double b[3][3]) { |
220 | – | |
221 | – | int i, j, k, l, m, n; |
222 | – | double determinant; |
223 | – | |
224 | – | determinant = matDet3( a ); |
225 | – | |
226 | – | if (determinant == 0.0) { |
227 | – | sprintf( painCave.errMsg, |
228 | – | "Can't invert a matrix with a zero determinant!\n"); |
229 | – | painCave.isFatal = 1; |
230 | – | simError(); |
231 | – | } |
232 | – | |
233 | – | for (i=0; i < 3; i++) { |
234 | – | j = (i+1)%3; |
235 | – | k = (i+2)%3; |
236 | – | for(l = 0; l < 3; l++) { |
237 | – | m = (l+1)%3; |
238 | – | n = (l+2)%3; |
239 | – | |
240 | – | b[l][i] = (a[j][m]*a[k][n] - a[j][n]*a[k][m]) / determinant; |
241 | – | } |
242 | – | } |
243 | – | } |
244 | – | |
245 | – | void SimInfo::matMul3(double a[3][3], double b[3][3], double c[3][3]) { |
246 | – | double r00, r01, r02, r10, r11, r12, r20, r21, r22; |
247 | – | |
248 | – | r00 = a[0][0]*b[0][0] + a[0][1]*b[1][0] + a[0][2]*b[2][0]; |
249 | – | r01 = a[0][0]*b[0][1] + a[0][1]*b[1][1] + a[0][2]*b[2][1]; |
250 | – | r02 = a[0][0]*b[0][2] + a[0][1]*b[1][2] + a[0][2]*b[2][2]; |
251 | – | |
252 | – | r10 = a[1][0]*b[0][0] + a[1][1]*b[1][0] + a[1][2]*b[2][0]; |
253 | – | r11 = a[1][0]*b[0][1] + a[1][1]*b[1][1] + a[1][2]*b[2][1]; |
254 | – | r12 = a[1][0]*b[0][2] + a[1][1]*b[1][2] + a[1][2]*b[2][2]; |
255 | – | |
256 | – | r20 = a[2][0]*b[0][0] + a[2][1]*b[1][0] + a[2][2]*b[2][0]; |
257 | – | r21 = a[2][0]*b[0][1] + a[2][1]*b[1][1] + a[2][2]*b[2][1]; |
258 | – | r22 = a[2][0]*b[0][2] + a[2][1]*b[1][2] + a[2][2]*b[2][2]; |
259 | – | |
260 | – | c[0][0] = r00; c[0][1] = r01; c[0][2] = r02; |
261 | – | c[1][0] = r10; c[1][1] = r11; c[1][2] = r12; |
262 | – | c[2][0] = r20; c[2][1] = r21; c[2][2] = r22; |
263 | – | } |
264 | – | |
265 | – | void SimInfo::matVecMul3(double m[3][3], double inVec[3], double outVec[3]) { |
266 | – | double a0, a1, a2; |
267 | – | |
268 | – | a0 = inVec[0]; a1 = inVec[1]; a2 = inVec[2]; |
269 | – | |
270 | – | outVec[0] = m[0][0]*a0 + m[0][1]*a1 + m[0][2]*a2; |
271 | – | outVec[1] = m[1][0]*a0 + m[1][1]*a1 + m[1][2]*a2; |
272 | – | outVec[2] = m[2][0]*a0 + m[2][1]*a1 + m[2][2]*a2; |
273 | – | } |
274 | – | |
275 | – | void SimInfo::transposeMat3(double in[3][3], double out[3][3]) { |
276 | – | double temp[3][3]; |
277 | – | int i, j; |
278 | – | |
279 | – | for (i = 0; i < 3; i++) { |
280 | – | for (j = 0; j < 3; j++) { |
281 | – | temp[j][i] = in[i][j]; |
282 | – | } |
283 | – | } |
284 | – | for (i = 0; i < 3; i++) { |
285 | – | for (j = 0; j < 3; j++) { |
286 | – | out[i][j] = temp[i][j]; |
287 | – | } |
288 | – | } |
289 | – | } |
290 | – | |
291 | – | void SimInfo::printMat3(double A[3][3] ){ |
292 | – | |
293 | – | std::cerr |
294 | – | << "[ " << A[0][0] << ", " << A[0][1] << ", " << A[0][2] << " ]\n" |
295 | – | << "[ " << A[1][0] << ", " << A[1][1] << ", " << A[1][2] << " ]\n" |
296 | – | << "[ " << A[2][0] << ", " << A[2][1] << ", " << A[2][2] << " ]\n"; |
297 | – | } |
298 | – | |
299 | – | void SimInfo::printMat9(double A[9] ){ |
300 | – | |
301 | – | std::cerr |
302 | – | << "[ " << A[0] << ", " << A[1] << ", " << A[2] << " ]\n" |
303 | – | << "[ " << A[3] << ", " << A[4] << ", " << A[5] << " ]\n" |
304 | – | << "[ " << A[6] << ", " << A[7] << ", " << A[8] << " ]\n"; |
305 | – | } |
306 | – | |
307 | – | |
308 | – | void SimInfo::crossProduct3(double a[3],double b[3], double out[3]){ |
309 | – | |
310 | – | out[0] = a[1] * b[2] - a[2] * b[1]; |
311 | – | out[1] = a[2] * b[0] - a[0] * b[2] ; |
312 | – | out[2] = a[0] * b[1] - a[1] * b[0]; |
313 | – | |
314 | – | } |
315 | – | |
316 | – | double SimInfo::dotProduct3(double a[3], double b[3]){ |
317 | – | return a[0]*b[0] + a[1]*b[1]+ a[2]*b[2]; |
318 | – | } |
319 | – | |
320 | – | double SimInfo::length3(double a[3]){ |
321 | – | return sqrt(a[0]*a[0] + a[1]*a[1] + a[2]*a[2]); |
322 | – | } |
323 | – | |
214 | void SimInfo::calcBoxL( void ){ | |
215 | ||
216 | double dx, dy, dz, dsq; | |
# | Line 376 | Line 266 | double SimInfo::calcMaxCutOff(){ | |
266 | rk[0] = Hmat[0][2]; | |
267 | rk[1] = Hmat[1][2]; | |
268 | rk[2] = Hmat[2][2]; | |
269 | < | |
270 | < | crossProduct3(ri,rj, rij); |
271 | < | distXY = dotProduct3(rk,rij) / length3(rij); |
269 | > | |
270 | > | crossProduct3(ri, rj, rij); |
271 | > | distXY = dotProduct3(rk,rij) / norm3(rij); |
272 | ||
273 | crossProduct3(rj,rk, rjk); | |
274 | < | distYZ = dotProduct3(ri,rjk) / length3(rjk); |
274 | > | distYZ = dotProduct3(ri,rjk) / norm3(rjk); |
275 | ||
276 | crossProduct3(rk,ri, rki); | |
277 | < | distZX = dotProduct3(rj,rki) / length3(rki); |
277 | > | distZX = dotProduct3(rj,rki) / norm3(rki); |
278 | ||
279 | minDist = min(min(distXY, distYZ), distZX); | |
280 | return minDist/2; | |
# | Line 432 | Line 322 | int SimInfo::getNDF(){ | |
322 | ||
323 | int SimInfo::getNDF(){ | |
324 | int ndf_local; | |
325 | + | |
326 | + | ndf_local = 0; |
327 | ||
328 | < | ndf_local = 3 * n_atoms + 3 * n_oriented - n_constraints; |
328 | > | for(int i = 0; i < integrableObjects.size(); i++){ |
329 | > | ndf_local += 3; |
330 | > | if (integrableObjects[i]->isDirectional()) { |
331 | > | if (integrableObjects[i]->isLinear()) |
332 | > | ndf_local += 2; |
333 | > | else |
334 | > | ndf_local += 3; |
335 | > | } |
336 | > | } |
337 | ||
338 | + | // n_constraints is local, so subtract them on each processor: |
339 | + | |
340 | + | ndf_local -= n_constraints; |
341 | + | |
342 | #ifdef IS_MPI | |
343 | MPI_Allreduce(&ndf_local,&ndf,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD); | |
344 | #else | |
345 | ndf = ndf_local; | |
346 | #endif | |
347 | ||
348 | + | // nZconstraints is global, as are the 3 COM translations for the |
349 | + | // entire system: |
350 | + | |
351 | ndf = ndf - 3 - nZconstraints; | |
352 | ||
353 | return ndf; | |
# | Line 450 | Line 357 | int SimInfo::getNDFraw() { | |
357 | int ndfRaw_local; | |
358 | ||
359 | // Raw degrees of freedom that we have to set | |
360 | < | ndfRaw_local = 3 * n_atoms + 3 * n_oriented; |
361 | < | |
360 | > | ndfRaw_local = 0; |
361 | > | |
362 | > | for(int i = 0; i < integrableObjects.size(); i++){ |
363 | > | ndfRaw_local += 3; |
364 | > | if (integrableObjects[i]->isDirectional()) { |
365 | > | if (integrableObjects[i]->isLinear()) |
366 | > | ndfRaw_local += 2; |
367 | > | else |
368 | > | ndfRaw_local += 3; |
369 | > | } |
370 | > | } |
371 | > | |
372 | #ifdef IS_MPI | |
373 | MPI_Allreduce(&ndfRaw_local,&ndfRaw,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD); | |
374 | #else | |
# | Line 464 | Line 381 | int SimInfo::getNDFtranslational() { | |
381 | int SimInfo::getNDFtranslational() { | |
382 | int ndfTrans_local; | |
383 | ||
384 | < | ndfTrans_local = 3 * n_atoms - n_constraints; |
384 | > | ndfTrans_local = 3 * integrableObjects.size() - n_constraints; |
385 | ||
386 | + | |
387 | #ifdef IS_MPI | |
388 | MPI_Allreduce(&ndfTrans_local,&ndfTrans,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD); | |
389 | #else | |
# | Line 477 | Line 395 | int SimInfo::getNDFtranslational() { | |
395 | return ndfTrans; | |
396 | } | |
397 | ||
398 | + | int SimInfo::getTotIntegrableObjects() { |
399 | + | int nObjs_local; |
400 | + | int nObjs; |
401 | + | |
402 | + | nObjs_local = integrableObjects.size(); |
403 | + | |
404 | + | |
405 | + | #ifdef IS_MPI |
406 | + | MPI_Allreduce(&nObjs_local,&nObjs,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD); |
407 | + | #else |
408 | + | nObjs = nObjs_local; |
409 | + | #endif |
410 | + | |
411 | + | |
412 | + | return nObjs; |
413 | + | } |
414 | + | |
415 | void SimInfo::refreshSim(){ | |
416 | ||
417 | simtype fInfo; | |
# | Line 503 | Line 438 | void SimInfo::refreshSim(){ | |
438 | fInfo.SIM_uses_GB = useGB; | |
439 | fInfo.SIM_uses_EAM = useEAM; | |
440 | ||
441 | < | excl = Exclude::getArray(); |
442 | < | |
441 | > | n_exclude = excludes->getSize(); |
442 | > | excl = excludes->getFortranArray(); |
443 | > | |
444 | #ifdef IS_MPI | |
445 | n_global = mpiSim->getTotAtoms(); | |
446 | #else | |
447 | n_global = n_atoms; | |
448 | #endif | |
449 | < | |
449 | > | |
450 | isError = 0; | |
451 | < | |
451 | > | |
452 | > | getFortranGroupArray(this, mfact, ngroup, groupList, groupStart); |
453 | > | |
454 | setFsimulation( &fInfo, &n_global, &n_atoms, identArray, &n_exclude, excl, | |
455 | < | &nGlobalExcludes, globalExcludes, molMembershipArray, |
456 | < | &isError ); |
457 | < | |
455 | > | &nGlobalExcludes, globalExcludes, molMembershipArray, |
456 | > | &mfact[0], &ngroup, &groupList[0], &groupStart[0], &isError); |
457 | > | |
458 | if( isError ){ | |
459 | < | |
459 | > | |
460 | sprintf( painCave.errMsg, | |
461 | < | "There was an error setting the simulation information in fortran.\n" ); |
461 | > | "There was an error setting the simulation information in fortran.\n" ); |
462 | painCave.isFatal = 1; | |
463 | simError(); | |
464 | } | |
465 | < | |
465 | > | |
466 | #ifdef IS_MPI | |
467 | sprintf( checkPointMsg, | |
468 | "succesfully sent the simulation information to fortran.\n"); | |
469 | MPIcheckPoint(); | |
470 | #endif // is_mpi | |
471 | < | |
471 | > | |
472 | this->ndf = this->getNDF(); | |
473 | this->ndfRaw = this->getNDFraw(); | |
474 | this->ndfTrans = this->getNDFtranslational(); | |
475 | } | |
476 | ||
477 | void SimInfo::setDefaultRcut( double theRcut ){ | |
478 | < | |
478 | > | |
479 | haveRcut = 1; | |
480 | rCut = theRcut; | |
481 | < | |
544 | < | ( rCut > ecr )? rList = rCut + 1.0: rList = ecr + 1.0; |
545 | < | |
546 | < | notifyFortranCutOffs( &rCut, &rList, &ecr, &est ); |
547 | < | } |
548 | < | |
549 | < | void SimInfo::setDefaultEcr( double theEcr ){ |
550 | < | |
551 | < | haveEcr = 1; |
552 | < | ecr = theEcr; |
481 | > | rList = rCut + 1.0; |
482 | ||
483 | < | ( rCut > ecr )? rList = rCut + 1.0: rList = ecr + 1.0; |
555 | < | |
556 | < | notifyFortranCutOffs( &rCut, &rList, &ecr, &est ); |
483 | > | notifyFortranCutOffs( &rCut, &rSw, &rList ); |
484 | } | |
485 | ||
486 | < | void SimInfo::setDefaultEcr( double theEcr, double theEst ){ |
486 | > | void SimInfo::setDefaultRcut( double theRcut, double theRsw ){ |
487 | ||
488 | < | est = theEst; |
489 | < | setDefaultEcr( theEcr ); |
488 | > | rSw = theRsw; |
489 | > | setDefaultRcut( theRcut ); |
490 | } | |
491 | ||
492 | ||
# | Line 571 | Line 498 | void SimInfo::checkCutOffs( void ){ | |
498 | ||
499 | if( rCut > maxCutoff ){ | |
500 | sprintf( painCave.errMsg, | |
501 | < | "Box size is too small for the long range cutoff radius, " |
502 | < | "%G, at time %G\n" |
501 | > | "cutoffRadius is too large for the current periodic box.\n" |
502 | > | "\tCurrent Value of cutoffRadius = %G at time %G\n " |
503 | > | "\tThis is larger than half of at least one of the\n" |
504 | > | "\tperiodic box vectors. Right now, the Box matrix is:\n" |
505 | > | "\n" |
506 | "\t[ %G %G %G ]\n" | |
507 | "\t[ %G %G %G ]\n" | |
508 | "\t[ %G %G %G ]\n", | |
# | Line 582 | Line 512 | void SimInfo::checkCutOffs( void ){ | |
512 | Hmat[2][0], Hmat[2][1], Hmat[2][2]); | |
513 | painCave.isFatal = 1; | |
514 | simError(); | |
515 | < | } |
586 | < | |
587 | < | if( haveEcr ){ |
588 | < | if( ecr > maxCutoff ){ |
589 | < | sprintf( painCave.errMsg, |
590 | < | "Box size is too small for the electrostatic cutoff radius, " |
591 | < | "%G, at time %G\n" |
592 | < | "\t[ %G %G %G ]\n" |
593 | < | "\t[ %G %G %G ]\n" |
594 | < | "\t[ %G %G %G ]\n", |
595 | < | ecr, currentTime, |
596 | < | Hmat[0][0], Hmat[0][1], Hmat[0][2], |
597 | < | Hmat[1][0], Hmat[1][1], Hmat[1][2], |
598 | < | Hmat[2][0], Hmat[2][1], Hmat[2][2]); |
599 | < | painCave.isFatal = 1; |
600 | < | simError(); |
601 | < | } |
602 | < | } |
515 | > | } |
516 | } else { | |
517 | // initialize this stuff before using it, OK? | |
518 | sprintf( painCave.errMsg, | |
# | Line 647 | Line 560 | GenericData* SimInfo::getProperty(const string& propNa | |
560 | return NULL; | |
561 | } | |
562 | ||
650 | – | vector<GenericData*> SimInfo::getProperties(){ |
563 | ||
564 | < | vector<GenericData*> result; |
565 | < | map<string, GenericData*>::iterator i; |
564 | > | void getFortranGroupArray(SimInfo* info, vector<double>& mfact, int& ngroup, |
565 | > | vector<int>& groupList, vector<int>& groupStart){ |
566 | > | Molecule* mol; |
567 | > | Atom** myAtoms; |
568 | > | int numAtom; |
569 | > | int curIndex; |
570 | > | double mtot; |
571 | > | |
572 | > | mfact.clear(); |
573 | > | groupList.clear(); |
574 | > | groupStart.clear(); |
575 | ||
576 | < | for(i = properties.begin(); i != properties.end(); i++) |
577 | < | result.push_back((*i).second); |
576 | > | //Be careful, fortran array begin at 1 |
577 | > | curIndex = 1; |
578 | > | |
579 | > | if(info->useMolecularCutoffs){ |
580 | ||
581 | < | return result; |
582 | < | } |
581 | > | #ifdef IS_MPI |
582 | > | ngroup = mpiSim->getMyNMol(); |
583 | > | #else |
584 | > | ngroup = info->n_mol; |
585 | > | #endif |
586 | > | |
587 | > | for(int i = 0; i < ngroup; i ++){ |
588 | > | mol = &(info->molecules[i]); |
589 | > | numAtom = mol->getNAtoms(); |
590 | > | myAtoms = mol->getMyAtoms(); |
591 | > | mtot = 0.0; |
592 | ||
593 | < | double SimInfo::matTrace3(double m[3][3]){ |
594 | < | double trace; |
595 | < | trace = m[0][0] + m[1][1] + m[2][2]; |
593 | > | for(int j=0; j < numAtom; j++) |
594 | > | mtot += myAtoms[j]->getMass(); |
595 | > | |
596 | > | for(int j=0; j < numAtom; j++){ |
597 | > | |
598 | > | // We want the local Index: |
599 | > | groupList.push_back(myAtoms[j]->getIndex() + 1); |
600 | > | mfact.push_back(myAtoms[j]->getMass() / mtot); |
601 | ||
602 | < | return trace; |
602 | > | } |
603 | > | |
604 | > | groupStart.push_back(curIndex); |
605 | > | curIndex += numAtom; |
606 | > | |
607 | > | } //end for(int i =0 ; i < ngroup; i++) |
608 | > | } |
609 | > | else{ |
610 | > | //using atomic cutoff, every single atom is just a group |
611 | > | |
612 | > | #ifdef IS_MPI |
613 | > | ngroup = mpiSim->getMyNlocal(); |
614 | > | #else |
615 | > | ngroup = info->n_atoms; |
616 | > | #endif |
617 | > | |
618 | > | for(int i =0 ; i < ngroup; i++){ |
619 | > | groupStart.push_back(curIndex++); |
620 | > | groupList.push_back((info->atoms[i])->getIndex() + 1); |
621 | > | mfact.push_back(1.0); |
622 | > | |
623 | > | }//end for(int i =0 ; i < ngroup; i++) |
624 | > | |
625 | > | }//end if (info->useMolecularCutoffs) |
626 | > | |
627 | } |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |