Merge pull request #1769 from peastman/loops

Use C++11 style loops

Merge pull request #1769 from peastman/loops
Use C++11 style loops
08e8b206 · peastman · GitHub · 55ee0b9f · 083bc501 · 08e8b206
Commit 08e8b206 authored Mar 31, 2017 by peastman Committed by GitHub Mar 31, 2017
20 changed files
--- a/openmmapi/src/ThreadPool.cpp
+++ b/openmmapi/src/ThreadPool.cpp
@@ -89,13 +89,13 @@ ThreadPool::ThreadPool(int numThreads) : currentTask(NULL) {
 }
 ThreadPool::~ThreadPool() {
-    for (int i = 0; i < (int) threadData.size(); i++)
+    for (auto data : threadData)
-        threadData[i]->isDeleted = true;
+        data->isDeleted = true;
    pthread_mutex_lock(&lock);
    pthread_cond_broadcast(&startCondition);
    pthread_mutex_unlock(&lock);
-    for (int i = 0; i < (int) thread.size(); i++)
+    for (auto t : thread)
-        pthread_join(thread[i], NULL);
+        pthread_join(t, NULL);
    pthread_mutex_destroy(&lock);
    pthread_cond_destroy(&startCondition);
    pthread_cond_destroy(&endCondition);

--- a/platforms/cpu/src/CpuBondForce.cpp
+++ b/platforms/cpu/src/CpuBondForce.cpp
@@ -159,8 +159,8 @@ void CpuBondForce::assignBond(int bond, int thread, vector<int>& atomThread, vec
        if (atom != -1)
            throw OpenMMException("CpuBondForce: Internal error: atoms assigned to threads incorrectly");
        atom = thread;
-        for (set<int>::const_iterator iter = atomBonds[atom].begin(); iter != atomBonds[atom].end(); ++iter)
+        for (int bond : atomBonds[atom])
-            candidateBonds.push_back(*iter);
+            candidateBonds.push_back(bond);
    }
 }

--- 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/CpuKernels.cpp
+++ b/platforms/cpu/src/CpuKernels.cpp
@@ -98,8 +98,8 @@ static void validateVariables(const Lepton::ExpressionTreeNode& node, const set<
    const Lepton::Operation& op = node.getOperation();
    if (op.getId() == Lepton::Operation::VARIABLE && variables.find(op.getName()) == variables.end())
        throw OpenMMException("Unknown variable in expression: "+op.getName());
-    for (int i = 0; i < (int) node.getChildren().size(); i++)
+    for (auto& child : node.getChildren())
-        validateVariables(node.getChildren()[i], variables);
+        validateVariables(child, variables);
 }
 /**
@@ -867,8 +867,8 @@ void CpuCalcCustomNonbondedForceKernel::initialize(const System& system, const C
    // 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 information for the long range correction.
@@ -909,11 +909,11 @@ double CpuCalcCustomNonbondedForceKernel::execute(ContextImpl& context, bool inc
        nonbonded->setPeriodic(boxVectors);
    }
    bool globalParamsChanged = false;
-    for (int i = 0; i < (int) globalParameterNames.size(); i++) {
+    for (auto& name : globalParameterNames) {
-        double value = context.getParameter(globalParameterNames[i]);
+        double value = context.getParameter(name);
-        if (globalParamValues[globalParameterNames[i]] != value)
+        if (globalParamValues[name] != value)
            globalParamsChanged = true;
-        globalParamValues[globalParameterNames[i]] = value;
+        globalParamValues[name] = value;
    }
    if (useSwitchingFunction)
        nonbonded->setUseSwitchingFunction(switchingDistance);
@@ -1155,8 +1155,8 @@ void CpuCalcCustomGBForceKernel::initialize(const System& system, const CustomGB
    // 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;
    ixn = new CpuCustomGBForce(numParticles, exclusions, valueExpressions, valueDerivExpressions, valueGradientExpressions, valueParamDerivExpressions,
        valueNames, valueTypes, energyExpressions, energyDerivExpressions, energyGradientExpressions, energyParamDerivExpressions, energyTypes,
        particleParameterNames, data.threads);
@@ -1174,8 +1174,8 @@ double CpuCalcCustomGBForceKernel::execute(ContextImpl& context, bool includeFor
        ixn->setUseCutoff(nonbondedCutoff, *data.neighborList);
    }
    map<string, double> globalParameters;
-    for (int i = 0; i < (int) globalParameterNames.size(); i++)
+    for (auto& name : globalParameterNames)
-        globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
+        globalParameters[name] = context.getParameter(name);
    vector<double> energyParamDerivValues(energyParamDerivNames.size()+1, 0.0);
    ixn->calculateIxn(numParticles, &data.posq[0], particleParamArray, globalParameters, data.threadForce, includeForces, includeEnergy, energy, &energyParamDerivValues[0]);
    map<string, double>& energyParamDerivs = extractEnergyParameterDerivatives(context);
@@ -1236,8 +1236,8 @@ void CpuCalcCustomManyParticleForceKernel::initialize(const System& system, cons
 double CpuCalcCustomManyParticleForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
    map<string, double> globalParameters;
-    for (int i = 0; i < (int) globalParameterNames.size(); i++)
+    for (auto& name : globalParameterNames)
-        globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
+        globalParameters[name] = context.getParameter(name);
    if (nonbondedMethod == CutoffPeriodic) {
        Vec3* boxVectors = extractBoxVectors(context);
        double minAllowedSize = 2*cutoffDistance;

--- a/platforms/cpu/src/CpuNeighborList.cpp
+++ b/platforms/cpu/src/CpuNeighborList.cpp
@@ -577,10 +577,10 @@ void CpuNeighborList::threadComputeNeighborList(ThreadPool& threads, int threadI
        for (int j = 0; j < atomsInBlock; j++) {
            const set<int>& atomExclusions = (*exclusions)[sortedAtoms[firstIndex+j]];
            char mask = 1<<j;
-            for (set<int>::const_iterator iter = atomExclusions.begin(); iter != atomExclusions.end(); ++iter) {
+            for (int exclusion : atomExclusions) {
-                map<int, char>::iterator thisAtomFlags = atomFlags.find(*iter);
+                map<int, char>::iterator thisAtomFlags = atomFlags.find(exclusion);
                if (thisAtomFlags == atomFlags.end())
-                    atomFlags[*iter] = mask;
+                    atomFlags[exclusion] = mask;
                else
                    thisAtomFlags->second |= mask;
            }

--- a/platforms/cpu/src/CpuNonbondedForce.cpp
+++ b/platforms/cpu/src/CpuNonbondedForce.cpp
@@ -447,9 +447,9 @@ void CpuNonbondedForce::threadComputeDirect(ThreadPool& threads, int threadIndex
            for (int i = start; i < end; i++) {
                fvec4 posI((float) atomCoordinates[i][0], (float) atomCoordinates[i][1], (float) atomCoordinates[i][2], 0.0f);
                float scaledChargeI = (float) (ONE_4PI_EPS0*posq[4*i+3]);
-                for (set<int>::const_iterator iter = exclusions[i].begin(); iter != exclusions[i].end(); ++iter) {
+                for (int excluded : exclusions[i]) {
-                    if (*iter > i) {
+                    if (excluded > i) {
-                        int j = *iter;
+                        int j = excluded;
                        fvec4 deltaR;
                        fvec4 posJ((float) atomCoordinates[j][0], (float) atomCoordinates[j][1], (float) atomCoordinates[j][2], 0.0f);
                        float r2;

--- 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/cuda/src/CudaContext.cpp
+++ b/platforms/cuda/src/CudaContext.cpp
@@ -385,14 +385,14 @@ CudaContext::CudaContext(const System& system, int deviceIndex, bool useBlocking
 CudaContext::~CudaContext() {
    setAsCurrent();
-    for (int i = 0; i < (int) forces.size(); i++)
+    for (auto force : forces)
-        delete forces[i];
+        delete force;
-    for (int i = 0; i < (int) reorderListeners.size(); i++)
+    for (auto listener : reorderListeners)
-        delete reorderListeners[i];
+        delete listener;
-    for (int i = 0; i < (int) preComputations.size(); i++)
+    for (auto computation : preComputations)
-        delete preComputations[i];
+        delete computation;
-    for (int i = 0; i < (int) postComputations.size(); i++)
+    for (auto computation : postComputations)
-        delete postComputations[i];
+        delete computation;
    if (pinnedBuffer != NULL)
        cuMemFreeHost(pinnedBuffer);
    if (posq != NULL)
@@ -498,17 +498,17 @@ string CudaContext::replaceStrings(const string& input, const std::map<std::stri
            symbolChars.insert(c);
    }
    string result = input;
-    for (map<string, string>::const_iterator iter = replacements.begin(); iter != replacements.end(); iter++) {
+    for (auto& pair : replacements) {
        int index = 0;
-        int size = iter->first.size();
+        int size = pair.first.size();
        do {
-            index = result.find(iter->first, index);
+            index = result.find(pair.first, index);
            if (index != result.npos) {
                if ((index == 0 || symbolChars.find(result[index-1]) == symbolChars.end()) && (index == result.size()-size || symbolChars.find(result[index+size]) == symbolChars.end())) {
                    // We have found a complete symbol, not part of a longer symbol.
-                    result.replace(index, size, iter->second);
+                    result.replace(index, size, pair.second);
-                    index += iter->second.size();
+                    index += pair.second.size();
                }
                else
                    index++;
@@ -528,10 +528,10 @@ CUmodule CudaContext::createModule(const string source, const map<string, string
    stringstream src;
    if (!options.empty())
        src << "// Compilation Options: " << options << endl << endl;
-    for (map<string, string>::const_iterator iter = compilationDefines.begin(); iter != compilationDefines.end(); ++iter) {
+    for (auto& pair : compilationDefines) {
-        src << "#define " << iter->first;
+        src << "#define " << pair.first;
-        if (!iter->second.empty())
+        if (!pair.second.empty())
-            src << " " << iter->second;
+            src << " " << pair.second;
        src << endl;
    }
    if (!compilationDefines.empty())
@@ -561,10 +561,10 @@ CUmodule CudaContext::createModule(const string source, const map<string, string
        src << "typedef float4 mixed4;\n";
    }
    src << "typedef unsigned int tileflags;\n";
-    for (map<string, string>::const_iterator iter = defines.begin(); iter != defines.end(); ++iter) {
+    for (auto& pair : defines) {
-        src << "#define " << iter->first;
+        src << "#define " << pair.first;
-        if (!iter->second.empty())
+        if (!pair.second.empty())
-            src << " " << iter->second;
+            src << " " << pair.second;
        src << endl;
    }
    if (!defines.empty())
@@ -966,10 +966,10 @@ void CudaContext::findMoleculeGroups() {
            atomBonds[particle1].push_back(particle2);
            atomBonds[particle2].push_back(particle1);
        }
-        for (int i = 0; i < (int) forces.size(); i++) {
+        for (auto force : forces) {
-            for (int j = 0; j < forces[i]->getNumParticleGroups(); j++) {
+            for (int j = 0; j < force->getNumParticleGroups(); j++) {
                vector<int> particles;
-                forces[i]->getParticlesInGroup(j, particles);
+                force->getParticlesInGroup(j, particles);
                for (int k = 0; k < (int) particles.size(); k++)
                    for (int m = 0; m < (int) particles.size(); m++)
                        if (k != m)
@@ -1187,8 +1187,8 @@ bool CudaContext::invalidateMolecules(CudaForceInfo* force) {
    }
    atomIndexDevice->upload(atomIndex);
    findMoleculeGroups();
-    for (int i = 0; i < (int) reorderListeners.size(); i++)
+    for (auto listener : reorderListeners)
-        reorderListeners[i]->execute();
+        listener->execute();
    reorderAtoms();
    return true;
 }
@@ -1250,10 +1250,9 @@ void CudaContext::reorderAtomsImpl() {
    vector<Real4> newPosqCorrection(paddedNumAtoms);
    vector<Mixed4> newVelm(paddedNumAtoms);
    vector<int4> newCellOffsets(numAtoms);
-    for (int group = 0; group < (int) moleculeGroups.size(); group++) {
+    for (auto& mol : moleculeGroups) {
        // Find the center of each molecule.
-        MoleculeGroup& mol = moleculeGroups[group];
        int numMolecules = mol.offsets.size();
        vector<int>& atoms = mol.atoms;
        vector<Real4> molPos(numMolecules);
@@ -1347,9 +1346,9 @@ void CudaContext::reorderAtomsImpl() {
        // Reorder the atoms.
        for (int i = 0; i < numMolecules; i++) {
-            for (int j = 0; j < (int)atoms.size(); j++) {
+            for (int atom : atoms) {
-                int oldIndex = mol.offsets[molBins[i].second]+atoms[j];
+                int oldIndex = mol.offsets[molBins[i].second]+atom;
-                int newIndex = mol.offsets[i]+atoms[j];
+                int newIndex = mol.offsets[i]+atom;
                originalIndex[newIndex] = atomIndex[oldIndex];
                newPosq[newIndex] = oldPosq[oldIndex];
                if (useMixedPrecision)
@@ -1371,8 +1370,8 @@ void CudaContext::reorderAtomsImpl() {
        posqCorrection->upload(newPosqCorrection);
    velm->upload(newVelm);
    atomIndexDevice->upload(atomIndex);
-    for (int i = 0; i < (int) reorderListeners.size(); i++)
+    for (auto listener : reorderListeners)
-        reorderListeners[i]->execute();
+        listener->execute();
 }
 void CudaContext::addReorderListener(ReorderListener* listener) {

--- a/platforms/cuda/src/CudaExpressionUtilities.cpp
+++ b/platforms/cuda/src/CudaExpressionUtilities.cpp
@@ -456,12 +456,12 @@ void CudaExpressionUtilities::processExpression(stringstream& out, const Express
                vector<bool> hasAssigned(powers.size(), false);
                exponents.push_back((int) fabs(exponent));
                names.push_back(name);
-                for (map<int, const ExpressionTreeNode*>::const_iterator iter = powers.begin(); iter != powers.end(); ++iter) {
+                for (auto& power : powers) {
-                    if (iter->first != exponent) {
+                    if (power.first != exponent) {
-                        exponents.push_back(iter->first >= 0 ? iter->first : -iter->first);
+                        exponents.push_back(power.first >= 0 ? power.first : -power.first);
                        string name2 = prefix+context.intToString(temps.size());
                        names.push_back(name2);
-                        temps.push_back(make_pair(*iter->second, name2));
+                        temps.push_back(make_pair(*power.second, name2));
                        out << tempType << " " << name2 << " = 0.0f;\n";
                    }
                }

--- a/platforms/cuda/src/CudaKernels.cpp
+++ b/platforms/cuda/src/CudaKernels.cpp
--- a/platforms/opencl/src/OpenCLBondedUtilities.cpp
+++ b/platforms/opencl/src/OpenCLBondedUtilities.cpp
@@ -184,8 +184,7 @@ void OpenCLBondedUtilities::initialize(const System& system) {
    // Create the kernels.
-    for (vector<vector<int> >::const_iterator iter = forceSets.begin(); iter != forceSets.end(); ++iter) {
+    for (auto& set : forceSets) {
-        const vector<int>& set = *iter;
        int setSize = set.size();
        stringstream s;
        s<<"#ifdef SUPPORTS_64_BIT_ATOMICS\n";

--- a/platforms/opencl/src/OpenCLContext.cpp
+++ b/platforms/opencl/src/OpenCLContext.cpp
@@ -6,7 +6,7 @@
 * Biological Structures at Stanford, funded under the NIH Roadmap for        *
 * Medical Research, grant U54 GM072970. See https://simtk.org.               *
 *                                                                            *
- * Portions copyright (c) 2009-2016 Stanford University and the Authors.      *
+ * Portions copyright (c) 2009-2017 Stanford University and the Authors.      *
 * Authors: Peter Eastman                                                     *
 * Contributors:                                                              *
 *                                                                            *
@@ -318,8 +318,8 @@ OpenCLContext::OpenCLContext(const System& system, int platformIndex, int device
        OpenCLArray valuesArray(*this, 20, sizeof(mm_float8), "values");
        vector<mm_float8> values(valuesArray.getSize());
        float nextValue = 1e-4f;
-        for (int i = 0; i < (int) values.size(); ++i) {
+        for (auto& val : values) {
-            values[i].s0 = nextValue;
+            val.s0 = nextValue;
            nextValue *= (float) M_PI;
        }
        valuesArray.upload(values);
@@ -328,14 +328,14 @@ OpenCLContext::OpenCLContext(const System& system, int platformIndex, int device
        executeKernel(accuracyKernel, values.size());
        valuesArray.download(values);
        double maxSqrtError = 0.0, maxRsqrtError = 0.0, maxRecipError = 0.0, maxExpError = 0.0, maxLogError = 0.0;
-        for (int i = 0; i < (int) values.size(); ++i) {
+        for (auto& val : values) {
-            double v = values[i].s0;
+            double v = val.s0;
            double correctSqrt = sqrt(v);
-            maxSqrtError = max(maxSqrtError, fabs(correctSqrt-values[i].s1)/correctSqrt);
+            maxSqrtError = max(maxSqrtError, fabs(correctSqrt-val.s1)/correctSqrt);
-            maxRsqrtError = max(maxRsqrtError, fabs(1.0/correctSqrt-values[i].s2)*correctSqrt);
+            maxRsqrtError = max(maxRsqrtError, fabs(1.0/correctSqrt-val.s2)*correctSqrt);
-            maxRecipError = max(maxRecipError, fabs(1.0/v-values[i].s3)/values[i].s3);
+            maxRecipError = max(maxRecipError, fabs(1.0/v-val.s3)/val.s3);
-            maxExpError = max(maxExpError, fabs(exp(v)-values[i].s4)/values[i].s4);
+            maxExpError = max(maxExpError, fabs(exp(v)-val.s4)/val.s4);
-            maxLogError = max(maxLogError, fabs(log(v)-values[i].s5)/values[i].s5);
+            maxLogError = max(maxLogError, fabs(log(v)-val.s5)/val.s5);
        }
        compilationDefines["SQRT"] = (maxSqrtError < 1e-6) ? "native_sqrt" : "sqrt";
        compilationDefines["RSQRT"] = (maxRsqrtError < 1e-6) ? "native_rsqrt" : "rsqrt";
@@ -412,14 +412,14 @@ OpenCLContext::OpenCLContext(const System& system, int platformIndex, int device
 }
 OpenCLContext::~OpenCLContext() {
-    for (int i = 0; i < (int) forces.size(); i++)
+    for (auto force : forces)
-        delete forces[i];
+        delete force;
-    for (int i = 0; i < (int) reorderListeners.size(); i++)
+    for (auto listener : reorderListeners)
-        delete reorderListeners[i];
+        delete listener;
-    for (int i = 0; i < (int) preComputations.size(); i++)
+    for (auto computation : preComputations)
-        delete preComputations[i];
+        delete computation;
-    for (int i = 0; i < (int) postComputations.size(); i++)
+    for (auto computation : postComputations)
-        delete postComputations[i];
+        delete computation;
    if (pinnedBuffer != NULL)
        delete pinnedBuffer;
    if (posq != NULL)
@@ -458,8 +458,8 @@ void OpenCLContext::initialize() {
    bonded->initialize(system);
    numForceBuffers = platformData.contexts.size();
    numForceBuffers = std::max(numForceBuffers, bonded->getNumForceBuffers());
-    for (int i = 0; i < (int) forces.size(); i++)
+    for (auto force : forces)
-        numForceBuffers = std::max(numForceBuffers, forces[i]->getRequiredForceBuffers());
+        numForceBuffers = std::max(numForceBuffers, force->getRequiredForceBuffers());
    int energyBufferSize = max(numThreadBlocks*ThreadBlockSize, nonbonded->getNumEnergyBuffers());
    if (useDoublePrecision) {
        forceBuffers = OpenCLArray::create<mm_double4>(*this, paddedNumAtoms*numForceBuffers, "forceBuffers");
@@ -525,17 +525,17 @@ string OpenCLContext::replaceStrings(const string& input, const std::map<std::st
            symbolChars.insert(c);
    }
    string result = input;
-    for (map<string, string>::const_iterator iter = replacements.begin(); iter != replacements.end(); iter++) {
+    for (auto& pair : replacements) {
        int index = 0;
-        int size = iter->first.size();
+        int size = pair.first.size();
        do {
-            index = result.find(iter->first, index);
+            index = result.find(pair.first, index);
            if (index != result.npos) {
                if ((index == 0 || symbolChars.find(result[index-1]) == symbolChars.end()) && (index == result.size()-size || symbolChars.find(result[index+size]) == symbolChars.end())) {
                    // We have found a complete symbol, not part of a longer symbol.
-                    result.replace(index, size, iter->second);
+                    result.replace(index, size, pair.second);
-                    index += iter->second.size();
+                    index += pair.second.size();
                }
                else
                    index++;
@@ -554,10 +554,10 @@ cl::Program OpenCLContext::createProgram(const string source, const map<string,
    stringstream src;
    if (!options.empty())
        src << "// Compilation Options: " << options << endl << endl;
-    for (map<string, string>::const_iterator iter = compilationDefines.begin(); iter != compilationDefines.end(); ++iter) {
+    for (auto& pair : compilationDefines) {
-        src << "#define " << iter->first;
+        src << "#define " << pair.first;
-        if (!iter->second.empty())
+        if (!pair.second.empty())
-            src << " " << iter->second;
+            src << " " << pair.second;
        src << endl;
    }
    if (!compilationDefines.empty())
@@ -588,10 +588,10 @@ cl::Program OpenCLContext::createProgram(const string source, const map<string,
        src << "typedef float3 mixed3;\n";
        src << "typedef float4 mixed4;\n";
    }
-    for (map<string, string>::const_iterator iter = defines.begin(); iter != defines.end(); ++iter) {
+    for (auto& pair : defines) {
-        src << "#define " << iter->first;
+        src << "#define " << pair.first;
-        if (!iter->second.empty())
+        if (!pair.second.empty())
-            src << " " << iter->second;
+            src << " " << pair.second;
        src << endl;
    }
    if (!defines.empty())
@@ -856,10 +856,10 @@ void OpenCLContext::findMoleculeGroups() {
            atomBonds[particle1].push_back(particle2);
            atomBonds[particle2].push_back(particle1);
        }
-        for (int i = 0; i < (int) forces.size(); i++) {
+        for (auto force : forces) {
-            for (int j = 0; j < forces[i]->getNumParticleGroups(); j++) {
+            for (int j = 0; j < force->getNumParticleGroups(); j++) {
                vector<int> particles;
-                forces[i]->getParticlesInGroup(j, particles);
+                force->getParticlesInGroup(j, particles);
                for (int k = 0; k < (int) particles.size(); k++)
                    for (int m = 0; m < (int) particles.size(); m++)
                        if (k != m)
@@ -1076,8 +1076,8 @@ bool OpenCLContext::invalidateMolecules(OpenCLForceInfo* force) {
    }
    atomIndexDevice->upload(atomIndex);
    findMoleculeGroups();
-    for (int i = 0; i < (int) reorderListeners.size(); i++)
+    for (auto listener : reorderListeners)
-        reorderListeners[i]->execute();
+        listener->execute();
    reorderAtoms();
    return true;
 }
@@ -1138,10 +1138,9 @@ void OpenCLContext::reorderAtomsImpl() {
    vector<Real4> newPosqCorrection(paddedNumAtoms, Real4(0,0,0,0));
    vector<Mixed4> newVelm(paddedNumAtoms, Mixed4(0,0,0,0));
    vector<mm_int4> newCellOffsets(numAtoms);
-    for (int group = 0; group < (int) moleculeGroups.size(); group++) {
+    for (auto& mol : moleculeGroups) {
        // Find the center of each molecule.
-        MoleculeGroup& mol = moleculeGroups[group];
        int numMolecules = mol.offsets.size();
        vector<int>& atoms = mol.atoms;
        vector<Real4> molPos(numMolecules);
@@ -1235,9 +1234,9 @@ void OpenCLContext::reorderAtomsImpl() {
        // Reorder the atoms.
        for (int i = 0; i < numMolecules; i++) {
-            for (int j = 0; j < (int)atoms.size(); j++) {
+            for (int atom : atoms) {
-                int oldIndex = mol.offsets[molBins[i].second]+atoms[j];
+                int oldIndex = mol.offsets[molBins[i].second]+atom;
-                int newIndex = mol.offsets[i]+atoms[j];
+                int newIndex = mol.offsets[i]+atom;
                originalIndex[newIndex] = atomIndex[oldIndex];
                newPosq[newIndex] = oldPosq[oldIndex];
                if (useMixedPrecision)
@@ -1259,8 +1258,8 @@ void OpenCLContext::reorderAtomsImpl() {
        posqCorrection->upload(newPosqCorrection);
    velm->upload(newVelm);
    atomIndexDevice->upload(atomIndex);
-    for (int i = 0; i < (int) reorderListeners.size(); i++)
+    for (auto listener : reorderListeners)
-        reorderListeners[i]->execute();
+        listener->execute();
 }
 void OpenCLContext::addReorderListener(ReorderListener* listener) {

--- a/platforms/opencl/src/OpenCLExpressionUtilities.cpp
+++ b/platforms/opencl/src/OpenCLExpressionUtilities.cpp
@@ -448,12 +448,12 @@ void OpenCLExpressionUtilities::processExpression(stringstream& out, const Expre
                vector<bool> hasAssigned(powers.size(), false);
                exponents.push_back((int) fabs(exponent));
                names.push_back(name);
-                for (map<int, const ExpressionTreeNode*>::const_iterator iter = powers.begin(); iter != powers.end(); ++iter) {
+                for (auto& power : powers) {
-                    if (iter->first != exponent) {
+                    if (power.first != exponent) {
-                        exponents.push_back(iter->first >= 0 ? iter->first : -iter->first);
+                        exponents.push_back(power.first >= 0 ? power.first : -power.first);
                        string name2 = prefix+context.intToString(temps.size());
                        names.push_back(name2);
-                        temps.push_back(make_pair(*iter->second, name2));
+                        temps.push_back(make_pair(*power.second, name2));
                        out << tempType << " " << name2 << " = 0.0f;\n";
                    }
                }

--- a/platforms/opencl/src/OpenCLKernels.cpp
+++ b/platforms/opencl/src/OpenCLKernels.cpp
--- a/platforms/reference/src/ReferenceKernels.cpp
+++ b/platforms/reference/src/ReferenceKernels.cpp
@@ -159,8 +159,8 @@ static void validateVariables(const Lepton::ExpressionTreeNode& node, const set<
    const Lepton::Operation& op = node.getOperation();
    if (op.getId() == Lepton::Operation::VARIABLE && variables.find(op.getName()) == variables.end())
        throw OpenMMException("Unknown variable in expression: "+op.getName());
-    for (int i = 0; i < (int) node.getChildren().size(); i++)
+    for (auto& child : node.getChildren())
-        validateVariables(node.getChildren()[i], variables);
+        validateVariables(child, variables);
 }
 /**
@@ -214,8 +214,8 @@ void ReferenceCalcForcesAndEnergyKernel::beginComputation(ContextImpl& context,
    }
    else
        savedForces = forceData;
-    for (map<string, double>::const_iterator iter = context.getParameters().begin(); iter != context.getParameters().end(); ++iter)
+    for (auto& param : context.getParameters())
-        extractEnergyParameterDerivatives(context)[iter->first] = 0;
+        extractEnergyParameterDerivatives(context)[param.first] = 0;
 }
 double ReferenceCalcForcesAndEnergyKernel::finishComputation(ContextImpl& context, bool includeForces, bool includeEnergy, int groups, bool& valid) {
@@ -466,8 +466,8 @@ double ReferenceCalcCustomBondForceKernel::execute(ContextImpl& context, bool in
    vector<Vec3>& forceData = extractForces(context);
    double energy = 0;
    map<string, double> globalParameters;
-    for (int i = 0; i < (int) globalParameterNames.size(); i++)
+    for (auto& name : globalParameterNames)
-        globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
+        globalParameters[name] = context.getParameter(name);
    ReferenceCustomBondIxn bond(energyExpression, forceExpression, parameterNames, globalParameters, energyParamDerivExpressions);
    if (usePeriodic)
        bond.setPeriodic(extractBoxVectors(context));
@@ -600,8 +600,8 @@ double ReferenceCalcCustomAngleForceKernel::execute(ContextImpl& context, bool i
    vector<Vec3>& forceData = extractForces(context);
    double energy = 0;
    map<string, double> globalParameters;
-    for (int i = 0; i < (int) globalParameterNames.size(); i++)
+    for (auto& name : globalParameterNames)
-        globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
+        globalParameters[name] = context.getParameter(name);
    ReferenceCustomAngleIxn customAngle(energyExpression, forceExpression, parameterNames, globalParameters, energyParamDerivExpressions);
    if (usePeriodic)
        customAngle.setPeriodic(extractBoxVectors(context));
@@ -870,8 +870,8 @@ double ReferenceCalcCustomTorsionForceKernel::execute(ContextImpl& context, bool
    vector<Vec3>& forceData = extractForces(context);
    double energy = 0;
    map<string, double> globalParameters;
-    for (int i = 0; i < (int) globalParameterNames.size(); i++)
+    for (auto& name : globalParameterNames)
-        globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
+        globalParameters[name] = context.getParameter(name);
    ReferenceCustomTorsionIxn customTorsion(energyExpression, forceExpression, parameterNames, globalParameters, energyParamDerivExpressions);
    if (usePeriodic)
        customTorsion.setPeriodic(extractBoxVectors(context));
@@ -1165,8 +1165,8 @@ void ReferenceCalcCustomNonbondedForceKernel::initialize(const System& system, c
    // 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 information for the long range correction.
@@ -1208,11 +1208,11 @@ double ReferenceCalcCustomNonbondedForceKernel::execute(ContextImpl& context, bo
    if (interactionGroups.size() > 0)
        ixn.setInteractionGroups(interactionGroups);
    bool globalParamsChanged = false;
-    for (int i = 0; i < (int) globalParameterNames.size(); i++) {
+    for (auto& name : globalParameterNames) {
-        double value = context.getParameter(globalParameterNames[i]);
+        double value = context.getParameter(name);
-        if (globalParamValues[globalParameterNames[i]] != value)
+        if (globalParamValues[name] != value)
            globalParamsChanged = true;
-        globalParamValues[globalParameterNames[i]] = value;
+        globalParamValues[name] = value;
    }
    if (useSwitchingFunction)
        ixn.setUseSwitchingFunction(switchingDistance);
@@ -1459,8 +1459,8 @@ void ReferenceCalcCustomGBForceKernel::initialize(const System& system, const Cu
    // 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;
 }
 double ReferenceCalcCustomGBForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
@@ -1477,8 +1477,8 @@ double ReferenceCalcCustomGBForceKernel::execute(ContextImpl& context, bool incl
        ixn.setUseCutoff(nonbondedCutoff, *neighborList);
    }
    map<string, double> globalParameters;
-    for (int i = 0; i < (int) globalParameterNames.size(); i++)
+    for (auto& name : globalParameterNames)
-        globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
+        globalParameters[name] = context.getParameter(name);
    vector<double> energyParamDerivValues(energyParamDerivNames.size()+1, 0.0);
    ixn.calculateIxn(numParticles, posData, particleParamArray, exclusions, globalParameters, forceData, includeEnergy ? &energy : NULL, &energyParamDerivValues[0]);
    map<string, double>& energyParamDerivs = extractEnergyParameterDerivatives(context);
@@ -1593,8 +1593,8 @@ double ReferenceCalcCustomExternalForceKernel::execute(ContextImpl& context, boo
    boxVectors = extractBoxVectors(context);
    double energy = 0;
    map<string, double> globalParameters;
-    for (int i = 0; i < (int) globalParameterNames.size(); i++)
+    for (auto& name : globalParameterNames)
-        globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
+        globalParameters[name] = context.getParameter(name);
    ReferenceCustomExternalIxn force(energyExpression, forceExpressionX, forceExpressionY, forceExpressionZ, parameterNames, globalParameters);
    for (int i = 0; i < numParticles; ++i)
        force.calculateForce(particles[i], posData, particleParamArray[i], forceData, includeEnergy ? &energy : NULL);
@@ -1699,8 +1699,8 @@ void ReferenceCalcCustomHbondForceKernel::initialize(const System& system, const
    // 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;
 }
 double ReferenceCalcCustomHbondForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
@@ -1710,8 +1710,8 @@ double ReferenceCalcCustomHbondForceKernel::execute(ContextImpl& context, bool i
        ixn->setPeriodic(extractBoxVectors(context));
    double energy = 0;
    map<string, double> globalParameters;
-    for (int i = 0; i < (int) globalParameterNames.size(); i++)
+    for (auto& name : globalParameterNames)
-        globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
+        globalParameters[name] = context.getParameter(name);
    ixn->calculatePairIxn(posData, donorParamArray, acceptorParamArray, exclusions, globalParameters, forceData, includeEnergy ? &energy : NULL);
    return energy;
 }
@@ -1803,8 +1803,8 @@ void ReferenceCalcCustomCentroidBondForceKernel::initialize(const System& system
    // 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;
 }
 double ReferenceCalcCustomCentroidBondForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
@@ -1812,8 +1812,8 @@ double ReferenceCalcCustomCentroidBondForceKernel::execute(ContextImpl& context,
    vector<Vec3>& forceData = extractForces(context);
    double energy = 0;
    map<string, double> globalParameters;
-    for (int i = 0; i < (int) globalParameterNames.size(); i++)
+    for (auto& name : globalParameterNames)
-        globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
+        globalParameters[name] = context.getParameter(name);
    if (usePeriodic)
        ixn->setPeriodic(extractBoxVectors(context));
    vector<double> energyParamDerivValues(energyParamDerivNames.size()+1, 0.0);
@@ -1893,8 +1893,8 @@ void ReferenceCalcCustomCompoundBondForceKernel::initialize(const System& system
    // 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;
 }
 double ReferenceCalcCustomCompoundBondForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
@@ -1902,8 +1902,8 @@ double ReferenceCalcCustomCompoundBondForceKernel::execute(ContextImpl& context,
    vector<Vec3>& forceData = extractForces(context);
    double energy = 0;
    map<string, double> globalParameters;
-    for (int i = 0; i < (int) globalParameterNames.size(); i++)
+    for (auto& name : globalParameterNames)
-        globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
+        globalParameters[name] = context.getParameter(name);
    if (usePeriodic)
        ixn->setPeriodic(extractBoxVectors(context));
    vector<double> energyParamDerivValues(energyParamDerivNames.size()+1, 0.0);
@@ -1966,8 +1966,8 @@ double ReferenceCalcCustomManyParticleForceKernel::execute(ContextImpl& context,
    vector<Vec3>& forceData = extractForces(context);
    double energy = 0;
    map<string, double> globalParameters;
-    for (int i = 0; i < (int) globalParameterNames.size(); i++)
+    for (auto& name : globalParameterNames)
-        globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
+        globalParameters[name] = context.getParameter(name);
    if (nonbondedMethod == CutoffPeriodic) {
        Vec3* boxVectors = extractBoxVectors(context);
        double minAllowedSize = 2*cutoffDistance;
@@ -2232,8 +2232,8 @@ void ReferenceIntegrateCustomStepKernel::initialize(const System& system, const
    for (int i = 0; i < numParticles; ++i)
        masses[i] = system.getParticleMass(i);
    perDofValues.resize(integrator.getNumPerDofVariables());
-    for (int i = 0; i < (int) perDofValues.size(); i++)
+    for (auto& values : perDofValues)
-        perDofValues[i].resize(numParticles);
+        values.resize(numParticles);
    // Create the computation objects.

--- 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
@@ -127,8 +127,8 @@ ReferenceCCMAAlgorithm::ReferenceCCMAAlgorithm(int numberOfAtoms,
                    // We didn't find one, so look for an angle force field term.
                    const vector<int>& angleCandidates = atomAngles[atomb];
-                    for (vector<int>::const_iterator iter = angleCandidates.begin(); iter != angleCandidates.end(); iter++) {
+                    for (int candidate : angleCandidates) {
-                        const AngleInfo& angle = angles[*iter];
+                        const AngleInfo& angle = angles[candidate];
                        if ((angle.atom1 == atoma && angle.atom3 == atomc) || (angle.atom3 == atoma && angle.atom1 == atomc)) {
                            matrix[j].push_back(pair<int, double>(k, scale*cos(angle.angle)));
                            break;
@@ -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;