# | Line 36 | Line 36 | |
---|---|---|
36 | * [1] Meineke, et al., J. Comp. Chem. 26, 252-271 (2005). | |
37 | * [2] Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006). | |
38 | * [3] Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008). | |
39 | < | * [4] Vardeman & Gezelter, in progress (2009). |
39 | > | * [4] Kuang & Gezelter, J. Chem. Phys. 133, 164101 (2010). |
40 | > | * [5] Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011). |
41 | */ | |
42 | ||
43 | /** | |
# | Line 54 | Line 55 | |
55 | #include "math/Vector3.hpp" | |
56 | #include "primitives/Molecule.hpp" | |
57 | #include "primitives/StuntDouble.hpp" | |
57 | – | #include "UseTheForce/fCutoffPolicy.h" |
58 | – | #include "UseTheForce/DarkSide/fSwitchingFunctionType.h" |
59 | – | #include "UseTheForce/doForces_interface.h" |
60 | – | #include "UseTheForce/DarkSide/neighborLists_interface.h" |
61 | – | #include "UseTheForce/DarkSide/switcheroo_interface.h" |
58 | #include "utils/MemoryUtils.hpp" | |
59 | #include "utils/simError.h" | |
60 | #include "selection/SelectionManager.hpp" | |
61 | #include "io/ForceFieldOptions.hpp" | |
62 | #include "UseTheForce/ForceField.hpp" | |
63 | < | #include "nonbonded/InteractionManager.hpp" |
68 | < | |
69 | < | |
63 | > | #include "nonbonded/SwitchingFunction.hpp" |
64 | #ifdef IS_MPI | |
65 | < | #include "UseTheForce/mpiComponentPlan.h" |
66 | < | #include "UseTheForce/DarkSide/simParallel_interface.h" |
73 | < | #endif |
65 | > | #include <mpi.h> |
66 | > | #endif |
67 | ||
68 | using namespace std; | |
69 | namespace OpenMD { | |
# | Line 82 | Line 75 | namespace OpenMD { | |
75 | nGlobalIntegrableObjects_(0), nGlobalRigidBodies_(0), | |
76 | nAtoms_(0), nBonds_(0), nBends_(0), nTorsions_(0), nInversions_(0), | |
77 | nRigidBodies_(0), nIntegrableObjects_(0), nCutoffGroups_(0), | |
78 | < | nConstraints_(0), sman_(NULL), fortranInitialized_(false), |
78 | > | nConstraints_(0), sman_(NULL), topologyDone_(false), |
79 | calcBoxDipole_(false), useAtomicVirial_(true) { | |
80 | ||
81 | MoleculeStamp* molStamp; | |
# | Line 136 | Line 129 | namespace OpenMD { | |
129 | //equal to the total number of atoms minus number of atoms belong to | |
130 | //cutoff group defined in meta-data file plus the number of cutoff | |
131 | //groups defined in meta-data file | |
132 | + | |
133 | nGlobalCutoffGroups_ = nGlobalAtoms_ - nCutoffAtoms + nGroups; | |
134 | ||
135 | //every free atom (atom does not belong to rigid bodies) is an | |
# | Line 278 | Line 272 | namespace OpenMD { | |
272 | fdf_ = fdf_local; | |
273 | #endif | |
274 | return fdf_; | |
275 | + | } |
276 | + | |
277 | + | unsigned int SimInfo::getNLocalCutoffGroups(){ |
278 | + | int nLocalCutoffAtoms = 0; |
279 | + | Molecule* mol; |
280 | + | MoleculeIterator mi; |
281 | + | CutoffGroup* cg; |
282 | + | Molecule::CutoffGroupIterator ci; |
283 | + | |
284 | + | for (mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) { |
285 | + | |
286 | + | for (cg = mol->beginCutoffGroup(ci); cg != NULL; |
287 | + | cg = mol->nextCutoffGroup(ci)) { |
288 | + | nLocalCutoffAtoms += cg->getNumAtom(); |
289 | + | |
290 | + | } |
291 | + | } |
292 | + | |
293 | + | return nAtoms_ - nLocalCutoffAtoms + nCutoffGroups_; |
294 | } | |
295 | ||
296 | void SimInfo::calcNdfRaw() { | |
# | Line 656 | Line 669 | namespace OpenMD { | |
669 | molStampIds_.insert(molStampIds_.end(), nmol, curStampId); | |
670 | } | |
671 | ||
659 | – | void SimInfo::update() { |
672 | ||
673 | < | setupSimType(); |
674 | < | setupCutoffRadius(); |
675 | < | setupSwitchingRadius(); |
676 | < | setupCutoffMethod(); |
677 | < | setupSkinThickness(); |
678 | < | setupSwitchingFunction(); |
679 | < | setupAccumulateBoxDipole(); |
680 | < | |
681 | < | #ifdef IS_MPI |
670 | < | setupFortranParallel(); |
671 | < | #endif |
672 | < | setupFortranSim(); |
673 | < | fortranInitialized_ = true; |
674 | < | |
673 | > | /** |
674 | > | * update |
675 | > | * |
676 | > | * Performs the global checks and variable settings after the |
677 | > | * objects have been created. |
678 | > | * |
679 | > | */ |
680 | > | void SimInfo::update() { |
681 | > | setupSimVariables(); |
682 | calcNdf(); | |
683 | calcNdfRaw(); | |
684 | calcNdfTrans(); | |
685 | } | |
686 | ||
687 | + | /** |
688 | + | * getSimulatedAtomTypes |
689 | + | * |
690 | + | * Returns an STL set of AtomType* that are actually present in this |
691 | + | * simulation. Must query all processors to assemble this information. |
692 | + | * |
693 | + | */ |
694 | set<AtomType*> SimInfo::getSimulatedAtomTypes() { | |
695 | SimInfo::MoleculeIterator mi; | |
696 | Molecule* mol; | |
# | Line 684 | Line 698 | namespace OpenMD { | |
698 | Atom* atom; | |
699 | set<AtomType*> atomTypes; | |
700 | ||
701 | < | for(mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) { |
702 | < | for(atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) { |
701 | > | for(mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) { |
702 | > | for(atom = mol->beginAtom(ai); atom != NULL; |
703 | > | atom = mol->nextAtom(ai)) { |
704 | atomTypes.insert(atom->getAtomType()); | |
705 | } | |
706 | } | |
692 | – | return atomTypes; |
693 | – | } |
694 | – | |
695 | – | /** |
696 | – | * setupCutoffRadius |
697 | – | * |
698 | – | * If the cutoffRadius was explicitly set, use that value. |
699 | – | * If the cutoffRadius was not explicitly set: |
700 | – | * Are there electrostatic atoms? Use 12.0 Angstroms. |
701 | – | * No electrostatic atoms? Poll the atom types present in the |
702 | – | * simulation for suggested cutoff values (e.g. 2.5 * sigma). |
703 | – | * Use the maximum suggested value that was found. |
704 | – | */ |
705 | – | void SimInfo::setupCutoffRadius() { |
707 | ||
708 | < | if (simParams_->haveCutoffRadius()) { |
708 | < | cutoffRadius_ = simParams_->getCutoffRadius(); |
709 | < | } else { |
710 | < | if (usesElectrostaticAtoms_) { |
711 | < | sprintf(painCave.errMsg, |
712 | < | "SimInfo Warning: No value was set for the cutoffRadius.\n" |
713 | < | "\tOpenMD will use a default value of 12.0 angstroms" |
714 | < | "\tfor the cutoffRadius.\n"); |
715 | < | painCave.isFatal = 0; |
716 | < | simError(); |
717 | < | cutoffRadius_ = 12.0; |
718 | < | } else { |
719 | < | RealType thisCut; |
720 | < | set<AtomType*>::iterator i; |
721 | < | set<AtomType*> atomTypes; |
722 | < | atomTypes = getSimulatedAtomTypes(); |
723 | < | for (i = atomTypes.begin(); i != atomTypes.end(); ++i) { |
724 | < | thisCut = InteractionManager::Instance()->getSuggestedCutoffRadius((*i)); |
725 | < | cutoffRadius_ = max(thisCut, cutoffRadius_); |
726 | < | } |
727 | < | sprintf(painCave.errMsg, |
728 | < | "SimInfo Warning: No value was set for the cutoffRadius.\n" |
729 | < | "\tOpenMD will use %lf angstroms.\n", |
730 | < | cutoffRadius_); |
731 | < | painCave.isFatal = 0; |
732 | < | simError(); |
733 | < | } |
734 | < | } |
708 | > | #ifdef IS_MPI |
709 | ||
710 | < | InteractionManager::Instance()->setCutoffRadius(cutoffRadius_); |
711 | < | } |
738 | < | |
739 | < | /** |
740 | < | * setupSwitchingRadius |
741 | < | * |
742 | < | * If the switchingRadius was explicitly set, use that value (but check it) |
743 | < | * If the switchingRadius was not explicitly set: use 0.85 * cutoffRadius_ |
744 | < | */ |
745 | < | void SimInfo::setupSwitchingRadius() { |
710 | > | // loop over the found atom types on this processor, and add their |
711 | > | // numerical idents to a vector: |
712 | ||
713 | < | if (simParams_->haveSwitchingRadius()) { |
714 | < | switchingRadius_ = simParams_->getSwitchingRadius(); |
715 | < | if (switchingRadius_ > cutoffRadius_) { |
716 | < | sprintf(painCave.errMsg, |
751 | < | "SimInfo Error: switchingRadius (%f) is larger than cutoffRadius(%f)\n", |
752 | < | switchingRadius_, cutoffRadius_); |
753 | < | painCave.isFatal = 1; |
754 | < | simError(); |
713 | > | vector<int> foundTypes; |
714 | > | set<AtomType*>::iterator i; |
715 | > | for (i = atomTypes.begin(); i != atomTypes.end(); ++i) |
716 | > | foundTypes.push_back( (*i)->getIdent() ); |
717 | ||
718 | < | } |
719 | < | } else { |
758 | < | switchingRadius_ = 0.85 * cutoffRadius_; |
759 | < | sprintf(painCave.errMsg, |
760 | < | "SimInfo Warning: No value was set for the switchingRadius.\n" |
761 | < | "\tOpenMD will use a default value of 85 percent of the cutoffRadius.\n" |
762 | < | "\tswitchingRadius = %f. for this simulation\n", switchingRadius_); |
763 | < | painCave.isFatal = 0; |
764 | < | simError(); |
765 | < | } |
766 | < | InteractionManager::Instance()->setSwitchingRadius(switchingRadius_); |
767 | < | } |
718 | > | // count_local holds the number of found types on this processor |
719 | > | int count_local = foundTypes.size(); |
720 | ||
721 | < | /** |
722 | < | * setupSkinThickness |
723 | < | * |
724 | < | * If the skinThickness was explicitly set, use that value (but check it) |
725 | < | * If the skinThickness was not explicitly set: use 1.0 angstroms |
726 | < | */ |
727 | < | void SimInfo::setupSkinThickness() { |
728 | < | if (simParams_->haveSkinThickness()) { |
729 | < | skinThickness_ = simParams_->getSkinThickness(); |
730 | < | } else { |
731 | < | skinThickness_ = 1.0; |
732 | < | sprintf(painCave.errMsg, |
733 | < | "SimInfo Warning: No value was set for the skinThickness.\n" |
734 | < | "\tOpenMD will use a default value of %f Angstroms\n" |
735 | < | "\tfor this simulation\n", skinThickness_); |
736 | < | painCave.isFatal = 0; |
737 | < | simError(); |
738 | < | } |
721 | > | int nproc = MPI::COMM_WORLD.Get_size(); |
722 | > | |
723 | > | // we need arrays to hold the counts and displacement vectors for |
724 | > | // all processors |
725 | > | vector<int> counts(nproc, 0); |
726 | > | vector<int> disps(nproc, 0); |
727 | > | |
728 | > | // fill the counts array |
729 | > | MPI::COMM_WORLD.Allgather(&count_local, 1, MPI::INT, &counts[0], |
730 | > | 1, MPI::INT); |
731 | > | |
732 | > | // use the processor counts to compute the displacement array |
733 | > | disps[0] = 0; |
734 | > | int totalCount = counts[0]; |
735 | > | for (int iproc = 1; iproc < nproc; iproc++) { |
736 | > | disps[iproc] = disps[iproc-1] + counts[iproc-1]; |
737 | > | totalCount += counts[iproc]; |
738 | > | } |
739 | > | |
740 | > | // we need a (possibly redundant) set of all found types: |
741 | > | vector<int> ftGlobal(totalCount); |
742 | > | |
743 | > | // now spray out the foundTypes to all the other processors: |
744 | > | MPI::COMM_WORLD.Allgatherv(&foundTypes[0], count_local, MPI::INT, |
745 | > | &ftGlobal[0], &counts[0], &disps[0], |
746 | > | MPI::INT); |
747 | > | |
748 | > | vector<int>::iterator j; |
749 | > | |
750 | > | // foundIdents is a stl set, so inserting an already found ident |
751 | > | // will have no effect. |
752 | > | set<int> foundIdents; |
753 | > | |
754 | > | for (j = ftGlobal.begin(); j != ftGlobal.end(); ++j) |
755 | > | foundIdents.insert((*j)); |
756 | > | |
757 | > | // now iterate over the foundIdents and get the actual atom types |
758 | > | // that correspond to these: |
759 | > | set<int>::iterator it; |
760 | > | for (it = foundIdents.begin(); it != foundIdents.end(); ++it) |
761 | > | atomTypes.insert( forceField_->getAtomType((*it)) ); |
762 | > | |
763 | > | #endif |
764 | > | |
765 | > | return atomTypes; |
766 | } | |
767 | ||
768 | < | void SimInfo::setupSimType() { |
768 | > | void SimInfo::setupSimVariables() { |
769 | > | useAtomicVirial_ = simParams_->getUseAtomicVirial(); |
770 | > | // we only call setAccumulateBoxDipole if the accumulateBoxDipole parameter is true |
771 | > | calcBoxDipole_ = false; |
772 | > | if ( simParams_->haveAccumulateBoxDipole() ) |
773 | > | if ( simParams_->getAccumulateBoxDipole() ) { |
774 | > | calcBoxDipole_ = true; |
775 | > | } |
776 | > | |
777 | set<AtomType*>::iterator i; | |
778 | set<AtomType*> atomTypes; | |
779 | < | atomTypes = getSimulatedAtomTypes(); |
793 | < | |
794 | < | useAtomicVirial_ = simParams_->getUseAtomicVirial(); |
795 | < | |
779 | > | atomTypes = getSimulatedAtomTypes(); |
780 | int usesElectrostatic = 0; | |
781 | int usesMetallic = 0; | |
782 | int usesDirectional = 0; | |
# | Line 802 | Line 786 | namespace OpenMD { | |
786 | usesMetallic |= (*i)->isMetal(); | |
787 | usesDirectional |= (*i)->isDirectional(); | |
788 | } | |
789 | < | |
789 | > | |
790 | #ifdef IS_MPI | |
791 | int temp; | |
792 | temp = usesDirectional; | |
793 | MPI_Allreduce(&temp, &usesDirectionalAtoms_, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD); | |
794 | < | |
794 | > | |
795 | temp = usesMetallic; | |
796 | MPI_Allreduce(&temp, &usesMetallicAtoms_, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD); | |
797 | < | |
797 | > | |
798 | temp = usesElectrostatic; | |
799 | MPI_Allreduce(&temp, &usesElectrostaticAtoms_, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD); | |
800 | + | #else |
801 | + | |
802 | + | usesDirectionalAtoms_ = usesDirectional; |
803 | + | usesMetallicAtoms_ = usesMetallic; |
804 | + | usesElectrostaticAtoms_ = usesElectrostatic; |
805 | + | |
806 | #endif | |
807 | < | fInfo_.SIM_uses_PBC = usesPeriodicBoundaries_; |
808 | < | fInfo_.SIM_uses_DirectionalAtoms = usesDirectionalAtoms_; |
809 | < | fInfo_.SIM_uses_MetallicAtoms = usesMetallicAtoms_; |
810 | < | fInfo_.SIM_requires_SkipCorrection = usesElectrostaticAtoms_; |
821 | < | fInfo_.SIM_requires_SelfCorrection = usesElectrostaticAtoms_; |
822 | < | fInfo_.SIM_uses_AtomicVirial = usesAtomicVirial_; |
807 | > | |
808 | > | requiresPrepair_ = usesMetallicAtoms_ ? true : false; |
809 | > | requiresSkipCorrection_ = usesElectrostaticAtoms_ ? true : false; |
810 | > | requiresSelfCorrection_ = usesElectrostaticAtoms_ ? true : false; |
811 | } | |
812 | ||
813 | < | void SimInfo::setupFortranSim() { |
814 | < | int isError; |
815 | < | int nExclude, nOneTwo, nOneThree, nOneFour; |
816 | < | vector<int> fortranGlobalGroupMembership; |
813 | > | |
814 | > | vector<int> SimInfo::getGlobalAtomIndices() { |
815 | > | SimInfo::MoleculeIterator mi; |
816 | > | Molecule* mol; |
817 | > | Molecule::AtomIterator ai; |
818 | > | Atom* atom; |
819 | > | |
820 | > | vector<int> GlobalAtomIndices(getNAtoms(), 0); |
821 | ||
822 | < | notifyFortranSkinThickness(&skinThickness_); |
822 | > | for (mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) { |
823 | > | |
824 | > | for (atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) { |
825 | > | GlobalAtomIndices[atom->getLocalIndex()] = atom->getGlobalIndex(); |
826 | > | } |
827 | > | } |
828 | > | return GlobalAtomIndices; |
829 | > | } |
830 | ||
832 | – | int ljsp = cutoffMethod_ == SHIFTED_POTENTIAL ? 1 : 0; |
833 | – | int ljsf = cutoffMethod_ == SHIFTED_FORCE ? 1 : 0; |
834 | – | notifyFortranCutoffs(&cutoffRadius_, &switchingRadius_, &ljsp, &ljsf); |
831 | ||
832 | < | isError = 0; |
832 | > | vector<int> SimInfo::getGlobalGroupIndices() { |
833 | > | SimInfo::MoleculeIterator mi; |
834 | > | Molecule* mol; |
835 | > | Molecule::CutoffGroupIterator ci; |
836 | > | CutoffGroup* cg; |
837 | ||
838 | < | //globalGroupMembership_ is filled by SimCreator |
839 | < | for (int i = 0; i < nGlobalAtoms_; i++) { |
840 | < | fortranGlobalGroupMembership.push_back(globalGroupMembership_[i] + 1); |
838 | > | vector<int> GlobalGroupIndices; |
839 | > | |
840 | > | for (mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) { |
841 | > | |
842 | > | //local index of cutoff group is trivial, it only depends on the |
843 | > | //order of travesing |
844 | > | for (cg = mol->beginCutoffGroup(ci); cg != NULL; |
845 | > | cg = mol->nextCutoffGroup(ci)) { |
846 | > | GlobalGroupIndices.push_back(cg->getGlobalIndex()); |
847 | > | } |
848 | } | |
849 | + | return GlobalGroupIndices; |
850 | + | } |
851 | ||
852 | + | |
853 | + | void SimInfo::prepareTopology() { |
854 | + | int nExclude, nOneTwo, nOneThree, nOneFour; |
855 | + | |
856 | //calculate mass ratio of cutoff group | |
844 | – | vector<RealType> mfact; |
857 | SimInfo::MoleculeIterator mi; | |
858 | Molecule* mol; | |
859 | Molecule::CutoffGroupIterator ci; | |
# | Line 850 | Line 862 | namespace OpenMD { | |
862 | Atom* atom; | |
863 | RealType totalMass; | |
864 | ||
865 | < | //to avoid memory reallocation, reserve enough space for mfact |
866 | < | mfact.reserve(getNCutoffGroups()); |
865 | > | /** |
866 | > | * The mass factor is the relative mass of an atom to the total |
867 | > | * mass of the cutoff group it belongs to. By default, all atoms |
868 | > | * are their own cutoff groups, and therefore have mass factors of |
869 | > | * 1. We need some special handling for massless atoms, which |
870 | > | * will be treated as carrying the entire mass of the cutoff |
871 | > | * group. |
872 | > | */ |
873 | > | massFactors_.clear(); |
874 | > | massFactors_.resize(getNAtoms(), 1.0); |
875 | ||
876 | for(mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) { | |
877 | < | for (cg = mol->beginCutoffGroup(ci); cg != NULL; cg = mol->nextCutoffGroup(ci)) { |
877 | > | for (cg = mol->beginCutoffGroup(ci); cg != NULL; |
878 | > | cg = mol->nextCutoffGroup(ci)) { |
879 | ||
880 | totalMass = cg->getMass(); | |
881 | for(atom = cg->beginAtom(ai); atom != NULL; atom = cg->nextAtom(ai)) { | |
882 | // Check for massless groups - set mfact to 1 if true | |
883 | < | if (totalMass != 0) |
884 | < | mfact.push_back(atom->getMass()/totalMass); |
883 | > | if (totalMass != 0) |
884 | > | massFactors_[atom->getLocalIndex()] = atom->getMass()/totalMass; |
885 | else | |
886 | < | mfact.push_back( 1.0 ); |
886 | > | massFactors_[atom->getLocalIndex()] = 1.0; |
887 | } | |
888 | } | |
889 | } | |
890 | ||
891 | < | //fill ident array of local atoms (it is actually ident of AtomType, it is so confusing !!!) |
871 | < | vector<int> identArray; |
891 | > | // Build the identArray_ |
892 | ||
893 | < | //to avoid memory reallocation, reserve enough space identArray |
894 | < | identArray.reserve(getNAtoms()); |
875 | < | |
893 | > | identArray_.clear(); |
894 | > | identArray_.reserve(getNAtoms()); |
895 | for(mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) { | |
896 | for(atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) { | |
897 | < | identArray.push_back(atom->getIdent()); |
897 | > | identArray_.push_back(atom->getIdent()); |
898 | } | |
899 | } | |
881 | – | |
882 | – | //fill molMembershipArray |
883 | – | //molMembershipArray is filled by SimCreator |
884 | – | vector<int> molMembershipArray(nGlobalAtoms_); |
885 | – | for (int i = 0; i < nGlobalAtoms_; i++) { |
886 | – | molMembershipArray[i] = globalMolMembership_[i] + 1; |
887 | – | } |
900 | ||
901 | < | //setup fortran simulation |
901 | > | //scan topology |
902 | ||
903 | nExclude = excludedInteractions_.getSize(); | |
904 | nOneTwo = oneTwoInteractions_.getSize(); | |
# | Line 898 | Line 910 | namespace OpenMD { | |
910 | int* oneThreeList = oneThreeInteractions_.getPairList(); | |
911 | int* oneFourList = oneFourInteractions_.getPairList(); | |
912 | ||
913 | < | setFortranSim( &fInfo_, &nGlobalAtoms_, &nAtoms_, &identArray[0], |
902 | < | &nExclude, excludeList, |
903 | < | &nOneTwo, oneTwoList, |
904 | < | &nOneThree, oneThreeList, |
905 | < | &nOneFour, oneFourList, |
906 | < | &molMembershipArray[0], &mfact[0], &nCutoffGroups_, |
907 | < | &fortranGlobalGroupMembership[0], &isError); |
908 | < | |
909 | < | if( isError ){ |
910 | < | |
911 | < | sprintf( painCave.errMsg, |
912 | < | "There was an error setting the simulation information in fortran.\n" ); |
913 | < | painCave.isFatal = 1; |
914 | < | painCave.severity = OPENMD_ERROR; |
915 | < | simError(); |
916 | < | } |
917 | < | |
918 | < | |
919 | < | sprintf( checkPointMsg, |
920 | < | "succesfully sent the simulation information to fortran.\n"); |
921 | < | |
922 | < | errorCheckPoint(); |
923 | < | |
924 | < | // Setup number of neighbors in neighbor list if present |
925 | < | if (simParams_->haveNeighborListNeighbors()) { |
926 | < | int nlistNeighbors = simParams_->getNeighborListNeighbors(); |
927 | < | setNeighbors(&nlistNeighbors); |
928 | < | } |
929 | < | |
930 | < | |
931 | < | } |
932 | < | |
933 | < | |
934 | < | void SimInfo::setupFortranParallel() { |
935 | < | #ifdef IS_MPI |
936 | < | //SimInfo is responsible for creating localToGlobalAtomIndex and localToGlobalGroupIndex |
937 | < | vector<int> localToGlobalAtomIndex(getNAtoms(), 0); |
938 | < | vector<int> localToGlobalCutoffGroupIndex; |
939 | < | SimInfo::MoleculeIterator mi; |
940 | < | Molecule::AtomIterator ai; |
941 | < | Molecule::CutoffGroupIterator ci; |
942 | < | Molecule* mol; |
943 | < | Atom* atom; |
944 | < | CutoffGroup* cg; |
945 | < | mpiSimData parallelData; |
946 | < | int isError; |
947 | < | |
948 | < | for (mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) { |
949 | < | |
950 | < | //local index(index in DataStorge) of atom is important |
951 | < | for (atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) { |
952 | < | localToGlobalAtomIndex[atom->getLocalIndex()] = atom->getGlobalIndex() + 1; |
953 | < | } |
954 | < | |
955 | < | //local index of cutoff group is trivial, it only depends on the order of travesing |
956 | < | for (cg = mol->beginCutoffGroup(ci); cg != NULL; cg = mol->nextCutoffGroup(ci)) { |
957 | < | localToGlobalCutoffGroupIndex.push_back(cg->getGlobalIndex() + 1); |
958 | < | } |
959 | < | |
960 | < | } |
961 | < | |
962 | < | //fill up mpiSimData struct |
963 | < | parallelData.nMolGlobal = getNGlobalMolecules(); |
964 | < | parallelData.nMolLocal = getNMolecules(); |
965 | < | parallelData.nAtomsGlobal = getNGlobalAtoms(); |
966 | < | parallelData.nAtomsLocal = getNAtoms(); |
967 | < | parallelData.nGroupsGlobal = getNGlobalCutoffGroups(); |
968 | < | parallelData.nGroupsLocal = getNCutoffGroups(); |
969 | < | parallelData.myNode = worldRank; |
970 | < | MPI_Comm_size(MPI_COMM_WORLD, &(parallelData.nProcessors)); |
971 | < | |
972 | < | //pass mpiSimData struct and index arrays to fortran |
973 | < | setFsimParallel(¶llelData, &(parallelData.nAtomsLocal), |
974 | < | &localToGlobalAtomIndex[0], &(parallelData.nGroupsLocal), |
975 | < | &localToGlobalCutoffGroupIndex[0], &isError); |
976 | < | |
977 | < | if (isError) { |
978 | < | sprintf(painCave.errMsg, |
979 | < | "mpiRefresh errror: fortran didn't like something we gave it.\n"); |
980 | < | painCave.isFatal = 1; |
981 | < | simError(); |
982 | < | } |
983 | < | |
984 | < | sprintf(checkPointMsg, " mpiRefresh successful.\n"); |
985 | < | errorCheckPoint(); |
986 | < | |
987 | < | #endif |
913 | > | topologyDone_ = true; |
914 | } | |
915 | ||
990 | – | |
991 | – | void SimInfo::setupSwitchingFunction() { |
992 | – | int ft = CUBIC; |
993 | – | |
994 | – | if (simParams_->haveSwitchingFunctionType()) { |
995 | – | string funcType = simParams_->getSwitchingFunctionType(); |
996 | – | toUpper(funcType); |
997 | – | if (funcType == "CUBIC") { |
998 | – | ft = CUBIC; |
999 | – | } else { |
1000 | – | if (funcType == "FIFTH_ORDER_POLYNOMIAL") { |
1001 | – | ft = FIFTH_ORDER_POLY; |
1002 | – | } else { |
1003 | – | // throw error |
1004 | – | sprintf( painCave.errMsg, |
1005 | – | "SimInfo error: Unknown switchingFunctionType. (Input file specified %s .)\n" |
1006 | – | "\tswitchingFunctionType must be one of: \"cubic\" or \"fifth_order_polynomial\".", |
1007 | – | funcType.c_str() ); |
1008 | – | painCave.isFatal = 1; |
1009 | – | simError(); |
1010 | – | } |
1011 | – | } |
1012 | – | } |
1013 | – | |
1014 | – | // send switching function notification to switcheroo |
1015 | – | setFunctionType(&ft); |
1016 | – | |
1017 | – | } |
1018 | – | |
1019 | – | void SimInfo::setupAccumulateBoxDipole() { |
1020 | – | |
1021 | – | // we only call setAccumulateBoxDipole if the accumulateBoxDipole parameter is true |
1022 | – | if ( simParams_->haveAccumulateBoxDipole() ) |
1023 | – | if ( simParams_->getAccumulateBoxDipole() ) { |
1024 | – | calcBoxDipole_ = true; |
1025 | – | } |
1026 | – | |
1027 | – | } |
1028 | – | |
916 | void SimInfo::addProperty(GenericData* genData) { | |
917 | properties_.addProperty(genData); | |
918 | } | |
# | Line 1060 | Line 947 | namespace OpenMD { | |
947 | Molecule* mol; | |
948 | RigidBody* rb; | |
949 | Atom* atom; | |
950 | + | CutoffGroup* cg; |
951 | SimInfo::MoleculeIterator mi; | |
952 | Molecule::RigidBodyIterator rbIter; | |
953 | < | Molecule::AtomIterator atomIter;; |
953 | > | Molecule::AtomIterator atomIter; |
954 | > | Molecule::CutoffGroupIterator cgIter; |
955 | ||
956 | for (mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) { | |
957 | ||
# | Line 1073 | Line 962 | namespace OpenMD { | |
962 | for (rb = mol->beginRigidBody(rbIter); rb != NULL; rb = mol->nextRigidBody(rbIter)) { | |
963 | rb->setSnapshotManager(sman_); | |
964 | } | |
965 | + | |
966 | + | for (cg = mol->beginCutoffGroup(cgIter); cg != NULL; cg = mol->nextCutoffGroup(cgIter)) { |
967 | + | cg->setSnapshotManager(sman_); |
968 | + | } |
969 | } | |
970 | ||
971 | } | |
# | Line 1301 | Line 1194 | namespace OpenMD { | |
1194 | ||
1195 | det = intTensor.determinant(); | |
1196 | sysconstants = geomCnst/(RealType)nGlobalIntegrableObjects_; | |
1197 | < | volume = 4.0/3.0*NumericConstant::PI*pow(sysconstants,3.0/2.0)*sqrt(det); |
1197 | > | volume = 4.0/3.0*NumericConstant::PI*pow(sysconstants,geomCnst)*sqrt(det); |
1198 | return; | |
1199 | } | |
1200 | ||
# | Line 1317 | Line 1210 | namespace OpenMD { | |
1210 | ||
1211 | detI = intTensor.determinant(); | |
1212 | sysconstants = geomCnst/(RealType)nGlobalIntegrableObjects_; | |
1213 | < | volume = 4.0/3.0*NumericConstant::PI*pow(sysconstants,3.0/2.0)*sqrt(detI); |
1213 | > | volume = 4.0/3.0*NumericConstant::PI*pow(sysconstants,geomCnst)*sqrt(detI); |
1214 | return; | |
1215 | } | |
1216 | /* |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |