# | 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 63 | Line 63 | |
63 | #include "UseTheForce/ForceField.hpp" | |
64 | #include "nonbonded/SwitchingFunction.hpp" | |
65 | ||
66 | – | |
66 | #ifdef IS_MPI | |
67 | #include "UseTheForce/mpiComponentPlan.h" | |
68 | #include "UseTheForce/DarkSide/simParallel_interface.h" | |
# | Line 133 | 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 657 | 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() { |
665 | < | |
669 | > | void SimInfo::update() { |
670 | setupSimVariables(); | |
667 | – | setupCutoffs(); |
668 | – | setupSwitching(); |
669 | – | setupElectrostatics(); |
670 | – | setupNeighborlists(); |
671 | – | |
672 | – | #ifdef IS_MPI |
673 | – | setupFortranParallel(); |
674 | – | #endif |
675 | – | setupFortranSim(); |
676 | – | fortranInitialized_ = true; |
677 | – | |
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 692 | Line 692 | namespace OpenMD { | |
692 | atomTypes.insert(atom->getAtomType()); | |
693 | } | |
694 | } | |
695 | – | return atomTypes; |
696 | – | } |
695 | ||
696 | < | /** |
699 | < | * setupCutoffs |
700 | < | * |
701 | < | * Sets the values of cutoffRadius and cutoffMethod |
702 | < | * |
703 | < | * cutoffRadius : realType |
704 | < | * If the cutoffRadius was explicitly set, use that value. |
705 | < | * If the cutoffRadius was not explicitly set: |
706 | < | * Are there electrostatic atoms? Use 12.0 Angstroms. |
707 | < | * No electrostatic atoms? Poll the atom types present in the |
708 | < | * simulation for suggested cutoff values (e.g. 2.5 * sigma). |
709 | < | * Use the maximum suggested value that was found. |
710 | < | * |
711 | < | * cutoffMethod : (one of HARD, SWITCHED, SHIFTED_FORCE, SHIFTED_POTENTIAL) |
712 | < | * If cutoffMethod was explicitly set, use that choice. |
713 | < | * If cutoffMethod was not explicitly set, use SHIFTED_FORCE |
714 | < | */ |
715 | < | void SimInfo::setupCutoffs() { |
716 | < | |
717 | < | if (simParams_->haveCutoffRadius()) { |
718 | < | cutoffRadius_ = simParams_->getCutoffRadius(); |
719 | < | } else { |
720 | < | if (usesElectrostaticAtoms_) { |
721 | < | sprintf(painCave.errMsg, |
722 | < | "SimInfo: No value was set for the cutoffRadius.\n" |
723 | < | "\tOpenMD will use a default value of 12.0 angstroms" |
724 | < | "\tfor the cutoffRadius.\n"); |
725 | < | painCave.isFatal = 0; |
726 | < | painCave.severity = OPENMD_INFO; |
727 | < | simError(); |
728 | < | cutoffRadius_ = 12.0; |
729 | < | } else { |
730 | < | RealType thisCut; |
731 | < | set<AtomType*>::iterator i; |
732 | < | set<AtomType*> atomTypes; |
733 | < | atomTypes = getSimulatedAtomTypes(); |
734 | < | for (i = atomTypes.begin(); i != atomTypes.end(); ++i) { |
735 | < | thisCut = InteractionManager::Instance()->getSuggestedCutoffRadius((*i)); |
736 | < | cutoffRadius_ = max(thisCut, cutoffRadius_); |
737 | < | } |
738 | < | sprintf(painCave.errMsg, |
739 | < | "SimInfo: No value was set for the cutoffRadius.\n" |
740 | < | "\tOpenMD will use %lf angstroms.\n", |
741 | < | cutoffRadius_); |
742 | < | painCave.isFatal = 0; |
743 | < | painCave.severity = OPENMD_INFO; |
744 | < | simError(); |
745 | < | } |
746 | < | } |
696 | > | #ifdef IS_MPI |
697 | ||
698 | < | InteractionManager::Instance()->setCutoffRadius(cutoffRadius_); |
698 | > | // loop over the found atom types on this processor, and add their |
699 | > | // numerical idents to a vector: |
700 | ||
701 | < | map<string, CutoffMethod> stringToCutoffMethod; |
702 | < | stringToCutoffMethod["HARD"] = HARD; |
703 | < | stringToCutoffMethod["SWITCHING_FUNCTION"] = SWITCHING_FUNCTION; |
704 | < | stringToCutoffMethod["SHIFTED_POTENTIAL"] = SHIFTED_POTENTIAL; |
754 | < | stringToCutoffMethod["SHIFTED_FORCE"] = SHIFTED_FORCE; |
755 | < | |
756 | < | if (simParams_->haveCutoffMethod()) { |
757 | < | string cutMeth = toUpperCopy(simParams_->getCutoffMethod()); |
758 | < | map<string, CutoffMethod>::iterator i; |
759 | < | i = stringToCutoffMethod.find(cutMeth); |
760 | < | if (i == stringToCutoffMethod.end()) { |
761 | < | sprintf(painCave.errMsg, |
762 | < | "SimInfo: Could not find chosen cutoffMethod %s\n" |
763 | < | "\tShould be one of: " |
764 | < | "HARD, SWITCHING_FUNCTION, SHIFTED_POTENTIAL, or SHIFTED_FORCE\n", |
765 | < | cutMeth.c_str()); |
766 | < | painCave.isFatal = 1; |
767 | < | painCave.severity = OPENMD_ERROR; |
768 | < | simError(); |
769 | < | } else { |
770 | < | cutoffMethod_ = i->second; |
771 | < | } |
772 | < | } else { |
773 | < | sprintf(painCave.errMsg, |
774 | < | "SimInfo: No value was set for the cutoffMethod.\n" |
775 | < | "\tOpenMD will use SHIFTED_FORCE.\n"); |
776 | < | painCave.isFatal = 0; |
777 | < | painCave.severity = OPENMD_INFO; |
778 | < | simError(); |
779 | < | cutoffMethod_ = SHIFTED_FORCE; |
780 | < | } |
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 | < | InteractionManager::Instance()->setCutoffMethod(cutoffMethod_); |
707 | < | } |
784 | < | |
785 | < | /** |
786 | < | * setupSwitching |
787 | < | * |
788 | < | * Sets the values of switchingRadius and |
789 | < | * If the switchingRadius was explicitly set, use that value (but check it) |
790 | < | * If the switchingRadius was not explicitly set: use 0.85 * cutoffRadius_ |
791 | < | */ |
792 | < | void SimInfo::setupSwitching() { |
793 | < | |
794 | < | if (simParams_->haveSwitchingRadius()) { |
795 | < | switchingRadius_ = simParams_->getSwitchingRadius(); |
796 | < | if (switchingRadius_ > cutoffRadius_) { |
797 | < | sprintf(painCave.errMsg, |
798 | < | "SimInfo: switchingRadius (%f) is larger than cutoffRadius(%f)\n", |
799 | < | switchingRadius_, cutoffRadius_); |
800 | < | painCave.isFatal = 1; |
801 | < | painCave.severity = OPENMD_ERROR; |
802 | < | simError(); |
803 | < | } |
804 | < | } else { |
805 | < | switchingRadius_ = 0.85 * cutoffRadius_; |
806 | < | sprintf(painCave.errMsg, |
807 | < | "SimInfo: No value was set for the switchingRadius.\n" |
808 | < | "\tOpenMD will use a default value of 85 percent of the cutoffRadius.\n" |
809 | < | "\tswitchingRadius = %f. for this simulation\n", switchingRadius_); |
810 | < | painCave.isFatal = 0; |
811 | < | painCave.severity = OPENMD_WARNING; |
812 | < | simError(); |
813 | < | } |
814 | < | |
815 | < | InteractionManager::Instance()->setSwitchingRadius(switchingRadius_); |
706 | > | // count_local holds the number of found types on this processor |
707 | > | int count_local = foundTypes.size(); |
708 | ||
709 | < | SwitchingFunctionType ft; |
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(); |
821 | < | toUpper(funcType); |
822 | < | if (funcType == "CUBIC") { |
823 | < | ft = cubic; |
824 | < | } else { |
825 | < | if (funcType == "FIFTH_ORDER_POLYNOMIAL") { |
826 | < | ft = fifth_order_poly; |
827 | < | } else { |
828 | < | // throw error |
829 | < | sprintf( painCave.errMsg, |
830 | < | "SimInfo : Unknown switchingFunctionType. (Input file specified %s .)\n" |
831 | < | "\tswitchingFunctionType must be one of: " |
832 | < | "\"cubic\" or \"fifth_order_polynomial\".", |
833 | < | funcType.c_str() ); |
834 | < | painCave.isFatal = 1; |
835 | < | painCave.severity = OPENMD_ERROR; |
836 | < | simError(); |
837 | < | } |
838 | < | } |
839 | < | } |
726 | > | MPI::COMM_WORLD.Allgatherv(&foundTypes[0], count_local, MPI::INT, |
727 | > | &ftGlobal[0], &counts[0], &disps[0], MPI::INT); |
728 | ||
729 | < | InteractionManager::Instance()->setSwitchingFunctionType(ft); |
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 | < | /** |
748 | < | * setupSkinThickness |
749 | < | * |
750 | < | * If the skinThickness was explicitly set, use that value (but check it) |
751 | < | * If the skinThickness was not explicitly set: use 1.0 angstroms |
752 | < | */ |
753 | < | void SimInfo::setupSkinThickness() { |
754 | < | if (simParams_->haveSkinThickness()) { |
852 | < | skinThickness_ = simParams_->getSkinThickness(); |
853 | < | } else { |
854 | < | skinThickness_ = 1.0; |
855 | < | sprintf(painCave.errMsg, |
856 | < | "SimInfo Warning: No value was set for the skinThickness.\n" |
857 | < | "\tOpenMD will use a default value of %f Angstroms\n" |
858 | < | "\tfor this simulation\n", skinThickness_); |
859 | < | painCave.isFatal = 0; |
860 | < | simError(); |
861 | < | } |
862 | < | } |
747 | > | void SimInfo::setupSimVariables() { |
748 | > | useAtomicVirial_ = simParams_->getUseAtomicVirial(); |
749 | > | // we only call setAccumulateBoxDipole if the accumulateBoxDipole parameter is true |
750 | > | calcBoxDipole_ = false; |
751 | > | if ( simParams_->haveAccumulateBoxDipole() ) |
752 | > | if ( simParams_->getAccumulateBoxDipole() ) { |
753 | > | calcBoxDipole_ = true; |
754 | > | } |
755 | ||
864 | – | void SimInfo::setupSimType() { |
756 | set<AtomType*>::iterator i; | |
757 | set<AtomType*> atomTypes; | |
758 | < | atomTypes = getSimulatedAtomTypes(); |
868 | < | |
869 | < | useAtomicVirial_ = simParams_->getUseAtomicVirial(); |
870 | < | |
758 | > | atomTypes = getSimulatedAtomTypes(); |
759 | int usesElectrostatic = 0; | |
760 | int usesMetallic = 0; | |
761 | int usesDirectional = 0; | |
# | Line 897 | 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 | ||
905 | – | notifyFortranSkinThickness(&skinThickness_); |
906 | – | |
907 | – | int ljsp = cutoffMethod_ == SHIFTED_POTENTIAL ? 1 : 0; |
908 | – | int ljsf = cutoffMethod_ == SHIFTED_FORCE ? 1 : 0; |
909 | – | notifyFortranCutoffs(&cutoffRadius_, &switchingRadius_, &ljsp, &ljsf); |
910 | – | |
793 | isError = 0; | |
794 | ||
795 | //globalGroupMembership_ is filled by SimCreator | |
# | Line 942 | Line 824 | namespace OpenMD { | |
824 | } | |
825 | } | |
826 | ||
827 | < | //fill ident array of local atoms (it is actually ident of AtomType, it is so confusing !!!) |
946 | < | vector<int> identArray; |
827 | > | // Build the identArray_ |
828 | ||
829 | < | //to avoid memory reallocation, reserve enough space identArray |
830 | < | identArray.reserve(getNAtoms()); |
950 | < | |
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 1002 | Line 882 | namespace OpenMD { | |
882 | setNeighbors(&nlistNeighbors); | |
883 | } | |
884 | ||
1005 | – | |
1006 | – | } |
1007 | – | |
1008 | – | |
1009 | – | 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; | |
1014 | – | SimInfo::MoleculeIterator mi; |
1015 | – | Molecule::AtomIterator ai; |
1016 | – | Molecule::CutoffGroupIterator ci; |
1017 | – | Molecule* mol; |
1018 | – | Atom* atom; |
1019 | – | CutoffGroup* cg; |
890 | mpiSimData parallelData; | |
1021 | – | int isError; |
891 | ||
892 | for (mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) { | |
893 | ||
# | Line 1058 | Line 927 | namespace OpenMD { | |
927 | ||
928 | sprintf(checkPointMsg, " mpiRefresh successful.\n"); | |
929 | errorCheckPoint(); | |
1061 | – | |
930 | #endif | |
1063 | – | } |
931 | ||
932 | < | |
933 | < | void SimInfo::setupSwitchingFunction() { |
934 | < | |
935 | < | } |
936 | < | |
937 | < | void SimInfo::setupAccumulateBoxDipole() { |
938 | < | |
939 | < | // we only call setAccumulateBoxDipole if the accumulateBoxDipole parameter is true |
1073 | < | if ( simParams_->haveAccumulateBoxDipole() ) |
1074 | < | if ( simParams_->getAccumulateBoxDipole() ) { |
1075 | < | calcBoxDipole_ = true; |
1076 | < | } |
1077 | < | |
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 1111 | 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 1123 | 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 |