# | Line 54 | Line 54 | |
---|---|---|
54 | #include "math/Vector3.hpp" | |
55 | #include "primitives/Molecule.hpp" | |
56 | #include "primitives/StuntDouble.hpp" | |
57 | – | #include "UseTheForce/fCutoffPolicy.h" |
58 | – | #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 64 | Line 63 | |
63 | #include "UseTheForce/ForceField.hpp" | |
64 | #include "nonbonded/SwitchingFunction.hpp" | |
65 | ||
67 | – | |
66 | #ifdef IS_MPI | |
67 | #include "UseTheForce/mpiComponentPlan.h" | |
68 | #include "UseTheForce/DarkSide/simParallel_interface.h" | |
# | Line 134 | 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 658 | 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() { |
666 | < | |
669 | > | void SimInfo::update() { |
670 | setupSimVariables(); | |
668 | – | setupCutoffs(); |
669 | – | setupSwitching(); |
670 | – | setupElectrostatics(); |
671 | – | setupNeighborlists(); |
672 | – | |
673 | – | #ifdef IS_MPI |
674 | – | setupFortranParallel(); |
675 | – | #endif |
676 | – | setupFortranSim(); |
677 | – | fortranInitialized_ = true; |
678 | – | |
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 693 | Line 692 | namespace OpenMD { | |
692 | atomTypes.insert(atom->getAtomType()); | |
693 | } | |
694 | } | |
696 | – | return atomTypes; |
697 | – | } |
695 | ||
696 | < | /** |
700 | < | * setupCutoffs |
701 | < | * |
702 | < | * Sets the values of cutoffRadius and cutoffMethod |
703 | < | * |
704 | < | * cutoffRadius : realType |
705 | < | * If the cutoffRadius was explicitly set, use that value. |
706 | < | * If the cutoffRadius was not explicitly set: |
707 | < | * Are there electrostatic atoms? Use 12.0 Angstroms. |
708 | < | * No electrostatic atoms? Poll the atom types present in the |
709 | < | * simulation for suggested cutoff values (e.g. 2.5 * sigma). |
710 | < | * Use the maximum suggested value that was found. |
711 | < | * |
712 | < | * cutoffMethod : (one of HARD, SWITCHED, SHIFTED_FORCE, SHIFTED_POTENTIAL) |
713 | < | * If cutoffMethod was explicitly set, use that choice. |
714 | < | * If cutoffMethod was not explicitly set, use SHIFTED_FORCE |
715 | < | */ |
716 | < | void SimInfo::setupCutoffs() { |
717 | < | |
718 | < | if (simParams_->haveCutoffRadius()) { |
719 | < | cutoffRadius_ = simParams_->getCutoffRadius(); |
720 | < | } else { |
721 | < | if (usesElectrostaticAtoms_) { |
722 | < | sprintf(painCave.errMsg, |
723 | < | "SimInfo: No value was set for the cutoffRadius.\n" |
724 | < | "\tOpenMD will use a default value of 12.0 angstroms" |
725 | < | "\tfor the cutoffRadius.\n"); |
726 | < | painCave.isFatal = 0; |
727 | < | painCave.severity = OPENMD_INFO; |
728 | < | simError(); |
729 | < | cutoffRadius_ = 12.0; |
730 | < | } else { |
731 | < | RealType thisCut; |
732 | < | set<AtomType*>::iterator i; |
733 | < | set<AtomType*> atomTypes; |
734 | < | atomTypes = getSimulatedAtomTypes(); |
735 | < | for (i = atomTypes.begin(); i != atomTypes.end(); ++i) { |
736 | < | thisCut = InteractionManager::Instance()->getSuggestedCutoffRadius((*i)); |
737 | < | cutoffRadius_ = max(thisCut, cutoffRadius_); |
738 | < | } |
739 | < | sprintf(painCave.errMsg, |
740 | < | "SimInfo: No value was set for the cutoffRadius.\n" |
741 | < | "\tOpenMD will use %lf angstroms.\n", |
742 | < | cutoffRadius_); |
743 | < | painCave.isFatal = 0; |
744 | < | painCave.severity = OPENMD_INFO; |
745 | < | simError(); |
746 | < | } |
747 | < | } |
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; |
755 | < | stringToCutoffMethod["SHIFTED_FORCE"] = SHIFTED_FORCE; |
756 | < | |
757 | < | if (simParams_->haveCutoffMethod()) { |
758 | < | string cutMeth = toUpperCopy(simParams_->getCutoffMethod()); |
759 | < | map<string, CutoffMethod>::iterator i; |
760 | < | i = stringToCutoffMethod.find(cutMeth); |
761 | < | if (i == stringToCutoffMethod.end()) { |
762 | < | sprintf(painCave.errMsg, |
763 | < | "SimInfo: Could not find chosen cutoffMethod %s\n" |
764 | < | "\tShould be one of: " |
765 | < | "HARD, SWITCHING_FUNCTION, SHIFTED_POTENTIAL, or SHIFTED_FORCE\n", |
766 | < | cutMeth.c_str()); |
767 | < | painCave.isFatal = 1; |
768 | < | painCave.severity = OPENMD_ERROR; |
769 | < | simError(); |
770 | < | } else { |
771 | < | cutoffMethod_ = i->second; |
772 | < | } |
773 | < | } else { |
774 | < | sprintf(painCave.errMsg, |
775 | < | "SimInfo: No value was set for the cutoffMethod.\n" |
776 | < | "\tOpenMD will use SHIFTED_FORCE.\n"); |
777 | < | painCave.isFatal = 0; |
778 | < | painCave.severity = OPENMD_INFO; |
779 | < | simError(); |
780 | < | cutoffMethod_ = SHIFTED_FORCE; |
781 | < | } |
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 | < | } |
785 | < | |
786 | < | /** |
787 | < | * setupSwitching |
788 | < | * |
789 | < | * Sets the values of switchingRadius and |
790 | < | * If the switchingRadius was explicitly set, use that value (but check it) |
791 | < | * If the switchingRadius was not explicitly set: use 0.85 * cutoffRadius_ |
792 | < | */ |
793 | < | void SimInfo::setupSwitching() { |
794 | < | |
795 | < | if (simParams_->haveSwitchingRadius()) { |
796 | < | switchingRadius_ = simParams_->getSwitchingRadius(); |
797 | < | if (switchingRadius_ > cutoffRadius_) { |
798 | < | sprintf(painCave.errMsg, |
799 | < | "SimInfo: switchingRadius (%f) is larger than cutoffRadius(%f)\n", |
800 | < | switchingRadius_, cutoffRadius_); |
801 | < | painCave.isFatal = 1; |
802 | < | painCave.severity = OPENMD_ERROR; |
803 | < | simError(); |
804 | < | } |
805 | < | } else { |
806 | < | switchingRadius_ = 0.85 * cutoffRadius_; |
807 | < | sprintf(painCave.errMsg, |
808 | < | "SimInfo: No value was set for the switchingRadius.\n" |
809 | < | "\tOpenMD will use a default value of 85 percent of the cutoffRadius.\n" |
810 | < | "\tswitchingRadius = %f. for this simulation\n", switchingRadius_); |
811 | < | painCave.isFatal = 0; |
812 | < | painCave.severity = OPENMD_WARNING; |
813 | < | simError(); |
814 | < | } |
815 | < | |
816 | < | 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; |
710 | < | |
711 | < | if (simParams_->haveSwitchingFunctionType()) { |
712 | < | string funcType = simParams_->getSwitchingFunctionType(); |
822 | < | toUpper(funcType); |
823 | < | if (funcType == "CUBIC") { |
824 | < | ft = cubic; |
825 | < | } else { |
826 | < | if (funcType == "FIFTH_ORDER_POLYNOMIAL") { |
827 | < | ft = fifth_order_poly; |
828 | < | } else { |
829 | < | // throw error |
830 | < | sprintf( painCave.errMsg, |
831 | < | "SimInfo : Unknown switchingFunctionType. (Input file specified %s .)\n" |
832 | < | "\tswitchingFunctionType must be one of: " |
833 | < | "\"cubic\" or \"fifth_order_polynomial\".", |
834 | < | funcType.c_str() ); |
835 | < | painCave.isFatal = 1; |
836 | < | painCave.severity = OPENMD_ERROR; |
837 | < | simError(); |
838 | < | } |
839 | < | } |
840 | < | } |
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 | < | InteractionManager::Instance()->setSwitchingFunctionType(ft); |
715 | < | } |
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 | < | /** |
720 | < | * setupSkinThickness |
721 | < | * |
722 | < | * If the skinThickness was explicitly set, use that value (but check it) |
849 | < | * If the skinThickness was not explicitly set: use 1.0 angstroms |
850 | < | */ |
851 | < | void SimInfo::setupSkinThickness() { |
852 | < | if (simParams_->haveSkinThickness()) { |
853 | < | skinThickness_ = simParams_->getSkinThickness(); |
854 | < | } else { |
855 | < | skinThickness_ = 1.0; |
856 | < | sprintf(painCave.errMsg, |
857 | < | "SimInfo Warning: No value was set for the skinThickness.\n" |
858 | < | "\tOpenMD will use a default value of %f Angstroms\n" |
859 | < | "\tfor this simulation\n", skinThickness_); |
860 | < | painCave.isFatal = 0; |
861 | < | simError(); |
862 | < | } |
863 | < | } |
719 | > | int nproc = MPI::COMM_WORLD.Get_size(); |
720 | > | counts.resize(nproc); |
721 | > | vector<int> disps; |
722 | > | disps.resize(nproc); |
723 | ||
724 | < | void SimInfo::setupSimType() { |
725 | < | set<AtomType*>::iterator i; |
726 | < | set<AtomType*> atomTypes; |
727 | < | atomTypes = getSimulatedAtomTypes(); |
724 | > | // now spray out the foundTypes to all the other processors: |
725 | > | |
726 | > | MPI::COMM_WORLD.Allgatherv(&foundTypes[0], count_local, MPI::INT, |
727 | > | &ftGlobal[0], &counts[0], &disps[0], MPI::INT); |
728 | ||
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() { |
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 | ||
756 | + | set<AtomType*>::iterator i; |
757 | + | set<AtomType*> atomTypes; |
758 | + | atomTypes = getSimulatedAtomTypes(); |
759 | int usesElectrostatic = 0; | |
760 | int usesMetallic = 0; | |
761 | int usesDirectional = 0; | |
# | Line 898 | Line 785 | namespace OpenMD { | |
785 | fInfo_.SIM_uses_AtomicVirial = usesAtomicVirial_; | |
786 | } | |
787 | ||
788 | < | void SimInfo::setupFortranSim() { |
788 | > | |
789 | > | vector<int> SimInfo::getGlobalAtomIndices() { |
790 | > | SimInfo::MoleculeIterator mi; |
791 | > | Molecule* mol; |
792 | > | Molecule::AtomIterator ai; |
793 | > | Atom* atom; |
794 | > | |
795 | > | vector<int> GlobalAtomIndices(getNAtoms(), 0); |
796 | > | |
797 | > | for (mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) { |
798 | > | |
799 | > | for (atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) { |
800 | > | GlobalAtomIndices[atom->getLocalIndex()] = atom->getGlobalIndex(); |
801 | > | } |
802 | > | } |
803 | > | return GlobalAtomIndices; |
804 | > | } |
805 | > | |
806 | > | |
807 | > | vector<int> SimInfo::getGlobalGroupIndices() { |
808 | > | SimInfo::MoleculeIterator mi; |
809 | > | Molecule* mol; |
810 | > | Molecule::CutoffGroupIterator ci; |
811 | > | CutoffGroup* cg; |
812 | > | |
813 | > | vector<int> GlobalGroupIndices; |
814 | > | |
815 | > | for (mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) { |
816 | > | |
817 | > | //local index of cutoff group is trivial, it only depends on the |
818 | > | //order of travesing |
819 | > | for (cg = mol->beginCutoffGroup(ci); cg != NULL; |
820 | > | cg = mol->nextCutoffGroup(ci)) { |
821 | > | GlobalGroupIndices.push_back(cg->getGlobalIndex()); |
822 | > | } |
823 | > | } |
824 | > | return GlobalGroupIndices; |
825 | > | } |
826 | > | |
827 | > | |
828 | > | void SimInfo::setupFortran() { |
829 | int isError; | |
830 | int nExclude, nOneTwo, nOneThree, nOneFour; | |
831 | vector<int> fortranGlobalGroupMembership; | |
832 | ||
906 | – | notifyFortranSkinThickness(&skinThickness_); |
907 | – | |
908 | – | int ljsp = cutoffMethod_ == SHIFTED_POTENTIAL ? 1 : 0; |
909 | – | int ljsf = cutoffMethod_ == SHIFTED_FORCE ? 1 : 0; |
910 | – | notifyFortranCutoffs(&cutoffRadius_, &switchingRadius_, &ljsp, &ljsf); |
911 | – | |
833 | isError = 0; | |
834 | ||
835 | //globalGroupMembership_ is filled by SimCreator | |
# | Line 943 | Line 864 | namespace OpenMD { | |
864 | } | |
865 | } | |
866 | ||
867 | < | //fill ident array of local atoms (it is actually ident of AtomType, it is so confusing !!!) |
947 | < | vector<int> identArray; |
867 | > | // Build the identArray_ |
868 | ||
869 | < | //to avoid memory reallocation, reserve enough space identArray |
870 | < | identArray.reserve(getNAtoms()); |
951 | < | |
869 | > | identArray_.clear(); |
870 | > | identArray_.reserve(getNAtoms()); |
871 | for(mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) { | |
872 | for(atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) { | |
873 | < | identArray.push_back(atom->getIdent()); |
873 | > | identArray_.push_back(atom->getIdent()); |
874 | } | |
875 | } | |
876 | ||
# | Line 974 | Line 893 | namespace OpenMD { | |
893 | int* oneThreeList = oneThreeInteractions_.getPairList(); | |
894 | int* oneFourList = oneFourInteractions_.getPairList(); | |
895 | ||
896 | < | setFortranSim( &fInfo_, &nGlobalAtoms_, &nAtoms_, &identArray[0], |
896 | > | setFortranSim( &fInfo_, &nGlobalAtoms_, &nAtoms_, &identArray_[0], |
897 | &nExclude, excludeList, | |
898 | &nOneTwo, oneTwoList, | |
899 | &nOneThree, oneThreeList, | |
# | Line 1003 | Line 922 | namespace OpenMD { | |
922 | setNeighbors(&nlistNeighbors); | |
923 | } | |
924 | ||
1006 | – | |
1007 | – | } |
1008 | – | |
1009 | – | |
1010 | – | void SimInfo::setupFortranParallel() { |
925 | #ifdef IS_MPI | |
1012 | – | //SimInfo is responsible for creating localToGlobalAtomIndex and localToGlobalGroupIndex |
1013 | – | vector<int> localToGlobalAtomIndex(getNAtoms(), 0); |
1014 | – | vector<int> localToGlobalCutoffGroupIndex; |
1015 | – | SimInfo::MoleculeIterator mi; |
1016 | – | Molecule::AtomIterator ai; |
1017 | – | Molecule::CutoffGroupIterator ci; |
1018 | – | Molecule* mol; |
1019 | – | Atom* atom; |
1020 | – | CutoffGroup* cg; |
926 | mpiSimData parallelData; | |
1022 | – | int isError; |
927 | ||
1024 | – | for (mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) { |
1025 | – | |
1026 | – | //local index(index in DataStorge) of atom is important |
1027 | – | for (atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) { |
1028 | – | localToGlobalAtomIndex[atom->getLocalIndex()] = atom->getGlobalIndex() + 1; |
1029 | – | } |
1030 | – | |
1031 | – | //local index of cutoff group is trivial, it only depends on the order of travesing |
1032 | – | for (cg = mol->beginCutoffGroup(ci); cg != NULL; cg = mol->nextCutoffGroup(ci)) { |
1033 | – | localToGlobalCutoffGroupIndex.push_back(cg->getGlobalIndex() + 1); |
1034 | – | } |
1035 | – | |
1036 | – | } |
1037 | – | |
928 | //fill up mpiSimData struct | |
929 | parallelData.nMolGlobal = getNGlobalMolecules(); | |
930 | parallelData.nMolLocal = getNMolecules(); | |
# | Line 1046 | Line 936 | namespace OpenMD { | |
936 | MPI_Comm_size(MPI_COMM_WORLD, &(parallelData.nProcessors)); | |
937 | ||
938 | //pass mpiSimData struct and index arrays to fortran | |
939 | < | setFsimParallel(¶llelData, &(parallelData.nAtomsLocal), |
940 | < | &localToGlobalAtomIndex[0], &(parallelData.nGroupsLocal), |
941 | < | &localToGlobalCutoffGroupIndex[0], &isError); |
939 | > | //setFsimParallel(¶llelData, &(parallelData.nAtomsLocal), |
940 | > | // &localToGlobalAtomIndex[0], &(parallelData.nGroupsLocal), |
941 | > | // &localToGlobalCutoffGroupIndex[0], &isError); |
942 | ||
943 | if (isError) { | |
944 | sprintf(painCave.errMsg, | |
# | Line 1059 | Line 949 | namespace OpenMD { | |
949 | ||
950 | sprintf(checkPointMsg, " mpiRefresh successful.\n"); | |
951 | errorCheckPoint(); | |
1062 | – | |
952 | #endif | |
1064 | – | } |
1065 | – | |
1066 | – | |
1067 | – | void SimInfo::setupSwitchingFunction() { |
1068 | – | |
1069 | – | } |
1070 | – | |
1071 | – | void SimInfo::setupAccumulateBoxDipole() { |
953 | ||
954 | < | // we only call setAccumulateBoxDipole if the accumulateBoxDipole parameter is true |
955 | < | if ( simParams_->haveAccumulateBoxDipole() ) |
956 | < | if ( simParams_->getAccumulateBoxDipole() ) { |
957 | < | calcBoxDipole_ = true; |
958 | < | } |
959 | < | |
954 | > | initFortranFF(&isError); |
955 | > | if (isError) { |
956 | > | sprintf(painCave.errMsg, |
957 | > | "initFortranFF errror: fortran didn't like something we gave it.\n"); |
958 | > | painCave.isFatal = 1; |
959 | > | simError(); |
960 | > | } |
961 | > | fortranInitialized_ = true; |
962 | } | |
963 | ||
964 | void SimInfo::addProperty(GenericData* genData) { | |
# | Line 1112 | Line 995 | namespace OpenMD { | |
995 | Molecule* mol; | |
996 | RigidBody* rb; | |
997 | Atom* atom; | |
998 | + | CutoffGroup* cg; |
999 | SimInfo::MoleculeIterator mi; | |
1000 | Molecule::RigidBodyIterator rbIter; | |
1001 | < | Molecule::AtomIterator atomIter;; |
1001 | > | Molecule::AtomIterator atomIter; |
1002 | > | Molecule::CutoffGroupIterator cgIter; |
1003 | ||
1004 | for (mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) { | |
1005 | ||
# | Line 1124 | Line 1009 | namespace OpenMD { | |
1009 | ||
1010 | for (rb = mol->beginRigidBody(rbIter); rb != NULL; rb = mol->nextRigidBody(rbIter)) { | |
1011 | rb->setSnapshotManager(sman_); | |
1012 | + | } |
1013 | + | |
1014 | + | for (cg = mol->beginCutoffGroup(cgIter); cg != NULL; cg = mol->nextCutoffGroup(cgIter)) { |
1015 | + | cg->setSnapshotManager(sman_); |
1016 | } | |
1017 | } | |
1018 |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |