ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/brains/SimInfo.cpp
(Generate patch)

Comparing branches/development/src/brains/SimInfo.cpp (file contents):
Revision 1529 by gezelter, Mon Dec 27 18:35:59 2010 UTC vs.
Revision 1569 by gezelter, Thu May 26 13:55:04 2011 UTC

# 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/DarkSide/fSwitchingFunctionType.h"
59 – #include "UseTheForce/doForces_interface.h"
60 – #include "UseTheForce/DarkSide/neighborLists_interface.h"
61 – #include "UseTheForce/DarkSide/switcheroo_interface.h"
57   #include "utils/MemoryUtils.hpp"
58   #include "utils/simError.h"
59   #include "selection/SelectionManager.hpp"
60   #include "io/ForceFieldOptions.hpp"
61   #include "UseTheForce/ForceField.hpp"
62 < #include "nonbonded/InteractionManager.hpp"
62 > #include "nonbonded/SwitchingFunction.hpp"
63  
69 –
70 – #ifdef IS_MPI
71 – #include "UseTheForce/mpiComponentPlan.h"
72 – #include "UseTheForce/DarkSide/simParallel_interface.h"
73 – #endif
74 –
64   using namespace std;
65   namespace OpenMD {
66    
# Line 82 | Line 71 | namespace OpenMD {
71      nGlobalIntegrableObjects_(0), nGlobalRigidBodies_(0),
72      nAtoms_(0), nBonds_(0),  nBends_(0), nTorsions_(0), nInversions_(0),
73      nRigidBodies_(0), nIntegrableObjects_(0), nCutoffGroups_(0),
74 <    nConstraints_(0), sman_(NULL), fortranInitialized_(false),
74 >    nConstraints_(0), sman_(NULL), topologyDone_(false),
75      calcBoxDipole_(false), useAtomicVirial_(true) {    
76      
77      MoleculeStamp* molStamp;
# Line 136 | Line 125 | namespace OpenMD {
125      //equal to the total number of atoms minus number of atoms belong to
126      //cutoff group defined in meta-data file plus the number of cutoff
127      //groups defined in meta-data file
128 +    std::cerr << "nGA = " << nGlobalAtoms_ << "\n";
129 +    std::cerr << "nCA = " << nCutoffAtoms << "\n";
130 +    std::cerr << "nG = " << nGroups << "\n";
131 +
132      nGlobalCutoffGroups_ = nGlobalAtoms_ - nCutoffAtoms + nGroups;
133 +
134 +    std::cerr << "nGCG = " << nGlobalCutoffGroups_ << "\n";
135      
136      //every free atom (atom does not belong to rigid bodies) is an
137      //integrable object therefore the total number of integrable objects
# Line 656 | Line 651 | namespace OpenMD {
651      molStampIds_.insert(molStampIds_.end(), nmol, curStampId);
652    }
653  
659 –  void SimInfo::update() {
654  
655 <    setupSimType();
656 <    setupCutoffRadius();
657 <    setupSwitchingRadius();
658 <    setupCutoffMethod();
659 <    setupSkinThickness();
660 <    setupSwitchingFunction();
661 <    setupAccumulateBoxDipole();
662 <
663 < #ifdef IS_MPI
670 <    setupFortranParallel();
671 < #endif
672 <    setupFortranSim();
673 <    fortranInitialized_ = true;
674 <
655 >  /**
656 >   * update
657 >   *
658 >   *  Performs the global checks and variable settings after the
659 >   *  objects have been created.
660 >   *
661 >   */
662 >  void SimInfo::update() {  
663 >    setupSimVariables();
664      calcNdf();
665      calcNdfRaw();
666      calcNdfTrans();
667    }
668    
669 +  /**
670 +   * getSimulatedAtomTypes
671 +   *
672 +   * Returns an STL set of AtomType* that are actually present in this
673 +   * simulation.  Must query all processors to assemble this information.
674 +   *
675 +   */
676    set<AtomType*> SimInfo::getSimulatedAtomTypes() {
677      SimInfo::MoleculeIterator mi;
678      Molecule* mol;
# Line 689 | Line 685 | namespace OpenMD {
685          atomTypes.insert(atom->getAtomType());
686        }      
687      }    
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() {
706 –    
707 –    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 –    }
688  
689 <    InteractionManager::Instance()->setCutoffRadius(cutoffRadius_);
737 <  }
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() {
746 <    
747 <    if (simParams_->haveSwitchingRadius()) {
748 <      switchingRadius_ = simParams_->getSwitchingRadius();
749 <      if (switchingRadius_ > cutoffRadius_) {        
750 <        sprintf(painCave.errMsg,
751 <                "SimInfo Error: switchingRadius (%f) is larger than cutoffRadius(%f)\n",
752 <                switchingRadius_, cutoffRadius_);
753 <        painCave.isFatal = 1;
754 <        simError();
689 > #ifdef IS_MPI
690  
691 <      }
692 <    } 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 <  }
691 >    // loop over the found atom types on this processor, and add their
692 >    // numerical idents to a vector:
693  
694 <  /**
770 <   * setupSkinThickness
771 <   *
772 <   *  If the skinThickness was explicitly set, use that value (but check it)
773 <   *  If the skinThickness was not explicitly set: use 1.0 angstroms
774 <   */
775 <  void SimInfo::setupSkinThickness() {    
776 <    if (simParams_->haveSkinThickness()) {
777 <      skinThickness_ = simParams_->getSkinThickness();
778 <    } else {      
779 <      skinThickness_ = 1.0;
780 <      sprintf(painCave.errMsg,
781 <              "SimInfo Warning: No value was set for the skinThickness.\n"
782 <              "\tOpenMD will use a default value of %f Angstroms\n"
783 <              "\tfor this simulation\n", skinThickness_);
784 <      painCave.isFatal = 0;
785 <      simError();
786 <    }            
787 <  }
788 <
789 <  void SimInfo::setupSimType() {
694 >    vector<int> foundTypes;
695      set<AtomType*>::iterator i;
696 <    set<AtomType*> atomTypes;
697 <    atomTypes = getSimulatedAtomTypes();
696 >    for (i = atomTypes.begin(); i != atomTypes.end(); ++i)
697 >      foundTypes.push_back( (*i)->getIdent() );
698  
699 +    // count_local holds the number of found types on this processor
700 +    int count_local = foundTypes.size();
701 +
702 +    // count holds the total number of found types on all processors
703 +    // (some will be redundant with the ones found locally):
704 +    int count;
705 +    MPI::COMM_WORLD.Allreduce(&count_local, &count, 1, MPI::INT, MPI::SUM);
706 +
707 +    // create a vector to hold the globally found types, and resize it:
708 +    vector<int> ftGlobal;
709 +    ftGlobal.resize(count);
710 +    vector<int> counts;
711 +
712 +    int nproc = MPI::COMM_WORLD.Get_size();
713 +    counts.resize(nproc);
714 +    vector<int> disps;
715 +    disps.resize(nproc);
716 +
717 +    // now spray out the foundTypes to all the other processors:
718 +    
719 +    MPI::COMM_WORLD.Allgatherv(&foundTypes[0], count_local, MPI::INT,
720 +                               &ftGlobal[0], &counts[0], &disps[0], MPI::INT);
721 +
722 +    // foundIdents is a stl set, so inserting an already found ident
723 +    // will have no effect.
724 +    set<int> foundIdents;
725 +    vector<int>::iterator j;
726 +    for (j = ftGlobal.begin(); j != ftGlobal.end(); ++j)
727 +      foundIdents.insert((*j));
728 +    
729 +    // now iterate over the foundIdents and get the actual atom types
730 +    // that correspond to these:
731 +    set<int>::iterator it;
732 +    for (it = foundIdents.begin(); it != foundIdents.end(); ++it)
733 +      atomTypes.insert( forceField_->getAtomType((*it)) );
734 +
735 + #endif
736 +    
737 +    return atomTypes;        
738 +  }
739 +
740 +  void SimInfo::setupSimVariables() {
741      useAtomicVirial_ = simParams_->getUseAtomicVirial();
742 +    // we only call setAccumulateBoxDipole if the accumulateBoxDipole parameter is true
743 +    calcBoxDipole_ = false;
744 +    if ( simParams_->haveAccumulateBoxDipole() )
745 +      if ( simParams_->getAccumulateBoxDipole() ) {
746 +        calcBoxDipole_ = true;      
747 +      }
748  
749 +    set<AtomType*>::iterator i;
750 +    set<AtomType*> atomTypes;
751 +    atomTypes = getSimulatedAtomTypes();    
752      int usesElectrostatic = 0;
753      int usesMetallic = 0;
754      int usesDirectional = 0;
# Line 814 | Line 770 | namespace OpenMD {
770      temp = usesElectrostatic;
771      MPI_Allreduce(&temp, &usesElectrostaticAtoms_, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);
772   #endif
817 –    fInfo_.SIM_uses_PBC = usesPeriodicBoundaries_;    
818 –    fInfo_.SIM_uses_DirectionalAtoms = usesDirectionalAtoms_;
819 –    fInfo_.SIM_uses_MetallicAtoms = usesMetallicAtoms_;
820 –    fInfo_.SIM_requires_SkipCorrection = usesElectrostaticAtoms_;
821 –    fInfo_.SIM_requires_SelfCorrection = usesElectrostaticAtoms_;
822 –    fInfo_.SIM_uses_AtomicVirial = usesAtomicVirial_;
773    }
774  
825 –  void SimInfo::setupFortranSim() {
826 –    int isError;
827 –    int nExclude, nOneTwo, nOneThree, nOneFour;
828 –    vector<int> fortranGlobalGroupMembership;
829 –    
830 –    notifyFortranSkinThickness(&skinThickness_);
775  
776 <    int ljsp = cutoffMethod_ == SHIFTED_POTENTIAL ? 1 : 0;
777 <    int ljsf = cutoffMethod_ == SHIFTED_FORCE ? 1 : 0;
778 <    notifyFortranCutoffs(&cutoffRadius_, &switchingRadius_, &ljsp, &ljsf);
779 <
780 <    isError = 0;
776 >  vector<int> SimInfo::getGlobalAtomIndices() {
777 >    SimInfo::MoleculeIterator mi;
778 >    Molecule* mol;
779 >    Molecule::AtomIterator ai;
780 >    Atom* atom;
781  
782 <    //globalGroupMembership_ is filled by SimCreator    
783 <    for (int i = 0; i < nGlobalAtoms_; i++) {
784 <      fortranGlobalGroupMembership.push_back(globalGroupMembership_[i] + 1);
782 >    vector<int> GlobalAtomIndices(getNAtoms(), 0);
783 >    
784 >    for (mol = beginMolecule(mi); mol != NULL; mol  = nextMolecule(mi)) {
785 >      
786 >      for (atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) {
787 >        GlobalAtomIndices[atom->getLocalIndex()] = atom->getGlobalIndex();
788 >      }
789      }
790 +    return GlobalAtomIndices;
791 +  }
792  
793 +
794 +  vector<int> SimInfo::getGlobalGroupIndices() {
795 +    SimInfo::MoleculeIterator mi;
796 +    Molecule* mol;
797 +    Molecule::CutoffGroupIterator ci;
798 +    CutoffGroup* cg;
799 +
800 +    vector<int> GlobalGroupIndices;
801 +    
802 +    for (mol = beginMolecule(mi); mol != NULL; mol  = nextMolecule(mi)) {
803 +      
804 +      //local index of cutoff group is trivial, it only depends on the
805 +      //order of travesing
806 +      for (cg = mol->beginCutoffGroup(ci); cg != NULL;
807 +           cg = mol->nextCutoffGroup(ci)) {
808 +        GlobalGroupIndices.push_back(cg->getGlobalIndex());
809 +      }        
810 +    }
811 +    return GlobalGroupIndices;
812 +  }
813 +
814 +
815 +  void SimInfo::prepareTopology() {
816 +    int nExclude, nOneTwo, nOneThree, nOneFour;
817 +
818      //calculate mass ratio of cutoff group
844 –    vector<RealType> mfact;
819      SimInfo::MoleculeIterator mi;
820      Molecule* mol;
821      Molecule::CutoffGroupIterator ci;
# Line 850 | Line 824 | namespace OpenMD {
824      Atom* atom;
825      RealType totalMass;
826  
827 <    //to avoid memory reallocation, reserve enough space for mfact
828 <    mfact.reserve(getNCutoffGroups());
827 >    //to avoid memory reallocation, reserve enough space for massFactors_
828 >    massFactors_.clear();
829 >    massFactors_.reserve(getNCutoffGroups());
830      
831      for(mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) {        
832 <      for (cg = mol->beginCutoffGroup(ci); cg != NULL; cg = mol->nextCutoffGroup(ci)) {
832 >      for (cg = mol->beginCutoffGroup(ci); cg != NULL;
833 >           cg = mol->nextCutoffGroup(ci)) {
834  
835          totalMass = cg->getMass();
836          for(atom = cg->beginAtom(ai); atom != NULL; atom = cg->nextAtom(ai)) {
837            // Check for massless groups - set mfact to 1 if true
838            if (totalMass != 0)
839 <            mfact.push_back(atom->getMass()/totalMass);
839 >            massFactors_.push_back(atom->getMass()/totalMass);
840            else
841 <            mfact.push_back( 1.0 );
841 >            massFactors_.push_back( 1.0 );
842          }
843        }      
844      }
845  
846 <    //fill ident array of local atoms (it is actually ident of AtomType, it is so confusing !!!)
871 <    vector<int> identArray;
846 >    // Build the identArray_
847  
848 <    //to avoid memory reallocation, reserve enough space identArray
849 <    identArray.reserve(getNAtoms());
875 <    
848 >    identArray_.clear();
849 >    identArray_.reserve(getNAtoms());    
850      for(mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) {        
851        for(atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) {
852 <        identArray.push_back(atom->getIdent());
852 >        identArray_.push_back(atom->getIdent());
853        }
854      }    
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 –    }
855      
856 <    //setup fortran simulation
856 >    //scan topology
857  
858      nExclude = excludedInteractions_.getSize();
859      nOneTwo = oneTwoInteractions_.getSize();
# Line 898 | Line 865 | namespace OpenMD {
865      int* oneThreeList = oneThreeInteractions_.getPairList();
866      int* oneFourList = oneFourInteractions_.getPairList();
867  
868 <    setFortranSim( &fInfo_, &nGlobalAtoms_, &nAtoms_, &identArray[0],
869 <                   &nExclude, excludeList,
870 <                   &nOneTwo, oneTwoList,
871 <                   &nOneThree, oneThreeList,
872 <                   &nOneFour, oneFourList,
873 <                   &molMembershipArray[0], &mfact[0], &nCutoffGroups_,
874 <                   &fortranGlobalGroupMembership[0], &isError);
868 >    //setFortranSim( &fInfo_, &nGlobalAtoms_, &nAtoms_, &identArray_[0],
869 >    //               &nExclude, excludeList,
870 >    //               &nOneTwo, oneTwoList,
871 >    //               &nOneThree, oneThreeList,
872 >    //               &nOneFour, oneFourList,
873 >    //               &molMembershipArray[0], &mfact[0], &nCutoffGroups_,
874 >    //               &fortranGlobalGroupMembership[0], &isError);
875      
876 <    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(&parallelData, &(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
988 <  }
989 <
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 <
876 >    topologyDone_ = true;
877    }
878  
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 –
879    void SimInfo::addProperty(GenericData* genData) {
880      properties_.addProperty(genData);  
881    }
# Line 1060 | Line 910 | namespace OpenMD {
910      Molecule* mol;
911      RigidBody* rb;
912      Atom* atom;
913 +    CutoffGroup* cg;
914      SimInfo::MoleculeIterator mi;
915      Molecule::RigidBodyIterator rbIter;
916 <    Molecule::AtomIterator atomIter;;
916 >    Molecule::AtomIterator atomIter;
917 >    Molecule::CutoffGroupIterator cgIter;
918  
919      for (mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) {
920          
# Line 1073 | Line 925 | namespace OpenMD {
925        for (rb = mol->beginRigidBody(rbIter); rb != NULL; rb = mol->nextRigidBody(rbIter)) {
926          rb->setSnapshotManager(sman_);
927        }
928 +
929 +      for (cg = mol->beginCutoffGroup(cgIter); cg != NULL; cg = mol->nextCutoffGroup(cgIter)) {
930 +        cg->setSnapshotManager(sman_);
931 +      }
932      }    
933      
934    }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines