Use C++11 style loops

28b79b2f · peastman · ab8f1021 · 28b79b2f · 28b79b2f · 28b79b2f
Commit 28b79b2f authored Mar 03, 2017 by peastman
20 changed files
--- a/platforms/cpu/src/CpuCustomGBForce.cpp
+++ b/platforms/cpu/src/CpuCustomGBForce.cpp
@@ -74,48 +74,48 @@ CpuCustomGBForce::ThreadData::ThreadData(int numAtoms, int numThreads, int threa
            variableLocations[name.str()] = &particleValue[2*i+j];
        }
    }
-    for (int i = 0; i < (int) valueExpressions.size(); i++) {
+    for (auto& expression : this->valueExpressions) {
-        this->valueExpressions[i].setVariableLocations(variableLocations);
+        expression.setVariableLocations(variableLocations);
-        expressionSet.registerExpression(this->valueExpressions[i]);
+        expressionSet.registerExpression(expression);
    }
-    for (int i = 0; i < (int) valueDerivExpressions.size(); i++)
+    for (auto& expressions : this->valueDerivExpressions)
-        for (int j = 0; j < (int) valueDerivExpressions[i].size(); j++) {
+        for (auto& expression : expressions) {
-            this->valueDerivExpressions[i][j].setVariableLocations(variableLocations);
+            expression.setVariableLocations(variableLocations);
-            expressionSet.registerExpression(this->valueDerivExpressions[i][j]);
+            expressionSet.registerExpression(expression);
        }
-    for (int i = 0; i < (int) valueGradientExpressions.size(); i++)
+    for (auto& expressions : this->valueGradientExpressions)
-        for (int j = 0; j < (int) valueGradientExpressions[i].size(); j++) {
+        for (auto& expression : expressions) {
-            this->valueGradientExpressions[i][j].setVariableLocations(variableLocations);
+            expression.setVariableLocations(variableLocations);
-            expressionSet.registerExpression(this->valueGradientExpressions[i][j]);
+            expressionSet.registerExpression(expression);
        }
-    for (int i = 0; i < (int) valueParamDerivExpressions.size(); i++)
+    for (auto& expressions : this->valueParamDerivExpressions)
-        for (int j = 0; j < (int) valueParamDerivExpressions[i].size(); j++) {
+        for (auto& expression : expressions) {
-            this->valueParamDerivExpressions[i][j].setVariableLocations(variableLocations);
+            expression.setVariableLocations(variableLocations);
-            expressionSet.registerExpression(this->valueParamDerivExpressions[i][j]);
+            expressionSet.registerExpression(expression);
        }
-    for (int i = 0; i < (int) energyExpressions.size(); i++) {
+    for (auto& expression : this->energyExpressions) {
-        this->energyExpressions[i].setVariableLocations(variableLocations);
+        expression.setVariableLocations(variableLocations);
-        expressionSet.registerExpression(this->energyExpressions[i]);
+        expressionSet.registerExpression(expression);
    }
-    for (int i = 0; i < (int) energyDerivExpressions.size(); i++)
+    for (auto& expressions : this->energyDerivExpressions)
-        for (int j = 0; j < (int) energyDerivExpressions[i].size(); j++) {
+        for (auto& expression : expressions) {
-            this->energyDerivExpressions[i][j].setVariableLocations(variableLocations);
+            expression.setVariableLocations(variableLocations);
-            expressionSet.registerExpression(this->energyDerivExpressions[i][j]);
+            expressionSet.registerExpression(expression);
        }
-    for (int i = 0; i < (int) energyGradientExpressions.size(); i++)
+    for (auto& expressions : this->energyGradientExpressions)
-        for (int j = 0; j < (int) energyGradientExpressions[i].size(); j++) {
+        for (auto& expression : expressions) {
-            this->energyGradientExpressions[i][j].setVariableLocations(variableLocations);
+            expression.setVariableLocations(variableLocations);
-            expressionSet.registerExpression(this->energyGradientExpressions[i][j]);
+            expressionSet.registerExpression(expression);
        }
-    for (int i = 0; i < (int) energyParamDerivExpressions.size(); i++)
+    for (auto& expressions : this->energyParamDerivExpressions)
-        for (int j = 0; j < (int) energyParamDerivExpressions[i].size(); j++) {
+        for (auto& expression : expressions) {
-            this->energyParamDerivExpressions[i][j].setVariableLocations(variableLocations);
+            expression.setVariableLocations(variableLocations);
-            expressionSet.registerExpression(this->energyParamDerivExpressions[i][j]);
+            expressionSet.registerExpression(expression);
        }
    value0.resize(numAtoms);
    dEdV.resize(valueNames.size());
-    for (int i = 0; i < (int) dEdV.size(); i++)
+    for (auto& v : dEdV)
-        dEdV[i].resize(numAtoms);
+        v.resize(numAtoms);
    dVdX.resize(valueDerivExpressions.size());
    dVdY.resize(valueDerivExpressions.size());
    dVdZ.resize(valueDerivExpressions.size());
@@ -155,8 +155,8 @@ CpuCustomGBForce::CpuCustomGBForce(int numAtoms, const std::vector<std::set<int>
 }
 CpuCustomGBForce::~CpuCustomGBForce() {
-    for (int i = 0; i < (int) threadData.size(); i++)
+    for (auto data : threadData)
-        delete threadData[i];
+        delete data;
 }
 void CpuCustomGBForce::setUseCutoff(float distance, const CpuNeighborList& neighbors) {
@@ -256,16 +256,16 @@ void CpuCustomGBForce::threadComputeForce(ThreadPool& threads, int threadIndex)
    ThreadData& data = *threadData[threadIndex];
    fvec4 boxSize(periodicBoxSize[0], periodicBoxSize[1], periodicBoxSize[2], 0);
    fvec4 invBoxSize((1/periodicBoxSize[0]), (1/periodicBoxSize[1]), (1/periodicBoxSize[2]), 0);
-    for (map<string, double>::const_iterator iter = globalParameters->begin(); iter != globalParameters->end(); ++iter)
+    for (auto& param : *globalParameters)
-        data.expressionSet.setVariable(data.expressionSet.getVariableIndex(iter->first), iter->second);
+        data.expressionSet.setVariable(data.expressionSet.getVariableIndex(param.first), param.second);
    // Calculate the first computed value.
-    for (int i = 0; i < (int) data.value0.size(); i++)
+    for (auto& v : data.value0)
-        data.value0[i] = 0.0f;
+        v = 0.0f;
-    for (int i = 0; i < (int) data.dValue0dParam.size(); i++)
+    for (auto& vals : data.dValue0dParam)
-        for (int j = 0; j < (int) data.dValue0dParam[i].size(); j++)
+        for (auto& v : vals)
-            data.dValue0dParam[i][j] = 0.0;
+            v = 0.0f;
    if (valueTypes[0] == CustomGBForce::ParticlePair)
        calculateParticlePairValue(0, data, numberOfAtoms, posq, atomParameters, true, boxSize, invBoxSize);
    else
@@ -291,8 +291,8 @@ void CpuCustomGBForce::threadComputeForce(ThreadPool& threads, int threadIndex)
    int numValues = valueTypes.size();
    for (int atom = data.firstAtom; atom < data.lastAtom; atom++) {
        float sum = 0.0f;
-        for (int j = 0; j < (int) threadData.size(); j++)
+        for (auto& data : threadData)
-            sum += threadData[j]->value0[atom];
+            sum += data->value0[atom];
        values[0][atom] = sum;
        data.x = posq[4*atom];
        data.y = posq[4*atom+1];
@@ -320,11 +320,11 @@ void CpuCustomGBForce::threadComputeForce(ThreadPool& threads, int threadIndex)
    // Now calculate the energy and its derivatives.
-    for (int i = 0; i < (int) data.dEdV.size(); i++)
+    for (auto& vals : data.dEdV)
-        for (int j = 0; j < (int) data.dEdV[i].size(); j++)
+        for (auto& v : vals)
-            data.dEdV[i][j] = 0.0f;
+            v = 0.0f;
-    for (int i = 0; i < (int) data.energyParamDerivs.size(); i++)
+    for (auto& v : data.energyParamDerivs)
-        data.energyParamDerivs[i] = 0.0f;
+        v = 0.0f;
    for (int termIndex = 0; termIndex < (int) data.energyExpressions.size(); termIndex++) {
        if (energyTypes[termIndex] == CustomGBForce::SingleParticle)
            calculateSingleParticleEnergyTerm(termIndex, data, numberOfAtoms, posq, atomParameters, forces, energy);
@@ -340,8 +340,8 @@ void CpuCustomGBForce::threadComputeForce(ThreadPool& threads, int threadIndex)
    for (int atom = data.firstAtom; atom < data.lastAtom; atom++) {
        for (int i = 0; i < (int) dEdV.size(); i++) {
            float sum = 0.0f;
-            for (int j = 0; j < (int) threadData.size(); j++)
+            for (auto& data : threadData)
-                sum += threadData[j]->dEdV[i][atom];
+                sum += data->dEdV[i][atom];
            dEdV[i][atom] = sum;
        }
    }

--- a/platforms/cpu/src/CpuCustomManyParticleForce.cpp
+++ b/platforms/cpu/src/CpuCustomManyParticleForce.cpp
@@ -63,8 +63,8 @@ CpuCustomManyParticleForce::CpuCustomManyParticleForce(const CustomManyParticleF
    // Delete the custom functions.
-    for (map<string, Lepton::CustomFunction*>::iterator iter = functions.begin(); iter != functions.end(); iter++)
+    for (auto& function : functions)
-        delete iter->second;
+        delete function.second;
    // Record exclusions.
@@ -84,8 +84,8 @@ CpuCustomManyParticleForce::CpuCustomManyParticleForce(const CustomManyParticleF
 CpuCustomManyParticleForce::~CpuCustomManyParticleForce() {
    if (neighborList != NULL)
        delete neighborList;
-    for (int i = 0; i < (int) threadData.size(); i++)
+    for (auto data : threadData)
-        delete threadData[i];
+        delete data;
 }
 void CpuCustomManyParticleForce::calculateIxn(AlignedArray<float>& posq, double** particleParameters,
@@ -150,8 +150,8 @@ void CpuCustomManyParticleForce::threadComputeForce(ThreadPool& threads, int thr
    float* forces = &(*threadForce)[threadIndex][0];
    ThreadData& data = *threadData[threadIndex];
    data.energy = 0;
-    for (map<string, double>::const_iterator iter = globalParameters->begin(); iter != globalParameters->end(); ++iter)
+    for (auto& param : *globalParameters)
-        data.expressionSet.setVariable(data.expressionSet.getVariableIndex(iter->first), iter->second);
+        data.expressionSet.setVariable(data.expressionSet.getVariableIndex(param.first), param.second);
    if (useCutoff) {
        // Loop over interactions from the neighbor list.
@@ -287,18 +287,12 @@ void CpuCustomManyParticleForce::calculateOneIxn(vector<int>& particleSet, doubl
    // Compute all of the variables the energy can depend on.
-    for (int i = 0; i < (int) data.particleTerms.size(); i++) {
+    for (auto& term : data.particleTerms)
-        const ParticleTermInfo& term = data.particleTerms[i];
        expressionSet.setVariable(term.variableIndex, posq[4*permutedParticles[term.atom]+term.component]);
-    }
+    for (auto& term : data.distanceTerms)
-    for (int i = 0; i < (int) data.distanceTerms.size(); i++) {
-        const DistanceTermInfo& term = data.distanceTerms[i];
        expressionSet.setVariable(term.variableIndex, normDelta[term.delta]);
-    }
+    for (auto& term : data.angleTerms)
-    for (int i = 0; i < (int) data.angleTerms.size(); i++) {
-        const AngleTermInfo& term = data.angleTerms[i];
        expressionSet.setVariable(term.variableIndex, computeAngle(delta[term.delta1], delta[term.delta2], norm2Delta[term.delta1], norm2Delta[term.delta2], term.delta1Sign*term.delta2Sign));
-    }
    for (int i = 0; i < (int) data.dihedralTerms.size(); i++) {
        const DihedralTermInfo& term = data.dihedralTerms[i];
        expressionSet.setVariable(term.variableIndex, getDihedralAngleBetweenThreeVectors(delta[term.delta1], delta[term.delta2], delta[term.delta3], cross1[i], cross2[i], delta[term.delta1]));
@@ -310,8 +304,7 @@ void CpuCustomManyParticleForce::calculateOneIxn(vector<int>& particleSet, doubl
        AlignedArray<fvec4>& f = data.f;
        for (int i = 0; i < numParticlesPerSet; i++)
            f[i] = fvec4(0.0f);
-        for (int i = 0; i < (int) data.particleTerms.size(); i++) {
+        for (auto& term : data.particleTerms) {
-            const ParticleTermInfo& term = data.particleTerms[i];
            float temp[4];
            f[term.atom].store(temp);
            temp[term.component] -= term.forceExpression.evaluate();
@@ -320,8 +313,7 @@ void CpuCustomManyParticleForce::calculateOneIxn(vector<int>& particleSet, doubl
        // Apply forces based on distances.
-        for (int i = 0; i < (int) data.distanceTerms.size(); i++) {
+        for (auto& term : data.distanceTerms) {
-            const DistanceTermInfo& term = data.distanceTerms[i];
            float dEdR = (float) (term.forceExpression.evaluate()*term.deltaSign/(normDelta[term.delta]));
            fvec4 force = -dEdR*delta[term.delta];
            f[term.p1] -= force;
@@ -330,8 +322,7 @@ void CpuCustomManyParticleForce::calculateOneIxn(vector<int>& particleSet, doubl
        // Apply forces based on angles.
-        for (int i = 0; i < (int) data.angleTerms.size(); i++) {
+        for (auto& term : data.angleTerms) {
-            const AngleTermInfo& term = data.angleTerms[i];
            float dEdTheta = (float) term.forceExpression.evaluate();
            fvec4 thetaCross = cross(delta[term.delta1], delta[term.delta2]);
            float lengthThetaCross = sqrtf(dot3(thetaCross, thetaCross));
@@ -482,20 +473,20 @@ CpuCustomManyParticleForce::ThreadData::ThreadData(const CustomManyParticleForce
            particleParamIndices[i].push_back(expressionSet.getVariableIndex(paramname.str()));
        }
    }
-    for (map<string, vector<int> >::const_iterator iter = dihedrals.begin(); iter != dihedrals.end(); ++iter)
+    for (auto& term : dihedrals)
-        dihedralTerms.push_back(CpuCustomManyParticleForce::DihedralTermInfo(iter->first, iter->second, energyExpr.differentiate(iter->first).optimize().createCompiledExpression(), *this));
+        dihedralTerms.push_back(CpuCustomManyParticleForce::DihedralTermInfo(term.first, term.second, energyExpr.differentiate(term.first).optimize().createCompiledExpression(), *this));
-    for (map<string, vector<int> >::const_iterator iter = distances.begin(); iter != distances.end(); ++iter)
+    for (auto& term : distances)
-        distanceTerms.push_back(CpuCustomManyParticleForce::DistanceTermInfo(iter->first, iter->second, energyExpr.differentiate(iter->first).optimize().createCompiledExpression(), *this));
+        distanceTerms.push_back(CpuCustomManyParticleForce::DistanceTermInfo(term.first, term.second, energyExpr.differentiate(term.first).optimize().createCompiledExpression(), *this));
-    for (map<string, vector<int> >::const_iterator iter = angles.begin(); iter != angles.end(); ++iter)
+    for (auto& term : angles)
-        angleTerms.push_back(CpuCustomManyParticleForce::AngleTermInfo(iter->first, iter->second, energyExpr.differentiate(iter->first).optimize().createCompiledExpression(), *this));
+        angleTerms.push_back(CpuCustomManyParticleForce::AngleTermInfo(term.first, term.second, energyExpr.differentiate(term.first).optimize().createCompiledExpression(), *this));
-    for (int i = 0; i < particleTerms.size(); i++)
+    for (auto& term : particleTerms)
-        expressionSet.registerExpression(particleTerms[i].forceExpression);
+        expressionSet.registerExpression(term.forceExpression);
-    for (int i = 0; i < distanceTerms.size(); i++)
+    for (auto& term : distanceTerms)
-        expressionSet.registerExpression(distanceTerms[i].forceExpression);
+        expressionSet.registerExpression(term.forceExpression);
-    for (int i = 0; i < angleTerms.size(); i++)
+    for (auto& term : angleTerms)
-        expressionSet.registerExpression(angleTerms[i].forceExpression);
+        expressionSet.registerExpression(term.forceExpression);
-    for (int i = 0; i < dihedralTerms.size(); i++)
+    for (auto& term : dihedralTerms)
-        expressionSet.registerExpression(dihedralTerms[i].forceExpression);
+        expressionSet.registerExpression(term.forceExpression);
    int numDeltas = deltaPairs.size();
    delta.resize(numDeltas);
    normDelta.resize(numDeltas);

--- a/platforms/cpu/src/CpuCustomNonbondedForce.cpp
+++ b/platforms/cpu/src/CpuCustomNonbondedForce.cpp
@@ -51,9 +51,9 @@ CpuCustomNonbondedForce::ThreadData::ThreadData(const Lepton::CompiledExpression
    this->forceExpression.setVariableLocations(variableLocations);
    expressionSet.registerExpression(this->energyExpression);
    expressionSet.registerExpression(this->forceExpression);
-    for (int i = 0; i < this->energyParamDerivExpressions.size(); i++) {
+    for (auto& expression : this->energyParamDerivExpressions) {
-        this->energyParamDerivExpressions[i].setVariableLocations(variableLocations);
+        expression.setVariableLocations(variableLocations);
-        expressionSet.registerExpression(this->energyParamDerivExpressions[i]);
+        expressionSet.registerExpression(expression);
    }
 }
@@ -66,8 +66,8 @@ CpuCustomNonbondedForce::CpuCustomNonbondedForce(const Lepton::CompiledExpressio
 }
 CpuCustomNonbondedForce::~CpuCustomNonbondedForce() {
-    for (int i = 0; i < (int) threadData.size(); i++)
+    for (auto data : threadData)
-        delete threadData[i];
+        delete data;
 }
 void CpuCustomNonbondedForce::setUseCutoff(double distance, const CpuNeighborList& neighbors) {
@@ -78,9 +78,9 @@ void CpuCustomNonbondedForce::setUseCutoff(double distance, const CpuNeighborLis
 void CpuCustomNonbondedForce::setInteractionGroups(const vector<pair<set<int>, set<int> > >& groups) {
    useInteractionGroups = true;
-    for (int group = 0; group < (int) groups.size(); group++) {
+    for (auto& group : groups) {
-        const set<int>& set1 = groups[group].first;
+        const set<int>& set1 = group.first;
-        const set<int>& set2 = groups[group].second;
+        const set<int>& set2 = group.second;
        for (set<int>::const_iterator atom1 = set1.begin(); atom1 != set1.end(); ++atom1) {
            for (set<int>::const_iterator atom2 = set2.begin(); atom2 != set2.end(); ++atom2) {
                if (*atom1 == *atom2 || exclusions[*atom1].find(*atom2) != exclusions[*atom1].end())
@@ -167,10 +167,10 @@ void CpuCustomNonbondedForce::threadComputeForce(ThreadPool& threads, int thread
    double& energy = threadEnergy[threadIndex];
    float* forces = &(*threadForce)[threadIndex][0];
    ThreadData& data = *threadData[threadIndex];
-    for (map<string, double>::const_iterator iter = globalParameters->begin(); iter != globalParameters->end(); ++iter)
+    for (auto& param : *globalParameters)
-        data.expressionSet.setVariable(data.expressionSet.getVariableIndex(iter->first), iter->second);
+        data.expressionSet.setVariable(data.expressionSet.getVariableIndex(param.first), param.second);
-    for (int i = 0; i < data.energyParamDerivs.size(); i++)
+    for (auto& deriv : data.energyParamDerivs)
-        data.energyParamDerivs[i] = 0.0;
+        deriv = 0.0;
    fvec4 boxSize(periodicBoxVectors[0][0], periodicBoxVectors[1][1], periodicBoxVectors[2][2], 0);
    fvec4 invBoxSize(recipBoxSize[0], recipBoxSize[1], recipBoxSize[2], 0);
    if (useInteractionGroups) {

--- a/platforms/cpu/src/CpuRandom.cpp
+++ b/platforms/cpu/src/CpuRandom.cpp
@@ -34,8 +34,8 @@ CpuRandom::CpuRandom() : hasInitialized(false) {
 }
 CpuRandom::~CpuRandom() {
-    for (int i = 0; i < (int) threadRandom.size(); i++)
+    for (auto random : threadRandom)
-        delete threadRandom[i];
+        delete random;
 }
 void CpuRandom::initialize(int seed, int numThreads) {

--- a/platforms/cpu/src/CpuSETTLE.cpp
+++ b/platforms/cpu/src/CpuSETTLE.cpp
@@ -56,8 +56,8 @@ CpuSETTLE::CpuSETTLE(const System& system, const ReferenceSETTLEAlgorithm& settl
 }
 CpuSETTLE::~CpuSETTLE() {
-    for (int i = 0; i < (int) threadSettle.size(); i++)
+    for (auto settle : threadSettle)
-        delete threadSettle[i];
+        delete settle;
 }
 void CpuSETTLE::apply(vector<OpenMM::Vec3>& atomCoordinates, vector<OpenMM::Vec3>& atomCoordinatesP, vector<double>& inverseMasses, double tolerance) {

--- a/platforms/reference/src/SimTKReference/ReferenceAndersenThermostat.cpp
+++ b/platforms/reference/src/SimTKReference/ReferenceAndersenThermostat.cpp
@@ -66,13 +66,12 @@ using namespace OpenMM;
              double temperature, double collisionFrequency, double stepSize) const {
          const double collisionProbability = 1.0f - exp(-collisionFrequency*stepSize);
-          for (int i = 0; i < (int) atomGroups.size(); ++i) {
+          for (auto& group : atomGroups) {
              if (SimTKOpenMMUtilities::getUniformlyDistributedRandomNumber() < collisionProbability) {
                  // A collision occurred, so set the velocities to new values chosen from a Boltzmann distribution.
-                  for (int j = 0; j < (int) atomGroups[i].size(); j++) {
+                  for (int atom : group) {
-                      int atom = atomGroups[i][j];
                      if (atomMasses[atom] != 0) {
                          const double velocityScale = static_cast<double>(sqrt(BOLTZ*temperature/atomMasses[atom]));
                          atomVelocities[atom][0] = velocityScale*SimTKOpenMMUtilities::getNormallyDistributedRandomNumber();

--- a/platforms/reference/src/SimTKReference/ReferenceCCMAAlgorithm.cpp
+++ b/platforms/reference/src/SimTKReference/ReferenceCCMAAlgorithm.cpp
@@ -145,8 +145,7 @@ ReferenceCCMAAlgorithm::ReferenceCCMAAlgorithm(int numberOfAtoms,
        vector<double> matrixValue;
        for (int i = 0; i < numberOfConstraints; i++) {
            matrixRowStart.push_back(matrixValue.size());
-            for (int j = 0; j < (int) matrix[i].size(); j++) {
+            for (auto& element : matrix[i]) {
-                pair<int, double> element = matrix[i][j];
                matrixColIndex.push_back(element.first);
                matrixValue.push_back(element.second);
            }
@@ -292,10 +291,8 @@ void ReferenceCCMAAlgorithm::applyConstraints(vector<Vec3>& atomCoordinates,
        if (_matrix.size() > 0) {
            for (int i = 0; i < _numberOfConstraints; i++) {
                double sum = 0.0;
-                for (int j = 0; j < (int) _matrix[i].size(); j++) {
+                for (auto& element : _matrix[i])
-                    pair<int, double> element = _matrix[i][j];
                    sum += element.second*constraintDelta[element.first];
-                }
                tempDelta[i] = sum;
            }
            constraintDelta = tempDelta;

--- a/platforms/reference/src/SimTKReference/ReferenceCustomAngleIxn.cpp
+++ b/platforms/reference/src/SimTKReference/ReferenceCustomAngleIxn.cpp
@@ -47,10 +47,10 @@ ReferenceCustomAngleIxn::ReferenceCustomAngleIxn(const Lepton::CompiledExpressio
        expressionSet.registerExpression(this->energyParamDerivExpressions[i]);
    thetaIndex = expressionSet.getVariableIndex("theta");
    numParameters = parameterNames.size();
-    for (int i = 0; i < (int) numParameters; i++)
+    for (auto& param : parameterNames)
-        angleParamIndex.push_back(expressionSet.getVariableIndex(parameterNames[i]));
+        angleParamIndex.push_back(expressionSet.getVariableIndex(param));
-    for (map<string, double>::const_iterator iter = globalParameters.begin(); iter != globalParameters.end(); ++iter)
+    for (auto& param : globalParameters)
-        expressionSet.setVariable(expressionSet.getVariableIndex(iter->first), iter->second);
+        expressionSet.setVariable(expressionSet.getVariableIndex(param.first), param.second);
 }
 /**---------------------------------------------------------------------------------------

--- a/platforms/reference/src/SimTKReference/ReferenceCustomBondIxn.cpp
+++ b/platforms/reference/src/SimTKReference/ReferenceCustomBondIxn.cpp
@@ -48,10 +48,10 @@ ReferenceCustomBondIxn::ReferenceCustomBondIxn(const Lepton::CompiledExpression&
        expressionSet.registerExpression(this->energyParamDerivExpressions[i]);
    rIndex = expressionSet.getVariableIndex("r");
    numParameters = parameterNames.size();
-    for (int i = 0; i < (int) numParameters; i++)
+    for (auto& param : parameterNames)
-        bondParamIndex.push_back(expressionSet.getVariableIndex(parameterNames[i]));
+        bondParamIndex.push_back(expressionSet.getVariableIndex(param));
-    for (map<string, double>::const_iterator iter = globalParameters.begin(); iter != globalParameters.end(); ++iter)
+    for (auto& param : globalParameters)
-        expressionSet.setVariable(expressionSet.getVariableIndex(iter->first), iter->second);
+        expressionSet.setVariable(expressionSet.getVariableIndex(param.first), param.second);
 }
 /**---------------------------------------------------------------------------------------

--- a/platforms/reference/src/SimTKReference/ReferenceCustomCentroidBondIxn.cpp
+++ b/platforms/reference/src/SimTKReference/ReferenceCustomCentroidBondIxn.cpp
@@ -56,12 +56,12 @@ ReferenceCustomCentroidBondIxn::ReferenceCustomCentroidBondIxn(int numGroupsPerB
        positionTerms.push_back(ReferenceCustomCentroidBondIxn::PositionTermInfo(yname.str(), i, 1, energyExpression.differentiate(yname.str()).createCompiledExpression()));
        positionTerms.push_back(ReferenceCustomCentroidBondIxn::PositionTermInfo(zname.str(), i, 2, energyExpression.differentiate(zname.str()).createCompiledExpression()));
    }
-    for (map<string, vector<int> >::const_iterator iter = distances.begin(); iter != distances.end(); ++iter)
+    for (auto& term : distances)
-        distanceTerms.push_back(ReferenceCustomCentroidBondIxn::DistanceTermInfo(iter->first, iter->second, energyExpression.differentiate(iter->first).createCompiledExpression()));
+        distanceTerms.push_back(ReferenceCustomCentroidBondIxn::DistanceTermInfo(term.first, term.second, energyExpression.differentiate(term.first).createCompiledExpression()));
-    for (map<string, vector<int> >::const_iterator iter = angles.begin(); iter != angles.end(); ++iter)
+    for (auto& term : angles)
-        angleTerms.push_back(ReferenceCustomCentroidBondIxn::AngleTermInfo(iter->first, iter->second, energyExpression.differentiate(iter->first).createCompiledExpression()));
+        angleTerms.push_back(ReferenceCustomCentroidBondIxn::AngleTermInfo(term.first, term.second, energyExpression.differentiate(term.first).createCompiledExpression()));
-    for (map<string, vector<int> >::const_iterator iter = dihedrals.begin(); iter != dihedrals.end(); ++iter)
+    for (auto& term : dihedrals)
-        dihedralTerms.push_back(ReferenceCustomCentroidBondIxn::DihedralTermInfo(iter->first, iter->second, energyExpression.differentiate(iter->first).createCompiledExpression()));
+        dihedralTerms.push_back(ReferenceCustomCentroidBondIxn::DihedralTermInfo(term.first, term.second, energyExpression.differentiate(term.first).createCompiledExpression()));
    for (int i = 0; i < positionTerms.size(); i++) {
        expressionSet.registerExpression(positionTerms[i].forceExpression);
        positionTerms[i].index = expressionSet.getVariableIndex(positionTerms[i].name);
@@ -108,8 +108,8 @@ void ReferenceCustomCentroidBondIxn::calculatePairIxn(vector<Vec3>& atomCoordina
    // Compute the forces on groups.
-    for (map<string, double>::const_iterator iter = globalParameters.begin(); iter != globalParameters.end(); ++iter)
+    for (auto& param : globalParameters)
-        expressionSet.setVariable(expressionSet.getVariableIndex(iter->first), iter->second);
+        expressionSet.setVariable(expressionSet.getVariableIndex(param.first), param.second);
    vector<Vec3> groupForces(numGroups);
    int numBonds = bondGroups.size();
    for (int bond = 0; bond < numBonds; bond++) {
@@ -131,23 +131,18 @@ void ReferenceCustomCentroidBondIxn::calculateOneIxn(int bond, vector<Vec3>& gro
    // Compute all of the variables the energy can depend on.
    const vector<int>& groups = bondGroups[bond];
-    for (int i = 0; i < (int) positionTerms.size(); i++) {
+    for (auto& term : positionTerms)
-        const PositionTermInfo& term = positionTerms[i];
        expressionSet.setVariable(term.index, groupCenters[groups[term.group]][term.component]);
-    }
+    for (auto& term : distanceTerms) {
-    for (int i = 0; i < (int) distanceTerms.size(); i++) {
-        const DistanceTermInfo& term = distanceTerms[i];
        computeDelta(groups[term.g1], groups[term.g2], term.delta, groupCenters);
        expressionSet.setVariable(term.index, term.delta[ReferenceForce::RIndex]);
    }
-    for (int i = 0; i < (int) angleTerms.size(); i++) {
+    for (auto& term : angleTerms) {
-        const AngleTermInfo& term = angleTerms[i];
        computeDelta(groups[term.g1], groups[term.g2], term.delta1, groupCenters);
        computeDelta(groups[term.g3], groups[term.g2], term.delta2, groupCenters);
        expressionSet.setVariable(term.index, computeAngle(term.delta1, term.delta2));
    }
-    for (int i = 0; i < (int) dihedralTerms.size(); i++) {
+    for (auto& term : dihedralTerms) {
-        const DihedralTermInfo& term = dihedralTerms[i];
        computeDelta(groups[term.g2], groups[term.g1], term.delta1, groupCenters);
        computeDelta(groups[term.g2], groups[term.g3], term.delta2, groupCenters);
        computeDelta(groups[term.g4], groups[term.g3], term.delta3, groupCenters);
@@ -158,15 +153,12 @@ void ReferenceCustomCentroidBondIxn::calculateOneIxn(int bond, vector<Vec3>& gro
    // Apply forces based on individual particle coordinates.
-    for (int i = 0; i < (int) positionTerms.size(); i++) {
+    for (auto& term : positionTerms)
-        const PositionTermInfo& term = positionTerms[i];
        forces[groups[term.group]][term.component] -= term.forceExpression.evaluate();
-    }
    // Apply forces based on distances.
-    for (int i = 0; i < (int) distanceTerms.size(); i++) {
+    for (auto& term : distanceTerms) {
-        const DistanceTermInfo& term = distanceTerms[i];
        double dEdR = term.forceExpression.evaluate()/(term.delta[ReferenceForce::RIndex]);
        for (int i = 0; i < 3; i++) {
           double force  = -dEdR*term.delta[i];
@@ -177,8 +169,7 @@ void ReferenceCustomCentroidBondIxn::calculateOneIxn(int bond, vector<Vec3>& gro
    // Apply forces based on angles.
-    for (int i = 0; i < (int) angleTerms.size(); i++) {
+    for (auto& term : angleTerms) {
-        const AngleTermInfo& term = angleTerms[i];
        double dEdTheta = term.forceExpression.evaluate();
        double thetaCross[ReferenceForce::LastDeltaRIndex];
        SimTKOpenMMUtilities::crossProductVector3(term.delta1, term.delta2, thetaCross);
@@ -204,8 +195,7 @@ void ReferenceCustomCentroidBondIxn::calculateOneIxn(int bond, vector<Vec3>& gro
    // Apply forces based on dihedrals.
-    for (int i = 0; i < (int) dihedralTerms.size(); i++) {
+    for (auto& term : dihedralTerms) {
-        const DihedralTermInfo& term = dihedralTerms[i];
        double dEdTheta = term.forceExpression.evaluate();
        double internalF[4][3];
        double forceFactors[4];

--- a/platforms/reference/src/SimTKReference/ReferenceCustomCompoundBondIxn.cpp
+++ b/platforms/reference/src/SimTKReference/ReferenceCustomCompoundBondIxn.cpp
@@ -61,12 +61,12 @@ ReferenceCustomCompoundBondIxn::ReferenceCustomCompoundBondIxn(int numParticlesP
        particleTerms.push_back(ReferenceCustomCompoundBondIxn::ParticleTermInfo(yname.str(), i, 1, energyExpression.differentiate(yname.str()).createCompiledExpression()));
        particleTerms.push_back(ReferenceCustomCompoundBondIxn::ParticleTermInfo(zname.str(), i, 2, energyExpression.differentiate(zname.str()).createCompiledExpression()));
    }
-    for (map<string, vector<int> >::const_iterator iter = distances.begin(); iter != distances.end(); ++iter)
+    for (auto& term : distances)
-        distanceTerms.push_back(ReferenceCustomCompoundBondIxn::DistanceTermInfo(iter->first, iter->second, energyExpression.differentiate(iter->first).createCompiledExpression()));
+        distanceTerms.push_back(ReferenceCustomCompoundBondIxn::DistanceTermInfo(term.first, term.second, energyExpression.differentiate(term.first).createCompiledExpression()));
-    for (map<string, vector<int> >::const_iterator iter = angles.begin(); iter != angles.end(); ++iter)
+    for (auto& term : angles)
-        angleTerms.push_back(ReferenceCustomCompoundBondIxn::AngleTermInfo(iter->first, iter->second, energyExpression.differentiate(iter->first).createCompiledExpression()));
+        angleTerms.push_back(ReferenceCustomCompoundBondIxn::AngleTermInfo(term.first, term.second, energyExpression.differentiate(term.first).createCompiledExpression()));
-    for (map<string, vector<int> >::const_iterator iter = dihedrals.begin(); iter != dihedrals.end(); ++iter)
+    for (auto& term : dihedrals)
-        dihedralTerms.push_back(ReferenceCustomCompoundBondIxn::DihedralTermInfo(iter->first, iter->second, energyExpression.differentiate(iter->first).createCompiledExpression()));
+        dihedralTerms.push_back(ReferenceCustomCompoundBondIxn::DihedralTermInfo(term.first, term.second, energyExpression.differentiate(term.first).createCompiledExpression()));
    for (int i = 0; i < particleTerms.size(); i++) {
        expressionSet.registerExpression(particleTerms[i].forceExpression);
        particleTerms[i].index = expressionSet.getVariableIndex(particleTerms[i].name);
@@ -119,8 +119,8 @@ void ReferenceCustomCompoundBondIxn::setPeriodic(OpenMM::Vec3* vectors) {
 void ReferenceCustomCompoundBondIxn::calculatePairIxn(vector<Vec3>& atomCoordinates, double** bondParameters,
                                             const map<string, double>& globalParameters, vector<Vec3>& forces,
                                             double* totalEnergy, double* energyParamDerivs) {
-    for (map<string, double>::const_iterator iter = globalParameters.begin(); iter != globalParameters.end(); ++iter)
+    for (auto& param : globalParameters)
-        expressionSet.setVariable(expressionSet.getVariableIndex(iter->first), iter->second);
+        expressionSet.setVariable(expressionSet.getVariableIndex(param.first), param.second);
    int numBonds = bondAtoms.size();
    for (int bond = 0; bond < numBonds; bond++) {
        for (int i = 0; i < numParameters; i++)
@@ -146,23 +146,18 @@ void ReferenceCustomCompoundBondIxn::calculateOneIxn(int bond, vector<Vec3>& ato
    // Compute all of the variables the energy can depend on.
    const vector<int>& atoms = bondAtoms[bond];
-    for (int i = 0; i < (int) particleTerms.size(); i++) {
+    for (auto& term : particleTerms)
-        const ParticleTermInfo& term = particleTerms[i];
        expressionSet.setVariable(term.index, atomCoordinates[atoms[term.atom]][term.component]);
-    }
+    for (auto& term : distanceTerms) {
-    for (int i = 0; i < (int) distanceTerms.size(); i++) {
-        const DistanceTermInfo& term = distanceTerms[i];
        computeDelta(atoms[term.p1], atoms[term.p2], term.delta, atomCoordinates);
        expressionSet.setVariable(term.index, term.delta[ReferenceForce::RIndex]);
    }
-    for (int i = 0; i < (int) angleTerms.size(); i++) {
+    for (auto& term : angleTerms) {
-        const AngleTermInfo& term = angleTerms[i];
        computeDelta(atoms[term.p1], atoms[term.p2], term.delta1, atomCoordinates);
        computeDelta(atoms[term.p3], atoms[term.p2], term.delta2, atomCoordinates);
        expressionSet.setVariable(term.index, computeAngle(term.delta1, term.delta2));
    }
-    for (int i = 0; i < (int) dihedralTerms.size(); i++) {
+    for (auto& term : dihedralTerms) {
-        const DihedralTermInfo& term = dihedralTerms[i];
        computeDelta(atoms[term.p2], atoms[term.p1], term.delta1, atomCoordinates);
        computeDelta(atoms[term.p2], atoms[term.p3], term.delta2, atomCoordinates);
        computeDelta(atoms[term.p4], atoms[term.p3], term.delta3, atomCoordinates);
@@ -173,15 +168,12 @@ void ReferenceCustomCompoundBondIxn::calculateOneIxn(int bond, vector<Vec3>& ato
    // Apply forces based on individual particle coordinates.
-    for (int i = 0; i < (int) particleTerms.size(); i++) {
+    for (auto& term : particleTerms)
-        const ParticleTermInfo& term = particleTerms[i];
        forces[atoms[term.atom]][term.component] -= term.forceExpression.evaluate();
-    }
    // Apply forces based on distances.
-    for (int i = 0; i < (int) distanceTerms.size(); i++) {
+    for (auto& term : distanceTerms) {
-        const DistanceTermInfo& term = distanceTerms[i];
        double dEdR = term.forceExpression.evaluate()/(term.delta[ReferenceForce::RIndex]);
        for (int i = 0; i < 3; i++) {
           double force  = -dEdR*term.delta[i];
@@ -192,8 +184,7 @@ void ReferenceCustomCompoundBondIxn::calculateOneIxn(int bond, vector<Vec3>& ato
    // Apply forces based on angles.
-    for (int i = 0; i < (int) angleTerms.size(); i++) {
+    for (auto& term : angleTerms) {
-        const AngleTermInfo& term = angleTerms[i];
        double dEdTheta = term.forceExpression.evaluate();
        double thetaCross[ReferenceForce::LastDeltaRIndex];
        SimTKOpenMMUtilities::crossProductVector3(term.delta1, term.delta2, thetaCross);
@@ -219,8 +210,7 @@ void ReferenceCustomCompoundBondIxn::calculateOneIxn(int bond, vector<Vec3>& ato
    // Apply forces based on dihedrals.
-    for (int i = 0; i < (int) dihedralTerms.size(); i++) {
+    for (auto& term : dihedralTerms) {
-        const DihedralTermInfo& term = dihedralTerms[i];
        double dEdTheta = term.forceExpression.evaluate();
        double internalF[4][3];
        double forceFactors[4];

--- a/platforms/reference/src/SimTKReference/ReferenceCustomDynamics.cpp
+++ b/platforms/reference/src/SimTKReference/ReferenceCustomDynamics.cpp
@@ -175,8 +175,8 @@ ExpressionTreeNode ReferenceCustomDynamics::replaceDerivFunctions(const Expressi
    }
    else {
        vector<ExpressionTreeNode> children;
-        for (int i = 0; i < (int) node.getChildren().size(); i++)
+        for (auto& child : node.getChildren())
-            children.push_back(replaceDerivFunctions(node.getChildren()[i], context));
+            children.push_back(replaceDerivFunctions(child, context));
        return ExpressionTreeNode(op.clone(), children);
    }
 }
@@ -204,8 +204,8 @@ void ReferenceCustomDynamics::update(ContextImpl& context, int numberOfAtoms, ve
        initialize(context, masses, globals);
    int numSteps = stepType.size();
    globals.insert(context.getParameters().begin(), context.getParameters().end());
-    for (map<string, double>::const_iterator iter = globals.begin(); iter != globals.end(); ++iter)
+    for (auto& global : globals)
-        expressionSet.setVariable(expressionSet.getVariableIndex(iter->first), iter->second);
+        expressionSet.setVariable(expressionSet.getVariableIndex(global.first), global.second);
    oldPos = atomCoordinates;
    // Loop over steps and execute them.
@@ -276,8 +276,8 @@ void ReferenceCustomDynamics::update(ContextImpl& context, int numberOfAtoms, ve
                recordChangedParameters(context, globals);
                context.updateContextState();
                globals.insert(context.getParameters().begin(), context.getParameters().end());
-                for (map<string, double>::const_iterator iter = globals.begin(); iter != globals.end(); ++iter)
+                for (auto& global : globals)
-                    expressionSet.setVariable(expressionSet.getVariableIndex(iter->first), iter->second);
+                    expressionSet.setVariable(expressionSet.getVariableIndex(global.first), global.second);
                break;
            }
            case CustomIntegrator::IfBlockStart: {
@@ -355,10 +355,10 @@ bool ReferenceCustomDynamics::evaluateCondition(int step) {
 * Check which context parameters have changed and register them with the context.
 */
 void ReferenceCustomDynamics::recordChangedParameters(OpenMM::ContextImpl& context, std::map<std::string, double>& globals) {
-    for (map<string, double>::const_iterator iter = context.getParameters().begin(); iter != context.getParameters().end(); ++iter) {
+    for (auto& param : context.getParameters()) {
-        string name = iter->first;
+        string name = param.first;
        double value = globals[name];
-        if (value != iter->second)
+        if (value != param.second)
            context.setParameter(name, globals[name]);
    }
 }
@@ -385,8 +385,8 @@ double ReferenceCustomDynamics::computeKineticEnergy(OpenMM::ContextImpl& contex
    if (invalidatesForces.size() == 0)
        initialize(context, masses, globals);
    globals.insert(context.getParameters().begin(), context.getParameters().end());
-    for (map<string, double>::const_iterator iter = globals.begin(); iter != globals.end(); ++iter)
+    for (auto& global : globals)
-        expressionSet.setVariable(expressionSet.getVariableIndex(iter->first), iter->second);
+        expressionSet.setVariable(expressionSet.getVariableIndex(global.first), global.second);
    if (kineticEnergyNeedsForce) {
        energy = context.calcForcesAndEnergy(true, true, -1);
        forcesAreValid = true;

--- a/platforms/reference/src/SimTKReference/ReferenceCustomExternalIxn.cpp
+++ b/platforms/reference/src/SimTKReference/ReferenceCustomExternalIxn.cpp
@@ -57,17 +57,17 @@ ReferenceCustomExternalIxn::ReferenceCustomExternalIxn(const Lepton::CompiledExp
    forceZY = ReferenceForce::getVariablePointer(this->forceExpressionZ, "y");
    forceZZ = ReferenceForce::getVariablePointer(this->forceExpressionZ, "z");
    numParameters = parameterNames.size();
-    for (int i = 0; i < (int) numParameters; i++) {
+    for (auto& param : parameterNames) {
-        energyParams.push_back(ReferenceForce::getVariablePointer(this->energyExpression, parameterNames[i]));
+        energyParams.push_back(ReferenceForce::getVariablePointer(this->energyExpression, param));
-        forceXParams.push_back(ReferenceForce::getVariablePointer(this->forceExpressionX, parameterNames[i]));
+        forceXParams.push_back(ReferenceForce::getVariablePointer(this->forceExpressionX, param));
-        forceYParams.push_back(ReferenceForce::getVariablePointer(this->forceExpressionY, parameterNames[i]));
+        forceYParams.push_back(ReferenceForce::getVariablePointer(this->forceExpressionY, param));
-        forceZParams.push_back(ReferenceForce::getVariablePointer(this->forceExpressionZ, parameterNames[i]));
+        forceZParams.push_back(ReferenceForce::getVariablePointer(this->forceExpressionZ, param));
    }
-    for (map<string, double>::const_iterator iter = globalParameters.begin(); iter != globalParameters.end(); ++iter) {
+    for (auto& param : globalParameters) {
-        ReferenceForce::setVariable(ReferenceForce::getVariablePointer(this->energyExpression, iter->first), iter->second);
+        ReferenceForce::setVariable(ReferenceForce::getVariablePointer(this->energyExpression, param.first), param.second);
-        ReferenceForce::setVariable(ReferenceForce::getVariablePointer(this->forceExpressionX, iter->first), iter->second);
+        ReferenceForce::setVariable(ReferenceForce::getVariablePointer(this->forceExpressionX, param.first), param.second);
-        ReferenceForce::setVariable(ReferenceForce::getVariablePointer(this->forceExpressionY, iter->first), iter->second);
+        ReferenceForce::setVariable(ReferenceForce::getVariablePointer(this->forceExpressionY, param.first), param.second);
-        ReferenceForce::setVariable(ReferenceForce::getVariablePointer(this->forceExpressionZ, iter->first), iter->second);
+        ReferenceForce::setVariable(ReferenceForce::getVariablePointer(this->forceExpressionZ, param.first), param.second);
    }
 }

--- a/platforms/reference/src/SimTKReference/ReferenceCustomGBIxn.cpp
+++ b/platforms/reference/src/SimTKReference/ReferenceCustomGBIxn.cpp
@@ -84,19 +84,19 @@ ReferenceCustomGBIxn::ReferenceCustomGBIxn(const vector<Lepton::CompiledExpressi
    xIndex = expressionSet.getVariableIndex("x");
    yIndex = expressionSet.getVariableIndex("y");
    zIndex = expressionSet.getVariableIndex("z");
-    for (int i = 0; i < (int) parameterNames.size(); i++) {
+    for (auto& param : parameterNames) {
-        paramIndex.push_back(expressionSet.getVariableIndex(parameterNames[i]));
+        paramIndex.push_back(expressionSet.getVariableIndex(param));
        for (int j = 1; j < 3; j++) {
            stringstream name;
-            name << parameterNames[i] << j;
+            name << param << j;
            particleParamIndex.push_back(expressionSet.getVariableIndex(name.str()));
        }
    }
-    for (int i = 0; i < (int) valueNames.size(); i++) {
+    for (auto& value : valueNames) {
-        valueIndex.push_back(expressionSet.getVariableIndex(valueNames[i]));
+        valueIndex.push_back(expressionSet.getVariableIndex(value));
        for (int j = 1; j < 3; j++) {
            stringstream name;
-            name << valueNames[i] << j;
+            name << value << j;
            particleValueIndex.push_back(expressionSet.getVariableIndex(name.str()));
        }
    }
@@ -153,8 +153,8 @@ ReferenceCustomGBIxn::~ReferenceCustomGBIxn() {
 void ReferenceCustomGBIxn::calculateIxn(int numberOfAtoms, vector<Vec3>& atomCoordinates, double** atomParameters,
                                           const vector<set<int> >& exclusions, map<string, double>& globalParameters, vector<Vec3>& forces,
                                           double* totalEnergy, double* energyParamDerivs) {
-    for (map<string, double>::const_iterator iter = globalParameters.begin(); iter != globalParameters.end(); ++iter)
+    for (auto& param : globalParameters)
-        expressionSet.setVariable(expressionSet.getVariableIndex(iter->first), iter->second);
+        expressionSet.setVariable(expressionSet.getVariableIndex(param.first), param.second);
    // Initialize arrays for storing values.
@@ -225,8 +225,7 @@ void ReferenceCustomGBIxn::calculateParticlePairValue(int index, int numAtoms, v
    if (cutoff) {
        // Loop over all pairs in the neighbor list.
-        for (int i = 0; i < (int) neighborList->size(); i++) {
+        for (auto& pair : *neighborList) {
-            OpenMM::AtomPair pair = (*neighborList)[i];
            if (useExclusions && exclusions[pair.first].find(pair.second) != exclusions[pair.first].end())
                continue;
            calculateOnePairValue(index, pair.first, pair.second, atomCoordinates, atomParameters);
@@ -306,8 +305,7 @@ void ReferenceCustomGBIxn::calculateParticlePairEnergyTerm(int index, int numAto
    if (cutoff) {
        // Loop over all pairs in the neighbor list.
-        for (int i = 0; i < (int) neighborList->size(); i++) {
+        for (auto& pair : *neighborList) {
-            OpenMM::AtomPair pair = (*neighborList)[i];
            if (useExclusions && exclusions[pair.first].find(pair.second) != exclusions[pair.first].end())
                continue;
            calculateOnePairEnergyTerm(index, pair.first, pair.second, atomCoordinates, atomParameters, forces, totalEnergy, energyParamDerivs);
@@ -377,8 +375,7 @@ void ReferenceCustomGBIxn::calculateChainRuleForces(int numAtoms, vector<Vec3>&
    if (cutoff) {
        // Loop over all pairs in the neighbor list.
-        for (int i = 0; i < (int) neighborList->size(); i++) {
+        for (auto& pair : *neighborList) {
-            OpenMM::AtomPair pair = (*neighborList)[i];
            bool isExcluded = (exclusions[pair.first].find(pair.second) != exclusions[pair.first].end());
            calculateOnePairChainRule(pair.first, pair.second, atomCoordinates, atomParameters, forces, isExcluded);
            calculateOnePairChainRule(pair.second, pair.first, atomCoordinates, atomParameters, forces, isExcluded);

--- a/platforms/reference/src/SimTKReference/ReferenceCustomHbondIxn.cpp
+++ b/platforms/reference/src/SimTKReference/ReferenceCustomHbondIxn.cpp
@@ -49,12 +49,12 @@ ReferenceCustomHbondIxn::ReferenceCustomHbondIxn(const vector<vector<int> >& don
            const map<string, vector<int> >& distances, const map<string, vector<int> >& angles, const map<string, vector<int> >& dihedrals) :
            cutoff(false), periodic(false), donorAtoms(donorAtoms), acceptorAtoms(acceptorAtoms), energyExpression(energyExpression.createProgram()),
            donorParamNames(donorParameterNames), acceptorParamNames(acceptorParameterNames) {
-    for (map<string, vector<int> >::const_iterator iter = distances.begin(); iter != distances.end(); ++iter)
+    for (auto& term : distances)
-        distanceTerms.push_back(ReferenceCustomHbondIxn::DistanceTermInfo(iter->first, iter->second, energyExpression.differentiate(iter->first).optimize().createProgram()));
+        distanceTerms.push_back(ReferenceCustomHbondIxn::DistanceTermInfo(term.first, term.second, energyExpression.differentiate(term.first).optimize().createProgram()));
-    for (map<string, vector<int> >::const_iterator iter = angles.begin(); iter != angles.end(); ++iter)
+    for (auto& term : angles)
-        angleTerms.push_back(ReferenceCustomHbondIxn::AngleTermInfo(iter->first, iter->second, energyExpression.differentiate(iter->first).optimize().createProgram()));
+        angleTerms.push_back(ReferenceCustomHbondIxn::AngleTermInfo(term.first, term.second, energyExpression.differentiate(term.first).optimize().createProgram()));
-    for (map<string, vector<int> >::const_iterator iter = dihedrals.begin(); iter != dihedrals.end(); ++iter)
+    for (auto& term : dihedrals)
-        dihedralTerms.push_back(ReferenceCustomHbondIxn::DihedralTermInfo(iter->first, iter->second, energyExpression.differentiate(iter->first).optimize().createProgram()));
+        dihedralTerms.push_back(ReferenceCustomHbondIxn::DihedralTermInfo(term.first, term.second, energyExpression.differentiate(term.first).optimize().createProgram()));
 }
 /**---------------------------------------------------------------------------------------

--- a/platforms/reference/src/SimTKReference/ReferenceCustomManyParticleIxn.cpp
+++ b/platforms/reference/src/SimTKReference/ReferenceCustomManyParticleIxn.cpp
@@ -60,8 +60,8 @@ ReferenceCustomManyParticleIxn::ReferenceCustomManyParticleIxn(const CustomManyP
    // Delete the custom functions.
-    for (map<string, Lepton::CustomFunction*>::iterator iter = functions.begin(); iter != functions.end(); iter++)
+    for (auto& function : functions)
-        delete iter->second;
+        delete function.second;
    // Differentiate the energy to get expressions for the force.
@@ -80,12 +80,12 @@ ReferenceCustomManyParticleIxn::ReferenceCustomManyParticleIxn(const CustomManyP
            particleParamNames[i].push_back(paramname.str());
        }
    }
-    for (map<string, vector<int> >::const_iterator iter = distances.begin(); iter != distances.end(); ++iter)
+    for (auto& term : distances)
-        distanceTerms.push_back(ReferenceCustomManyParticleIxn::DistanceTermInfo(iter->first, iter->second, energyExpr.differentiate(iter->first).optimize().createProgram()));
+        distanceTerms.push_back(ReferenceCustomManyParticleIxn::DistanceTermInfo(term.first, term.second, energyExpr.differentiate(term.first).optimize().createProgram()));
-    for (map<string, vector<int> >::const_iterator iter = angles.begin(); iter != angles.end(); ++iter)
+    for (auto& term : angles)
-        angleTerms.push_back(ReferenceCustomManyParticleIxn::AngleTermInfo(iter->first, iter->second, energyExpr.differentiate(iter->first).optimize().createProgram()));
+        angleTerms.push_back(ReferenceCustomManyParticleIxn::AngleTermInfo(term.first, term.second, energyExpr.differentiate(term.first).optimize().createProgram()));
-    for (map<string, vector<int> >::const_iterator iter = dihedrals.begin(); iter != dihedrals.end(); ++iter)
+    for (auto& term : dihedrals)
-        dihedralTerms.push_back(ReferenceCustomManyParticleIxn::DihedralTermInfo(iter->first, iter->second, energyExpr.differentiate(iter->first).optimize().createProgram()));
+        dihedralTerms.push_back(ReferenceCustomManyParticleIxn::DihedralTermInfo(term.first, term.second, energyExpr.differentiate(term.first).optimize().createProgram()));
    // Record exclusions.
@@ -192,23 +192,18 @@ void ReferenceCustomManyParticleIxn::calculateOneIxn(const vector<int>& particle
    // Compute all of the variables the energy can depend on.
-    for (int i = 0; i < (int) particleTerms.size(); i++) {
+    for (auto& term : particleTerms)
-        const ParticleTermInfo& term = particleTerms[i];
        variables[term.name] = atomCoordinates[permutedParticles[term.atom]][term.component];
-    }
+    for (auto& term : distanceTerms) {
-    for (int i = 0; i < (int) distanceTerms.size(); i++) {
-        const DistanceTermInfo& term = distanceTerms[i];
        computeDelta(permutedParticles[term.p1], permutedParticles[term.p2], term.delta, atomCoordinates);
        variables[term.name] = term.delta[ReferenceForce::RIndex];
    }
-    for (int i = 0; i < (int) angleTerms.size(); i++) {
+    for (auto& term : angleTerms) {
-        const AngleTermInfo& term = angleTerms[i];
        computeDelta(permutedParticles[term.p1], permutedParticles[term.p2], term.delta1, atomCoordinates);
        computeDelta(permutedParticles[term.p3], permutedParticles[term.p2], term.delta2, atomCoordinates);
        variables[term.name] = computeAngle(term.delta1, term.delta2);
    }
-    for (int i = 0; i < (int) dihedralTerms.size(); i++) {
+    for (auto& term : dihedralTerms) {
-        const DihedralTermInfo& term = dihedralTerms[i];
        computeDelta(permutedParticles[term.p2], permutedParticles[term.p1], term.delta1, atomCoordinates);
        computeDelta(permutedParticles[term.p2], permutedParticles[term.p3], term.delta2, atomCoordinates);
        computeDelta(permutedParticles[term.p4], permutedParticles[term.p3], term.delta3, atomCoordinates);
@@ -219,15 +214,12 @@ void ReferenceCustomManyParticleIxn::calculateOneIxn(const vector<int>& particle
    // Apply forces based on individual particle coordinates.
-    for (int i = 0; i < (int) particleTerms.size(); i++) {
+    for (auto& term : particleTerms)
-        const ParticleTermInfo& term = particleTerms[i];
        forces[permutedParticles[term.atom]][term.component] -= term.forceExpression.evaluate(variables);
-    }
    // Apply forces based on distances.
-    for (int i = 0; i < (int) distanceTerms.size(); i++) {
+    for (auto& term : distanceTerms) {
-        const DistanceTermInfo& term = distanceTerms[i];
        double dEdR = term.forceExpression.evaluate(variables)/(term.delta[ReferenceForce::RIndex]);
        for (int i = 0; i < 3; i++) {
           double force  = -dEdR*term.delta[i];
@@ -238,8 +230,7 @@ void ReferenceCustomManyParticleIxn::calculateOneIxn(const vector<int>& particle
    // Apply forces based on angles.
-    for (int i = 0; i < (int) angleTerms.size(); i++) {
+    for (auto& term : angleTerms) {
-        const AngleTermInfo& term = angleTerms[i];
        double dEdTheta = term.forceExpression.evaluate(variables);
        double thetaCross[ReferenceForce::LastDeltaRIndex];
        SimTKOpenMMUtilities::crossProductVector3(term.delta1, term.delta2, thetaCross);
@@ -265,8 +256,7 @@ void ReferenceCustomManyParticleIxn::calculateOneIxn(const vector<int>& particle
    // Apply forces based on dihedrals.
-    for (int i = 0; i < (int) dihedralTerms.size(); i++) {
+    for (auto& term : dihedralTerms) {
-        const DihedralTermInfo& term = dihedralTerms[i];
        double dEdTheta = term.forceExpression.evaluate(variables);
        double internalF[4][3];
        double forceFactors[4];

--- a/platforms/reference/src/SimTKReference/ReferenceCustomNonbondedIxn.cpp
+++ b/platforms/reference/src/SimTKReference/ReferenceCustomNonbondedIxn.cpp
@@ -53,10 +53,10 @@ ReferenceCustomNonbondedIxn::ReferenceCustomNonbondedIxn(const Lepton::CompiledE
    for (int i = 0; i < this->energyParamDerivExpressions.size(); i++)
        expressionSet.registerExpression(this->energyParamDerivExpressions[i]);
    rIndex = expressionSet.getVariableIndex("r");
-    for (int i = 0; i < (int) paramNames.size(); i++) {
+    for (auto& param : paramNames) {
        for (int j = 1; j < 3; j++) {
            stringstream name;
-            name << paramNames[i] << j;
+            name << param << j;
            particleParamIndex.push_back(expressionSet.getVariableIndex(name.str()));
        }
    }
@@ -159,14 +159,14 @@ void ReferenceCustomNonbondedIxn::calculatePairIxn(int numberOfAtoms, vector<Vec
                                             double* fixedParameters, const map<string, double>& globalParameters, vector<Vec3>& forces,
                                             double* energyByAtom, double* totalEnergy, double* energyParamDerivs) {
-    for (map<string, double>::const_iterator iter = globalParameters.begin(); iter != globalParameters.end(); ++iter)
+    for (auto& param : globalParameters)
-        expressionSet.setVariable(expressionSet.getVariableIndex(iter->first), iter->second);
+        expressionSet.setVariable(expressionSet.getVariableIndex(param.first), param.second);
    if (interactionGroups.size() > 0) { 
        // The user has specified interaction groups, so compute only the requested interactions.
-        for (int group = 0; group < (int) interactionGroups.size(); group++) {
+        for (auto& group : interactionGroups) {
-            const set<int>& set1 = interactionGroups[group].first;
+            const set<int>& set1 = group.first;
-            const set<int>& set2 = interactionGroups[group].second;
+            const set<int>& set2 = group.second;
            for (set<int>::const_iterator atom1 = set1.begin(); atom1 != set1.end(); ++atom1) {
                for (set<int>::const_iterator atom2 = set2.begin(); atom2 != set2.end(); ++atom2) {
                    if (*atom1 == *atom2 || exclusions[*atom1].find(*atom2) != exclusions[*atom1].end())
@@ -185,8 +185,7 @@ void ReferenceCustomNonbondedIxn::calculatePairIxn(int numberOfAtoms, vector<Vec
    else if (cutoff) {
        // We are using a cutoff, so get the interactions from the neighbor list.
-        for (int i = 0; i < (int) neighborList->size(); i++) {
+        for (auto& pair : *neighborList) {
-            OpenMM::AtomPair pair = (*neighborList)[i];
            for (int j = 0; j < (int) paramNames.size(); j++) {
                expressionSet.setVariable(particleParamIndex[j*2], atomParameters[pair.first][j]);
                expressionSet.setVariable(particleParamIndex[j*2+1], atomParameters[pair.second][j]);

--- a/platforms/reference/src/SimTKReference/ReferenceCustomTorsionIxn.cpp
+++ b/platforms/reference/src/SimTKReference/ReferenceCustomTorsionIxn.cpp
@@ -47,10 +47,10 @@ ReferenceCustomTorsionIxn::ReferenceCustomTorsionIxn(const Lepton::CompiledExpre
        expressionSet.registerExpression(this->energyParamDerivExpressions[i]);
    thetaIndex = expressionSet.getVariableIndex("theta");
    numParameters = parameterNames.size();
-    for (int i = 0; i < (int) numParameters; i++)
+    for (auto& param : parameterNames)
-        torsionParamIndex.push_back(expressionSet.getVariableIndex(parameterNames[i]));
+        torsionParamIndex.push_back(expressionSet.getVariableIndex(param));
-    for (map<string, double>::const_iterator iter = globalParameters.begin(); iter != globalParameters.end(); ++iter)
+    for (auto& param : globalParameters)
-        expressionSet.setVariable(expressionSet.getVariableIndex(iter->first), iter->second);
+        expressionSet.setVariable(expressionSet.getVariableIndex(param.first), param.second);
 }
 /**---------------------------------------------------------------------------------------

--- a/platforms/reference/src/SimTKReference/ReferenceLJCoulombIxn.cpp
+++ b/platforms/reference/src/SimTKReference/ReferenceLJCoulombIxn.cpp
@@ -395,8 +395,7 @@ void ReferenceLJCoulombIxn::calculateEwaldIxn(int numberOfAtoms, vector<Vec3>& a
    double totalRealSpaceEwaldEnergy = 0.0f;
-    for (int i = 0; i < (int) neighborList->size(); i++) {
+    for (auto& pair : *neighborList) {
-        OpenMM::AtomPair pair = (*neighborList)[i];
        int ii = pair.first;
        int jj = pair.second;
@@ -581,11 +580,9 @@ void ReferenceLJCoulombIxn::calculatePairIxn(int numberOfAtoms, vector<Vec3>& at
    if (!includeDirect)
        return;
    if (cutoff) {
-        for (int i = 0; i < (int) neighborList->size(); i++) {
+        for (auto& pair : *neighborList)
-            OpenMM::AtomPair pair = (*neighborList)[i];
            calculateOneIxn(pair.first, pair.second, atomCoordinates, atomParameters, forces, energyByAtom, totalEnergy);
    }
-    }
    else {
        for (int ii = 0; ii < numberOfAtoms; ii++) {
            // loop over atom pairs

--- a/platforms/reference/src/SimTKReference/ReferenceMonteCarloBarostat.cpp
+++ b/platforms/reference/src/SimTKReference/ReferenceMonteCarloBarostat.cpp
@@ -72,15 +72,15 @@ void ReferenceMonteCarloBarostat::applyBarostat(vector<Vec3>& atomPositions, con
    // Loop over molecules.
-    for (int i = 0; i < (int) molecules.size(); i++) {
+    for (auto& molecule : molecules) {
        // Find the molecule center.
        Vec3 pos(0, 0, 0);
-        for (int j = 0; j < (int) molecules[i].size(); j++) {
+        for (int atom : molecule) {
-            Vec3& atomPos = atomPositions[molecules[i][j]];
+            Vec3& atomPos = atomPositions[atom];
            pos += atomPos;
        }
-        pos /= molecules[i].size();
+        pos /= molecule.size();
        // Move it into the first periodic box.
@@ -95,8 +95,8 @@ void ReferenceMonteCarloBarostat::applyBarostat(vector<Vec3>& atomPositions, con
        newPos[1] *= scaleY;
        newPos[2] *= scaleZ;
        Vec3 offset = newPos-pos;
-        for (int j = 0; j < (int) molecules[i].size(); j++) {
+        for (int atom : molecule) {
-            Vec3& atomPos = atomPositions[molecules[i][j]];
+            Vec3& atomPos = atomPositions[atom];
            atomPos += offset;
        }
    }