# | Line 42 | Line 42 | SimInfo::SimInfo(){ | |
---|---|---|
42 | thermalTime = 0.0; | |
43 | currentTime = 0.0; | |
44 | rCut = 0.0; | |
45 | < | ecr = 0.0; |
46 | < | est = 0.0; |
45 | > | rSw = 0.0; |
46 | ||
47 | haveRcut = 0; | |
48 | < | haveEcr = 0; |
48 | > | haveRsw = 0; |
49 | boxIsInit = 0; | |
50 | ||
51 | resetTime = 1e99; | |
# | Line 63 | Line 62 | SimInfo::SimInfo(){ | |
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(); | |
# | Line 71 | Line 74 | SimInfo::SimInfo(){ | |
74 | has_minimizer = false; | |
75 | the_minimizer =NULL; | |
76 | ||
77 | + | ngroup = 0; |
78 | + | |
79 | wrapMeSimInfo( this ); | |
80 | } | |
81 | ||
# | Line 83 | 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 322 | Line 327 | int SimInfo::getNDF(){ | |
327 | int SimInfo::getNDF(){ | |
328 | int ndf_local; | |
329 | ||
330 | + | ndf_local = 0; |
331 | + | |
332 | for(int i = 0; i < integrableObjects.size(); i++){ | |
333 | ndf_local += 3; | |
334 | < | if (integrableObjects[i]->isDirectional()) |
335 | < | ndf_local += 3; |
334 | > | if (integrableObjects[i]->isDirectional()) { |
335 | > | if (integrableObjects[i]->isLinear()) |
336 | > | ndf_local += 2; |
337 | > | else |
338 | > | ndf_local += 3; |
339 | > | } |
340 | } | |
341 | ||
342 | // n_constraints is local, so subtract them on each processor: | |
# | Line 350 | Line 361 | int SimInfo::getNDFraw() { | |
361 | int ndfRaw_local; | |
362 | ||
363 | // Raw degrees of freedom that we have to set | |
364 | + | ndfRaw_local = 0; |
365 | ||
366 | for(int i = 0; i < integrableObjects.size(); i++){ | |
367 | ndfRaw_local += 3; | |
368 | < | if (integrableObjects[i]->isDirectional()) |
369 | < | ndfRaw_local += 3; |
368 | > | if (integrableObjects[i]->isDirectional()) { |
369 | > | if (integrableObjects[i]->isLinear()) |
370 | > | ndfRaw_local += 2; |
371 | > | else |
372 | > | ndfRaw_local += 3; |
373 | > | } |
374 | } | |
375 | ||
376 | #ifdef IS_MPI | |
# | Line 428 | Line 444 | void SimInfo::refreshSim(){ | |
444 | ||
445 | n_exclude = excludes->getSize(); | |
446 | excl = excludes->getFortranArray(); | |
447 | < | |
447 | > | |
448 | #ifdef IS_MPI | |
449 | < | n_global = mpiSim->getTotAtoms(); |
449 | > | n_global = mpiSim->getNAtomsGlobal(); |
450 | #else | |
451 | n_global = n_atoms; | |
452 | #endif | |
453 | < | |
453 | > | |
454 | isError = 0; | |
455 | < | |
456 | < | setFsimulation( &fInfo, &n_global, &n_atoms, identArray, &n_exclude, excl, |
457 | < | &nGlobalExcludes, globalExcludes, molMembershipArray, |
458 | < | &isError ); |
459 | < | |
460 | < | if( isError ){ |
461 | < | |
455 | > | |
456 | > | getFortranGroupArrays(this, FglobalGroupMembership, mfact); |
457 | > | //it may not be a good idea to pass the address of first element in vector |
458 | > | //since c++ standard does not require vector to be stored continuously in meomory |
459 | > | //Most of the compilers will organize the memory of vector continuously |
460 | > | setFsimulation( &fInfo, &n_global, &n_atoms, identArray, &n_exclude, excl, |
461 | > | &nGlobalExcludes, globalExcludes, molMembershipArray, |
462 | > | &mfact[0], &ngroup, &FglobalGroupMembership[0], &isError); |
463 | > | |
464 | > | if( isError ){ |
465 | > | |
466 | sprintf( painCave.errMsg, | |
467 | < | "There was an error setting the simulation information in fortran.\n" ); |
467 | > | "There was an error setting the simulation information in fortran.\n" ); |
468 | painCave.isFatal = 1; | |
469 | simError(); | |
470 | } | |
471 | < | |
471 | > | |
472 | #ifdef IS_MPI | |
473 | sprintf( checkPointMsg, | |
474 | "succesfully sent the simulation information to fortran.\n"); | |
475 | MPIcheckPoint(); | |
476 | #endif // is_mpi | |
477 | < | |
477 | > | |
478 | this->ndf = this->getNDF(); | |
479 | this->ndfRaw = this->getNDFraw(); | |
480 | this->ndfTrans = this->getNDFtranslational(); | |
481 | } | |
482 | ||
483 | void SimInfo::setDefaultRcut( double theRcut ){ | |
484 | < | |
484 | > | |
485 | haveRcut = 1; | |
486 | rCut = theRcut; | |
487 | < | |
468 | < | ( rCut > ecr )? rList = rCut + 1.0: rList = ecr + 1.0; |
469 | < | |
470 | < | notifyFortranCutOffs( &rCut, &rList, &ecr, &est ); |
471 | < | } |
472 | < | |
473 | < | void SimInfo::setDefaultEcr( double theEcr ){ |
474 | < | |
475 | < | haveEcr = 1; |
476 | < | ecr = theEcr; |
487 | > | rList = rCut + 1.0; |
488 | ||
489 | < | ( rCut > ecr )? rList = rCut + 1.0: rList = ecr + 1.0; |
479 | < | |
480 | < | notifyFortranCutOffs( &rCut, &rList, &ecr, &est ); |
489 | > | notifyFortranCutOffs( &rCut, &rSw, &rList ); |
490 | } | |
491 | ||
492 | < | void SimInfo::setDefaultEcr( double theEcr, double theEst ){ |
492 | > | void SimInfo::setDefaultRcut( double theRcut, double theRsw ){ |
493 | ||
494 | < | est = theEst; |
495 | < | setDefaultEcr( theEcr ); |
494 | > | rSw = theRsw; |
495 | > | setDefaultRcut( theRcut ); |
496 | } | |
497 | ||
498 | ||
# | Line 495 | Line 504 | void SimInfo::checkCutOffs( void ){ | |
504 | ||
505 | if( rCut > maxCutoff ){ | |
506 | sprintf( painCave.errMsg, | |
507 | < | "LJrcut is too large for the current periodic box.\n" |
508 | < | "\tCurrent Value of LJrcut = %G at time %G\n " |
507 | > | "cutoffRadius is too large for the current periodic box.\n" |
508 | > | "\tCurrent Value of cutoffRadius = %G at time %G\n " |
509 | "\tThis is larger than half of at least one of the\n" | |
510 | "\tperiodic box vectors. Right now, the Box matrix is:\n" | |
511 | < | "\n, %G" |
511 | > | "\n" |
512 | "\t[ %G %G %G ]\n" | |
513 | "\t[ %G %G %G ]\n" | |
514 | "\t[ %G %G %G ]\n", | |
515 | < | rCut, currentTime, maxCutoff, |
515 | > | rCut, currentTime, |
516 | Hmat[0][0], Hmat[0][1], Hmat[0][2], | |
517 | Hmat[1][0], Hmat[1][1], Hmat[1][2], | |
518 | Hmat[2][0], Hmat[2][1], Hmat[2][2]); | |
519 | painCave.isFatal = 1; | |
520 | simError(); | |
521 | < | } |
513 | < | |
514 | < | if( haveEcr ){ |
515 | < | if( ecr > maxCutoff ){ |
516 | < | sprintf( painCave.errMsg, |
517 | < | "electrostaticCutoffRadius is too large for the current\n" |
518 | < | "\tperiodic box.\n\n" |
519 | < | "\tCurrent Value of ECR = %G at time %G\n " |
520 | < | "\tThis is larger than half of at least one of the\n" |
521 | < | "\tperiodic box vectors. Right now, the Box matrix is:\n" |
522 | < | "\n" |
523 | < | "\t[ %G %G %G ]\n" |
524 | < | "\t[ %G %G %G ]\n" |
525 | < | "\t[ %G %G %G ]\n", |
526 | < | ecr, currentTime, |
527 | < | Hmat[0][0], Hmat[0][1], Hmat[0][2], |
528 | < | Hmat[1][0], Hmat[1][1], Hmat[1][2], |
529 | < | Hmat[2][0], Hmat[2][1], Hmat[2][2]); |
530 | < | painCave.isFatal = 1; |
531 | < | simError(); |
532 | < | } |
533 | < | } |
521 | > | } |
522 | } else { | |
523 | // initialize this stuff before using it, OK? | |
524 | sprintf( painCave.errMsg, | |
# | Line 578 | Line 566 | GenericData* SimInfo::getProperty(const string& propNa | |
566 | return NULL; | |
567 | } | |
568 | ||
581 | – | vector<GenericData*> SimInfo::getProperties(){ |
569 | ||
570 | < | vector<GenericData*> result; |
571 | < | map<string, GenericData*>::iterator i; |
570 | > | void SimInfo::getFortranGroupArrays(SimInfo* info, |
571 | > | vector<int>& FglobalGroupMembership, |
572 | > | vector<double>& mfact){ |
573 | ||
574 | < | for(i = properties.begin(); i != properties.end(); i++) |
575 | < | result.push_back((*i).second); |
576 | < | |
577 | < | return result; |
574 | > | Molecule* myMols; |
575 | > | Atom** myAtoms; |
576 | > | int numAtom; |
577 | > | double mtot; |
578 | > | int numMol; |
579 | > | int numCutoffGroups; |
580 | > | CutoffGroup* myCutoffGroup; |
581 | > | vector<CutoffGroup*>::iterator iterCutoff; |
582 | > | Atom* cutoffAtom; |
583 | > | vector<Atom*>::iterator iterAtom; |
584 | > | int atomIndex; |
585 | > | double totalMass; |
586 | > | |
587 | > | mfact.clear(); |
588 | > | FglobalGroupMembership.clear(); |
589 | > | |
590 | > | |
591 | > | // Fix the silly fortran indexing problem |
592 | > | #ifdef IS_MPI |
593 | > | numAtom = mpiSim->getNAtomsGlobal(); |
594 | > | #else |
595 | > | numAtom = n_atoms; |
596 | > | #endif |
597 | > | for (int i = 0; i < numAtom; i++) |
598 | > | FglobalGroupMembership.push_back(globalGroupMembership[i] + 1); |
599 | > | |
600 | > | myMols = info->molecules; |
601 | > | numMol = info->n_mol; |
602 | > | for(int i = 0; i < numMol; i++){ |
603 | > | numCutoffGroups = myMols[i].getNCutoffGroups(); |
604 | > | for(myCutoffGroup =myMols[i].beginCutoffGroup(iterCutoff); |
605 | > | myCutoffGroup != NULL; |
606 | > | myCutoffGroup =myMols[i].nextCutoffGroup(iterCutoff)){ |
607 | > | |
608 | > | totalMass = myCutoffGroup->getMass(); |
609 | > | |
610 | > | for(cutoffAtom = myCutoffGroup->beginAtom(iterAtom); |
611 | > | cutoffAtom != NULL; |
612 | > | cutoffAtom = myCutoffGroup->nextAtom(iterAtom)){ |
613 | > | mfact.push_back(cutoffAtom->getMass()/totalMass); |
614 | > | } |
615 | > | } |
616 | > | } |
617 | > | |
618 | } |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |