# | Line 54 | Line 54 | |
---|---|---|
54 | #include "math/Vector3.hpp" | |
55 | #include "primitives/Molecule.hpp" | |
56 | #include "primitives/StuntDouble.hpp" | |
57 | – | #include "UseTheForce/doForces_interface.h" |
57 | #include "UseTheForce/DarkSide/neighborLists_interface.h" | |
58 | + | #include "UseTheForce/doForces_interface.h" |
59 | #include "utils/MemoryUtils.hpp" | |
60 | #include "utils/simError.h" | |
61 | #include "selection/SelectionManager.hpp" | |
# | Line 132 | Line 132 | namespace OpenMD { | |
132 | //equal to the total number of atoms minus number of atoms belong to | |
133 | //cutoff group defined in meta-data file plus the number of cutoff | |
134 | //groups defined in meta-data file | |
135 | + | std::cerr << "nGA = " << nGlobalAtoms_ << "\n"; |
136 | + | std::cerr << "nCA = " << nCutoffAtoms << "\n"; |
137 | + | std::cerr << "nG = " << nGroups << "\n"; |
138 | + | |
139 | nGlobalCutoffGroups_ = nGlobalAtoms_ - nCutoffAtoms + nGroups; | |
140 | + | |
141 | + | std::cerr << "nGCG = " << nGlobalCutoffGroups_ << "\n"; |
142 | ||
143 | //every free atom (atom does not belong to rigid bodies) is an | |
144 | //integrable object therefore the total number of integrable objects | |
# | Line 656 | Line 662 | namespace OpenMD { | |
662 | /** | |
663 | * update | |
664 | * | |
665 | < | * Performs the global checks and variable settings after the objects have been |
666 | < | * created. |
665 | > | * Performs the global checks and variable settings after the |
666 | > | * objects have been created. |
667 | * | |
668 | */ | |
669 | < | void SimInfo::update() { |
664 | < | |
669 | > | void SimInfo::update() { |
670 | setupSimVariables(); | |
666 | – | setupCutoffs(); |
667 | – | setupSwitching(); |
668 | – | setupElectrostatics(); |
669 | – | setupNeighborlists(); |
670 | – | |
671 | – | #ifdef IS_MPI |
672 | – | setupFortranParallel(); |
673 | – | #endif |
674 | – | setupFortranSim(); |
675 | – | fortranInitialized_ = true; |
676 | – | |
671 | calcNdf(); | |
672 | calcNdfRaw(); | |
673 | calcNdfTrans(); | |
674 | } | |
675 | ||
676 | + | /** |
677 | + | * getSimulatedAtomTypes |
678 | + | * |
679 | + | * Returns an STL set of AtomType* that are actually present in this |
680 | + | * simulation. Must query all processors to assemble this information. |
681 | + | * |
682 | + | */ |
683 | set<AtomType*> SimInfo::getSimulatedAtomTypes() { | |
684 | SimInfo::MoleculeIterator mi; | |
685 | Molecule* mol; | |
# | Line 691 | Line 692 | namespace OpenMD { | |
692 | atomTypes.insert(atom->getAtomType()); | |
693 | } | |
694 | } | |
694 | – | return atomTypes; |
695 | – | } |
695 | ||
696 | < | /** |
698 | < | * setupCutoffs |
699 | < | * |
700 | < | * Sets the values of cutoffRadius and cutoffMethod |
701 | < | * |
702 | < | * cutoffRadius : realType |
703 | < | * If the cutoffRadius was explicitly set, use that value. |
704 | < | * If the cutoffRadius was not explicitly set: |
705 | < | * Are there electrostatic atoms? Use 12.0 Angstroms. |
706 | < | * No electrostatic atoms? Poll the atom types present in the |
707 | < | * simulation for suggested cutoff values (e.g. 2.5 * sigma). |
708 | < | * Use the maximum suggested value that was found. |
709 | < | * |
710 | < | * cutoffMethod : (one of HARD, SWITCHED, SHIFTED_FORCE, SHIFTED_POTENTIAL) |
711 | < | * If cutoffMethod was explicitly set, use that choice. |
712 | < | * If cutoffMethod was not explicitly set, use SHIFTED_FORCE |
713 | < | */ |
714 | < | void SimInfo::setupCutoffs() { |
715 | < | |
716 | < | if (simParams_->haveCutoffRadius()) { |
717 | < | cutoffRadius_ = simParams_->getCutoffRadius(); |
718 | < | } else { |
719 | < | if (usesElectrostaticAtoms_) { |
720 | < | sprintf(painCave.errMsg, |
721 | < | "SimInfo: No value was set for the cutoffRadius.\n" |
722 | < | "\tOpenMD will use a default value of 12.0 angstroms" |
723 | < | "\tfor the cutoffRadius.\n"); |
724 | < | painCave.isFatal = 0; |
725 | < | painCave.severity = OPENMD_INFO; |
726 | < | simError(); |
727 | < | cutoffRadius_ = 12.0; |
728 | < | } else { |
729 | < | RealType thisCut; |
730 | < | set<AtomType*>::iterator i; |
731 | < | set<AtomType*> atomTypes; |
732 | < | atomTypes = getSimulatedAtomTypes(); |
733 | < | for (i = atomTypes.begin(); i != atomTypes.end(); ++i) { |
734 | < | thisCut = InteractionManager::Instance()->getSuggestedCutoffRadius((*i)); |
735 | < | cutoffRadius_ = max(thisCut, cutoffRadius_); |
736 | < | } |
737 | < | sprintf(painCave.errMsg, |
738 | < | "SimInfo: No value was set for the cutoffRadius.\n" |
739 | < | "\tOpenMD will use %lf angstroms.\n", |
740 | < | cutoffRadius_); |
741 | < | painCave.isFatal = 0; |
742 | < | painCave.severity = OPENMD_INFO; |
743 | < | simError(); |
744 | < | } |
745 | < | } |
696 | > | #ifdef IS_MPI |
697 | ||
698 | < | map<string, CutoffMethod> stringToCutoffMethod; |
699 | < | stringToCutoffMethod["HARD"] = HARD; |
700 | < | stringToCutoffMethod["SWITCHING_FUNCTION"] = SWITCHING_FUNCTION; |
701 | < | stringToCutoffMethod["SHIFTED_POTENTIAL"] = SHIFTED_POTENTIAL; |
702 | < | stringToCutoffMethod["SHIFTED_FORCE"] = SHIFTED_FORCE; |
703 | < | |
704 | < | if (simParams_->haveCutoffMethod()) { |
705 | < | string cutMeth = toUpperCopy(simParams_->getCutoffMethod()); |
706 | < | map<string, CutoffMethod>::iterator i; |
707 | < | i = stringToCutoffMethod.find(cutMeth); |
708 | < | if (i == stringToCutoffMethod.end()) { |
709 | < | sprintf(painCave.errMsg, |
710 | < | "SimInfo: Could not find chosen cutoffMethod %s\n" |
711 | < | "\tShould be one of: " |
712 | < | "HARD, SWITCHING_FUNCTION, SHIFTED_POTENTIAL, or SHIFTED_FORCE\n", |
713 | < | cutMeth.c_str()); |
714 | < | painCave.isFatal = 1; |
715 | < | painCave.severity = OPENMD_ERROR; |
716 | < | simError(); |
717 | < | } else { |
718 | < | cutoffMethod_ = i->second; |
719 | < | } |
720 | < | } else { |
721 | < | sprintf(painCave.errMsg, |
722 | < | "SimInfo: No value was set for the cutoffMethod.\n" |
723 | < | "\tOpenMD will use SHIFTED_FORCE.\n"); |
724 | < | painCave.isFatal = 0; |
774 | < | painCave.severity = OPENMD_INFO; |
775 | < | simError(); |
776 | < | cutoffMethod_ = SHIFTED_FORCE; |
777 | < | } |
778 | < | } |
779 | < | |
780 | < | /** |
781 | < | * setupSwitching |
782 | < | * |
783 | < | * Sets the values of switchingRadius and |
784 | < | * If the switchingRadius was explicitly set, use that value (but check it) |
785 | < | * If the switchingRadius was not explicitly set: use 0.85 * cutoffRadius_ |
786 | < | */ |
787 | < | void SimInfo::setupSwitching() { |
788 | < | |
789 | < | if (simParams_->haveSwitchingRadius()) { |
790 | < | switchingRadius_ = simParams_->getSwitchingRadius(); |
791 | < | if (switchingRadius_ > cutoffRadius_) { |
792 | < | sprintf(painCave.errMsg, |
793 | < | "SimInfo: switchingRadius (%f) is larger than cutoffRadius(%f)\n", |
794 | < | switchingRadius_, cutoffRadius_); |
795 | < | painCave.isFatal = 1; |
796 | < | painCave.severity = OPENMD_ERROR; |
797 | < | simError(); |
798 | < | } |
799 | < | } else { |
800 | < | switchingRadius_ = 0.85 * cutoffRadius_; |
801 | < | sprintf(painCave.errMsg, |
802 | < | "SimInfo: No value was set for the switchingRadius.\n" |
803 | < | "\tOpenMD will use a default value of 85 percent of the cutoffRadius.\n" |
804 | < | "\tswitchingRadius = %f. for this simulation\n", switchingRadius_); |
805 | < | painCave.isFatal = 0; |
806 | < | painCave.severity = OPENMD_WARNING; |
807 | < | simError(); |
808 | < | } |
698 | > | // loop over the found atom types on this processor, and add their |
699 | > | // numerical idents to a vector: |
700 | > | |
701 | > | vector<int> foundTypes; |
702 | > | set<AtomType*>::iterator i; |
703 | > | for (i = atomTypes.begin(); i != atomTypes.end(); ++i) |
704 | > | foundTypes.push_back( (*i)->getIdent() ); |
705 | > | |
706 | > | // count_local holds the number of found types on this processor |
707 | > | int count_local = foundTypes.size(); |
708 | > | |
709 | > | // count holds the total number of found types on all processors |
710 | > | // (some will be redundant with the ones found locally): |
711 | > | int count; |
712 | > | MPI::COMM_WORLD.Allreduce(&count_local, &count, 1, MPI::INT, MPI::SUM); |
713 | > | |
714 | > | // create a vector to hold the globally found types, and resize it: |
715 | > | vector<int> ftGlobal; |
716 | > | ftGlobal.resize(count); |
717 | > | vector<int> counts; |
718 | > | |
719 | > | int nproc = MPI::COMM_WORLD.Get_size(); |
720 | > | counts.resize(nproc); |
721 | > | vector<int> disps; |
722 | > | disps.resize(nproc); |
723 | > | |
724 | > | // now spray out the foundTypes to all the other processors: |
725 | ||
726 | < | if (simParams_->haveSwitchingFunctionType()) { |
727 | < | string funcType = simParams_->getSwitchingFunctionType(); |
812 | < | toUpper(funcType); |
813 | < | if (funcType == "CUBIC") { |
814 | < | sft_ = cubic; |
815 | < | } else { |
816 | < | if (funcType == "FIFTH_ORDER_POLYNOMIAL") { |
817 | < | sft_ = fifth_order_poly; |
818 | < | } else { |
819 | < | // throw error |
820 | < | sprintf( painCave.errMsg, |
821 | < | "SimInfo : Unknown switchingFunctionType. (Input file specified %s .)\n" |
822 | < | "\tswitchingFunctionType must be one of: " |
823 | < | "\"cubic\" or \"fifth_order_polynomial\".", |
824 | < | funcType.c_str() ); |
825 | < | painCave.isFatal = 1; |
826 | < | painCave.severity = OPENMD_ERROR; |
827 | < | simError(); |
828 | < | } |
829 | < | } |
830 | < | } |
831 | < | } |
726 | > | MPI::COMM_WORLD.Allgatherv(&foundTypes[0], count_local, MPI::INT, |
727 | > | &ftGlobal[0], &counts[0], &disps[0], MPI::INT); |
728 | ||
729 | < | /** |
730 | < | * setupNeighborlists |
731 | < | * |
732 | < | * If the skinThickness was explicitly set, use that value (but check it) |
733 | < | * If the skinThickness was not explicitly set: use 1.0 angstroms |
734 | < | */ |
735 | < | void SimInfo::setupNeighborlists() { |
736 | < | if (simParams_->haveSkinThickness()) { |
737 | < | skinThickness_ = simParams_->getSkinThickness(); |
738 | < | } else { |
739 | < | skinThickness_ = 1.0; |
740 | < | sprintf(painCave.errMsg, |
741 | < | "SimInfo: No value was set for the skinThickness.\n" |
742 | < | "\tOpenMD will use a default value of %f Angstroms\n" |
743 | < | "\tfor this simulation\n", skinThickness_); |
744 | < | painCave.severity = OPENMD_INFO; |
849 | < | painCave.isFatal = 0; |
850 | < | simError(); |
851 | < | } |
729 | > | // foundIdents is a stl set, so inserting an already found ident |
730 | > | // will have no effect. |
731 | > | set<int> foundIdents; |
732 | > | vector<int>::iterator j; |
733 | > | for (j = ftGlobal.begin(); j != ftGlobal.end(); ++j) |
734 | > | foundIdents.insert((*j)); |
735 | > | |
736 | > | // now iterate over the foundIdents and get the actual atom types |
737 | > | // that correspond to these: |
738 | > | set<int>::iterator it; |
739 | > | for (it = foundIdents.begin(); it != foundIdents.end(); ++it) |
740 | > | atomTypes.insert( forceField_->getAtomType((*it)) ); |
741 | > | |
742 | > | #endif |
743 | > | |
744 | > | return atomTypes; |
745 | } | |
746 | ||
747 | void SimInfo::setupSimVariables() { | |
# | Line 892 | Line 785 | namespace OpenMD { | |
785 | fInfo_.SIM_uses_AtomicVirial = usesAtomicVirial_; | |
786 | } | |
787 | ||
788 | < | void SimInfo::setupFortranSim() { |
788 | > | void SimInfo::setupFortran() { |
789 | int isError; | |
790 | int nExclude, nOneTwo, nOneThree, nOneFour; | |
791 | vector<int> fortranGlobalGroupMembership; | |
792 | ||
900 | – | notifyFortranSkinThickness(&skinThickness_); |
901 | – | |
902 | – | int ljsp = cutoffMethod_ == SHIFTED_POTENTIAL ? 1 : 0; |
903 | – | int ljsf = cutoffMethod_ == SHIFTED_FORCE ? 1 : 0; |
904 | – | notifyFortranCutoffs(&cutoffRadius_, &switchingRadius_, &ljsp, &ljsf); |
905 | – | |
793 | isError = 0; | |
794 | ||
795 | //globalGroupMembership_ is filled by SimCreator | |
# | Line 937 | Line 824 | namespace OpenMD { | |
824 | } | |
825 | } | |
826 | ||
827 | < | //fill ident array of local atoms (it is actually ident of AtomType, it is so confusing !!!) |
941 | < | vector<int> identArray; |
827 | > | // Build the identArray_ |
828 | ||
829 | < | //to avoid memory reallocation, reserve enough space identArray |
830 | < | identArray.reserve(getNAtoms()); |
945 | < | |
829 | > | identArray_.clear(); |
830 | > | identArray_.reserve(getNAtoms()); |
831 | for(mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) { | |
832 | for(atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) { | |
833 | < | identArray.push_back(atom->getIdent()); |
833 | > | identArray_.push_back(atom->getIdent()); |
834 | } | |
835 | } | |
836 | ||
# | Line 997 | Line 882 | namespace OpenMD { | |
882 | setNeighbors(&nlistNeighbors); | |
883 | } | |
884 | ||
1000 | – | |
1001 | – | } |
1002 | – | |
1003 | – | |
1004 | – | void SimInfo::setupFortranParallel() { |
885 | #ifdef IS_MPI | |
886 | < | //SimInfo is responsible for creating localToGlobalAtomIndex and localToGlobalGroupIndex |
886 | > | //SimInfo is responsible for creating localToGlobalAtomIndex and |
887 | > | //localToGlobalGroupIndex |
888 | vector<int> localToGlobalAtomIndex(getNAtoms(), 0); | |
889 | vector<int> localToGlobalCutoffGroupIndex; | |
1009 | – | SimInfo::MoleculeIterator mi; |
1010 | – | Molecule::AtomIterator ai; |
1011 | – | Molecule::CutoffGroupIterator ci; |
1012 | – | Molecule* mol; |
1013 | – | Atom* atom; |
1014 | – | CutoffGroup* cg; |
890 | mpiSimData parallelData; | |
1016 | – | int isError; |
891 | ||
892 | for (mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) { | |
893 | ||
# | Line 1053 | Line 927 | namespace OpenMD { | |
927 | ||
928 | sprintf(checkPointMsg, " mpiRefresh successful.\n"); | |
929 | errorCheckPoint(); | |
1056 | – | |
930 | #endif | |
1058 | – | } |
1059 | – | |
1060 | – | |
1061 | – | void SimInfo::setupAccumulateBoxDipole() { |
1062 | – | |
931 | ||
932 | + | initFortranFF(&isError); |
933 | + | if (isError) { |
934 | + | sprintf(painCave.errMsg, |
935 | + | "initFortranFF errror: fortran didn't like something we gave it.\n"); |
936 | + | painCave.isFatal = 1; |
937 | + | simError(); |
938 | + | } |
939 | + | fortranInitialized_ = true; |
940 | } | |
941 | ||
942 | void SimInfo::addProperty(GenericData* genData) { | |
# | Line 1097 | Line 973 | namespace OpenMD { | |
973 | Molecule* mol; | |
974 | RigidBody* rb; | |
975 | Atom* atom; | |
976 | + | CutoffGroup* cg; |
977 | SimInfo::MoleculeIterator mi; | |
978 | Molecule::RigidBodyIterator rbIter; | |
979 | < | Molecule::AtomIterator atomIter;; |
979 | > | Molecule::AtomIterator atomIter; |
980 | > | Molecule::CutoffGroupIterator cgIter; |
981 | ||
982 | for (mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) { | |
983 | ||
# | Line 1109 | Line 987 | namespace OpenMD { | |
987 | ||
988 | for (rb = mol->beginRigidBody(rbIter); rb != NULL; rb = mol->nextRigidBody(rbIter)) { | |
989 | rb->setSnapshotManager(sman_); | |
990 | + | } |
991 | + | |
992 | + | for (cg = mol->beginCutoffGroup(cgIter); cg != NULL; cg = mol->nextCutoffGroup(cgIter)) { |
993 | + | cg->setSnapshotManager(sman_); |
994 | } | |
995 | } | |
996 |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |