# | 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 | < | useMolecularCutoffs = 0; |
65 | > | |
66 | > | haveCutoffGroups = false; |
67 | ||
68 | excludes = Exclude::Instance(); | |
69 | ||
# | Line 452 | Line 452 | void SimInfo::refreshSim(){ | |
452 | isError = 0; | |
453 | ||
454 | getFortranGroupArray(this, mfact, ngroup, groupList, groupStart); | |
455 | < | |
455 | > | //it may not be a good idea to pass the address of first element in vector |
456 | > | //since c++ standard does not require vector to be stored continously in meomory |
457 | > | //Most of the compilers will organize the memory of vector continously |
458 | setFsimulation( &fInfo, &n_global, &n_atoms, identArray, &n_exclude, excl, | |
459 | &nGlobalExcludes, globalExcludes, molMembershipArray, | |
460 | &mfact[0], &ngroup, &groupList[0], &groupStart[0], &isError); | |
# | Line 480 | Line 482 | void SimInfo::setDefaultRcut( double theRcut ){ | |
482 | ||
483 | haveRcut = 1; | |
484 | rCut = theRcut; | |
485 | + | rList = rCut + 1.0; |
486 | ||
487 | < | ( rCut > ecr )? rList = rCut + 1.0: rList = ecr + 1.0; |
485 | < | |
486 | < | notifyFortranCutOffs( &rCut, &rList, &ecr, &est ); |
487 | > | notifyFortranCutOffs( &rCut, &rSw, &rList ); |
488 | } | |
489 | ||
490 | < | void SimInfo::setDefaultEcr( double theEcr ){ |
490 | > | void SimInfo::setDefaultRcut( double theRcut, double theRsw ){ |
491 | ||
492 | < | haveEcr = 1; |
493 | < | ecr = theEcr; |
493 | < | |
494 | < | ( rCut > ecr )? rList = rCut + 1.0: rList = ecr + 1.0; |
495 | < | |
496 | < | notifyFortranCutOffs( &rCut, &rList, &ecr, &est ); |
492 | > | rSw = theRsw; |
493 | > | setDefaultRcut( theRcut ); |
494 | } | |
495 | ||
499 | – | void SimInfo::setDefaultEcr( double theEcr, double theEst ){ |
496 | ||
501 | – | est = theEst; |
502 | – | setDefaultEcr( theEcr ); |
503 | – | } |
504 | – | |
505 | – | |
497 | void SimInfo::checkCutOffs( void ){ | |
498 | ||
499 | if( boxIsInit ){ | |
# | Line 511 | Line 502 | void SimInfo::checkCutOffs( void ){ | |
502 | ||
503 | if( rCut > maxCutoff ){ | |
504 | sprintf( painCave.errMsg, | |
505 | < | "LJrcut is too large for the current periodic box.\n" |
506 | < | "\tCurrent Value of LJrcut = %G at time %G\n " |
505 | > | "cutoffRadius is too large for the current periodic box.\n" |
506 | > | "\tCurrent Value of cutoffRadius = %G at time %G\n " |
507 | "\tThis is larger than half of at least one of the\n" | |
508 | "\tperiodic box vectors. Right now, the Box matrix is:\n" | |
509 | "\n" | |
# | Line 525 | Line 516 | void SimInfo::checkCutOffs( void ){ | |
516 | Hmat[2][0], Hmat[2][1], Hmat[2][2]); | |
517 | painCave.isFatal = 1; | |
518 | simError(); | |
519 | < | } |
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 | < | } |
519 | > | } |
520 | } else { | |
521 | // initialize this stuff before using it, OK? | |
522 | sprintf( painCave.errMsg, | |
# | Line 597 | Line 567 | void getFortranGroupArray(SimInfo* info, vector<double | |
567 | ||
568 | void getFortranGroupArray(SimInfo* info, vector<double>& mfact, int& ngroup, | |
569 | vector<int>& groupList, vector<int>& groupStart){ | |
570 | < | Molecule* mol; |
570 | > | Molecule* myMols; |
571 | Atom** myAtoms; | |
572 | int numAtom; | |
573 | int curIndex; | |
574 | double mtot; | |
575 | < | |
575 | > | int numMol; |
576 | > | int numCutoffGroups; |
577 | > | CutoffGroup* myCutoffGroup; |
578 | > | vector<CutoffGroup*>::iterator iterCutoff; |
579 | > | Atom* cutoffAtom; |
580 | > | vector<Atom*>::iterator iterAtom; |
581 | > | int atomIndex; |
582 | > | double totalMass; |
583 | > | |
584 | mfact.clear(); | |
585 | groupList.clear(); | |
586 | groupStart.clear(); | |
587 | ||
588 | //Be careful, fortran array begin at 1 | |
589 | curIndex = 1; | |
590 | < | |
591 | < | if(info->useMolecularCutoffs){ |
592 | < | |
593 | < | #ifdef IS_MPI |
594 | < | ngroup = mpiSim->getMyNMol(); |
595 | < | #else |
596 | < | ngroup = info->n_mol; |
619 | < | #endif |
590 | > | |
591 | > | myMols = info->molecules; |
592 | > | numMol = info->n_mol; |
593 | > | for(int i = 0; i < numMol; i++){ |
594 | > | numAtom = myMols[i].getNAtoms(); |
595 | > | myAtoms = myMols[i].getMyAtoms(); |
596 | > | |
597 | ||
598 | < | for(int i = 0; i < ngroup; i ++){ |
622 | < | mol = &(info->molecules[i]); |
623 | < | numAtom = mol->getNAtoms(); |
624 | < | myAtoms = mol->getMyAtoms(); |
625 | < | mtot = 0.0; |
598 | > | for(int j = 0; j < numAtom; j++){ |
599 | ||
627 | – | for(int j=0; j < numAtom; j++) |
628 | – | mtot += myAtoms[j]->getMass(); |
629 | – | |
630 | – | for(int j=0; j < numAtom; j++){ |
631 | – | |
632 | – | // We want the local Index: |
633 | – | groupList.push_back(myAtoms[j]->getIndex() + 1); |
634 | – | mfact.push_back(myAtoms[j]->getMass() / mtot); |
635 | – | |
636 | – | } |
637 | – | |
638 | – | groupStart.push_back(curIndex); |
639 | – | curIndex += numAtom; |
640 | – | |
641 | – | } //end for(int i =0 ; i < ngroup; i++) |
642 | – | } |
643 | – | else{ |
644 | – | //using atomic cutoff, every single atom is just a group |
600 | ||
601 | < | #ifdef IS_MPI |
602 | < | ngroup = mpiSim->getMyNlocal(); |
601 | > | #ifdef IS_MPI |
602 | > | atomIndex = myAtoms[j]->getGlobalIndex(); |
603 | #else | |
604 | < | ngroup = info->n_atoms; |
604 | > | atomIndex = myAtoms[j]->getIndex(); |
605 | #endif | |
606 | < | |
607 | < | for(int i =0 ; i < ngroup; i++){ |
608 | < | groupStart.push_back(curIndex++); |
609 | < | groupList.push_back((info->atoms[i])->getIndex() + 1); |
610 | < | mfact.push_back(1.0); |
606 | > | |
607 | > | if(myMols[i].belongToCutoffGroup(atomIndex)) |
608 | > | continue; |
609 | > | else{ |
610 | > | // this is a fraction of the cutoff group's mass, not the mass itself! |
611 | > | mfact.push_back(1.0); |
612 | > | groupList.push_back(myAtoms[j]->getIndex() + 1); |
613 | > | groupStart.push_back(curIndex++); |
614 | > | } |
615 | > | } |
616 | ||
617 | < | }//end for(int i =0 ; i < ngroup; i++) |
618 | < | |
619 | < | }//end if (info->useMolecularCutoffs) |
617 | > | numCutoffGroups = myMols[i].getNCutoffGroups(); |
618 | > | for(myCutoffGroup =myMols[i].beginCutoffGroup(iterCutoff); myCutoffGroup != NULL; |
619 | > | myCutoffGroup =myMols[i].nextCutoffGroup(iterCutoff)){ |
620 | > | |
621 | > | totalMass = myCutoffGroup->getMass(); |
622 | > | |
623 | > | for(cutoffAtom = myCutoffGroup->beginAtom(iterAtom); cutoffAtom != NULL; |
624 | > | cutoffAtom = myCutoffGroup->nextAtom(iterAtom)){ |
625 | > | mfact.push_back(cutoffAtom->getMass()/totalMass); |
626 | > | groupList.push_back(cutoffAtom->getIndex() + 1); |
627 | > | } |
628 | > | |
629 | > | groupStart.push_back(curIndex); |
630 | > | curIndex += myCutoffGroup->getNumAtom(); |
631 | > | |
632 | > | }//end for(myCutoffGroup =myMols[i].beginCutoffGroup(iterCutoff)) |
633 | > | |
634 | > | }//end for(int i = 0; i < numMol; i++) |
635 | ||
636 | + | ngroup = groupStart.size(); |
637 | } |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |