Merge branch 'master' into hardwall

platforms/cpu/src/CpuNonbondedForce.cpp

@@ -28,7 +28,7 @@
 #include "CpuNonbondedForce.h"
 #include "ReferenceForce.h"
 #include "ReferencePME.h"
-#include "gmx_atomic.h"
+#include "openmm/internal/gmx_atomic.h"
 #include <algorithm>
 
 // In case we're using some primitive version of Visual Studio this will
@@ -322,6 +322,14 @@ void CpuNonbondedForce::calculateDirectIxn(int numberOfAtoms, float* posq, const
     threads.execute(task);
     threads.waitForThreads();
     
+    // Signal the threads to subtract the exclusions.
+    
+    if (ewald || pme) {
+        gmx_atomic_set(&counter, 0);
+        threads.resumeThreads();
+        threads.waitForThreads();
+    }
+    
     // Combine the energies from all the threads.
     
     if (totalEnergy != NULL) {
@@ -354,28 +362,37 @@ void CpuNonbondedForce::threadComputeDirect(ThreadPool& threads, int threadIndex
 
         // Now subtract off the exclusions, since they were implicitly included in the reciprocal space sum.
 
-        for (int i = threadIndex; i < numberOfAtoms; i += numThreads) {
-            fvec4 posI((float) atomCoordinates[i][0], (float) atomCoordinates[i][1], (float) atomCoordinates[i][2], 0.0f);
-            for (set<int>::const_iterator iter = exclusions[i].begin(); iter != exclusions[i].end(); ++iter) {
-                if (*iter > i) {
-                    int j = *iter;
-                    fvec4 deltaR;
-                    fvec4 posJ((float) atomCoordinates[j][0], (float) atomCoordinates[j][1], (float) atomCoordinates[j][2], 0.0f);
-                    float r2;
-                    getDeltaR(posJ, posI, deltaR, r2, false, boxSize, invBoxSize);
-                    float r = sqrtf(r2);
-                    float inverseR = 1/r;
-                    float chargeProd = ONE_4PI_EPS0*posq[4*i+3]*posq[4*j+3];
-                    float alphaR = alphaEwald*r;
-                    float erfAlphaR = erf(alphaR);
-                    if (erfAlphaR > 1e-6f) {
-                        float dEdR = (float) (chargeProd * inverseR * inverseR * inverseR);
-                        dEdR = (float) (dEdR * (erfAlphaR-TWO_OVER_SQRT_PI*alphaR*exp(-alphaR*alphaR)));
-                        fvec4 result = deltaR*dEdR;
-                        (fvec4(forces+4*i)-result).store(forces+4*i);
-                        (fvec4(forces+4*j)+result).store(forces+4*j);
-                        if (includeEnergy)
-                            threadEnergy[threadIndex] -= chargeProd*inverseR*erfAlphaR;
+        threads.syncThreads();
+        const int groupSize = max(1, numberOfAtoms/(10*numThreads));
+        while (true) {
+            int start = gmx_atomic_fetch_add(reinterpret_cast<gmx_atomic_t*>(atomicCounter), groupSize);
+            if (start >= numberOfAtoms)
+                break;
+            int end = min(start+groupSize, numberOfAtoms);
+            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) {
+                    if (*iter > i) {
+                        int j = *iter;
+                        fvec4 deltaR;
+                        fvec4 posJ((float) atomCoordinates[j][0], (float) atomCoordinates[j][1], (float) atomCoordinates[j][2], 0.0f);
+                        float r2;
+                        getDeltaR(posJ, posI, deltaR, r2, false, boxSize, invBoxSize);
+                        float r = sqrtf(r2);
+                        float alphaR = alphaEwald*r;
+                        float erfAlphaR = erf(alphaR);
+                        if (erfAlphaR > 1e-6f) {
+                            float inverseR = 1/r;
+                            float chargeProdOverR = scaledChargeI*posq[4*j+3]*inverseR;
+                            float dEdR = chargeProdOverR*inverseR*inverseR;
+                            dEdR = dEdR * (erfAlphaR-(float)TWO_OVER_SQRT_PI*alphaR*(float)exp(-alphaR*alphaR));
+                            fvec4 result = deltaR*dEdR;
+                            (fvec4(forces+4*i)-result).store(forces+4*i);
+                            (fvec4(forces+4*j)+result).store(forces+4*j);
+                            if (includeEnergy)
+                                threadEnergy[threadIndex] -= chargeProdOverR*erfAlphaR;
+                        }
                     }
                 }
             }

platforms/cpu/src/CpuPlatform.cpp

@@ -61,6 +61,7 @@ map<const ContextImpl*, CpuPlatform::PlatformData*> CpuPlatform::contextData;
 CpuPlatform::CpuPlatform() {
     CpuKernelFactory* factory = new CpuKernelFactory();
     registerKernelFactory(CalcForcesAndEnergyKernel::Name(), factory);
+    registerKernelFactory(CalcHarmonicAngleForceKernel::Name(), factory);
     registerKernelFactory(CalcPeriodicTorsionForceKernel::Name(), factory);
     registerKernelFactory(CalcRBTorsionForceKernel::Name(), factory);
     registerKernelFactory(CalcNonbondedForceKernel::Name(), factory);

platforms/cpu/src/CpuSETTLE.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) 2013 Stanford University and the Authors.           *
+ * Portions copyright (c) 2013-2015 Stanford University and the Authors.      *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -30,6 +30,7 @@
  * -------------------------------------------------------------------------- */
 
 #include "CpuSETTLE.h"
+#include "openmm/internal/gmx_atomic.h"
 
 using namespace OpenMM;
 using namespace std;
@@ -39,10 +40,14 @@ public:
     ApplyToPositionsTask(vector<OpenMM::RealVec>& atomCoordinates, vector<OpenMM::RealVec>& atomCoordinatesP, vector<RealOpenMM>& inverseMasses,
             RealOpenMM tolerance, vector<ReferenceSETTLEAlgorithm*>& threadSettle) : atomCoordinates(atomCoordinates), atomCoordinatesP(atomCoordinatesP),
             inverseMasses(inverseMasses), tolerance(tolerance), threadSettle(threadSettle) {
+        gmx_atomic_set(&atomicCounter, 0);
     }
     void execute(ThreadPool& threads, int threadIndex) {
-        if (threadIndex < threadSettle.size()) {
-            threadSettle[threadIndex]->apply(atomCoordinates, atomCoordinatesP, inverseMasses, tolerance);
+        while (true) {
+            int index = gmx_atomic_fetch_add(&atomicCounter, 1);
+            if (index >= threadSettle.size())
+                break;
+            threadSettle[index]->apply(atomCoordinates, atomCoordinatesP, inverseMasses, tolerance);
         }
     }
     vector<OpenMM::RealVec>& atomCoordinates;
@@ -50,6 +55,7 @@ public:
     vector<RealOpenMM>& inverseMasses;
     RealOpenMM tolerance;
     vector<ReferenceSETTLEAlgorithm*>& threadSettle;
+    gmx_atomic_t atomicCounter;
 };
 
 class CpuSETTLE::ApplyToVelocitiesTask : public ThreadPool::Task {
@@ -57,10 +63,14 @@ public:
     ApplyToVelocitiesTask(vector<OpenMM::RealVec>& atomCoordinates, vector<OpenMM::RealVec>& velocities, vector<RealOpenMM>& inverseMasses,
             RealOpenMM tolerance, vector<ReferenceSETTLEAlgorithm*>& threadSettle) : atomCoordinates(atomCoordinates), velocities(velocities),
             inverseMasses(inverseMasses), tolerance(tolerance), threadSettle(threadSettle) {
+        gmx_atomic_set(&atomicCounter, 0);
     }
     void execute(ThreadPool& threads, int threadIndex) {
-        if (threadIndex < threadSettle.size()) {
-            threadSettle[threadIndex]->applyToVelocities(atomCoordinates, velocities, inverseMasses, tolerance);
+        while (true) {
+            int index = gmx_atomic_fetch_add(&atomicCounter, 1);
+            if (index >= threadSettle.size())
+                break;
+            threadSettle[index]->applyToVelocities(atomCoordinates, velocities, inverseMasses, tolerance);
         }
     }
     vector<OpenMM::RealVec>& atomCoordinates;
@@ -68,17 +78,18 @@ public:
     vector<RealOpenMM>& inverseMasses;
     RealOpenMM tolerance;
     vector<ReferenceSETTLEAlgorithm*>& threadSettle;
+    gmx_atomic_t atomicCounter;
 };
 
 CpuSETTLE::CpuSETTLE(const System& system, const ReferenceSETTLEAlgorithm& settle, ThreadPool& threads) : threads(threads) {
-    int numThreads = threads.getNumThreads();
+    int numBlocks = 10*threads.getNumThreads();
     int numClusters = settle.getNumClusters();
     vector<RealOpenMM> mass(system.getNumParticles());
     for (int i = 0; i < system.getNumParticles(); i++)
         mass[i] = system.getParticleMass(i);
-    for (int i = 0; i < numThreads; i++) {
-        int start = i*numClusters/numThreads;
-        int end = (i+1)*numClusters/numThreads;
+    for (int i = 0; i < numBlocks; i++) {
+        int start = i*numClusters/numBlocks;
+        int end = (i+1)*numClusters/numBlocks;
         if (start != end) {
             int numThreadClusters = end-start;
             vector<int> atom1(numThreadClusters), atom2(numThreadClusters), atom3(numThreadClusters);

platforms/cpu/tests/CpuTests.h

+/* -------------------------------------------------------------------------- *
+ *                                   OpenMM                                   *
+ * -------------------------------------------------------------------------- *
+ * This is part of the OpenMM molecular simulation toolkit originating from   *
+ * Simbios, the NIH National Center for Physics-Based Simulation of           *
+ * Biological Structures at Stanford, funded under the NIH Roadmap for        *
+ * Medical Research, grant U54 GM072970. See https://simtk.org.               *
+ *                                                                            *
+ * Portions copyright (c) 2015 Stanford University and the Authors.           *
+ * Authors: Peter Eastman                                                     *
+ * Contributors:                                                              *
+ *                                                                            *
+ * Permission is hereby granted, free of charge, to any person obtaining a    *
+ * copy of this software and associated documentation files (the "Software"), *
+ * to deal in the Software without restriction, including without limitation  *
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,   *
+ * and/or sell copies of the Software, and to permit persons to whom the      *
+ * Software is furnished to do so, subject to the following conditions:       *
+ *                                                                            *
+ * The above copyright notice and this permission notice shall be included in *
+ * all copies or substantial portions of the Software.                        *
+ *                                                                            *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *
+ * THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,    *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR      *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE  *
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
+ * -------------------------------------------------------------------------- */
+
+#ifdef WIN32
+  #define _USE_MATH_DEFINES // Needed to get M_PI
+#endif
+#include "CpuPlatform.h"
+#include <cstdlib>
+#include <iostream>
+
+OpenMM::CpuPlatform platform;
+
+void initializeTests(int argc, char* argv[]) {
+    if (!OpenMM::CpuPlatform::isProcessorSupported()) {
+        std::cout << "CPU is not supported.  Exiting." << std::endl;
+        exit(0);
+    }
+}

platforms/cpu/tests/TestCpuCheckpoints.cpp

+/* -------------------------------------------------------------------------- *
+ *                                   OpenMM                                   *
+ * -------------------------------------------------------------------------- *
+ * This is part of the OpenMM molecular simulation toolkit originating from   *
+ * Simbios, the NIH National Center for Physics-Based Simulation of           *
+ * Biological Structures at Stanford, funded under the NIH Roadmap for        *
+ * Medical Research, grant U54 GM072970. See https://simtk.org.               *
+ *                                                                            *
+ * Portions copyright (c) 2012-2015 Stanford University and the Authors.      *
+ * Authors: Peter Eastman                                                     *
+ * Contributors:                                                              *
+ *                                                                            *
+ * Permission is hereby granted, free of charge, to any person obtaining a    *
+ * copy of this software and associated documentation files (the "Software"), *
+ * to deal in the Software without restriction, including without limitation  *
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,   *
+ * and/or sell copies of the Software, and to permit persons to whom the      *
+ * Software is furnished to do so, subject to the following conditions:       *
+ *                                                                            *
+ * The above copyright notice and this permission notice shall be included in *
+ * all copies or substantial portions of the Software.                        *
+ *                                                                            *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *
+ * THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,    *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR      *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE  *
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
+ * -------------------------------------------------------------------------- */
+
+#include "CpuTests.h"
+#include "TestCheckpoints.h"
+
+void testCheckpoint() {
+    const int numParticles = 100;
+    const double boxSize = 5.0;
+    const double temperature = 200.0;
+    System system;
+    system.addForce(new AndersenThermostat(0.0, 100.0));
+    NonbondedForce* nonbonded = new NonbondedForce();
+    system.addForce(nonbonded);
+    nonbonded->setNonbondedMethod(NonbondedForce::CutoffPeriodic);
+    vector<Vec3> positions(numParticles);
+    OpenMM_SFMT::SFMT sfmt;
+    init_gen_rand(0, sfmt);
+    for (int i = 0; i < numParticles; i++) {
+        system.addParticle(1.0);
+        nonbonded->addParticle(i%2 == 0 ? 0.1 : -0.1, 0.2, 0.1);
+        bool clash;
+        do {
+            clash = false;
+            positions[i] = Vec3(boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt));
+            for (int j = 0; j < i; j++) {
+                Vec3 delta = positions[i]-positions[j];
+                if (sqrt(delta.dot(delta)) < 0.1)
+                    clash = true;
+            }
+        } while (clash);
+    }
+    VerletIntegrator integrator(0.001);
+    Context context(system, integrator, platform);
+    context.setPositions(positions);
+    context.setPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize));
+    context.setParameter(AndersenThermostat::Temperature(), temperature);
+    
+    // Run for a little while.
+    
+    integrator.step(100);
+    
+    // Record the current state and make a checkpoint.
+    
+    State s1 = context.getState(State::Positions | State::Velocities | State::Parameters);
+    stringstream stream1(ios_base::out | ios_base::in | ios_base::binary);
+    context.createCheckpoint(stream1);
+    
+    // Continue the simulation for a few more steps and record the state again.
+    
+    integrator.step(10);
+    State s2 = context.getState(State::Positions | State::Velocities | State::Parameters);
+    
+    // Restore from the checkpoint and see if everything gets restored correctly.
+    
+    context.setPeriodicBoxVectors(Vec3(2*boxSize, 0, 0), Vec3(0, 2*boxSize, 0), Vec3(0, 0, 2*boxSize));
+    context.setParameter(AndersenThermostat::Temperature(), temperature+10);
+    context.loadCheckpoint(stream1);
+    State s3 = context.getState(State::Positions | State::Velocities | State::Parameters);
+    compareStates(s1, s3);
+    
+    // Now simulate from there and see if the trajectory is identical.
+    
+    integrator.step(10);
+    State s4 = context.getState(State::Positions | State::Velocities | State::Parameters);
+    compareStates(s2, s4);
+}
+
+void runPlatformTests() {
+    testCheckpoint();
+}

platforms/cpu/tests/TestCpuCustomGBForce.cpp

-
 /* -------------------------------------------------------------------------- *
  *                                   OpenMM                                   *
  * -------------------------------------------------------------------------- *
@@ -7,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) 2008-2014 Stanford University and the Authors.      *
+ * Portions copyright (c) 2015 Stanford University and the Authors.           *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -30,454 +29,8 @@
  * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
  * -------------------------------------------------------------------------- */
 
-/**
- * This tests all the different force terms in the reference implementation of CustomGBForce.
- */
-
-#include "openmm/internal/AssertionUtilities.h"
-#include "sfmt/SFMT.h"
-#include "openmm/Context.h"
-#include "CpuPlatform.h"
-#include "openmm/CustomGBForce.h"
-#include "openmm/GBSAOBCForce.h"
-#include "openmm/GBVIForce.h"
-#include "openmm/OpenMMException.h"
-#include "openmm/System.h"
-#include "openmm/VerletIntegrator.h"
-#include <iostream>
-#include <vector>
-#include <algorithm>
-
-using namespace OpenMM;
-using namespace std;
-
-const double TOL = 1e-5;
-
-void testOBC(GBSAOBCForce::NonbondedMethod obcMethod, CustomGBForce::NonbondedMethod customMethod) {
-    const int numMolecules = 70;
-    const int numParticles = numMolecules*2;
-    const double boxSize = 10.0;
-    const double cutoff = 2.0;
-    CpuPlatform platform;
-
-    // Create two systems: one with a GBSAOBCForce, and one using a CustomGBForce to implement the same interaction.
-
-    System standardSystem;
-    System customSystem;
-    for (int i = 0; i < numParticles; i++) {
-        standardSystem.addParticle(1.0);
-        customSystem.addParticle(1.0);
-    }
-    standardSystem.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0.0, 0.0), Vec3(0.0, boxSize, 0.0), Vec3(0.0, 0.0, boxSize));
-    customSystem.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0.0, 0.0), Vec3(0.0, boxSize, 0.0), Vec3(0.0, 0.0, boxSize));
-    GBSAOBCForce* obc = new GBSAOBCForce();
-    CustomGBForce* custom = new CustomGBForce();
-    obc->setCutoffDistance(cutoff);
-    custom->setCutoffDistance(cutoff);
-    custom->addPerParticleParameter("q");
-    custom->addPerParticleParameter("radius");
-    custom->addPerParticleParameter("scale");
-    custom->addGlobalParameter("solventDielectric", obc->getSolventDielectric());
-    custom->addGlobalParameter("soluteDielectric", obc->getSoluteDielectric());
-    custom->addComputedValue("I", "step(r+sr2-or1)*0.5*(1/L-1/U+0.25*(1/U^2-1/L^2)*(r-sr2*sr2/r)+0.5*log(L/U)/r+C);"
-                                  "U=r+sr2;"
-                                  "C=2*(1/or1-1/L)*step(sr2-r-or1);"
-                                  "L=max(or1, D);"
-                                  "D=abs(r-sr2);"
-                                  "sr2 = scale2*or2;"
-                                  "or1 = radius1-0.009; or2 = radius2-0.009", CustomGBForce::ParticlePairNoExclusions);
-    custom->addComputedValue("B", "1/(1/or-tanh(1*psi-0.8*psi^2+4.85*psi^3)/radius);"
-                                  "psi=I*or; or=radius-0.009", CustomGBForce::SingleParticle);
-    custom->addEnergyTerm("28.3919551*(radius+0.14)^2*(radius/B)^6-0.5*138.935485*(1/soluteDielectric-1/solventDielectric)*q^2/B", CustomGBForce::SingleParticle);
-    string invCutoffString = "";
-    if (obcMethod != GBSAOBCForce::NoCutoff) {
-        stringstream s;
-        s<<(1.0/cutoff);
-        invCutoffString = s.str();
-    }
-    custom->addEnergyTerm("138.935485*(1/soluteDielectric-1/solventDielectric)*q1*q2*("+invCutoffString+"-1/f);"
-                          "f=sqrt(r^2+B1*B2*exp(-r^2/(4*B1*B2)))", CustomGBForce::ParticlePairNoExclusions);
-    vector<Vec3> positions(numParticles);
-    vector<Vec3> velocities(numParticles);
-    OpenMM_SFMT::SFMT sfmt;
-    init_gen_rand(0, sfmt);
-
-    vector<double> params(3);
-    for (int i = 0; i < numMolecules; i++) {
-        if (i < numMolecules/2) {
-            obc->addParticle(1.0, 0.2, 0.5);
-            params[0] = 1.0;
-            params[1] = 0.2;
-            params[2] = 0.5;
-            custom->addParticle(params);
-            obc->addParticle(-1.0, 0.1, 0.5);
-            params[0] = -1.0;
-            params[1] = 0.1;
-            custom->addParticle(params);
-        }
-        else {
-            obc->addParticle(1.0, 0.2, 0.8);
-            params[0] = 1.0;
-            params[1] = 0.2;
-            params[2] = 0.8;
-            custom->addParticle(params);
-            obc->addParticle(-1.0, 0.1, 0.8);
-            params[0] = -1.0;
-            params[1] = 0.1;
-            custom->addParticle(params);
-        }
-        positions[2*i] = Vec3(boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt));
-        positions[2*i+1] = Vec3(positions[2*i][0]+1.0, positions[2*i][1], positions[2*i][2]);
-        velocities[2*i] = Vec3(genrand_real2(sfmt), genrand_real2(sfmt), genrand_real2(sfmt));
-        velocities[2*i+1] = Vec3(genrand_real2(sfmt), genrand_real2(sfmt), genrand_real2(sfmt));
-    }
-    obc->setNonbondedMethod(obcMethod);
-    custom->setNonbondedMethod(customMethod);
-    standardSystem.addForce(obc);
-    customSystem.addForce(custom);
-    VerletIntegrator integrator1(0.01);
-    VerletIntegrator integrator2(0.01);
-    Context context1(standardSystem, integrator1, platform);
-    context1.setPositions(positions);
-    context1.setVelocities(velocities);
-    State state1 = context1.getState(State::Forces | State::Energy);
-    Context context2(customSystem, integrator2, platform);
-    context2.setPositions(positions);
-    context2.setVelocities(velocities);
-    State state2 = context2.getState(State::Forces | State::Energy);
-    ASSERT_EQUAL_TOL(state1.getPotentialEnergy(), state2.getPotentialEnergy(), 1e-4);
-    for (int i = 0; i < numParticles; i++) {
-        ASSERT_EQUAL_VEC(state1.getForces()[i], state2.getForces()[i], 1e-4);
-    }
-    
-    // Try changing the particle parameters and make sure it's still correct.
-    
-    for (int i = 0; i < numMolecules/2; i++) {
-        obc->setParticleParameters(2*i, 1.1, 0.3, 0.6);
-        params[0] = 1.1;
-        params[1] = 0.3;
-        params[2] = 0.6;
-        custom->setParticleParameters(2*i, params);
-        obc->setParticleParameters(2*i+1, -1.1, 0.2, 0.4);
-        params[0] = -1.1;
-        params[1] = 0.2;
-        params[2] = 0.4;
-        custom->setParticleParameters(2*i+1, params);
-    }
-    obc->updateParametersInContext(context1);
-    custom->updateParametersInContext(context2);
-    state1 = context1.getState(State::Forces | State::Energy);
-    state2 = context2.getState(State::Forces | State::Energy);
-    ASSERT_EQUAL_TOL(state1.getPotentialEnergy(), state2.getPotentialEnergy(), 1e-4);
-    for (int i = 0; i < numParticles; i++) {
-        ASSERT_EQUAL_VEC(state1.getForces()[i], state2.getForces()[i], 1e-4);
-    }
-}
-
-void testMembrane() {
-    const int numMolecules = 70;
-    const int numParticles = numMolecules*2;
-    const double boxSize = 10.0;
-    CpuPlatform platform;
-
-    // Create a system with an implicit membrane.
-
-    System system;
-    for (int i = 0; i < numParticles; i++) {
-        system.addParticle(1.0);
-    }
-    system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0.0, 0.0), Vec3(0.0, boxSize, 0.0), Vec3(0.0, 0.0, boxSize));
-    CustomGBForce* custom = new CustomGBForce();
-    custom->setCutoffDistance(2.0);
-    custom->addPerParticleParameter("q");
-    custom->addPerParticleParameter("radius");
-    custom->addPerParticleParameter("scale");
-    custom->addGlobalParameter("thickness", 3);
-    custom->addGlobalParameter("solventDielectric", 78.3);
-    custom->addGlobalParameter("soluteDielectric", 1);
-    custom->addComputedValue("Imol", "step(r+sr2-or1)*0.5*(1/L-1/U+0.25*(1/U^2-1/L^2)*(r-sr2*sr2/r)+0.5*log(L/U)/r+C);"
-                             "U=r+sr2;"
-                             "C=2*(1/or1-1/L)*step(sr2-r-or1);"
-                             "L=max(or1, D);"
-                             "D=abs(r-sr2);"
-                             "sr2 = scale2*or2;"
-                             "or1 = radius1-0.009; or2 = radius2-0.009", CustomGBForce::ParticlePairNoExclusions);
-    custom->addComputedValue("Imem", "(1/radius+2*log(2)/thickness)/(1+exp(7.2*(abs(z)+radius-0.5*thickness)))", CustomGBForce::SingleParticle);
-    custom->addComputedValue("B", "1/(1/or-tanh(1*psi-0.8*psi^2+4.85*psi^3)/radius);"
-                             "psi=max(Imol,Imem)*or; or=radius-0.009", CustomGBForce::SingleParticle);
-    custom->addEnergyTerm("28.3919551*(radius+0.14)^2*(radius/B)^6-0.5*138.935456*(1/soluteDielectric-1/solventDielectric)*q^2/B", CustomGBForce::SingleParticle);
-    custom->addEnergyTerm("-138.935456*(1/soluteDielectric-1/solventDielectric)*q1*q2/f;"
-                          "f=sqrt(r^2+B1*B2*exp(-r^2/(4*B1*B2)))", CustomGBForce::ParticlePairNoExclusions);
-    vector<Vec3> positions(numParticles);
-    vector<Vec3> velocities(numParticles);
-    OpenMM_SFMT::SFMT sfmt;
-    init_gen_rand(0, sfmt);
-    vector<double> params(3);
-    for (int i = 0; i < numMolecules; i++) {
-        if (i < numMolecules/2) {
-            params[0] = 1.0;
-            params[1] = 0.2;
-            params[2] = 0.5;
-            custom->addParticle(params);
-            params[0] = -1.0;
-            params[1] = 0.1;
-            custom->addParticle(params);
-        }
-        else {
-            params[0] = 1.0;
-            params[1] = 0.2;
-            params[2] = 0.8;
-            custom->addParticle(params);
-            params[0] = -1.0;
-            params[1] = 0.1;
-            custom->addParticle(params);
-        }
-        positions[2*i] = Vec3(boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt));
-        positions[2*i+1] = Vec3(positions[2*i][0]+1.0, positions[2*i][1], positions[2*i][2]);
-        velocities[2*i] = Vec3(genrand_real2(sfmt), genrand_real2(sfmt), genrand_real2(sfmt));
-        velocities[2*i+1] = Vec3(genrand_real2(sfmt), genrand_real2(sfmt), genrand_real2(sfmt));
-    }
-    system.addForce(custom);
-    VerletIntegrator integrator(0.01);
-    Context context(system, integrator, platform);
-    context.setPositions(positions);
-    context.setVelocities(velocities);
-    State state = context.getState(State::Forces | State::Energy);
-    const vector<Vec3>& forces = state.getForces();
-
-    // Take a small step in the direction of the energy gradient and see whether the potential energy changes by the expected amount.
-
-    double norm = 0.0;
-    for (int i = 0; i < (int) forces.size(); ++i)
-        norm += forces[i].dot(forces[i]);
-    norm = std::sqrt(norm);
-    const double stepSize = 1e-2;
-    double step = 0.5*stepSize/norm;
-    vector<Vec3> positions2(numParticles), positions3(numParticles);
-    for (int i = 0; i < (int) positions.size(); ++i) {
-        Vec3 p = positions[i];
-        Vec3 f = forces[i];
-        positions2[i] = Vec3(p[0]-f[0]*step, p[1]-f[1]*step, p[2]-f[2]*step);
-        positions3[i] = Vec3(p[0]+f[0]*step, p[1]+f[1]*step, p[2]+f[2]*step);
-    }
-    context.setPositions(positions2);
-    State state2 = context.getState(State::Energy);
-    context.setPositions(positions3);
-    State state3 = context.getState(State::Energy);
-    ASSERT_EQUAL_TOL(norm, (state2.getPotentialEnergy()-state3.getPotentialEnergy())/stepSize, 1e-3);
-}
-
-void testTabulatedFunction() {
-    CpuPlatform platform;
-    System system;
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    VerletIntegrator integrator(0.01);
-    CustomGBForce* force = new CustomGBForce();
-    force->addComputedValue("a", "0", CustomGBForce::ParticlePair);
-    force->addEnergyTerm("fn(r)+1", CustomGBForce::ParticlePair);
-    force->addParticle(vector<double>());
-    force->addParticle(vector<double>());
-    vector<double> table;
-    for (int i = 0; i < 21; i++)
-        table.push_back(std::sin(0.25*i));
-    force->addTabulatedFunction("fn", new Continuous1DFunction(table, 1.0, 6.0));
-    system.addForce(force);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(2);
-    positions[0] = Vec3(0, 0, 0);
-    for (int i = 1; i < 30; i++) {
-        double x = (7.0/30.0)*i;
-        positions[1] = Vec3(x, 0, 0);
-        context.setPositions(positions);
-        State state = context.getState(State::Forces | State::Energy);
-        const vector<Vec3>& forces = state.getForces();
-        double force = (x < 1.0 || x > 6.0 ? 0.0 : -std::cos(x-1.0));
-        double energy = (x < 1.0 || x > 6.0 ? 0.0 : std::sin(x-1.0))+1.0;
-        ASSERT_EQUAL_VEC(Vec3(-force, 0, 0), forces[0], 0.1);
-        ASSERT_EQUAL_VEC(Vec3(force, 0, 0), forces[1], 0.1);
-        ASSERT_EQUAL_TOL(energy, state.getPotentialEnergy(), 0.02);
-    }
-}
-
-void testMultipleChainRules() {
-    CpuPlatform platform;
-    System system;
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    VerletIntegrator integrator(0.01);
-    CustomGBForce* force = new CustomGBForce();
-    force->addComputedValue("a", "2*r", CustomGBForce::ParticlePair);
-    force->addComputedValue("b", "a+1", CustomGBForce::SingleParticle);
-    force->addComputedValue("c", "2*b+a", CustomGBForce::SingleParticle);
-    force->addEnergyTerm("0.1*a+1*b+10*c", CustomGBForce::SingleParticle); // 0.1*(2*r) + 2*r+1 + 10*(3*a+2) = 0.2*r + 2*r+1 + 40*r+20+20*r = 62.2*r+21
-    force->addParticle(vector<double>());
-    force->addParticle(vector<double>());
-    system.addForce(force);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(2);
-    positions[0] = Vec3(0, 0, 0);
-    for (int i = 1; i < 5; i++) {
-        positions[1] = Vec3(i, 0, 0);
-        context.setPositions(positions);
-        State state = context.getState(State::Forces | State::Energy);
-        const vector<Vec3>& forces = state.getForces();
-        ASSERT_EQUAL_VEC(Vec3(124.4, 0, 0), forces[0], 1e-4);
-        ASSERT_EQUAL_VEC(Vec3(-124.4, 0, 0), forces[1], 1e-4);
-        ASSERT_EQUAL_TOL(2*(62.2*i+21), state.getPotentialEnergy(), 0.02);
-    }
-}
-
-void testPositionDependence() {
-    CpuPlatform platform;
-    System system;
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    VerletIntegrator integrator(0.01);
-    CustomGBForce* force = new CustomGBForce();
-    force->addComputedValue("a", "r", CustomGBForce::ParticlePair);
-    force->addComputedValue("b", "a+x*y", CustomGBForce::SingleParticle);
-    force->addEnergyTerm("b*z", CustomGBForce::SingleParticle);
-    force->addEnergyTerm("b1+b2", CustomGBForce::ParticlePair); // = 2*r+x1*y1+x2*y2
-    force->addParticle(vector<double>());
-    force->addParticle(vector<double>());
-    system.addForce(force);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(2);
-    vector<Vec3> forces(2);
-    OpenMM_SFMT::SFMT sfmt;
-    init_gen_rand(0, sfmt);
-
-    for (int i = 0; i < 5; i++) {
-        positions[0] = Vec3(genrand_real2(sfmt), genrand_real2(sfmt), genrand_real2(sfmt));
-        positions[1] = Vec3(genrand_real2(sfmt), genrand_real2(sfmt), genrand_real2(sfmt));
-        context.setPositions(positions);
-        State state = context.getState(State::Forces | State::Energy);
-        const vector<Vec3>& forces = state.getForces();
-        Vec3 delta = positions[0]-positions[1];
-        double r = sqrt(delta.dot(delta));
-        double energy = 2*r+positions[0][0]*positions[0][1]+positions[1][0]*positions[1][1];
-        for (int j = 0; j < 2; j++)
-            energy += positions[j][2]*(r+positions[j][0]*positions[j][1]);
-        Vec3 force1(-(1+positions[0][2])*delta[0]/r-(1+positions[0][2])*positions[0][1]-(1+positions[1][2])*delta[0]/r,
-                    -(1+positions[0][2])*delta[1]/r-(1+positions[0][2])*positions[0][0]-(1+positions[1][2])*delta[1]/r,
-                    -(1+positions[0][2])*delta[2]/r-(r+positions[0][0]*positions[0][1])-(1+positions[1][2])*delta[2]/r);
-        Vec3 force2((1+positions[0][2])*delta[0]/r+(1+positions[1][2])*delta[0]/r-(1+positions[1][2])*positions[1][1],
-                    (1+positions[0][2])*delta[1]/r+(1+positions[1][2])*delta[1]/r-(1+positions[1][2])*positions[1][0],
-                    (1+positions[0][2])*delta[2]/r+(1+positions[1][2])*delta[2]/r-(r+positions[1][0]*positions[1][1]));
-        ASSERT_EQUAL_VEC(force1, forces[0], 1e-4);
-        ASSERT_EQUAL_VEC(force2, forces[1], 1e-4);
-        ASSERT_EQUAL_TOL(energy, state.getPotentialEnergy(), 0.02);
-
-        // Take a small step in the direction of the energy gradient and see whether the potential energy changes by the expected amount.
-
-        double norm = 0.0;
-        for (int i = 0; i < (int) forces.size(); ++i)
-            norm += forces[i].dot(forces[i]);
-        norm = std::sqrt(norm);
-        const double stepSize = 1e-3;
-        double step = 0.5*stepSize/norm;
-        vector<Vec3> positions2(2), positions3(2);
-        for (int i = 0; i < (int) positions.size(); ++i) {
-            Vec3 p = positions[i];
-            Vec3 f = forces[i];
-            positions2[i] = Vec3(p[0]-f[0]*step, p[1]-f[1]*step, p[2]-f[2]*step);
-            positions3[i] = Vec3(p[0]+f[0]*step, p[1]+f[1]*step, p[2]+f[2]*step);
-        }
-        context.setPositions(positions2);
-        State state2 = context.getState(State::Energy);
-        context.setPositions(positions3);
-        State state3 = context.getState(State::Energy);
-        ASSERT_EQUAL_TOL(norm, (state2.getPotentialEnergy()-state3.getPotentialEnergy())/stepSize, 1e-3);
-    }
-}
-
-void testExclusions() {
-    CpuPlatform platform;
-    for (int i = 3; i < 4; i++) {
-        System system;
-        system.addParticle(1.0);
-        system.addParticle(1.0);
-        VerletIntegrator integrator(0.01);
-        CustomGBForce* force = new CustomGBForce();
-        force->addComputedValue("a", "r", i < 2 ? CustomGBForce::ParticlePair : CustomGBForce::ParticlePairNoExclusions);
-        force->addEnergyTerm("a", CustomGBForce::SingleParticle);
-        force->addEnergyTerm("(1+a1+a2)*r", i%2 == 0 ? CustomGBForce::ParticlePair : CustomGBForce::ParticlePairNoExclusions);
-        force->addParticle(vector<double>());
-        force->addParticle(vector<double>());
-        force->addExclusion(0, 1);
-        system.addForce(force);
-        Context context(system, integrator, platform);
-        vector<Vec3> positions(2);
-        positions[0] = Vec3(0, 0, 0);
-        positions[1] = Vec3(1, 0, 0);
-        context.setPositions(positions);
-        State state = context.getState(State::Forces | State::Energy);
-        const vector<Vec3>& forces = state.getForces();
-        double f, energy;
-        switch (i)
-        {
-            case 0: // e = 0
-                f = 0;
-                energy = 0;
-                break;
-            case 1: // e = r
-                f = 1;
-                energy = 1;
-                break;
-            case 2: // e = 2r
-                f = 2;
-                energy = 2;
-                break;
-            case 3: // e = 3r + 2r^2
-                f = 7;
-                energy = 5;
-                break;
-            default:
-                ASSERT(false);
-        }
-        ASSERT_EQUAL_VEC(Vec3(f, 0, 0), forces[0], 1e-4);
-        ASSERT_EQUAL_VEC(Vec3(-f, 0, 0), forces[1], 1e-4);
-        ASSERT_EQUAL_TOL(energy, state.getPotentialEnergy(), 1e-4);
-
-        // Take a small step in the direction of the energy gradient and see whether the potential energy changes by the expected amount.
-
-        double norm = 0.0;
-        for (int i = 0; i < (int) forces.size(); ++i)
-            norm += forces[i].dot(forces[i]);
-        norm = std::sqrt(norm);
-        const double stepSize = 1e-3;
-        double step = stepSize/norm;
-        for (int i = 0; i < (int) positions.size(); ++i) {
-            Vec3 p = positions[i];
-            Vec3 f = forces[i];
-            positions[i] = Vec3(p[0]-f[0]*step, p[1]-f[1]*step, p[2]-f[2]*step);
-        }
-        context.setPositions(positions);
-        State state2 = context.getState(State::Energy);
-        ASSERT_EQUAL_TOL(norm, (state2.getPotentialEnergy()-state.getPotentialEnergy())/stepSize, 1e-3*abs(state.getPotentialEnergy()));
-    }
-}
+#include "CpuTests.h"
+#include "TestCustomGBForce.h"
 
-int main() {
-    try {
-        if (!CpuPlatform::isProcessorSupported()) {
-            cout << "CPU is not supported.  Exiting." << endl;
-            return 0;
-        }
-        testOBC(GBSAOBCForce::NoCutoff, CustomGBForce::NoCutoff);
-        testOBC(GBSAOBCForce::CutoffNonPeriodic, CustomGBForce::CutoffNonPeriodic);
-        testOBC(GBSAOBCForce::CutoffPeriodic, CustomGBForce::CutoffPeriodic);
-        testMembrane();
-        testTabulatedFunction();
-        testMultipleChainRules();
-        testPositionDependence();
-        testExclusions();
-    }
-    catch(const exception& e) {
-        cout << "exception: " << e.what() << endl;
-        return 1;
-    }
-    cout << "Done" << endl;
-    return 0;
+void runPlatformTests() {
 }

platforms/cpu/tests/TestCpuCustomManyParticleForce.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) 2014 Stanford University and the Authors.           *
+ * Portions copyright (c) 2015 Stanford University and the Authors.           *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -29,713 +29,8 @@
  * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
  * -------------------------------------------------------------------------- */
 
-/**
- * This tests the CPU implementation of CustomManyParticleForce.
- */
+#include "CpuTests.h"
+#include "TestCustomManyParticleForce.h"
 
-#ifdef WIN32
-  #define _USE_MATH_DEFINES // Needed to get M_PI
-#endif
-#include "openmm/internal/AssertionUtilities.h"
-#include "openmm/Context.h"
-#include "CpuPlatform.h"
-#include "openmm/CustomCompoundBondForce.h"
-#include "openmm/CustomManyParticleForce.h"
-#include "openmm/System.h"
-#include "openmm/TabulatedFunction.h"
-#include "openmm/VerletIntegrator.h"
-#include "sfmt/SFMT.h"
-#include <iostream>
-#include <vector>
-
-using namespace OpenMM;
-using namespace std;
-
-const double TOL = 1e-5;
-
-Vec3 computeDelta(const Vec3& pos1, const Vec3& pos2, bool periodic, const Vec3* periodicBoxVectors) {
-    Vec3 diff = pos1-pos2;
-    if (periodic) {
-        diff -= periodicBoxVectors[2]*floor(diff[2]/periodicBoxVectors[2][2]+0.5);
-        diff -= periodicBoxVectors[1]*floor(diff[1]/periodicBoxVectors[1][1]+0.5);
-        diff -= periodicBoxVectors[0]*floor(diff[0]/periodicBoxVectors[0][0]+0.5);
-    }
-    return diff;
-}
-
-void validateAxilrodTeller(CustomManyParticleForce* force, const vector<Vec3>& positions, const vector<const int*>& expectedSets, double boxSize, bool triclinic) {
-    // Create a System and Context.
-
-    int numParticles = force->getNumParticles();
-    CustomManyParticleForce::NonbondedMethod nonbondedMethod = force->getNonbondedMethod();
-    System system;
-    for (int i = 0; i < numParticles; i++)
-        system.addParticle(1.0);
-    Vec3 boxVectors[3];
-    if (triclinic) {
-        boxVectors[0] = Vec3(boxSize, 0, 0);
-        boxVectors[1] = Vec3(0.2*boxSize, boxSize, 0);
-        boxVectors[2] = Vec3(-0.3*boxSize, -0.1*boxSize, boxSize);
-    }
-    else {
-        boxVectors[0] = Vec3(boxSize, 0, 0);
-        boxVectors[1] = Vec3(0, boxSize, 0);
-        boxVectors[2] = Vec3(0, 0, boxSize);
-    }
-    system.setDefaultPeriodicBoxVectors(boxVectors[0], boxVectors[1], boxVectors[2]);
-    system.addForce(force);
-    VerletIntegrator integrator(0.001);
-    CpuPlatform platform;
-    Context context(system, integrator, platform);
-    context.setPositions(positions);
-    State state1 = context.getState(State::Forces | State::Energy);
-    double c = context.getParameter("C");
-
-    // See if the energy matches the expected value.
-
-    double expectedEnergy = 0;
-    bool periodic = (nonbondedMethod == CustomManyParticleForce::CutoffPeriodic);
-    for (int i = 0; i < (int) expectedSets.size(); i++) {
-        int p1 = expectedSets[i][0];
-        int p2 = expectedSets[i][1];
-        int p3 = expectedSets[i][2];
-        Vec3 d12 = computeDelta(positions[p2], positions[p1], periodic, boxVectors);
-        Vec3 d13 = computeDelta(positions[p3], positions[p1], periodic, boxVectors);
-        Vec3 d23 = computeDelta(positions[p3], positions[p2], periodic, boxVectors);
-        double r12 = sqrt(d12.dot(d12));
-        double r13 = sqrt(d13.dot(d13));
-        double r23 = sqrt(d23.dot(d23));
-        double ctheta1 = d12.dot(d13)/(r12*r13);
-        double ctheta2 = -d12.dot(d23)/(r12*r23);
-        double ctheta3 = d13.dot(d23)/(r13*r23);
-        double rprod = r12*r13*r23;
-        expectedEnergy += c*(1+3*ctheta1*ctheta2*ctheta3)/(rprod*rprod*rprod);
-    }
-    ASSERT_EQUAL_TOL(expectedEnergy, state1.getPotentialEnergy(), 1e-5);
-
-    // Take a small step in the direction of the energy gradient and see whether the potential energy changes by the expected amount.
-
-    const vector<Vec3>& forces = state1.getForces();
-    double norm = 0.0;
-    for (int i = 0; i < (int) forces.size(); ++i)
-        norm += forces[i].dot(forces[i]);
-    norm = std::sqrt(norm);
-    const double stepSize = 1e-3;
-    double step = 0.5*stepSize/norm;
-    vector<Vec3> positions2(numParticles), positions3(numParticles);
-    for (int i = 0; i < (int) positions.size(); ++i) {
-        Vec3 p = positions[i];
-        Vec3 f = forces[i];
-        positions2[i] = Vec3(p[0]-f[0]*step, p[1]-f[1]*step, p[2]-f[2]*step);
-        positions3[i] = Vec3(p[0]+f[0]*step, p[1]+f[1]*step, p[2]+f[2]*step);
-    }
-    context.setPositions(positions2);
-    State state2 = context.getState(State::Energy);
-    context.setPositions(positions3);
-    State state3 = context.getState(State::Energy);
-    ASSERT_EQUAL_TOL(norm, (state2.getPotentialEnergy()-state3.getPotentialEnergy())/stepSize, 1e-4);
-}
-
-void validateStillingerWeber(CustomManyParticleForce* force, const vector<Vec3>& positions, const vector<const int*>& expectedSets, double boxSize) {
-    // Create a System and Context.
-    
-    int numParticles = force->getNumParticles();
-    CustomManyParticleForce::NonbondedMethod nonbondedMethod = force->getNonbondedMethod();
-    System system;
-    for (int i = 0; i < numParticles; i++)
-        system.addParticle(1.0);
-    system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize));
-    system.addForce(force);
-    VerletIntegrator integrator(0.001);
-    CpuPlatform platform;
-    Context context(system, integrator, platform);
-    context.setPositions(positions);
-    State state1 = context.getState(State::Forces | State::Energy);
-    double L = context.getParameter("L");
-    double eps = context.getParameter("eps");
-    double a = context.getParameter("a");
-    double gamma = context.getParameter("gamma");
-    double sigma = context.getParameter("sigma");
-    
-    // See if the energy matches the expected value.
-    
-    double expectedEnergy = 0;
-    for (int i = 0; i < (int) expectedSets.size(); i++) {
-        int p1 = expectedSets[i][0];
-        int p2 = expectedSets[i][1];
-        int p3 = expectedSets[i][2];
-        Vec3 d12 = positions[p2]-positions[p1];
-        Vec3 d13 = positions[p3]-positions[p1];
-        Vec3 d23 = positions[p3]-positions[p2];
-        if (nonbondedMethod == CustomManyParticleForce::CutoffPeriodic) {
-            for (int j = 0; j < 3; j++) {
-                d12[j] -= floor(d12[j]/boxSize+0.5f)*boxSize;
-                d13[j] -= floor(d13[j]/boxSize+0.5f)*boxSize;
-                d23[j] -= floor(d23[j]/boxSize+0.5f)*boxSize;
-            }
-        }
-        double r12 = sqrt(d12.dot(d12));
-        double r13 = sqrt(d13.dot(d13));
-        double r23 = sqrt(d23.dot(d23));
-        double ctheta1 = d12.dot(d13)/(r12*r13);
-        double ctheta2 = -d12.dot(d23)/(r12*r23);
-        double ctheta3 = d13.dot(d23)/(r13*r23);
-        expectedEnergy += L*eps*(ctheta1+1.0/3.0)*(ctheta1+1.0/3.0)*exp(sigma*gamma/(r12-a*sigma))*exp(sigma*gamma/(r13-a*sigma));
-    }
-    ASSERT_EQUAL_TOL(expectedEnergy, state1.getPotentialEnergy(), 1e-5);
-
-    // Take a small step in the direction of the energy gradient and see whether the potential energy changes by the expected amount.
-
-    const vector<Vec3>& forces = state1.getForces();
-    double norm = 0.0;
-    for (int i = 0; i < (int) forces.size(); ++i)
-        norm += forces[i].dot(forces[i]);
-    norm = std::sqrt(norm);
-    const double stepSize = 1e-3;
-    double step = 0.5*stepSize/norm;
-    vector<Vec3> positions2(numParticles), positions3(numParticles);
-    for (int i = 0; i < (int) positions.size(); ++i) {
-        Vec3 p = positions[i];
-        Vec3 f = forces[i];
-        positions2[i] = Vec3(p[0]-f[0]*step, p[1]-f[1]*step, p[2]-f[2]*step);
-        positions3[i] = Vec3(p[0]+f[0]*step, p[1]+f[1]*step, p[2]+f[2]*step);
-    }
-    context.setPositions(positions2);
-    State state2 = context.getState(State::Energy);
-    context.setPositions(positions3);
-    State state3 = context.getState(State::Energy);
-    ASSERT_EQUAL_TOL(norm, (state2.getPotentialEnergy()-state3.getPotentialEnergy())/stepSize, 1e-4);
-}
-
-void testNoCutoff() {
-    CustomManyParticleForce* force = new CustomManyParticleForce(3,
-        "C*(1+3*cos(theta1)*cos(theta2)*cos(theta3))/(r12*r13*r23)^3;"
-        "theta1=angle(p1,p2,p3); theta2=angle(p2,p3,p1); theta3=angle(p3,p1,p2);"
-        "r12=distance(p1,p2); r13=distance(p1,p3); r23=distance(p2,p3)");
-    force->addGlobalParameter("C", 1.5);
-    vector<double> params;
-    force->addParticle(params);
-    force->addParticle(params);
-    force->addParticle(params);
-    force->addParticle(params);
-    vector<Vec3> positions;
-    positions.push_back(Vec3(0, 0, 0));
-    positions.push_back(Vec3(1, 0, 0));
-    positions.push_back(Vec3(0, 1.1, 0.3));
-    positions.push_back(Vec3(0.4, 0, -0.8));
-    int sets[4][3] = {{0,1,2}, {1,2,3}, {2,3,0}, {3,0,1}};
-    vector<const int*> expectedSets(&sets[0], &sets[4]);
-    validateAxilrodTeller(force, positions, expectedSets, 2.0, false);
-}
-
-void testCutoff() {
-    CustomManyParticleForce* force = new CustomManyParticleForce(3,
-        "C*(1+3*cos(theta1)*cos(theta2)*cos(theta3))/(r12*r13*r23)^3;"
-        "theta1=angle(p1,p2,p3); theta2=angle(p2,p3,p1); theta3=angle(p3,p1,p2);"
-        "r12=distance(p1,p2); r13=distance(p1,p3); r23=distance(p2,p3)");
-    force->addGlobalParameter("C", 1.5);
-    force->setNonbondedMethod(CustomManyParticleForce::CutoffNonPeriodic);
-    force->setCutoffDistance(1.55);
-    vector<double> params;
-    force->addParticle(params);
-    force->addParticle(params);
-    force->addParticle(params);
-    force->addParticle(params);
-    force->addParticle(params);
-    vector<Vec3> positions;
-    positions.push_back(Vec3(0, 0, 0));
-    positions.push_back(Vec3(1, 0, 0));
-    positions.push_back(Vec3(0, 1.1, 0.3));
-    positions.push_back(Vec3(0.4, 0, -0.8));
-    positions.push_back(Vec3(0.2, 0.5, -0.1));
-    int sets[7][3] = {{0,1,2}, {0,1,3}, {0,1,4}, {0,2,4}, {0,3,4}, {1,2,4}, {1,3,4}};
-    vector<const int*> expectedSets(&sets[0], &sets[7]);
-    validateAxilrodTeller(force, positions, expectedSets, 2.0, false);
-}
-
-void testPeriodic() {
-    CustomManyParticleForce* force = new CustomManyParticleForce(3,
-        "C*(1+3*cos(theta1)*cos(theta2)*cos(theta3))/(r12*r13*r23)^3;"
-        "theta1=angle(p1,p2,p3); theta2=angle(p2,p3,p1); theta3=angle(p3,p1,p2);"
-        "r12=distance(p1,p2); r13=distance(p1,p3); r23=distance(p2,p3)");
-    force->addGlobalParameter("C", 1.5);
-    force->setNonbondedMethod(CustomManyParticleForce::CutoffPeriodic);
-    force->setCutoffDistance(1.05);
-    vector<double> params;
-    force->addParticle(params);
-    force->addParticle(params);
-    force->addParticle(params);
-    force->addParticle(params);
-    force->addParticle(params);
-    vector<Vec3> positions;
-    positions.push_back(Vec3(0, 0, 0));
-    positions.push_back(Vec3(1, 0, 0));
-    positions.push_back(Vec3(0, 1.1, 0.3));
-    positions.push_back(Vec3(0.4, 0, -0.8));
-    positions.push_back(Vec3(0.2, 0.5, -0.1));
-    double boxSize = 2.1;
-    int sets[5][3] = {{0,1,3}, {0,1,4}, {0,2,4}, {0,3,4}, {1,3,4}};
-    vector<const int*> expectedSets(&sets[0], &sets[5]);
-    validateAxilrodTeller(force, positions, expectedSets, boxSize, false);
-}
-
-void testTriclinic() {
-    CustomManyParticleForce* force = new CustomManyParticleForce(3,
-        "C*(1+3*cos(theta1)*cos(theta2)*cos(theta3))/(r12*r13*r23)^3;"
-        "theta1=angle(p1,p2,p3); theta2=angle(p2,p3,p1); theta3=angle(p3,p1,p2);"
-        "r12=distance(p1,p2); r13=distance(p1,p3); r23=distance(p2,p3)");
-    force->addGlobalParameter("C", 1.5);
-    force->setNonbondedMethod(CustomManyParticleForce::CutoffPeriodic);
-    force->setCutoffDistance(1.05);
-    vector<double> params;
-    force->addParticle(params);
-    force->addParticle(params);
-    force->addParticle(params);
-    force->addParticle(params);
-    force->addParticle(params);
-    vector<Vec3> positions;
-    positions.push_back(Vec3(0, 0, 0));
-    positions.push_back(Vec3(1, 0, 0));
-    positions.push_back(Vec3(0, 1.1, 0.3));
-    positions.push_back(Vec3(0.4, 0, -0.8));
-    positions.push_back(Vec3(0.2, 0.5, -0.1));
-    double boxSize = 2.1;
-    int sets[4][3] = {{0,1,3}, {0,1,4}, {0,3,4}, {1,3,4}};
-    vector<const int*> expectedSets(&sets[0], &sets[4]);
-    validateAxilrodTeller(force, positions, expectedSets, boxSize, true);
-}
-
-void testExclusions() {
-    CustomManyParticleForce* force = new CustomManyParticleForce(3,
-        "C*(1+3*cos(theta1)*cos(theta2)*cos(theta3))/(r12*r13*r23)^3;"
-        "theta1=angle(p1,p2,p3); theta2=angle(p2,p3,p1); theta3=angle(p3,p1,p2);"
-        "r12=distance(p1,p2); r13=distance(p1,p3); r23=distance(p2,p3)");
-    force->addGlobalParameter("C", 1.5);
-    vector<double> params;
-    force->addParticle(params);
-    force->addParticle(params);
-    force->addParticle(params);
-    force->addParticle(params);
-    force->addParticle(params);
-    vector<Vec3> positions;
-    positions.push_back(Vec3(0, 0, 0));
-    positions.push_back(Vec3(1, 0, 0));
-    positions.push_back(Vec3(0, 1.1, 0.3));
-    positions.push_back(Vec3(0.4, 0, -0.8));
-    positions.push_back(Vec3(0.2, 0.5, -0.1));
-    force->addExclusion(0, 2);
-    force->addExclusion(0, 3);
-    int sets[5][3] = {{0,1,4}, {1,2,3}, {1,2,4}, {1,3,4}, {2,3,4}};
-    vector<const int*> expectedSets(&sets[0], &sets[5]);
-    validateAxilrodTeller(force, positions, expectedSets, 2.0, false);
-}
-
-void testAllTerms() {
-    int numParticles = 4;
-    CpuPlatform platform;
-    
-    // Create a system with a CustomManyParticleForce.
-    
-    System system1;
-    CustomManyParticleForce* force1 = new CustomManyParticleForce(4,
-        "distance(p1,p2)+angle(p1,p4,p3)+dihedral(p1,p3,p2,p4)+x1+y4+z3");
-    system1.addForce(force1);
-    vector<double> params;
-    for (int i = 0; i < numParticles; i++) {
-        system1.addParticle(1.0);
-        force1->addParticle(params, i);
-    }
-    set<int> filter;
-    filter.insert(0);
-    force1->setTypeFilter(0, filter);
-    filter.clear();
-    filter.insert(1);
-    force1->setTypeFilter(1, filter);
-    filter.clear();
-    filter.insert(3);
-    force1->setTypeFilter(2, filter);
-    filter.clear();
-    filter.insert(2);
-    force1->setTypeFilter(3, filter);
-    
-    // Create a system that use a CustomCompoundBondForce to compute exactly the same interactions.
-    
-    System system2;
-    CustomCompoundBondForce* force2 = new CustomCompoundBondForce(4,
-        "distance(p1,p2)+angle(p1,p3,p4)+dihedral(p1,p4,p2,p3)+x1+y3+z4");
-    system2.addForce(force2);
-    vector<int> particles;
-    particles.push_back(0);
-    particles.push_back(1);
-    particles.push_back(2);
-    particles.push_back(3);
-    force2->addBond(particles, params);
-    for (int i = 0; i < numParticles; i++)
-        system2.addParticle(1.0);
-    
-    // Create contexts for both of them.
-
-    vector<Vec3> positions;
-    OpenMM_SFMT::SFMT sfmt;
-    init_gen_rand(0, sfmt);
-    for (int i = 0; i < numParticles; i++)
-        positions.push_back(Vec3(genrand_real2(sfmt), genrand_real2(sfmt), genrand_real2(sfmt)));
-    VerletIntegrator integrator1(0.001);
-    VerletIntegrator integrator2(0.001);
-    Context context1(system1, integrator1, platform);
-    Context context2(system2, integrator2, platform);
-    context1.setPositions(positions);
-    context2.setPositions(positions);
-    
-    // See if they produce identical forces and energies.
-    
-    State state1 = context1.getState(State::Forces | State::Energy);
-    State state2 = context2.getState(State::Forces | State::Energy);
-    ASSERT_EQUAL_TOL(state2.getPotentialEnergy(), state1.getPotentialEnergy(), 1e-4);
-    for (int i = 0; i < numParticles; i++)
-        ASSERT_EQUAL_VEC(state2.getForces()[i], state1.getForces()[i], 1e-4);
-}
-
-void testParameters() {
-    // Create a system.
-    
-    int numParticles = 5;
-    System system;
-    CustomManyParticleForce* force = new CustomManyParticleForce(3, "C*scale1*scale2*scale3*(distance(p1,p2)+distance(p2,p3)+distance(p1,p3))");
-    force->addGlobalParameter("C", 2.0);
-    force->addPerParticleParameter("scale");
-    vector<double> params(1);
-    vector<Vec3> positions;
-    OpenMM_SFMT::SFMT sfmt;
-    init_gen_rand(0, sfmt);
-    for (int i = 0; i < numParticles; i++) {
-        params[0] = i+1;
-        force->addParticle(params);
-        positions.push_back(Vec3(genrand_real2(sfmt), genrand_real2(sfmt), genrand_real2(sfmt)));
-        system.addParticle(1.0);
-    }
-    system.addForce(force);
-    VerletIntegrator integrator(0.001);
-    CpuPlatform platform;
-    Context context(system, integrator, platform);
-    context.setPositions(positions);
-    
-    // See if the energy is correct.
-
-    State state = context.getState(State::Energy);
-    double expectedEnergy = 0;
-    for (int i = 0; i < numParticles; i++)
-        for (int j = i+1; j < numParticles; j++)
-            for (int k = j+1; k < numParticles; k++) {
-                Vec3 d12 = positions[j]-positions[i];
-                Vec3 d13 = positions[k]-positions[i];
-                Vec3 d23 = positions[k]-positions[j];
-                double r12 = sqrt(d12.dot(d12));
-                double r13 = sqrt(d13.dot(d13));
-                double r23 = sqrt(d23.dot(d23));
-                expectedEnergy += 2.0*(i+1)*(j+1)*(k+1)*(r12+r13+r23);
-            }
-    ASSERT_EQUAL_TOL(expectedEnergy, state.getPotentialEnergy(), 1e-5);
-    
-    // Modify the parameters.
-    
-    context.setParameter("C", 3.5);
-    for (int i = 0; i < numParticles; i++) {
-        params[0] = 0.5*i-0.1;
-        force->setParticleParameters(i, params, 0);
-    }
-    force->updateParametersInContext(context);
-    
-    // See if the energy is still correct.
-    
-    state = context.getState(State::Energy);
-    expectedEnergy = 0;
-    for (int i = 0; i < numParticles; i++)
-        for (int j = i+1; j < numParticles; j++)
-            for (int k = j+1; k < numParticles; k++) {
-                Vec3 d12 = positions[j]-positions[i];
-                Vec3 d13 = positions[k]-positions[i];
-                Vec3 d23 = positions[k]-positions[j];
-                double r12 = sqrt(d12.dot(d12));
-                double r13 = sqrt(d13.dot(d13));
-                double r23 = sqrt(d23.dot(d23));
-                expectedEnergy += 3.5*(0.5*i-0.1)*(0.5*j-0.1)*(0.5*k-0.1)*(r12+r13+r23);
-            }
-    ASSERT_EQUAL_TOL(expectedEnergy, state.getPotentialEnergy(), 1e-5);
-}
-
-void testTabulatedFunctions() {
-    int numParticles = 5;
-    
-    // Create two tabulated functions.
-    
-    vector<double> values;
-    values.push_back(0.0);
-    values.push_back(50.0);
-    Continuous1DFunction* f1 = new Continuous1DFunction(values, 0, 100);
-    OpenMM_SFMT::SFMT sfmt;
-    init_gen_rand(0, sfmt);
-    vector<double> c(numParticles);
-    for (int i = 0; i < numParticles; i++)
-        c[i] = genrand_real2(sfmt);
-    values.resize(numParticles*numParticles*numParticles);
-    for (int i = 0; i < numParticles; i++)
-        for (int j = 0; j < numParticles; j++)
-            for (int k = 0; k < numParticles; k++)
-                values[i+numParticles*j+numParticles*numParticles*k] = c[i]+c[j]+c[k];
-    Discrete3DFunction* f2 = new Discrete3DFunction(numParticles, numParticles, numParticles, values);
-    
-    // Create a system.
-    
-    System system;
-    CustomManyParticleForce* force = new CustomManyParticleForce(3, "f1(distance(p1,p2)+distance(p2,p3)+distance(p1,p3))*f2(atom1, atom2, atom3)");
-    force->addPerParticleParameter("atom");
-    force->addTabulatedFunction("f1", f1);
-    force->addTabulatedFunction("f2", f2);
-    vector<double> params(1);
-    vector<Vec3> positions;
-    for (int i = 0; i < numParticles; i++) {
-        params[0] = i;
-        force->addParticle(params);
-        positions.push_back(Vec3(genrand_real2(sfmt), genrand_real2(sfmt), genrand_real2(sfmt)));
-        system.addParticle(1.0);
-    }
-    system.addForce(force);
-    VerletIntegrator integrator(0.001);
-    CpuPlatform platform;
-    Context context(system, integrator, platform);
-    context.setPositions(positions);
-    
-    // See if the energy is correct.
-
-    State state = context.getState(State::Energy);
-    double expectedEnergy = 0;
-    for (int i = 0; i < numParticles; i++)
-        for (int j = i+1; j < numParticles; j++)
-            for (int k = j+1; k < numParticles; k++) {
-                Vec3 d12 = positions[j]-positions[i];
-                Vec3 d13 = positions[k]-positions[i];
-                Vec3 d23 = positions[k]-positions[j];
-                double r12 = sqrt(d12.dot(d12));
-                double r13 = sqrt(d13.dot(d13));
-                double r23 = sqrt(d23.dot(d23));
-                expectedEnergy += 0.5*(r12+r13+r23)*(c[i]+c[j]+c[k]);
-            }
-    ASSERT_EQUAL_TOL(expectedEnergy, state.getPotentialEnergy(), 1e-5);
-}
-
-void testTypeFilters() {
-    // Create a system.
-    
-    System system;
-    for (int i = 0; i < 5; i++)
-        system.addParticle(1.0);
-    CustomManyParticleForce* force = new CustomManyParticleForce(3, "c1*(distance(p1,p2)+distance(p1,p3))");
-    force->addPerParticleParameter("c");
-    double c[] = {1.0, 2.0, 1.3, 1.5, -2.1};
-    int type[] = {0, 1, 0, 1, 5};
-    vector<double> params(1);
-    for (int i = 0; i < 5; i++) {
-        params[0] = c[i];
-        force->addParticle(params, type[i]);
-    }
-    vector<Vec3> positions;
-    positions.push_back(Vec3(0, 0, 0));
-    positions.push_back(Vec3(1, 0, 0));
-    positions.push_back(Vec3(0, 1.1, 0.3));
-    positions.push_back(Vec3(0.4, 0, -0.8));
-    positions.push_back(Vec3(0.2, 0.5, -0.1));
-    set<int> f1, f2;
-    f1.insert(0);
-    f2.insert(1);
-    f2.insert(5);
-    force->setTypeFilter(0, f1);
-    force->setTypeFilter(1, f2);
-    force->setTypeFilter(2, f2);
-    system.addForce(force);
-    VerletIntegrator integrator(0.001);
-    CpuPlatform platform;
-    Context context(system, integrator, platform);
-    context.setPositions(positions);
-    
-    // See if the energy is correct.
-
-    State state = context.getState(State::Energy);
-    double expectedEnergy = 0;
-    int sets[6][3] = {{0,1,3}, {0,1,4}, {0,3,4}, {2,1,3}, {2,1,4}, {2,3,4}};
-    for (int i = 0; i < 6; i++) {
-        int p1 = sets[i][0];
-        int p2 = sets[i][1];
-        int p3 = sets[i][2];
-            Vec3 d12 = positions[p2]-positions[p1];
-            Vec3 d13 = positions[p3]-positions[p1];
-            double r12 = sqrt(d12.dot(d12));
-            double r13 = sqrt(d13.dot(d13));
-            expectedEnergy += c[p1]*(r12+r13);
-    }
-    ASSERT_EQUAL_TOL(expectedEnergy, state.getPotentialEnergy(), 1e-5);
-}
-
-void testLargeSystem() {
-    int gridSize = 8;
-    int numParticles = gridSize*gridSize*gridSize;
-    double boxSize = 3.0;
-    double spacing = boxSize/gridSize;
-    CpuPlatform platform;
-    CustomManyParticleForce* force = new CustomManyParticleForce(3,
-        "C*(1+3*cos(theta1)*cos(theta2)*cos(theta3))/(r12*r13*r23)^3;"
-        "theta1=angle(p1,p2,p3); theta2=angle(p2,p3,p1); theta3=angle(p3,p1,p2);"
-        "r12=distance(p1,p2); r13=distance(p1,p3); r23=distance(p2,p3)");
-    force->addGlobalParameter("C", 1.5);
-    force->setNonbondedMethod(CustomManyParticleForce::CutoffPeriodic);
-    force->setCutoffDistance(0.6);
-    vector<double> params;
-    vector<Vec3> positions;
-    System system;
-    OpenMM_SFMT::SFMT sfmt;
-    init_gen_rand(0, sfmt);
-    for (int i = 0; i < gridSize; i++)
-        for (int j = 0; j < gridSize; j++)
-            for (int k = 0; k < gridSize; k++) {
-                force->addParticle(params);
-                positions.push_back(Vec3((i+0.4*genrand_real2(sfmt))*spacing, (j+0.4*genrand_real2(sfmt))*spacing, (k+0.4*genrand_real2(sfmt))*spacing));
-                system.addParticle(1.0);
-            }
-    system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize));
-    system.addForce(force);
-    VerletIntegrator integrator1(0.001);
-    VerletIntegrator integrator2(0.001);
-    Context context1(system, integrator1, Platform::getPlatformByName("Reference"));
-    Context context2(system, integrator2, platform);
-    context1.setPositions(positions);
-    context2.setPositions(positions);
-    State state1 = context1.getState(State::Forces | State::Energy);
-    State state2 = context2.getState(State::Forces | State::Energy);
-    ASSERT_EQUAL_TOL(state1.getPotentialEnergy(), state2.getPotentialEnergy(), 1e-4);
-    for (int i = 0; i < numParticles; i++)
-        ASSERT_EQUAL_VEC(state1.getForces()[i], state2.getForces()[i], 1e-4);
-}
-
-void testCentralParticleModeNoCutoff() {
-    CustomManyParticleForce* force = new CustomManyParticleForce(3,
-        "L*eps*(cos(theta1)+1/3)^2*exp(sigma*gamma/(r12-a*sigma))*exp(sigma*gamma/(r13-a*sigma));"
-        "r12 = distance(p1,p2); r13 = distance(p1,p3); theta1 = angle(p3,p1,p2)");
-    force->setPermutationMode(CustomManyParticleForce::UniqueCentralParticle);
-    force->addGlobalParameter("L", 23.13);
-    force->addGlobalParameter("eps", 25.894776);
-    force->addGlobalParameter("a", 1.8);
-    force->addGlobalParameter("sigma", 0.23925);
-    force->addGlobalParameter("gamma", 1.2);
-    vector<double> params;
-    force->addParticle(params);
-    force->addParticle(params);
-    force->addParticle(params);
-    force->addParticle(params);
-    vector<Vec3> positions;
-    positions.push_back(Vec3(0, 0, 0));
-    positions.push_back(Vec3(0.1, 0, 0));
-    positions.push_back(Vec3(0, 0.11, 0.03));
-    positions.push_back(Vec3(0.04, 0, -0.08));
-    int sets[12][3] = {{0,1,2}, {0,1,3}, {0,2,3}, {1,0,2}, {1,0,3}, {1, 2, 3}, {2,0,1}, {2,0,3}, {2, 1, 3}, {3,0,1}, {3,0,2}, {3,1,2}};
-    vector<const int*> expectedSets(&sets[0], &sets[12]);
-    validateStillingerWeber(force, positions, expectedSets, 2.0);
-}
-
-void testCentralParticleModeCutoff() {
-    CustomManyParticleForce* force = new CustomManyParticleForce(3,
-        "L*eps*(cos(theta1)+1/3)^2*exp(sigma*gamma/(r12-a*sigma))*exp(sigma*gamma/(r13-a*sigma));"
-        "r12 = distance(p1,p2); r13 = distance(p1,p3); theta1 = angle(p3,p1,p2)");
-    force->setPermutationMode(CustomManyParticleForce::UniqueCentralParticle);
-    force->addGlobalParameter("L", 23.13);
-    force->addGlobalParameter("eps", 25.894776);
-    force->addGlobalParameter("a", 1.8);
-    force->addGlobalParameter("sigma", 0.23925);
-    force->addGlobalParameter("gamma", 1.2);
-    force->setNonbondedMethod(CustomManyParticleForce::CutoffNonPeriodic);
-    force->setCutoffDistance(0.155);
-    vector<double> params;
-    force->addParticle(params);
-    force->addParticle(params);
-    force->addParticle(params);
-    force->addParticle(params);
-    vector<Vec3> positions;
-    positions.push_back(Vec3(0, 0, 0));
-    positions.push_back(Vec3(0.1, 0, 0));
-    positions.push_back(Vec3(0, 0.11, 0.03));
-    positions.push_back(Vec3(0.04, 0, -0.08));
-    int sets[8][3] = {{0,1,2}, {0,1,3}, {0,2,3}, {1,0,2}, {1,0,3}, {1, 2, 3}, {2,0,1}, {3,0,1}};
-    vector<const int*> expectedSets(&sets[0], &sets[8]);
-    validateStillingerWeber(force, positions, expectedSets, 2.0);
-}
-
-void testCentralParticleModeLargeSystem() {
-    int gridSize = 8;
-    int numParticles = gridSize*gridSize*gridSize;
-    double boxSize = 2.0;
-    double spacing = boxSize/gridSize;
-    CpuPlatform platform;
-    CustomManyParticleForce* force = new CustomManyParticleForce(3,
-        "L*eps*(cos(theta1)+1/3)^2*exp(sigma*gamma/(r12-a*sigma))*exp(sigma*gamma/(r13-a*sigma));"
-        "r12 = distance(p1,p2); r13 = distance(p1,p3); theta1 = angle(p3,p1,p2)");
-    force->setPermutationMode(CustomManyParticleForce::UniqueCentralParticle);
-    force->addGlobalParameter("L", 23.13);
-    force->addGlobalParameter("eps", 25.894776);
-    force->addGlobalParameter("a", 1.8);
-    force->addGlobalParameter("sigma", 0.23925);
-    force->addGlobalParameter("gamma", 1.2);
-    force->setNonbondedMethod(CustomManyParticleForce::CutoffPeriodic);
-    force->setCutoffDistance(1.8*0.23925);
-    vector<double> params;
-    vector<Vec3> positions;
-    System system;
-    OpenMM_SFMT::SFMT sfmt;
-    init_gen_rand(0, sfmt);
-    for (int i = 0; i < gridSize; i++)
-        for (int j = 0; j < gridSize; j++)
-            for (int k = 0; k < gridSize; k++) {
-                force->addParticle(params);
-                positions.push_back(Vec3((i+0.4*genrand_real2(sfmt))*spacing, (j+0.4*genrand_real2(sfmt))*spacing, (k+0.4*genrand_real2(sfmt))*spacing));
-                system.addParticle(1.0);
-            }
-    system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize));
-    system.addForce(force);
-    VerletIntegrator integrator1(0.001);
-    VerletIntegrator integrator2(0.001);
-    Context context1(system, integrator1, Platform::getPlatformByName("Reference"));
-    Context context2(system, integrator2, platform);
-    context1.setPositions(positions);
-    context2.setPositions(positions);
-    State state1 = context1.getState(State::Forces | State::Energy);
-    State state2 = context2.getState(State::Forces | State::Energy);
-    ASSERT_EQUAL_TOL(state1.getPotentialEnergy(), state2.getPotentialEnergy(), 1e-4);
-    for (int i = 0; i < numParticles; i++)
-        ASSERT_EQUAL_VEC(state1.getForces()[i], state2.getForces()[i], 1e-4);
-}
-
-int main() {
-    try {
-        if (!CpuPlatform::isProcessorSupported()) {
-            cout << "CPU is not supported.  Exiting." << endl;
-            return 0;
-        }
-        testNoCutoff();
-        testCutoff();
-        testPeriodic();
-        testTriclinic();
-        testExclusions();
-        testAllTerms();
-        testParameters();
-        testTabulatedFunctions();
-        testTypeFilters();
-        testLargeSystem();
-        testCentralParticleModeNoCutoff();
-        testCentralParticleModeCutoff();
-        testCentralParticleModeLargeSystem();
-    }
-    catch(const exception& e) {
-        cout << "exception: " << e.what() << endl;
-        return 1;
-    }
-    cout << "Done" << endl;
-    return 0;
+void runPlatformTests() {
 }

platforms/cpu/tests/TestCpuCustomNonbondedForce.cpp

-
 /* -------------------------------------------------------------------------- *
  *                                   OpenMM                                   *
  * -------------------------------------------------------------------------- *
@@ -7,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) 2008-2015 Stanford University and the Authors.      *
+ * Portions copyright (c) 2015 Stanford University and the Authors.           *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -30,962 +29,8 @@
  * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
  * -------------------------------------------------------------------------- */
 
-/**
- * This tests all the different force terms in the reference implementation of CustomNonbondedForce.
- */
-
-#ifdef WIN32
-  #define _USE_MATH_DEFINES // Needed to get M_PI
-#endif
-#include "CpuPlatform.h"
-#include "openmm/internal/AssertionUtilities.h"
-#include "openmm/Context.h"
-#include "openmm/CustomNonbondedForce.h"
-#include "openmm/NonbondedForce.h"
-#include "openmm/System.h"
-#include "openmm/VerletIntegrator.h"
-#include "sfmt/SFMT.h"
-#include <cmath>
-#include <iostream>
-#include <set>
-#include <vector>
-
-using namespace OpenMM;
-using namespace std;
-
-CpuPlatform platform;
-
-const double TOL = 1e-5;
-
-void testSimpleExpression() {
-    System system;
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    VerletIntegrator integrator(0.01);
-    CustomNonbondedForce* forceField = new CustomNonbondedForce("-0.1*r^3");
-    forceField->addParticle(vector<double>());
-    forceField->addParticle(vector<double>());
-    system.addForce(forceField);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(2);
-    positions[0] = Vec3(0, 0, 0);
-    positions[1] = Vec3(2, 0, 0);
-    context.setPositions(positions);
-    State state = context.getState(State::Forces | State::Energy);
-    const vector<Vec3>& forces = state.getForces();
-    double force = 0.1*3*(2*2);
-    ASSERT_EQUAL_VEC(Vec3(-force, 0, 0), forces[0], TOL);
-    ASSERT_EQUAL_VEC(Vec3(force, 0, 0), forces[1], TOL);
-    ASSERT_EQUAL_TOL(-0.1*(2*2*2), state.getPotentialEnergy(), TOL);
-}
-
-void testParameters() {
-    System system;
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    VerletIntegrator integrator(0.01);
-    CustomNonbondedForce* forceField = new CustomNonbondedForce("scale*a*(r*b)^3; a=a1*a2; b=c+b1+b2");
-    forceField->addPerParticleParameter("a");
-    forceField->addPerParticleParameter("b");
-    forceField->addGlobalParameter("scale", 3.0);
-    forceField->addGlobalParameter("c", -1.0);
-    vector<double> params(2);
-    params[0] = 1.5;
-    params[1] = 2.0;
-    forceField->addParticle(params);
-    params[0] = 2.0;
-    params[1] = 3.0;
-    forceField->addParticle(params);
-    system.addForce(forceField);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(2);
-    positions[0] = Vec3(0, 0, 0);
-    positions[1] = Vec3(2, 0, 0);
-    context.setPositions(positions);
-    context.setParameter("scale", 1.0);
-    context.setParameter("c", 0.0);
-    State state = context.getState(State::Forces | State::Energy);
-    vector<Vec3> forces = state.getForces();
-    double force = -3.0*3*5.0*(10*10);
-    ASSERT_EQUAL_VEC(Vec3(-force, 0, 0), forces[0], TOL);
-    ASSERT_EQUAL_VEC(Vec3(force, 0, 0), forces[1], TOL);
-    ASSERT_EQUAL_TOL(3.0*(10*10*10), state.getPotentialEnergy(), TOL);
-    
-    // Try changing the global parameters and make sure it's still correct.
-    
-    context.setParameter("scale", 1.5);
-    context.setParameter("c", 1.0);
-    state = context.getState(State::Forces | State::Energy);
-    forces = state.getForces();
-    force = -1.5*3.0*3*6.0*(12*12);
-    ASSERT_EQUAL_VEC(Vec3(-force, 0, 0), forces[0], TOL);
-    ASSERT_EQUAL_VEC(Vec3(force, 0, 0), forces[1], TOL);
-    ASSERT_EQUAL_TOL(1.5*3.0*(12*12*12), state.getPotentialEnergy(), TOL);
-    
-    // Try changing the per-particle parameters and make sure it's still correct.
-    
-    params[0] = 1.6;
-    params[1] = 2.1;
-    forceField->setParticleParameters(0, params);
-    params[0] = 1.9;
-    params[1] = 2.8;
-    forceField->setParticleParameters(1, params);
-    forceField->updateParametersInContext(context);
-    state = context.getState(State::Forces | State::Energy);
-    forces = state.getForces();
-    force = -1.5*1.6*1.9*3*5.9*(11.8*11.8);
-    ASSERT_EQUAL_VEC(Vec3(-force, 0, 0), forces[0], TOL);
-    ASSERT_EQUAL_VEC(Vec3(force, 0, 0), forces[1], TOL);
-    ASSERT_EQUAL_TOL(1.5*1.6*1.9*(11.8*11.8*11.8), state.getPotentialEnergy(), TOL);
-}
-
-void testExclusions() {
-    System system;
-    VerletIntegrator integrator(0.01);
-    CustomNonbondedForce* nonbonded = new CustomNonbondedForce("a*r; a=a1+a2");
-    nonbonded->addPerParticleParameter("a");
-    vector<double> params(1);
-    vector<Vec3> positions(4);
-    for (int i = 0; i < 4; i++) {
-        system.addParticle(1.0);
-        params[0] = i+1;
-        nonbonded->addParticle(params);
-        positions[i] = Vec3(i, 0, 0);
-    }
-    nonbonded->addExclusion(0, 1);
-    nonbonded->addExclusion(1, 2);
-    nonbonded->addExclusion(2, 3);
-    nonbonded->addExclusion(0, 2);
-    nonbonded->addExclusion(1, 3);
-    system.addForce(nonbonded);
-    Context context(system, integrator, platform);
-    context.setPositions(positions);
-    State state = context.getState(State::Forces | State::Energy);
-    const vector<Vec3>& forces = state.getForces();
-    ASSERT_EQUAL_VEC(Vec3(1+4, 0, 0), forces[0], TOL);
-    ASSERT_EQUAL_VEC(Vec3(0, 0, 0), forces[1], TOL);
-    ASSERT_EQUAL_VEC(Vec3(0, 0, 0), forces[2], TOL);
-    ASSERT_EQUAL_VEC(Vec3(-(1+4), 0, 0), forces[3], TOL);
-    ASSERT_EQUAL_TOL((1+4)*3.0, state.getPotentialEnergy(), TOL);
-}
-
-void testCutoff() {
-    System system;
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    VerletIntegrator integrator(0.01);
-    CustomNonbondedForce* forceField = new CustomNonbondedForce("r");
-    forceField->addParticle(vector<double>());
-    forceField->addParticle(vector<double>());
-    forceField->addParticle(vector<double>());
-    forceField->setNonbondedMethod(CustomNonbondedForce::CutoffNonPeriodic);
-    forceField->setCutoffDistance(2.5);
-    system.addForce(forceField);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(3);
-    positions[0] = Vec3(0, 0, 0);
-    positions[1] = Vec3(0, 2, 0);
-    positions[2] = Vec3(0, 3, 0);
-    context.setPositions(positions);
-    State state = context.getState(State::Forces | State::Energy);
-    const vector<Vec3>& forces = state.getForces();
-    ASSERT_EQUAL_VEC(Vec3(0, 1, 0), forces[0], TOL);
-    ASSERT_EQUAL_VEC(Vec3(0, 0, 0), forces[1], TOL);
-    ASSERT_EQUAL_VEC(Vec3(0, -1, 0), forces[2], TOL);
-    ASSERT_EQUAL_TOL(2.0+1.0, state.getPotentialEnergy(), TOL);
-}
-
-void testPeriodic() {
-    System system;
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    VerletIntegrator integrator(0.01);
-    CustomNonbondedForce* forceField = new CustomNonbondedForce("r");
-    forceField->addParticle(vector<double>());
-    forceField->addParticle(vector<double>());
-    forceField->addParticle(vector<double>());
-    forceField->setNonbondedMethod(CustomNonbondedForce::CutoffPeriodic);
-    forceField->setCutoffDistance(2.0);
-    system.setDefaultPeriodicBoxVectors(Vec3(4, 0, 0), Vec3(0, 4, 0), Vec3(0, 0, 4));
-    system.addForce(forceField);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(3);
-    positions[0] = Vec3(0, 0, 0);
-    positions[1] = Vec3(0, 2.1, 0);
-    positions[2] = Vec3(0, 3, 0);
-    context.setPositions(positions);
-    State state = context.getState(State::Forces | State::Energy);
-    const vector<Vec3>& forces = state.getForces();
-    ASSERT_EQUAL_VEC(Vec3(0, -2, 0), forces[0], TOL);
-    ASSERT_EQUAL_VEC(Vec3(0, 2, 0), forces[1], TOL);
-    ASSERT_EQUAL_VEC(Vec3(0, 0, 0), forces[2], TOL);
-    ASSERT_EQUAL_TOL(1.9+1+0.9, state.getPotentialEnergy(), TOL);
-}
-
-void testTriclinic() {
-    System system;
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    Vec3 a(3.1, 0, 0);
-    Vec3 b(0.4, 3.5, 0);
-    Vec3 c(-0.1, -0.5, 4.0);
-    system.setDefaultPeriodicBoxVectors(a, b, c);
-    VerletIntegrator integrator(0.01);
-    CustomNonbondedForce* nonbonded = new CustomNonbondedForce("r");
-    nonbonded->addParticle(vector<double>());
-    nonbonded->addParticle(vector<double>());
-    nonbonded->setNonbondedMethod(CustomNonbondedForce::CutoffPeriodic);
-    const double cutoff = 1.5;
-    nonbonded->setCutoffDistance(cutoff);
-    system.addForce(nonbonded);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(2);
-    OpenMM_SFMT::SFMT sfmt;
-    init_gen_rand(0, sfmt);
-    for (int iteration = 0; iteration < 50; iteration++) {
-        // Generate random positions for the two particles.
-
-        positions[0] = a*genrand_real2(sfmt) + b*genrand_real2(sfmt) + c*genrand_real2(sfmt);
-        positions[1] = a*genrand_real2(sfmt) + b*genrand_real2(sfmt) + c*genrand_real2(sfmt);
-        context.setPositions(positions);
-
-        // Loop over all possible periodic copies and find the nearest one.
-
-        Vec3 delta;
-        double distance2 = 100.0;
-        for (int i = -1; i < 2; i++)
-            for (int j = -1; j < 2; j++)
-                for (int k = -1; k < 2; k++) {
-                    Vec3 d = positions[1]-positions[0]+a*i+b*j+c*k;
-                    if (d.dot(d) < distance2) {
-                        delta = d;
-                        distance2 = d.dot(d);
-                    }
-                }
-        double distance = sqrt(distance2);
-
-        // See if the force and energy are correct.
-
-        State state = context.getState(State::Forces | State::Energy);
-        if (distance >= cutoff) {
-            ASSERT_EQUAL(0.0, state.getPotentialEnergy());
-            ASSERT_EQUAL_VEC(Vec3(0, 0, 0), state.getForces()[0], 0);
-            ASSERT_EQUAL_VEC(Vec3(0, 0, 0), state.getForces()[1], 0);
-        }
-        else {
-            const Vec3 force = delta/sqrt(delta.dot(delta));
-            ASSERT_EQUAL_TOL(distance, state.getPotentialEnergy(), TOL);
-            ASSERT_EQUAL_VEC(force, state.getForces()[0], TOL);
-            ASSERT_EQUAL_VEC(-force, state.getForces()[1], TOL);
-        }
-    }
-}
-
-void testContinuous1DFunction() {
-    System system;
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    VerletIntegrator integrator(0.01);
-    CustomNonbondedForce* forceField = new CustomNonbondedForce("fn(r)+1");
-    forceField->addParticle(vector<double>());
-    forceField->addParticle(vector<double>());
-    vector<double> table;
-    for (int i = 0; i < 21; i++)
-        table.push_back(sin(0.25*i));
-    forceField->addTabulatedFunction("fn", new Continuous1DFunction(table, 1.0, 6.0));
-    system.addForce(forceField);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(2);
-    positions[0] = Vec3(0, 0, 0);
-    for (int i = 1; i < 30; i++) {
-        double x = (7.0/30.0)*i;
-        positions[1] = Vec3(x, 0, 0);
-        context.setPositions(positions);
-        State state = context.getState(State::Forces | State::Energy);
-        const vector<Vec3>& forces = state.getForces();
-        double force = (x < 1.0 || x > 6.0 ? 0.0 : -cos(x-1.0));
-        double energy = (x < 1.0 || x > 6.0 ? 0.0 : sin(x-1.0))+1.0;
-        ASSERT_EQUAL_VEC(Vec3(-force, 0, 0), forces[0], 0.1);
-        ASSERT_EQUAL_VEC(Vec3(force, 0, 0), forces[1], 0.1);
-        ASSERT_EQUAL_TOL(energy, state.getPotentialEnergy(), 0.02);
-    }
-    for (int i = 1; i < 20; i++) {
-        double x = 0.25*i+1.0;
-        positions[1] = Vec3(x, 0, 0);
-        context.setPositions(positions);
-        State state = context.getState(State::Energy);
-        double energy = (x < 1.0 || x > 6.0 ? 0.0 : sin(x-1.0))+1.0;
-        ASSERT_EQUAL_TOL(energy, state.getPotentialEnergy(), 1e-4);
-    }
-}
-
-void testContinuous2DFunction() {
-    const int xsize = 20;
-    const int ysize = 21;
-    const double xmin = 0.4;
-    const double xmax = 1.5;
-    const double ymin = 0.0;
-    const double ymax = 2.1;
-    System system;
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    VerletIntegrator integrator(0.01);
-    CustomNonbondedForce* forceField = new CustomNonbondedForce("fn(r,a)+1");
-    forceField->addGlobalParameter("a", 0.0);
-    forceField->addParticle(vector<double>());
-    forceField->addParticle(vector<double>());
-    vector<double> table(xsize*ysize);
-    for (int i = 0; i < xsize; i++) {
-        for (int j = 0; j < ysize; j++) {
-            double x = xmin + i*(xmax-xmin)/xsize;
-            double y = ymin + j*(ymax-ymin)/ysize;
-            table[i+xsize*j] = sin(0.25*x)*cos(0.33*y);
-        }
-    }
-    forceField->addTabulatedFunction("fn", new Continuous2DFunction(xsize, ysize, table, xmin, xmax, ymin, ymax));
-    system.addForce(forceField);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(2);
-    positions[0] = Vec3(0, 0, 0);
-    for (double x = xmin-0.15; x < xmax+0.2; x += 0.1) {
-        for (double y = ymin-0.15; y < ymax+0.2; y += 0.1) {
-            positions[1] = Vec3(x, 0, 0);
-            context.setParameter("a", y);
-            context.setPositions(positions);
-            State state = context.getState(State::Forces | State::Energy);
-            const vector<Vec3>& forces = state.getForces();
-            double energy = 1;
-            double force = 0;
-            if (x >= xmin && x <= xmax && y >= ymin && y <= ymax) {
-                energy = sin(0.25*x)*cos(0.33*y)+1.0;
-                force = -0.25*cos(0.25*x)*cos(0.33*y);
-            }
-            ASSERT_EQUAL_VEC(Vec3(-force, 0, 0), forces[0], 0.1);
-            ASSERT_EQUAL_VEC(Vec3(force, 0, 0), forces[1], 0.1);
-            ASSERT_EQUAL_TOL(energy, state.getPotentialEnergy(), 0.02);
-        }
-    }
-}
-
-void testContinuous3DFunction() {
-    const int xsize = 10;
-    const int ysize = 11;
-    const int zsize = 12;
-    const double xmin = 0.4;
-    const double xmax = 1.1;
-    const double ymin = 0.0;
-    const double ymax = 0.9;
-    const double zmin = 0.2;
-    const double zmax = 1.3;
-    System system;
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    VerletIntegrator integrator(0.01);
-    CustomNonbondedForce* forceField = new CustomNonbondedForce("fn(r,a,b)+1");
-    forceField->addGlobalParameter("a", 0.0);
-    forceField->addGlobalParameter("b", 0.0);
-    forceField->addParticle(vector<double>());
-    forceField->addParticle(vector<double>());
-    vector<double> table(xsize*ysize*zsize);
-    for (int i = 0; i < xsize; i++) {
-        for (int j = 0; j < ysize; j++) {
-            for (int k = 0; k < zsize; k++) {
-                double x = xmin + i*(xmax-xmin)/xsize;
-                double y = ymin + j*(ymax-ymin)/ysize;
-                double z = zmin + k*(zmax-zmin)/zsize;
-                table[i+xsize*j+xsize*ysize*k] = sin(0.25*x)*cos(0.33*y)*(1+z);
-            }
-        }
-    }
-    forceField->addTabulatedFunction("fn", new Continuous3DFunction(xsize, ysize, zsize, table, xmin, xmax, ymin, ymax, zmin, zmax));
-    system.addForce(forceField);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(2);
-    positions[0] = Vec3(0, 0, 0);
-    for (double x = xmin-0.15; x < xmax+0.2; x += 0.1) {
-        for (double y = ymin-0.15; y < ymax+0.2; y += 0.1) {
-            for (double z = zmin-0.15; z < zmax+0.2; z += 0.1) {
-                positions[1] = Vec3(x, 0, 0);
-                context.setParameter("a", y);
-                context.setParameter("b", z);
-                context.setPositions(positions);
-                State state = context.getState(State::Forces | State::Energy);
-                const vector<Vec3>& forces = state.getForces();
-                double energy = 1;
-                double force = 0;
-                if (x >= xmin && x <= xmax && y >= ymin && y <= ymax && z >= zmin && z <= zmax) {
-                    energy = sin(0.25*x)*cos(0.33*y)*(1.0+z)+1.0;
-                    force = -0.25*cos(0.25*x)*cos(0.33*y)*(1.0+z);
-                }
-                ASSERT_EQUAL_VEC(Vec3(-force, 0, 0), forces[0], 0.1);
-                ASSERT_EQUAL_VEC(Vec3(force, 0, 0), forces[1], 0.1);
-                ASSERT_EQUAL_TOL(energy, state.getPotentialEnergy(), 0.05);
-            }
-        }
-    }
-}
-
-void testDiscrete1DFunction() {
-    System system;
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    VerletIntegrator integrator(0.01);
-    CustomNonbondedForce* forceField = new CustomNonbondedForce("fn(r)+1");
-    forceField->addParticle(vector<double>());
-    forceField->addParticle(vector<double>());
-    vector<double> table;
-    for (int i = 0; i < 21; i++)
-        table.push_back(sin(0.25*i));
-    forceField->addTabulatedFunction("fn", new Discrete1DFunction(table));
-    system.addForce(forceField);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(2);
-    positions[0] = Vec3(0, 0, 0);
-    for (int i = 0; i < (int) table.size(); i++) {
-        positions[1] = Vec3(i, 0, 0);
-        context.setPositions(positions);
-        State state = context.getState(State::Forces | State::Energy);
-        const vector<Vec3>& forces = state.getForces();
-        ASSERT_EQUAL_VEC(Vec3(0, 0, 0), forces[0], 1e-6);
-        ASSERT_EQUAL_VEC(Vec3(0, 0, 0), forces[1], 1e-6);
-        ASSERT_EQUAL_TOL(table[i]+1.0, state.getPotentialEnergy(), 1e-6);
-    }
-}
-
-void testDiscrete2DFunction() {
-    const int xsize = 10;
-    const int ysize = 5;
-    System system;
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    VerletIntegrator integrator(0.01);
-    CustomNonbondedForce* forceField = new CustomNonbondedForce("fn(r,a)+1");
-    forceField->addGlobalParameter("a", 0.0);
-    forceField->addParticle(vector<double>());
-    forceField->addParticle(vector<double>());
-    vector<double> table;
-    for (int i = 0; i < xsize; i++)
-        for (int j = 0; j < ysize; j++)
-            table.push_back(sin(0.25*i)+cos(0.33*j));
-    forceField->addTabulatedFunction("fn", new Discrete2DFunction(xsize, ysize, table));
-    system.addForce(forceField);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(2);
-    positions[0] = Vec3(0, 0, 0);
-    for (int i = 0; i < (int) table.size(); i++) {
-        positions[1] = Vec3(i%xsize, 0, 0);
-        context.setPositions(positions);
-        context.setParameter("a", i/xsize);
-        State state = context.getState(State::Forces | State::Energy);
-        const vector<Vec3>& forces = state.getForces();
-        ASSERT_EQUAL_VEC(Vec3(0, 0, 0), forces[0], 1e-6);
-        ASSERT_EQUAL_VEC(Vec3(0, 0, 0), forces[1], 1e-6);
-        ASSERT_EQUAL_TOL(table[i]+1.0, state.getPotentialEnergy(), 1e-6);
-    }
-}
-
-void testDiscrete3DFunction() {
-    const int xsize = 8;
-    const int ysize = 5;
-    const int zsize = 6;
-    System system;
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    VerletIntegrator integrator(0.01);
-    CustomNonbondedForce* forceField = new CustomNonbondedForce("fn(r,a,b)+1");
-    forceField->addGlobalParameter("a", 0.0);
-    forceField->addGlobalParameter("b", 0.0);
-    forceField->addParticle(vector<double>());
-    forceField->addParticle(vector<double>());
-    vector<double> table;
-    for (int i = 0; i < xsize; i++)
-        for (int j = 0; j < ysize; j++)
-            for (int k = 0; k < zsize; k++)
-                table.push_back(sin(0.25*i)+cos(0.33*j)+0.12345*k);
-    forceField->addTabulatedFunction("fn", new Discrete3DFunction(xsize, ysize, zsize, table));
-    system.addForce(forceField);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(2);
-    positions[0] = Vec3(0, 0, 0);
-    for (int i = 0; i < (int) table.size(); i++) {
-        positions[1] = Vec3(i%xsize, 0, 0);
-        context.setPositions(positions);
-        context.setParameter("a", (i/xsize)%ysize);
-        context.setParameter("b", i/(xsize*ysize));
-        State state = context.getState(State::Forces | State::Energy);
-        const vector<Vec3>& forces = state.getForces();
-        ASSERT_EQUAL_VEC(Vec3(0, 0, 0), forces[0], 1e-6);
-        ASSERT_EQUAL_VEC(Vec3(0, 0, 0), forces[1], 1e-6);
-        ASSERT_EQUAL_TOL(table[i]+1.0, state.getPotentialEnergy(), 1e-6);
-    }
-}
-
-void testCoulombLennardJones() {
-    const int numMolecules = 300;
-    const int numParticles = numMolecules*2;
-    const double boxSize = 20.0;
-
-    // Create two systems: one with a NonbondedForce, and one using a CustomNonbondedForce to implement the same interaction.
-
-    System standardSystem;
-    System customSystem;
-    for (int i = 0; i < numParticles; i++) {
-        standardSystem.addParticle(1.0);
-        customSystem.addParticle(1.0);
-    }
-    NonbondedForce* standardNonbonded = new NonbondedForce();
-    CustomNonbondedForce* customNonbonded = new CustomNonbondedForce("4*eps*((sigma/r)^12-(sigma/r)^6)+138.935456*q/r; q=q1*q2; sigma=0.5*(sigma1+sigma2); eps=sqrt(eps1*eps2)");
-    customNonbonded->addPerParticleParameter("q");
-    customNonbonded->addPerParticleParameter("sigma");
-    customNonbonded->addPerParticleParameter("eps");
-    vector<Vec3> positions(numParticles);
-    vector<Vec3> velocities(numParticles);
-    OpenMM_SFMT::SFMT sfmt;
-    init_gen_rand(0, sfmt);
-
-    vector<double> params(3);
-    for (int i = 0; i < numMolecules; i++) {
-        if (i < numMolecules/2) {
-            standardNonbonded->addParticle(1.0, 0.2, 0.1);
-            params[0] = 1.0;
-            params[1] = 0.2;
-            params[2] = 0.1;
-            customNonbonded->addParticle(params);
-            standardNonbonded->addParticle(-1.0, 0.1, 0.1);
-            params[0] = -1.0;
-            params[1] = 0.1;
-            customNonbonded->addParticle(params);
-        }
-        else {
-            standardNonbonded->addParticle(1.0, 0.2, 0.2);
-            params[0] = 1.0;
-            params[1] = 0.2;
-            params[2] = 0.2;
-            customNonbonded->addParticle(params);
-            standardNonbonded->addParticle(-1.0, 0.1, 0.2);
-            params[0] = -1.0;
-            params[1] = 0.1;
-            customNonbonded->addParticle(params);
-        }
-        positions[2*i] = Vec3(boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt));
-        positions[2*i+1] = Vec3(positions[2*i][0]+1.0, positions[2*i][1], positions[2*i][2]);
-        velocities[2*i] = Vec3(genrand_real2(sfmt), genrand_real2(sfmt), genrand_real2(sfmt));
-        velocities[2*i+1] = Vec3(genrand_real2(sfmt), genrand_real2(sfmt), genrand_real2(sfmt));
-        standardNonbonded->addException(2*i, 2*i+1, 0.0, 1.0, 0.0);
-        customNonbonded->addExclusion(2*i, 2*i+1);
-    }
-    standardNonbonded->setNonbondedMethod(NonbondedForce::NoCutoff);
-    customNonbonded->setNonbondedMethod(CustomNonbondedForce::NoCutoff);
-    standardSystem.addForce(standardNonbonded);
-    customSystem.addForce(customNonbonded);
-    VerletIntegrator integrator1(0.01);
-    VerletIntegrator integrator2(0.01);
-    Context context1(standardSystem, integrator1, platform);
-    Context context2(customSystem, integrator2, platform);
-    context1.setPositions(positions);
-    context2.setPositions(positions);
-    context1.setVelocities(velocities);
-    context2.setVelocities(velocities);
-    State state1 = context1.getState(State::Forces | State::Energy);
-    State state2 = context2.getState(State::Forces | State::Energy);
-    ASSERT_EQUAL_TOL(state1.getPotentialEnergy(), state2.getPotentialEnergy(), 1e-4);
-    for (int i = 0; i < numParticles; i++) {
-        ASSERT_EQUAL_VEC(state1.getForces()[i], state2.getForces()[i], 1e-4);
-    }
-}
-
-void testSwitchingFunction() {
-    System system;
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    VerletIntegrator integrator(0.01);
-    CustomNonbondedForce* nonbonded = new CustomNonbondedForce("10/r^2");
-    vector<double> params;
-    nonbonded->addParticle(params);
-    nonbonded->addParticle(params);
-    nonbonded->setNonbondedMethod(CustomNonbondedForce::CutoffNonPeriodic);
-    nonbonded->setCutoffDistance(2.0);
-    nonbonded->setUseSwitchingFunction(true);
-    nonbonded->setSwitchingDistance(1.5);
-    system.addForce(nonbonded);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(2);
-    positions[0] = Vec3(0, 0, 0);
-    
-    // Compute the interaction at various distances.
-    
-    for (double r = 1.0; r < 2.5; r += 0.1) {
-        positions[1] = Vec3(r, 0, 0);
-        context.setPositions(positions);
-        State state = context.getState(State::Forces | State::Energy);
-        
-        // See if the energy is correct.
-        
-        double expectedEnergy = 10/(r*r);
-        double switchValue;
-        if (r <= 1.5)
-            switchValue = 1;
-        else if (r >= 2.0)
-            switchValue = 0;
-        else {
-            double t = (r-1.5)/0.5;
-            switchValue = 1+t*t*t*(-10+t*(15-t*6));
-        }
-        ASSERT_EQUAL_TOL(switchValue*expectedEnergy, state.getPotentialEnergy(), TOL);
-        
-        // See if the force is the gradient of the energy.
-        
-        double delta = 1e-3;
-        positions[1] = Vec3(r-delta, 0, 0);
-        context.setPositions(positions);
-        double e1 = context.getState(State::Energy).getPotentialEnergy();
-        positions[1] = Vec3(r+delta, 0, 0);
-        context.setPositions(positions);
-        double e2 = context.getState(State::Energy).getPotentialEnergy();
-        ASSERT_EQUAL_TOL((e2-e1)/(2*delta), state.getForces()[0][0], 1e-3);
-    }
-}
-
-void testLongRangeCorrection() {
-    // Create a box of particles.
-
-    int gridSize = 5;
-    int numParticles = gridSize*gridSize*gridSize;
-    double boxSize = gridSize*0.7;
-    double cutoff = boxSize/3;
-    System standardSystem;
-    System customSystem;
-    VerletIntegrator integrator1(0.01);
-    VerletIntegrator integrator2(0.01);
-    NonbondedForce* standardNonbonded = new NonbondedForce();
-    CustomNonbondedForce* customNonbonded = new CustomNonbondedForce("4*eps*((sigma/r)^12-(sigma/r)^6); sigma=0.5*(sigma1+sigma2); eps=sqrt(eps1*eps2)");
-    customNonbonded->addPerParticleParameter("sigma");
-    customNonbonded->addPerParticleParameter("eps");
-    vector<Vec3> positions(numParticles);
-    int index = 0;
-    vector<double> params1(2);
-    params1[0] = 1.1;
-    params1[1] = 0.5;
-    vector<double> params2(2);
-    params2[0] = 1;
-    params2[1] = 1;
-    for (int i = 0; i < gridSize; i++)
-        for (int j = 0; j < gridSize; j++)
-            for (int k = 0; k < gridSize; k++) {
-                standardSystem.addParticle(1.0);
-                customSystem.addParticle(1.0);
-                if (index%2 == 0) {
-                    standardNonbonded->addParticle(0, params1[0], params1[1]);
-                    customNonbonded->addParticle(params1);
-                }
-                else {
-                    standardNonbonded->addParticle(0, params2[0], params2[1]);
-                    customNonbonded->addParticle(params2);
-                }
-                positions[index] = Vec3(i*boxSize/gridSize, j*boxSize/gridSize, k*boxSize/gridSize);
-                index++;
-            }
-    standardNonbonded->setNonbondedMethod(NonbondedForce::CutoffPeriodic);
-    customNonbonded->setNonbondedMethod(CustomNonbondedForce::CutoffPeriodic);
-    standardNonbonded->setCutoffDistance(cutoff);
-    customNonbonded->setCutoffDistance(cutoff);
-    standardSystem.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize));
-    customSystem.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize));
-    standardNonbonded->setUseDispersionCorrection(true);
-    customNonbonded->setUseLongRangeCorrection(true);
-    standardNonbonded->setUseSwitchingFunction(true);
-    customNonbonded->setUseSwitchingFunction(true);
-    standardNonbonded->setSwitchingDistance(0.8*cutoff);
-    customNonbonded->setSwitchingDistance(0.8*cutoff);
-    standardSystem.addForce(standardNonbonded);
-    customSystem.addForce(customNonbonded);
-
-    // Compute the correction for the standard force.
-
-    Context context1(standardSystem, integrator1, platform);
-    context1.setPositions(positions);
-    double standardEnergy1 = context1.getState(State::Energy).getPotentialEnergy();
-    standardNonbonded->setUseDispersionCorrection(false);
-    context1.reinitialize();
-    context1.setPositions(positions);
-    double standardEnergy2 = context1.getState(State::Energy).getPotentialEnergy();
-
-    // Compute the correction for the custom force.
-
-    Context context2(customSystem, integrator2, platform);
-    context2.setPositions(positions);
-    double customEnergy1 = context2.getState(State::Energy).getPotentialEnergy();
-    customNonbonded->setUseLongRangeCorrection(false);
-    context2.reinitialize();
-    context2.setPositions(positions);
-    double customEnergy2 = context2.getState(State::Energy).getPotentialEnergy();
-
-    // See if they agree.
-
-    ASSERT_EQUAL_TOL(standardEnergy1-standardEnergy2, customEnergy1-customEnergy2, 1e-4);
-}
-
-void testInteractionGroups() {
-    const int numParticles = 6;
-    System system;
-    VerletIntegrator integrator(0.01);
-    CustomNonbondedForce* nonbonded = new CustomNonbondedForce("v1+v2");
-    nonbonded->addPerParticleParameter("v");
-    vector<double> params(1, 0.001);
-    for (int i = 0; i < numParticles; i++) {
-        system.addParticle(1.0);
-        nonbonded->addParticle(params);
-        params[0] *= 10;
-    }
-    set<int> set1, set2, set3, set4;
-    set1.insert(2);
-    set2.insert(0);
-    set2.insert(1);
-    set2.insert(2);
-    set2.insert(3);
-    set2.insert(4);
-    set2.insert(5);
-    nonbonded->addInteractionGroup(set1, set2); // Particle 2 interacts with every other particle.
-    set3.insert(0);
-    set3.insert(1);
-    set4.insert(4);
-    set4.insert(5);
-    nonbonded->addInteractionGroup(set3, set4); // Particles 0 and 1 interact with 4 and 5.
-    nonbonded->addExclusion(1, 2); // Add an exclusion to make sure it gets skipped.
-    system.addForce(nonbonded);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(numParticles);
-    context.setPositions(positions);
-    State state = context.getState(State::Energy);
-    double expectedEnergy = 331.423; // Each digit is the number of interactions a particle particle is involved in.
-    ASSERT_EQUAL_TOL(expectedEnergy, state.getPotentialEnergy(), TOL);
-}
-
-void testLargeInteractionGroup() {
-    const int numMolecules = 300;
-    const int numParticles = numMolecules*2;
-    const double boxSize = 20.0;
-    
-    // Create a large system.
-    
-    System system;
-    system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize));
-    for (int i = 0; i < numParticles; i++)
-        system.addParticle(1.0);
-    CustomNonbondedForce* nonbonded = new CustomNonbondedForce("4*eps*((sigma/r)^12-(sigma/r)^6)+138.935456*q/r; q=q1*q2; sigma=0.5*(sigma1+sigma2); eps=sqrt(eps1*eps2)");
-    nonbonded->addPerParticleParameter("q");
-    nonbonded->addPerParticleParameter("sigma");
-    nonbonded->addPerParticleParameter("eps");
-    vector<Vec3> positions(numParticles);
-    OpenMM_SFMT::SFMT sfmt;
-    init_gen_rand(0, sfmt);
-    vector<double> params(3);
-    for (int i = 0; i < numMolecules; i++) {
-        if (i < numMolecules/2) {
-            params[0] = 1.0;
-            params[1] = 0.2;
-            params[2] = 0.1;
-            nonbonded->addParticle(params);
-            params[0] = -1.0;
-            params[1] = 0.1;
-            nonbonded->addParticle(params);
-        }
-        else {
-            params[0] = 1.0;
-            params[1] = 0.2;
-            params[2] = 0.2;
-            nonbonded->addParticle(params);
-            params[0] = -1.0;
-            params[1] = 0.1;
-            nonbonded->addParticle(params);
-        }
-        positions[2*i] = Vec3(boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt));
-        positions[2*i+1] = Vec3(positions[2*i][0]+1.0, positions[2*i][1], positions[2*i][2]);
-        nonbonded->addExclusion(2*i, 2*i+1);
-    }
-    nonbonded->setNonbondedMethod(CustomNonbondedForce::CutoffPeriodic);
-    system.addForce(nonbonded);
-    
-    // Compute the forces.
-    
-    VerletIntegrator integrator(0.01);
-    Context context(system, integrator, platform);
-    context.setPositions(positions);
-    State state1 = context.getState(State::Forces);
-    
-    // Modify the force so only one particle interacts with everything else.
-    
-    set<int> set1, set2;
-    set1.insert(151);
-    for (int i = 0; i < numParticles; i++)
-        set2.insert(i);
-    nonbonded->addInteractionGroup(set1, set2);
-    context.reinitialize();
-    context.setPositions(positions);
-    State state2 = context.getState(State::Forces);
-    
-    // The force on that one particle should be the same.
-    
-    ASSERT_EQUAL_VEC(state1.getForces()[151], state2.getForces()[151], 1e-4);
-    
-    // Modify the interaction group so it includes all interactions.  This should now reproduce the original forces
-    // on all atoms.
-
-    for (int i = 0; i < numParticles; i++)
-        set1.insert(i);
-    nonbonded->setInteractionGroupParameters(0, set1, set2);
-    context.reinitialize();
-    context.setPositions(positions);
-    State state3 = context.getState(State::Forces);
-    for (int i = 0; i < numParticles; i++)
-        ASSERT_EQUAL_VEC(state1.getForces()[i], state3.getForces()[i], 1e-4);
-}
-
-void testInteractionGroupLongRangeCorrection() {
-    const int numParticles = 10;
-    const double boxSize = 10.0;
-    const double cutoff = 0.5;
-    System system;
-    system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize));
-    CustomNonbondedForce* nonbonded = new CustomNonbondedForce("c1*c2*r^-4");
-    nonbonded->addPerParticleParameter("c");
-    vector<Vec3> positions(numParticles);
-    vector<double> params(1);
-    for (int i = 0; i < numParticles; i++) {
-        system.addParticle(1.0);
-        params[0] = (i%2 == 0 ? 1.1 : 2.0);
-        nonbonded->addParticle(params);
-        positions[i] = Vec3(0.5*i, 0, 0);
-    }
-    nonbonded->setNonbondedMethod(CustomNonbondedForce::CutoffPeriodic);
-    nonbonded->setCutoffDistance(cutoff);
-    system.addForce(nonbonded);
-    
-    // Setup nonbonded groups.  They involve 1 interaction of type AA,
-    // 2 of type BB, and 5 of type AB.
-    
-    set<int> set1, set2, set3, set4, set5;
-    set1.insert(0);
-    set1.insert(1);
-    set1.insert(2);
-    nonbonded->addInteractionGroup(set1, set1);
-    set2.insert(3);
-    set3.insert(4);
-    set3.insert(6);
-    set3.insert(8);
-    nonbonded->addInteractionGroup(set2, set3);
-    set4.insert(5);
-    set5.insert(7);
-    set5.insert(9);
-    nonbonded->addInteractionGroup(set4, set5);
-    
-    // Compute energy with and without the correction.
-    
-    VerletIntegrator integrator(0.01);
-    Context context(system, integrator, platform);
-    context.setPositions(positions);
-    double energy1 = context.getState(State::Energy).getPotentialEnergy();
-    nonbonded->setUseLongRangeCorrection(true);
-    context.reinitialize();
-    context.setPositions(positions);
-    double energy2 = context.getState(State::Energy).getPotentialEnergy();
-    
-    // Check the result.
-    
-    double sum = (1.1*1.1 + 2*2.0*2.0 + 5*1.1*2.0)*2.0;
-    int numPairs = (numParticles*(numParticles+1))/2;
-    double expected = 2*M_PI*numParticles*numParticles*sum/(numPairs*boxSize*boxSize*boxSize);
-    ASSERT_EQUAL_TOL(expected, energy2-energy1, 1e-4);
-}
-
-void testMultipleCutoffs() {
-    System system;
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    VerletIntegrator integrator(0.01);
-    
-    // Add multiple nonbonded forces that have different cutoffs.
-    
-    CustomNonbondedForce* nonbonded1 = new CustomNonbondedForce("2*r");
-    nonbonded1->addParticle(vector<double>());
-    nonbonded1->addParticle(vector<double>());
-    nonbonded1->setNonbondedMethod(CustomNonbondedForce::CutoffNonPeriodic);
-    nonbonded1->setCutoffDistance(2.5);
-    system.addForce(nonbonded1);
-    CustomNonbondedForce* nonbonded2 = new CustomNonbondedForce("3*r");
-    nonbonded2->addParticle(vector<double>());
-    nonbonded2->addParticle(vector<double>());
-    nonbonded2->setNonbondedMethod(CustomNonbondedForce::CutoffNonPeriodic);
-    nonbonded2->setCutoffDistance(2.9);
-    nonbonded2->setForceGroup(1);
-    system.addForce(nonbonded2);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(2);
-    positions[0] = Vec3(0, 0, 0);
-    positions[1] = Vec3(0, 0, 0);
-    for (double r = 2.4; r < 3.2; r += 0.2) {
-        positions[1][1] = r;
-        context.setPositions(positions);
-        double e1 = (r < 2.5 ? 2.0*r : 0.0);
-        double e2 = (r < 2.9 ? 3.0*r : 0.0);
-        double f1 = (r < 2.5 ? 2.0 : 0.0);
-        double f2 = (r < 2.9 ? 3.0 : 0.0);
-        
-        // Check the first force.
-        
-        State state = context.getState(State::Forces | State::Energy, false, 1);
-        ASSERT_EQUAL_VEC(Vec3(0, f1, 0), state.getForces()[0], TOL);
-        ASSERT_EQUAL_VEC(Vec3(0, -f1, 0), state.getForces()[1], TOL);
-        ASSERT_EQUAL_TOL(e1, state.getPotentialEnergy(), TOL);
-        
-        // Check the second force.
-        
-        state = context.getState(State::Forces | State::Energy, false, 2);
-        ASSERT_EQUAL_VEC(Vec3(0, f2, 0), state.getForces()[0], TOL);
-        ASSERT_EQUAL_VEC(Vec3(0, -f2, 0), state.getForces()[1], TOL);
-        ASSERT_EQUAL_TOL(e2, state.getPotentialEnergy(), TOL);
-        
-        // Check the sum of both forces.
-
-        state = context.getState(State::Forces | State::Energy);
-        ASSERT_EQUAL_VEC(Vec3(0, f1+f2, 0), state.getForces()[0], TOL);
-        ASSERT_EQUAL_VEC(Vec3(0, -f1-f2, 0), state.getForces()[1], TOL);
-        ASSERT_EQUAL_TOL(e1+e2, state.getPotentialEnergy(), TOL);
-    }
-}
+#include "CpuTests.h"
+#include "TestCustomNonbondedForce.h"
 
-int main() {
-    try {
-        if (!CpuPlatform::isProcessorSupported()) {
-            cout << "CPU is not supported.  Exiting." << endl;
-            return 0;
-        }
-        testSimpleExpression();
-        testParameters();
-        testExclusions();
-        testCutoff();
-        testPeriodic();
-        testTriclinic();
-        testContinuous1DFunction();
-        testContinuous2DFunction();
-        testContinuous3DFunction();
-        testDiscrete1DFunction();
-        testDiscrete2DFunction();
-        testDiscrete3DFunction();
-        testCoulombLennardJones();
-        testSwitchingFunction();
-        testLongRangeCorrection();
-        testInteractionGroups();
-        testLargeInteractionGroup();
-        testInteractionGroupLongRangeCorrection();
-        testMultipleCutoffs();
-    }
-    catch(const exception& e) {
-        cout << "exception: " << e.what() << endl;
-        return 1;
-    }
-    cout << "Done" << endl;
-    return 0;
+void runPlatformTests() {
 }

platforms/cpu/tests/TestCpuEwald.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) 2008-2013 Stanford University and the Authors.      *
+ * Portions copyright (c) 2015 Stanford University and the Authors.           *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -29,311 +29,8 @@
  * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
  * -------------------------------------------------------------------------- */
 
-/**
- * This tests the Ewald summation method CPU implementation of NonbondedForce.
- */
+#include "CpuTests.h"
+#include "TestEwald.h"
 
-#include "openmm/internal/AssertionUtilities.h"
-#include "openmm/Context.h"
-#include "CpuPlatform.h"
-#include "ReferencePlatform.h"
-#include "openmm/NonbondedForce.h"
-#include "openmm/System.h"
-#include "openmm/LangevinIntegrator.h"
-#include "openmm/VerletIntegrator.h"
-#include "openmm/internal/ContextImpl.h"
-#include "openmm/internal/NonbondedForceImpl.h"
-#include "SimTKOpenMMRealType.h"
-#include "sfmt/SFMT.h"
-#include <iostream>
-#include <vector>
-
-using namespace OpenMM;
-using namespace std;
-
-CpuPlatform platform;
-
-const double TOL = 1e-5;
-
-void testEwaldPME(bool includeExceptions) {
-
-//      Use amorphous NaCl system for the tests
-
-    const int numParticles = 894;
-    const double cutoff = 1.2;
-    const double boxSize = 3.00646;
-    double tol = 1e-5;
-
-    ReferencePlatform reference;
-    System system;
-    NonbondedForce* nonbonded = new NonbondedForce();
-    nonbonded->setNonbondedMethod(NonbondedForce::Ewald);
-    nonbonded->setCutoffDistance(cutoff);
-    nonbonded->setEwaldErrorTolerance(tol);
-
-    for (int i = 0; i < numParticles/2; i++)
-        system.addParticle(22.99);
-    for (int i = 0; i < numParticles/2; i++)
-        system.addParticle(35.45);
-    for (int i = 0; i < numParticles/2; i++)
-        nonbonded->addParticle(1.0, 1.0,0.0);
-    for (int i = 0; i < numParticles/2; i++)
-        nonbonded->addParticle(-1.0, 1.0,0.0);
-    system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize));
-    system.addForce(nonbonded);
-
-    vector<Vec3> positions(numParticles);
-    #include "nacl_amorph.dat"
-    if (includeExceptions) {
-        // Add some exclusions.
-
-        for (int i = 0; i < numParticles-1; i++) {
-            Vec3 delta = positions[i]-positions[i+1];
-            if (sqrt(delta.dot(delta)) < 0.5*cutoff)
-                nonbonded->addException(i, i+1, i%2 == 0 ? 0.0 : 0.5, 1.0, 0.0);
-        }
-    }
-
-//    (1)  Check whether the Reference and CPU platforms agree when using Ewald Method
-
-    VerletIntegrator integrator1(0.01);
-    VerletIntegrator integrator2(0.01);
-    Context cpuContext(system, integrator1, platform);
-    Context referenceContext(system, integrator2, reference);
-    cpuContext.setPositions(positions);
-    referenceContext.setPositions(positions);
-    State cpuState = cpuContext.getState(State::Forces | State::Energy);
-    State referenceState = referenceContext.getState(State::Forces | State::Energy);
-    tol = 1e-2;
-    for (int i = 0; i < numParticles; i++) {
-        ASSERT_EQUAL_VEC(referenceState.getForces()[i], cpuState.getForces()[i], tol);
-    }
-    tol = 1e-5;
-    ASSERT_EQUAL_TOL(referenceState.getPotentialEnergy(), cpuState.getPotentialEnergy(), tol);
-
-//    (2) Check whether Ewald method in CPU is self-consistent
-
-    double norm = 0.0;
-    for (int i = 0; i < numParticles; ++i) {
-        Vec3 f = cpuState.getForces()[i];
-        norm += f[0]*f[0] + f[1]*f[1] + f[2]*f[2];
-    }
-
-    norm = std::sqrt(norm);
-    const double delta = 5e-3;
-    double step = delta/norm;
-    for (int i = 0; i < numParticles; ++i) {
-        Vec3 p = positions[i];
-        Vec3 f = cpuState.getForces()[i];
-        positions[i] = Vec3(p[0]-f[0]*step, p[1]-f[1]*step, p[2]-f[2]*step);
-    }
-    VerletIntegrator integrator3(0.01);
-    Context cpuContext2(system, integrator3, platform);
-    cpuContext2.setPositions(positions);
-
-    tol = 1e-2;
-    State cpuState2 = cpuContext2.getState(State::Energy);
-    ASSERT_EQUAL_TOL(norm, (cpuState2.getPotentialEnergy()-cpuState.getPotentialEnergy())/delta, tol)
-
-//    (3)  Check whether the Reference and CPU platforms agree when using PME
-
-    nonbonded->setNonbondedMethod(NonbondedForce::PME);
-    cpuContext.reinitialize();
-    referenceContext.reinitialize();
-    cpuContext.setPositions(positions);
-    referenceContext.setPositions(positions);
-    cpuState = cpuContext.getState(State::Forces | State::Energy);
-    referenceState = referenceContext.getState(State::Forces | State::Energy);
-    tol = 1e-2;
-    for (int i = 0; i < numParticles; i++) {
-        ASSERT_EQUAL_VEC(referenceState.getForces()[i], cpuState.getForces()[i], tol);
-    }
-    tol = 1e-5;
-    ASSERT_EQUAL_TOL(referenceState.getPotentialEnergy(), cpuState.getPotentialEnergy(), tol);
-
-//    (4) Check whether PME method in CPU is self-consistent
-
-    norm = 0.0;
-    for (int i = 0; i < numParticles; ++i) {
-        Vec3 f = cpuState.getForces()[i];
-        norm += f[0]*f[0] + f[1]*f[1] + f[2]*f[2];
-    }
-
-    norm = std::sqrt(norm);
-    step = delta/norm;
-    for (int i = 0; i < numParticles; ++i) {
-        Vec3 p = positions[i];
-        Vec3 f = cpuState.getForces()[i];
-        positions[i] = Vec3(p[0]-f[0]*step, p[1]-f[1]*step, p[2]-f[2]*step);
-    }
-    VerletIntegrator integrator4(0.01);
-    Context cpuContext3(system, integrator4, platform);
-    cpuContext3.setPositions(positions);
-
-    tol = 1e-2;
-    State cpuState3 = cpuContext3.getState(State::Energy);
-    ASSERT_EQUAL_TOL(norm, (cpuState3.getPotentialEnergy()-cpuState.getPotentialEnergy())/delta, tol)
-}
-
-void testEwald2Ions() {
-    System system;
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    VerletIntegrator integrator(0.01);
-    NonbondedForce* nonbonded = new NonbondedForce();
-    nonbonded->addParticle(1.0, 1, 0);
-    nonbonded->addParticle(-1.0, 1, 0);
-    nonbonded->setNonbondedMethod(NonbondedForce::Ewald);
-    const double cutoff = 2.0;
-    nonbonded->setCutoffDistance(cutoff);
-    nonbonded->setEwaldErrorTolerance(TOL);
-    system.setDefaultPeriodicBoxVectors(Vec3(6, 0, 0), Vec3(0, 6, 0), Vec3(0, 0, 6));
-    system.addForce(nonbonded);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(2);
-    positions[0] = Vec3(3.048000,2.764000,3.156000);
-    positions[1] = Vec3(2.809000,2.888000,2.571000);
-    context.setPositions(positions);
-    State state = context.getState(State::Forces | State::Energy);
-    const vector<Vec3>& forces = state.getForces();
-
-    ASSERT_EQUAL_VEC(Vec3(-123.711,  64.1877, -302.716), forces[0], 10*TOL);
-    ASSERT_EQUAL_VEC(Vec3( 123.711, -64.1877,  302.716), forces[1], 10*TOL);
-    ASSERT_EQUAL_TOL(-217.276, state.getPotentialEnergy(), 0.01/*10*TOL*/);
-}
-
-void testTriclinic() {
-    // Create a triclinic box containing eight particles.
-
-    System system;
-    system.setDefaultPeriodicBoxVectors(Vec3(2.5, 0, 0), Vec3(0.5, 3.0, 0), Vec3(0.7, 0.9, 3.5));
-    for (int i = 0; i < 8; i++)
-        system.addParticle(1.0);
-    NonbondedForce* force = new NonbondedForce();
-    system.addForce(force);
-    force->setNonbondedMethod(NonbondedForce::PME);
-    force->setCutoffDistance(1.0);
-    force->setPMEParameters(3.45891, 32, 40, 48);
-    for (int i = 0; i < 4; i++)
-        force->addParticle(-1, 0.440104, 0.4184); // Cl parameters
-    for (int i = 0; i < 4; i++)
-        force->addParticle(1, 0.332840, 0.0115897); // Na parameters
-    vector<Vec3> positions(8);
-    positions[0] = Vec3(1.744, 2.788, 3.162);
-    positions[1] = Vec3(1.048, 0.762, 2.340);
-    positions[2] = Vec3(2.489, 1.570, 2.817);
-    positions[3] = Vec3(1.027, 1.893, 3.271);
-    positions[4] = Vec3(0.937, 0.825, 0.009);
-    positions[5] = Vec3(2.290, 1.887, 3.352);
-    positions[6] = Vec3(1.266, 1.111, 2.894);
-    positions[7] = Vec3(0.933, 1.862, 3.490);
-
-    // Compute the forces and energy.
-
-    VerletIntegrator integ(0.001);
-    Context context(system, integ, platform);
-    context.setPositions(positions);
-    State state = context.getState(State::Forces | State::Energy);
-
-    // Compare them to values computed by Gromacs.
-
-    double expectedEnergy = -963.370;
-    vector<Vec3> expectedForce(8);
-    expectedForce[0] = Vec3(4.25253e+01, -1.23503e+02, 1.22139e+02);
-    expectedForce[1] = Vec3(9.74752e+01, 1.68213e+02, 1.93169e+02);
-    expectedForce[2] = Vec3(-1.50348e+02, 1.29165e+02, 3.70435e+02);
-    expectedForce[3] = Vec3(9.18644e+02, -3.52571e+00, -1.34772e+03);
-    expectedForce[4] = Vec3(-1.61193e+02, 9.01528e+01, -7.12904e+01);
-    expectedForce[5] = Vec3(2.82630e+02, 2.78029e+01, -3.72864e+02);
-    expectedForce[6] = Vec3(-1.47454e+02, -2.14448e+02, -3.55789e+02);
-    expectedForce[7] = Vec3(-8.82195e+02, -7.39132e+01, 1.46202e+03);
-    for (int i = 0; i < 8; i++) {
-        ASSERT_EQUAL_VEC(expectedForce[i], state.getForces()[i], 1e-4);
-    }
-    ASSERT_EQUAL_TOL(expectedEnergy, state.getPotentialEnergy(), 1e-4);
-}
-
-void testErrorTolerance(NonbondedForce::NonbondedMethod method) {
-    // Create a cloud of random point charges.
-
-    const int numParticles = 51;
-    const double boxWidth = 5.0;
-    System system;
-    system.setDefaultPeriodicBoxVectors(Vec3(boxWidth, 0, 0), Vec3(0, boxWidth, 0), Vec3(0, 0, boxWidth));
-    NonbondedForce* force = new NonbondedForce();
-    system.addForce(force);
-    vector<Vec3> positions(numParticles);
-    OpenMM_SFMT::SFMT sfmt;
-    init_gen_rand(0, sfmt);
-
-    for (int i = 0; i < numParticles; i++) {
-        system.addParticle(1.0);
-        force->addParticle(-1.0+i*2.0/(numParticles-1), 1.0, 0.0);
-        positions[i] = Vec3(boxWidth*genrand_real2(sfmt), boxWidth*genrand_real2(sfmt), boxWidth*genrand_real2(sfmt));
-    }
-    force->setNonbondedMethod(method);
-
-    // For various values of the cutoff and error tolerance, see if the actual error is reasonable.
-
-    for (double cutoff = 1.0; cutoff < boxWidth/2; cutoff *= 1.2) {
-        force->setCutoffDistance(cutoff);
-        vector<Vec3> refForces;
-        double norm = 0.0;
-        for (double tol = 5e-5; tol < 1e-3; tol *= 2.0) {
-            force->setEwaldErrorTolerance(tol);
-            VerletIntegrator integrator(0.01);
-            Context context(system, integrator, platform);
-            context.setPositions(positions);
-            State state = context.getState(State::Forces);
-            if (refForces.size() == 0) {
-                refForces = state.getForces();
-                for (int i = 0; i < numParticles; i++)
-                    norm += refForces[i].dot(refForces[i]);
-                norm = sqrt(norm);
-            }
-            else {
-                double diff = 0.0;
-                for (int i = 0; i < numParticles; i++) {
-                    Vec3 delta = refForces[i]-state.getForces()[i];
-                    diff += delta.dot(delta);
-                }
-                diff = sqrt(diff)/norm;
-                ASSERT(diff < 2*tol);
-            }
-            if (method == NonbondedForce::PME) {
-                // See if the PME parameters were calculated correctly.
-
-                double expectedAlpha, actualAlpha;
-                int expectedSize[3], actualSize[3];
-                NonbondedForceImpl::calcPMEParameters(system, *force, expectedAlpha, expectedSize[0], expectedSize[1], expectedSize[2]);
-                force->getPMEParametersInContext(context, actualAlpha, actualSize[0], actualSize[1], actualSize[2]);
-                ASSERT_EQUAL_TOL(expectedAlpha, actualAlpha, 1e-5);
-                for (int i = 0; i < 3; i++) {
-                    ASSERT(actualSize[i] >= expectedSize[i]);
-                    ASSERT(actualSize[i] < expectedSize[i]+10);
-                }
-            }
-        }
-    }
-}
-
-int main(int argc, char* argv[]) {
-    try {
-        if (!CpuPlatform::isProcessorSupported()) {
-            cout << "CPU is not supported.  Exiting." << endl;
-            return 0;
-        }
-        testEwaldPME(false);
-        testEwaldPME(true);
-//        testEwald2Ions();
-        testTriclinic();
-        testErrorTolerance(NonbondedForce::Ewald);
-        testErrorTolerance(NonbondedForce::PME);
-    }
-    catch(const exception& e) {
-        cout << "exception: " << e.what() << endl;
-        return 1;
-    }
-    cout << "Done" << endl;
-    return 0;
+void runPlatformTests() {
 }

platforms/cpu/tests/TestCpuGBSAOBCForce.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) 2008-2014 Stanford University and the Authors.      *
+ * Portions copyright (c) 2015 Stanford University and the Authors.           *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -29,244 +29,8 @@
  * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
  * -------------------------------------------------------------------------- */
 
-/**
- * This tests the CPU implementation of GBSAOBCForce.
- */
+#include "CpuTests.h"
+#include "TestGBSAOBCForce.h"
 
-#include "openmm/internal/AssertionUtilities.h"
-#include "openmm/Context.h"
-#include "CpuPlatform.h"
-#include "openmm/GBSAOBCForce.h"
-#include "openmm/System.h"
-#include "openmm/LangevinIntegrator.h"
-#include "openmm/NonbondedForce.h"
-#include "SimTKOpenMMRealType.h"
-#include "sfmt/SFMT.h"
-#include <iostream>
-#include <vector>
-
-using namespace OpenMM;
-using namespace std;
-
-const double TOL = 1e-5;
-
-void testSingleParticle() {
-    CpuPlatform platform;
-    System system;
-    system.addParticle(2.0);
-    LangevinIntegrator integrator(0, 0.1, 0.01);
-    GBSAOBCForce* forceField = new GBSAOBCForce();
-    forceField->addParticle(0.5, 0.15, 1);
-    system.addForce(forceField);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(1);
-    positions[0] = Vec3(0, 0, 0);
-    context.setPositions(positions);
-    State state = context.getState(State::Energy);
-    double bornRadius = 0.15-0.009; // dielectric offset
-    double eps0 = EPSILON0;
-    double bornEnergy = (-0.5*0.5/(8*PI_M*eps0))*(1.0/forceField->getSoluteDielectric()-1.0/forceField->getSolventDielectric())/bornRadius;
-    double extendedRadius = 0.15+0.14; // probe radius
-    double nonpolarEnergy = 4*PI_M*2.25936*extendedRadius*extendedRadius*std::pow(0.15/bornRadius, 6.0);
-    ASSERT_EQUAL_TOL((bornEnergy+nonpolarEnergy), state.getPotentialEnergy(), 0.01);
-    
-    // Change the parameters and see if it is still correct.
-    
-    forceField->setParticleParameters(0, 0.4, 0.25, 1);
-    forceField->updateParametersInContext(context);
-    state = context.getState(State::Energy);
-    bornRadius = 0.25-0.009; // dielectric offset
-    bornEnergy = (-0.4*0.4/(8*PI_M*eps0))*(1.0/forceField->getSoluteDielectric()-1.0/forceField->getSolventDielectric())/bornRadius;
-    extendedRadius = 0.25+0.14;
-    nonpolarEnergy = 4*PI_M*2.25936*extendedRadius*extendedRadius*std::pow(0.25/bornRadius, 6.0);
-    ASSERT_EQUAL_TOL((bornEnergy+nonpolarEnergy), state.getPotentialEnergy(), 0.01);
-}
-
-void testGlobalSettings() {
-    CpuPlatform platform;
-    System system;
-    system.addParticle(2.0);
-    LangevinIntegrator integrator(0, 0.1, 0.01);
-    GBSAOBCForce* forceField = new GBSAOBCForce();
-    forceField->addParticle(0.5, 0.15, 1);
-    const double soluteDielectric = 2.1;
-    const double solventDielectric = 35.0;
-    const double surfaceAreaEnergy = 0.75;
-    forceField->setSoluteDielectric(soluteDielectric);
-    forceField->setSolventDielectric(solventDielectric);
-    forceField->setSurfaceAreaEnergy(surfaceAreaEnergy);
-    system.addForce(forceField);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(1);
-    positions[0] = Vec3(0, 0, 0);
-    context.setPositions(positions);
-    State state = context.getState(State::Energy);
-    double bornRadius = 0.15-0.009; // dielectric offset
-    double eps0 = EPSILON0;
-    double bornEnergy = (-0.5*0.5/(8*PI_M*eps0))*(1.0/soluteDielectric-1.0/solventDielectric)/bornRadius;
-    double extendedRadius = 0.15+0.14; // probe radius
-    double nonpolarEnergy = 4*PI_M*surfaceAreaEnergy*extendedRadius*extendedRadius*std::pow(0.15/bornRadius, 6.0);
-    ASSERT_EQUAL_TOL((bornEnergy+nonpolarEnergy), state.getPotentialEnergy(), 0.01);
-}
-
-void testCutoffAndPeriodic() {
-    CpuPlatform platform;
-    System system;
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    LangevinIntegrator integrator(0, 0.1, 0.01);
-    GBSAOBCForce* gbsa = new GBSAOBCForce();
-    NonbondedForce* nonbonded = new NonbondedForce();
-    gbsa->addParticle(-1, 0.15, 1);
-    nonbonded->addParticle(-1, 1, 0);
-    gbsa->addParticle(1, 0.15, 1);
-    nonbonded->addParticle(1, 1, 0);
-    const double cutoffDistance = 3.0;
-    const double boxSize = 10.0;
-    nonbonded->setCutoffDistance(cutoffDistance);
-    gbsa->setCutoffDistance(cutoffDistance);
-    system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize));
-    system.addForce(gbsa);
-    system.addForce(nonbonded);
-    vector<Vec3> positions(2);
-    positions[0] = Vec3(0, 0, 0);
-    positions[1] = Vec3(2, 0, 0);
-
-    // Calculate the forces for both cutoff and periodic with two different atom positions.
-
-    nonbonded->setNonbondedMethod(NonbondedForce::CutoffNonPeriodic);
-    gbsa->setNonbondedMethod(GBSAOBCForce::CutoffNonPeriodic);
-    Context context(system, integrator, platform);
-    context.setPositions(positions);
-    State state1 = context.getState(State::Forces);
-    nonbonded->setNonbondedMethod(NonbondedForce::CutoffPeriodic);
-    gbsa->setNonbondedMethod(GBSAOBCForce::CutoffPeriodic);
-    context.reinitialize();
-    context.setPositions(positions);
-    State state2 = context.getState(State::Forces);
-    positions[1][0]+= boxSize;
-    nonbonded->setNonbondedMethod(NonbondedForce::CutoffNonPeriodic);
-    gbsa->setNonbondedMethod(GBSAOBCForce::CutoffNonPeriodic);
-    context.reinitialize();
-    context.setPositions(positions);
-    State state3 = context.getState(State::Forces);
-    nonbonded->setNonbondedMethod(NonbondedForce::CutoffPeriodic);
-    gbsa->setNonbondedMethod(GBSAOBCForce::CutoffPeriodic);
-    context.reinitialize();
-    context.setPositions(positions);
-    State state4 = context.getState(State::Forces);
-
-    // All forces should be identical, exception state3 which should be zero.
-
-    ASSERT_EQUAL_VEC(state1.getForces()[0], state2.getForces()[0], 0.01);
-    ASSERT_EQUAL_VEC(state1.getForces()[1], state2.getForces()[1], 0.01);
-    ASSERT_EQUAL_VEC(state1.getForces()[0], state4.getForces()[0], 0.01);
-    ASSERT_EQUAL_VEC(state1.getForces()[1], state4.getForces()[1], 0.01);
-    ASSERT_EQUAL_VEC(state3.getForces()[0], Vec3(0, 0, 0), 0.01);
-    ASSERT_EQUAL_VEC(state3.getForces()[1], Vec3(0, 0, 0), 0.01);
-}
-
-void testForce(int numParticles, NonbondedForce::NonbondedMethod method, GBSAOBCForce::NonbondedMethod method2) {
-    CpuPlatform platform;
-    ReferencePlatform reference;
-    System system;
-    GBSAOBCForce* gbsa = new GBSAOBCForce();
-    NonbondedForce* nonbonded = new NonbondedForce();
-    for (int i = 0; i < numParticles; ++i) {
-        system.addParticle(1.0);
-        double charge = i%2 == 0 ? -1 : 1;
-        gbsa->addParticle(charge, 0.15, 1);
-        nonbonded->addParticle(charge, 1, 0);
-    }
-    nonbonded->setNonbondedMethod(method);
-    gbsa->setNonbondedMethod(method2);
-    nonbonded->setCutoffDistance(3.0);
-    gbsa->setCutoffDistance(3.0);
-    int grid = (int) floor(0.5+pow(numParticles, 1.0/3.0));
-    if (method == NonbondedForce::CutoffPeriodic) {
-        double boxSize = (grid+1)*1.1;
-        system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize));
-    }
-    system.addForce(gbsa);
-    system.addForce(nonbonded);
-    LangevinIntegrator integrator1(0, 0.1, 0.01);
-    LangevinIntegrator integrator2(0, 0.1, 0.01);
-    Context context(system, integrator1, platform);
-    Context refContext(system, integrator2, reference);
-
-    // Set random (but uniformly distributed) positions for all the particles.
-
-    vector<Vec3> positions(numParticles);
-    OpenMM_SFMT::SFMT sfmt;
-    init_gen_rand(0, sfmt);
-
-    for (int i = 0; i < grid; i++)
-        for (int j = 0; j < grid; j++)
-            for (int k = 0; k < grid; k++)
-                positions[i*grid*grid+j*grid+k] = Vec3(i*1.1, j*1.1, k*1.1);
-    for (int i = 0; i < numParticles; ++i)
-        positions[i] = positions[i] + Vec3(0.5*genrand_real2(sfmt), 0.5*genrand_real2(sfmt), 0.5*genrand_real2(sfmt));
-    context.setPositions(positions);
-    refContext.setPositions(positions);
-    State state = context.getState(State::Forces | State::Energy);
-    State refState = refContext.getState(State::Forces | State::Energy);
-
-    // Make sure the CPU and Reference platforms agree.
-
-    double norm = 0.0;
-    double diff = 0.0;
-    for (int i = 0; i < numParticles; ++i) {
-        Vec3 f = state.getForces()[i];
-        norm += f[0]*f[0] + f[1]*f[1] + f[2]*f[2];
-        Vec3 delta = f-refState.getForces()[i];
-        diff += delta[0]*delta[0] + delta[1]*delta[1] + delta[2]*delta[2];
-    }
-    norm = std::sqrt(norm);
-    diff = std::sqrt(diff);
-    ASSERT_EQUAL_TOL(0.0, diff, 0.001*norm);
-    ASSERT_EQUAL_TOL(state.getPotentialEnergy(), refState.getPotentialEnergy(), 1e-3);
-
-    // Take a small step in the direction of the energy gradient and see whether the potential energy changes by the expected amount.
-    // (This doesn't work with cutoffs, since the energy changes discontinuously at the cutoff distance.)
-
-    if (method == NonbondedForce::NoCutoff)
-    {
-        const double delta = 0.3;
-        double step = 0.5*delta/norm;
-        vector<Vec3> positions2(numParticles), positions3(numParticles);
-        for (int i = 0; i < numParticles; ++i) {
-            Vec3 p = positions[i];
-            Vec3 f = state.getForces()[i];
-            positions2[i] = Vec3(p[0]-f[0]*step, p[1]-f[1]*step, p[2]-f[2]*step);
-            positions3[i] = Vec3(p[0]+f[0]*step, p[1]+f[1]*step, p[2]+f[2]*step);
-        }
-        context.setPositions(positions2);
-        State state2 = context.getState(State::Energy);
-        context.setPositions(positions3);
-        State state3 = context.getState(State::Energy);
-        ASSERT_EQUAL_TOL(norm, (state2.getPotentialEnergy()-state3.getPotentialEnergy())/delta, 1e-2)
-    }
-}
-
-int main() {
-    try {
-        if (!CpuPlatform::isProcessorSupported()) {
-            cout << "CPU is not supported.  Exiting." << endl;
-            return 0;
-        }
-        testSingleParticle();
-        testGlobalSettings();
-        testCutoffAndPeriodic();
-        for (int i = 5; i < 11; i++) {
-            testForce(i*i*i, NonbondedForce::NoCutoff, GBSAOBCForce::NoCutoff);
-            testForce(i*i*i, NonbondedForce::CutoffNonPeriodic, GBSAOBCForce::CutoffNonPeriodic);
-            testForce(i*i*i, NonbondedForce::CutoffPeriodic, GBSAOBCForce::CutoffPeriodic);
-        }
-    }
-    catch(const exception& e) {
-        cout << "exception: " << e.what() << endl;
-        return 1;
-    }
-    cout << "Done" << endl;
-    return 0;
+void runPlatformTests() {
 }

platforms/cpu/tests/TestCpuHarmonicAngleForce.cpp

+/* -------------------------------------------------------------------------- *
+ *                                   OpenMM                                   *
+ * -------------------------------------------------------------------------- *
+ * This is part of the OpenMM molecular simulation toolkit originating from   *
+ * Simbios, the NIH National Center for Physics-Based Simulation of           *
+ * Biological Structures at Stanford, funded under the NIH Roadmap for        *
+ * Medical Research, grant U54 GM072970. See https://simtk.org.               *
+ *                                                                            *
+ * Portions copyright (c) 2008-2015 Stanford University and the Authors.      *
+ * Authors: Peter Eastman                                                     *
+ * Contributors:                                                              *
+ *                                                                            *
+ * Permission is hereby granted, free of charge, to any person obtaining a    *
+ * copy of this software and associated documentation files (the "Software"), *
+ * to deal in the Software without restriction, including without limitation  *
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,   *
+ * and/or sell copies of the Software, and to permit persons to whom the      *
+ * Software is furnished to do so, subject to the following conditions:       *
+ *                                                                            *
+ * The above copyright notice and this permission notice shall be included in *
+ * all copies or substantial portions of the Software.                        *
+ *                                                                            *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *
+ * THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,    *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR      *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE  *
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
+ * -------------------------------------------------------------------------- */
+
+#include "CpuTests.h"
+#include "TestHarmonicAngleForce.h"
+
+void testParallelComputation() {
+    System system;
+    const int numParticles = 200;
+    for (int i = 0; i < numParticles; i++)
+        system.addParticle(1.0);
+    HarmonicAngleForce* force = new HarmonicAngleForce();
+    for (int i = 2; i < numParticles; i++)
+        force->addAngle(i-2, i-1, i, 1.1, i);
+    system.addForce(force);
+    vector<Vec3> positions(numParticles);
+    for (int i = 0; i < numParticles; i++)
+        positions[i] = Vec3(i, i%2, 0);
+    VerletIntegrator integrator1(0.01);
+    ReferencePlatform reference;
+    Context context1(system, integrator1, reference);
+    context1.setPositions(positions);
+    State state1 = context1.getState(State::Forces | State::Energy);
+    VerletIntegrator integrator2(0.01);
+    Context context2(system, integrator2, platform);
+    context2.setPositions(positions);
+    State state2 = context2.getState(State::Forces | State::Energy);
+    ASSERT_EQUAL_TOL(state1.getPotentialEnergy(), state2.getPotentialEnergy(), 1e-5);
+    for (int i = 0; i < numParticles; i++)
+        ASSERT_EQUAL_VEC(state1.getForces()[i], state2.getForces()[i], 1e-5);
+}
+
+void runPlatformTests() {
+    testParallelComputation();
+}

platforms/cpu/tests/TestCpuLangevinIntegrator.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) 2008-2013 Stanford University and the Authors.      *
+ * Portions copyright (c) 2015 Stanford University and the Authors.           *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -29,255 +29,8 @@
  * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
  * -------------------------------------------------------------------------- */
 
-/**
- * This tests the reference implementation of LangevinIntegrator.
- */
+#include "CpuTests.h"
+#include "TestLangevinIntegrator.h"
 
-#include "openmm/internal/AssertionUtilities.h"
-#include "openmm/Context.h"
-#include "CpuPlatform.h"
-#include "openmm/HarmonicBondForce.h"
-#include "openmm/NonbondedForce.h"
-#include "openmm/System.h"
-#include "openmm/LangevinIntegrator.h"
-#include "SimTKOpenMMRealType.h"
-#include "sfmt/SFMT.h"
-#include <iostream>
-#include <vector>
-
-using namespace OpenMM;
-using namespace std;
-
-const double TOL = 1e-5;
-
-void testSingleBond() {
-    CpuPlatform platform;
-    System system;
-    system.addParticle(2.0);
-    system.addParticle(2.0);
-    LangevinIntegrator integrator(0, 0.1, 0.01);
-    HarmonicBondForce* forceField = new HarmonicBondForce();
-    forceField->addBond(0, 1, 1.5, 1);
-    system.addForce(forceField);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(2);
-    positions[0] = Vec3(-1, 0, 0);
-    positions[1] = Vec3(1, 0, 0);
-    context.setPositions(positions);
-    
-    // This is simply a damped harmonic oscillator, so compare it to the analytical solution.
-    
-    double freq = std::sqrt(1-0.05*0.05);
-    for (int i = 0; i < 1000; ++i) {
-        State state = context.getState(State::Positions | State::Velocities);
-        double time = state.getTime();
-        double expectedDist = 1.5+0.5*std::exp(-0.05*time)*std::cos(freq*time);
-        ASSERT_EQUAL_VEC(Vec3(-0.5*expectedDist, 0, 0), state.getPositions()[0], 0.02);
-        ASSERT_EQUAL_VEC(Vec3(0.5*expectedDist, 0, 0), state.getPositions()[1], 0.02);
-        double expectedSpeed = -0.5*std::exp(-0.05*time)*(0.05*std::cos(freq*time)+freq*std::sin(freq*time));
-        ASSERT_EQUAL_VEC(Vec3(-0.5*expectedSpeed, 0, 0), state.getVelocities()[0], 0.02);
-        ASSERT_EQUAL_VEC(Vec3(0.5*expectedSpeed, 0, 0), state.getVelocities()[1], 0.02);
-        integrator.step(1);
-    }
-    
-    // Not set the friction to a tiny value and see if it conserves energy.
-    
-    integrator.setFriction(5e-5);
-    context.setPositions(positions);
-    State state = context.getState(State::Energy);
-    double initialEnergy = state.getKineticEnergy()+state.getPotentialEnergy();
-    for (int i = 0; i < 1000; ++i) {
-        state = context.getState(State::Energy);
-        double energy = state.getKineticEnergy()+state.getPotentialEnergy();
-        ASSERT_EQUAL_TOL(initialEnergy, energy, 0.01);
-        integrator.step(1);
-    }
-}
-
-void testTemperature() {
-    const int numParticles = 8;
-    const double temp = 100.0;
-    CpuPlatform platform;
-    System system;
-    LangevinIntegrator integrator(temp, 2.0, 0.01);
-    NonbondedForce* forceField = new NonbondedForce();
-    for (int i = 0; i < numParticles; ++i) {
-        system.addParticle(2.0);
-        forceField->addParticle((i%2 == 0 ? 1.0 : -1.0), 1.0, 5.0);
-    }
-    system.addForce(forceField);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(numParticles);
-    for (int i = 0; i < numParticles; ++i)
-        positions[i] = Vec3((i%2 == 0 ? 2 : -2), (i%4 < 2 ? 2 : -2), (i < 4 ? 2 : -2));
-    context.setPositions(positions);
-    
-    // Let it equilibrate.
-    
-    integrator.step(10000);
-    
-    // Now run it for a while and see if the temperature is correct.
-    
-    double ke = 0.0;
-    for (int i = 0; i < 10000; ++i) {
-        State state = context.getState(State::Energy);
-        ke += state.getKineticEnergy();
-        integrator.step(1);
-    }
-    ke /= 10000;
-    double expected = 0.5*numParticles*3*BOLTZ*temp;
-    ASSERT_USUALLY_EQUAL_TOL(expected, ke, 6/std::sqrt(10000.0));
-}
-
-void testConstraints() {
-    const int numParticles = 8;
-    const double temp = 100.0;
-    CpuPlatform platform;
-    System system;
-    LangevinIntegrator integrator(temp, 2.0, 0.01);
-    integrator.setConstraintTolerance(1e-5);
-    NonbondedForce* forceField = new NonbondedForce();
-    for (int i = 0; i < numParticles; ++i) {
-        system.addParticle(10.0);
-        forceField->addParticle((i%2 == 0 ? 0.2 : -0.2), 0.5, 5.0);
-    }
-    for (int i = 0; i < numParticles-1; ++i)
-        system.addConstraint(i, i+1, 1.0);
-    system.addForce(forceField);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(numParticles);
-    vector<Vec3> velocities(numParticles);
-    OpenMM_SFMT::SFMT sfmt;
-    init_gen_rand(0, sfmt);
-
-    for (int i = 0; i < numParticles; ++i) {
-        positions[i] = Vec3(i/2, (i+1)/2, 0);
-        velocities[i] = Vec3(genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5);
-    }
-    context.setPositions(positions);
-    context.setVelocities(velocities);
-    
-    // Simulate it and see whether the constraints remain satisfied.
-    
-    for (int i = 0; i < 1000; ++i) {
-        State state = context.getState(State::Positions);
-        for (int j = 0; j < numParticles-1; ++j) {
-            Vec3 p1 = state.getPositions()[j];
-            Vec3 p2 = state.getPositions()[j+1];
-            double dist = std::sqrt((p1[0]-p2[0])*(p1[0]-p2[0])+(p1[1]-p2[1])*(p1[1]-p2[1])+(p1[2]-p2[2])*(p1[2]-p2[2]));
-            ASSERT_EQUAL_TOL(1.0, dist, 2e-5);
-        }
-        integrator.step(1);
-    }
-}
-
-void testConstrainedMasslessParticles() {
-    CpuPlatform platform;
-    System system;
-    system.addParticle(0.0);
-    system.addParticle(1.0);
-    system.addConstraint(0, 1, 1.5);
-    vector<Vec3> positions(2);
-    positions[0] = Vec3(-1, 0, 0);
-    positions[1] = Vec3(1, 0, 0);
-    LangevinIntegrator integrator(300.0, 2.0, 0.01);
-    bool failed = false;
-    try {
-        // This should throw an exception.
-        
-        Context context(system, integrator, platform);
-    }
-    catch (exception& ex) {
-        failed = true;
-    }
-    ASSERT(failed);
-    
-    // Now make both particles massless, which should work.
-    
-    system.setParticleMass(1, 0.0);
-    Context context(system, integrator, platform);
-    context.setPositions(positions);
-    context.setVelocitiesToTemperature(300.0);
-    integrator.step(1);
-    State state = context.getState(State::Velocities | State::Positions);
-    ASSERT_EQUAL(0.0, state.getVelocities()[0][0]);
-}
-
-void testRandomSeed() {
-    const int numParticles = 8;
-    const double temp = 100.0;
-    const double collisionFreq = 10.0;
-    CpuPlatform platform;
-    System system;
-    LangevinIntegrator integrator(temp, 2.0, 0.01);
-    NonbondedForce* forceField = new NonbondedForce();
-    for (int i = 0; i < numParticles; ++i) {
-        system.addParticle(2.0);
-        forceField->addParticle((i%2 == 0 ? 1.0 : -1.0), 1.0, 5.0);
-    }
-    system.addForce(forceField);
-    vector<Vec3> positions(numParticles);
-    vector<Vec3> velocities(numParticles);
-    for (int i = 0; i < numParticles; ++i) {
-        positions[i] = Vec3((i%2 == 0 ? 2 : -2), (i%4 < 2 ? 2 : -2), (i < 4 ? 2 : -2));
-        velocities[i] = Vec3(0, 0, 0);
-    }
-
-    // Try twice with the same random seed.
-
-    integrator.setRandomNumberSeed(5);
-    Context context(system, integrator, platform);
-    context.setPositions(positions);
-    context.setVelocities(velocities);
-    integrator.step(10);
-    State state1 = context.getState(State::Positions);
-    context.reinitialize();
-    context.setPositions(positions);
-    context.setVelocities(velocities);
-    integrator.step(10);
-    State state2 = context.getState(State::Positions);
-
-    // Try twice with a different random seed.
-
-    integrator.setRandomNumberSeed(10);
-    context.reinitialize();
-    context.setPositions(positions);
-    context.setVelocities(velocities);
-    integrator.step(10);
-    State state3 = context.getState(State::Positions);
-    context.reinitialize();
-    context.setPositions(positions);
-    context.setVelocities(velocities);
-    integrator.step(10);
-    State state4 = context.getState(State::Positions);
-
-    // Compare the results.
-
-    for (int i = 0; i < numParticles; i++) {
-        for (int j = 0; j < 3; j++) {
-            ASSERT_EQUAL_TOL(state1.getPositions()[i][j], state2.getPositions()[i][j], 1e-5);
-            ASSERT_EQUAL_TOL(state3.getPositions()[i][j], state4.getPositions()[i][j], 1e-5);
-            ASSERT(state1.getPositions()[i][j] != state3.getPositions()[i][j]);
-        }
-    }
-}
-
-int main() {
-    try {
-        if (!CpuPlatform::isProcessorSupported()) {
-            cout << "CPU is not supported.  Exiting." << endl;
-            return 0;
-        }
-        testSingleBond();
-        testTemperature();
-        testConstraints();
-        testConstrainedMasslessParticles();
-        testRandomSeed();
-    }
-    catch(const exception& e) {
-        cout << "exception: " << e.what() << endl;
-        return 1;
-    }
-    cout << "Done" << endl;
-    return 0;
+void runPlatformTests() {
 }

platforms/cpu/tests/TestCpuNonbondedForce.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) 2008-2015 Stanford University and the Authors.      *
+ * Portions copyright (c) 2015 Stanford University and the Authors.           *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -29,684 +29,8 @@
  * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
  * -------------------------------------------------------------------------- */
 
-/**
- * This tests all the different force terms in the CUDA implementation of NonbondedForce.
- */
+#include "CpuTests.h"
+#include "TestNonbondedForce.h"
 
-#include "openmm/internal/AssertionUtilities.h"
-#include "openmm/Context.h"
-#include "CpuPlatform.h"
-#include "ReferencePlatform.h"
-#include "openmm/HarmonicBondForce.h"
-#include "openmm/NonbondedForce.h"
-#include "openmm/System.h"
-#include "openmm/LangevinIntegrator.h"
-#include "openmm/VerletIntegrator.h"
-#include "openmm/internal/ContextImpl.h"
-#include "SimTKOpenMMRealType.h"
-#include "sfmt/SFMT.h"
-#include <iostream>
-#include <vector>
-
-using namespace OpenMM;
-using namespace std;
-
-CpuPlatform platform;
-
-const double TOL = 1e-5;
-
-void testCoulomb() {
-    System system;
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    VerletIntegrator integrator(0.01);
-    NonbondedForce* forceField = new NonbondedForce();
-    forceField->addParticle(0.5, 1, 0);
-    forceField->addParticle(-1.5, 1, 0);
-    system.addForce(forceField);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(2);
-    positions[0] = Vec3(0, 0, 0);
-    positions[1] = Vec3(2, 0, 0);
-    context.setPositions(positions);
-    State state = context.getState(State::Forces | State::Energy);
-    const vector<Vec3>& forces = state.getForces();
-    double force = ONE_4PI_EPS0*(-0.75)/4.0;
-    ASSERT_EQUAL_VEC(Vec3(-force, 0, 0), forces[0], TOL);
-    ASSERT_EQUAL_VEC(Vec3(force, 0, 0), forces[1], TOL);
-    ASSERT_EQUAL_TOL(ONE_4PI_EPS0*(-0.75)/2.0, state.getPotentialEnergy(), TOL);
-}
-
-void testLJ() {
-    System system;
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    VerletIntegrator integrator(0.01);
-    NonbondedForce* forceField = new NonbondedForce();
-    forceField->addParticle(0, 1.2, 1);
-    forceField->addParticle(0, 1.4, 2);
-    system.addForce(forceField);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(2);
-    positions[0] = Vec3(0, 0, 0);
-    positions[1] = Vec3(2, 0, 0);
-    context.setPositions(positions);
-    State state = context.getState(State::Forces | State::Energy);
-    const vector<Vec3>& forces = state.getForces();
-    double x = 1.3/2.0;
-    double eps = SQRT_TWO;
-    double force = 4.0*eps*(12*std::pow(x, 12.0)-6*std::pow(x, 6.0))/2.0;
-    ASSERT_EQUAL_VEC(Vec3(-force, 0, 0), forces[0], TOL);
-    ASSERT_EQUAL_VEC(Vec3(force, 0, 0), forces[1], TOL);
-    ASSERT_EQUAL_TOL(4.0*eps*(std::pow(x, 12.0)-std::pow(x, 6.0)), state.getPotentialEnergy(), TOL);
-}
-
-void testExclusionsAnd14() {
-    System system;
-    NonbondedForce* nonbonded = new NonbondedForce();
-    for (int i = 0; i < 5; ++i) {
-        system.addParticle(1.0);
-        nonbonded->addParticle(0, 1.5, 0);
-    }
-    vector<pair<int, int> > bonds;
-    bonds.push_back(pair<int, int>(0, 1));
-    bonds.push_back(pair<int, int>(1, 2));
-    bonds.push_back(pair<int, int>(2, 3));
-    bonds.push_back(pair<int, int>(3, 4));
-    nonbonded->createExceptionsFromBonds(bonds, 0.0, 0.0);
-    int first14, second14;
-    for (int i = 0; i < nonbonded->getNumExceptions(); i++) {
-        int particle1, particle2;
-        double chargeProd, sigma, epsilon;
-        nonbonded->getExceptionParameters(i, particle1, particle2, chargeProd, sigma, epsilon);
-        if ((particle1 == 0 && particle2 == 3) || (particle1 == 3 && particle2 == 0))
-            first14 = i;
-        if ((particle1 == 1 && particle2 == 4) || (particle1 == 4 && particle2 == 1))
-            second14 = i;
-    }
-    system.addForce(nonbonded);
-    VerletIntegrator integrator(0.01);
-    Context context(system, integrator, platform);
-    for (int i = 1; i < 5; ++i) {
-
-        // Test LJ forces
-
-        vector<Vec3> positions(5);
-        const double r = 1.0;
-        for (int j = 0; j < 5; ++j) {
-            nonbonded->setParticleParameters(j, 0, 1.5, 0);
-            positions[j] = Vec3(0, j, 0);
-        }
-        nonbonded->setParticleParameters(0, 0, 1.5, 1);
-        nonbonded->setParticleParameters(i, 0, 1.5, 1);
-        nonbonded->setExceptionParameters(first14, 0, 3, 0, 1.5, i == 3 ? 0.5 : 0.0);
-        nonbonded->setExceptionParameters(second14, 1, 4, 0, 1.5, 0.0);
-        positions[i] = Vec3(r, 0, 0);
-        context.reinitialize();
-        context.setPositions(positions);
-        State state = context.getState(State::Forces | State::Energy);
-        const vector<Vec3>& forces = state.getForces();
-        double x = 1.5/r;
-        double eps = 1.0;
-        double force = 4.0*eps*(12*std::pow(x, 12.0)-6*std::pow(x, 6.0))/r;
-        double energy = 4.0*eps*(std::pow(x, 12.0)-std::pow(x, 6.0));
-        if (i == 3) {
-            force *= 0.5;
-            energy *= 0.5;
-        }
-        if (i < 3) {
-            force = 0;
-            energy = 0;
-        }
-        ASSERT_EQUAL_VEC(Vec3(-force, 0, 0), forces[0], TOL);
-        ASSERT_EQUAL_VEC(Vec3(force, 0, 0), forces[i], TOL);
-        ASSERT_EQUAL_TOL(energy, state.getPotentialEnergy(), TOL);
-
-        // Test Coulomb forces
-
-        nonbonded->setParticleParameters(0, 2, 1.5, 0);
-        nonbonded->setParticleParameters(i, 2, 1.5, 0);
-        nonbonded->setExceptionParameters(first14, 0, 3, i == 3 ? 4/1.2 : 0, 1.5, 0);
-        nonbonded->setExceptionParameters(second14, 1, 4, 0, 1.5, 0);
-        context.reinitialize();
-        context.setPositions(positions);
-        state = context.getState(State::Forces | State::Energy);
-        const vector<Vec3>& forces2 = state.getForces();
-        force = ONE_4PI_EPS0*4/(r*r);
-        energy = ONE_4PI_EPS0*4/r;
-        if (i == 3) {
-            force /= 1.2;
-            energy /= 1.2;
-        }
-        if (i < 3) {
-            force = 0;
-            energy = 0;
-        }
-        ASSERT_EQUAL_VEC(Vec3(-force, 0, 0), forces2[0], TOL);
-        ASSERT_EQUAL_VEC(Vec3(force, 0, 0), forces2[i], TOL);
-        ASSERT_EQUAL_TOL(energy, state.getPotentialEnergy(), TOL);
-    }
-}
-
-void testCutoff() {
-    System system;
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    VerletIntegrator integrator(0.01);
-    NonbondedForce* forceField = new NonbondedForce();
-    forceField->addParticle(1.0, 1, 0);
-    forceField->addParticle(1.0, 1, 0);
-    forceField->addParticle(1.0, 1, 0);
-    forceField->setNonbondedMethod(NonbondedForce::CutoffNonPeriodic);
-    const double cutoff = 2.9;
-    forceField->setCutoffDistance(cutoff);
-    const double eps = 50.0;
-    forceField->setReactionFieldDielectric(eps);
-    system.addForce(forceField);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(3);
-    positions[0] = Vec3(0, 0, 0);
-    positions[1] = Vec3(0, 2, 0);
-    positions[2] = Vec3(0, 3, 0);
-    context.setPositions(positions);
-    State state = context.getState(State::Forces | State::Energy);
-    const vector<Vec3>& forces = state.getForces();
-    const double krf = (1.0/(cutoff*cutoff*cutoff))*(eps-1.0)/(2.0*eps+1.0);
-    const double crf = (1.0/cutoff)*(3.0*eps)/(2.0*eps+1.0);
-    const double force1 = ONE_4PI_EPS0*(1.0)*(0.25-2.0*krf*2.0);
-    const double force2 = ONE_4PI_EPS0*(1.0)*(1.0-2.0*krf*1.0);
-    ASSERT_EQUAL_VEC(Vec3(0, -force1, 0), forces[0], TOL);
-    ASSERT_EQUAL_VEC(Vec3(0, force1-force2, 0), forces[1], TOL);
-    ASSERT_EQUAL_VEC(Vec3(0, force2, 0), forces[2], TOL);
-    const double energy1 = ONE_4PI_EPS0*(1.0)*(0.5+krf*4.0-crf);
-    const double energy2 = ONE_4PI_EPS0*(1.0)*(1.0+krf*1.0-crf);
-    ASSERT_EQUAL_TOL(energy1+energy2, state.getPotentialEnergy(), TOL);
-}
-
-void testCutoff14() {
-    System system;
-    VerletIntegrator integrator(0.01);
-    NonbondedForce* nonbonded = new NonbondedForce();
-    nonbonded->setNonbondedMethod(NonbondedForce::CutoffNonPeriodic);
-    for (int i = 0; i < 5; ++i) {
-        system.addParticle(1.0);
-        nonbonded->addParticle(0, 1.5, 0);
-    }
-    const double cutoff = 3.5;
-    nonbonded->setCutoffDistance(cutoff);
-    const double eps = 30.0;
-    nonbonded->setReactionFieldDielectric(eps);
-    vector<pair<int, int> > bonds;
-    bonds.push_back(pair<int, int>(0, 1));
-    bonds.push_back(pair<int, int>(1, 2));
-    bonds.push_back(pair<int, int>(2, 3));
-    bonds.push_back(pair<int, int>(3, 4));
-    nonbonded->createExceptionsFromBonds(bonds, 0.0, 0.0);
-    int first14, second14;
-    for (int i = 0; i < nonbonded->getNumExceptions(); i++) {
-        int particle1, particle2;
-        double chargeProd, sigma, epsilon;
-        nonbonded->getExceptionParameters(i, particle1, particle2, chargeProd, sigma, epsilon);
-        if ((particle1 == 0 && particle2 == 3) || (particle1 == 3 && particle2 == 0))
-            first14 = i;
-        if ((particle1 == 1 && particle2 == 4) || (particle1 == 4 && particle2 == 1))
-            second14 = i;
-    }
-    system.addForce(nonbonded);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(5);
-    positions[0] = Vec3(0, 0, 0);
-    positions[1] = Vec3(1, 0, 0);
-    positions[2] = Vec3(2, 0, 0);
-    positions[3] = Vec3(3, 0, 0);
-    positions[4] = Vec3(4, 0, 0);
-    for (int i = 1; i < 5; ++i) {
-
-        // Test LJ forces
-
-        nonbonded->setParticleParameters(0, 0, 1.5, 1);
-        for (int j = 1; j < 5; ++j)
-            nonbonded->setParticleParameters(j, 0, 1.5, 0);
-        nonbonded->setParticleParameters(i, 0, 1.5, 1);
-        nonbonded->setExceptionParameters(first14, 0, 3, 0, 1.5, i == 3 ? 0.5 : 0.0);
-        nonbonded->setExceptionParameters(second14, 1, 4, 0, 1.5, 0.0);
-        context.reinitialize();
-        context.setPositions(positions);
-        State state = context.getState(State::Forces | State::Energy);
-        const vector<Vec3>& forces = state.getForces();
-        double r = positions[i][0];
-        double x = 1.5/r;
-        double e = 1.0;
-        double force = 4.0*e*(12*std::pow(x, 12.0)-6*std::pow(x, 6.0))/r;
-        double energy = 4.0*e*(std::pow(x, 12.0)-std::pow(x, 6.0));
-        if (i == 3) {
-            force *= 0.5;
-            energy *= 0.5;
-        }
-        if (i < 3 || r > cutoff) {
-            force = 0;
-            energy = 0;
-        }
-        ASSERT_EQUAL_VEC(Vec3(-force, 0, 0), forces[0], TOL);
-        ASSERT_EQUAL_VEC(Vec3(force, 0, 0), forces[i], TOL);
-        ASSERT_EQUAL_TOL(energy, state.getPotentialEnergy(), TOL);
-
-        // Test Coulomb forces
-
-        const double q = 0.7;
-        nonbonded->setParticleParameters(0, q, 1.5, 0);
-        nonbonded->setParticleParameters(i, q, 1.5, 0);
-        nonbonded->setExceptionParameters(first14, 0, 3, i == 3 ? q*q/1.2 : 0, 1.5, 0);
-        nonbonded->setExceptionParameters(second14, 1, 4, 0, 1.5, 0);
-        context.reinitialize();
-        context.setPositions(positions);
-        state = context.getState(State::Forces | State::Energy);
-        const vector<Vec3>& forces2 = state.getForces();
-        force = ONE_4PI_EPS0*q*q/(r*r);
-        energy = ONE_4PI_EPS0*q*q/r;
-        if (i == 3) {
-            force /= 1.2;
-            energy /= 1.2;
-        }
-        if (i < 3 || r > cutoff) {
-            force = 0;
-            energy = 0;
-        }
-        ASSERT_EQUAL_VEC(Vec3(-force, 0, 0), forces2[0], TOL);
-        ASSERT_EQUAL_VEC(Vec3(force, 0, 0), forces2[i], TOL);
-        ASSERT_EQUAL_TOL(energy, state.getPotentialEnergy(), TOL);
-    }
-}
-
-void testPeriodic() {
-    System system;
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    VerletIntegrator integrator(0.01);
-    NonbondedForce* nonbonded = new NonbondedForce();
-    nonbonded->addParticle(1.0, 1, 0);
-    nonbonded->addParticle(1.0, 1, 0);
-    nonbonded->addParticle(1.0, 1, 0);
-    nonbonded->addException(0, 1, 0.0, 1.0, 0.0);
-    nonbonded->setNonbondedMethod(NonbondedForce::CutoffPeriodic);
-    const double cutoff = 2.0;
-    nonbonded->setCutoffDistance(cutoff);
-    system.setDefaultPeriodicBoxVectors(Vec3(4, 0, 0), Vec3(0, 4, 0), Vec3(0, 0, 4));
-    system.addForce(nonbonded);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(3);
-    positions[0] = Vec3(0, 0, 0);
-    positions[1] = Vec3(2, 0, 0);
-    positions[2] = Vec3(3, 0, 0);
-    context.setPositions(positions);
-    State state = context.getState(State::Forces | State::Energy);
-    const vector<Vec3>& forces = state.getForces();
-    const double eps = 78.3;
-    const double krf = (1.0/(cutoff*cutoff*cutoff))*(eps-1.0)/(2.0*eps+1.0);
-    const double crf = (1.0/cutoff)*(3.0*eps)/(2.0*eps+1.0);
-    const double force = ONE_4PI_EPS0*(1.0)*(1.0-2.0*krf*1.0);
-    ASSERT_EQUAL_VEC(Vec3(force, 0, 0), forces[0], TOL);
-    ASSERT_EQUAL_VEC(Vec3(-force, 0, 0), forces[1], TOL);
-    ASSERT_EQUAL_VEC(Vec3(0, 0, 0), forces[2], TOL);
-    ASSERT_EQUAL_TOL(2*ONE_4PI_EPS0*(1.0)*(1.0+krf*1.0-crf), state.getPotentialEnergy(), TOL);
-}
-
-void testTriclinic() {
-    System system;
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    Vec3 a(3.1, 0, 0);
-    Vec3 b(0.4, 3.5, 0);
-    Vec3 c(-0.1, -0.5, 4.0);
-    system.setDefaultPeriodicBoxVectors(a, b, c);
-    VerletIntegrator integrator(0.01);
-    NonbondedForce* nonbonded = new NonbondedForce();
-    nonbonded->addParticle(1.0, 1, 0);
-    nonbonded->addParticle(1.0, 1, 0);
-    nonbonded->setNonbondedMethod(NonbondedForce::CutoffPeriodic);
-    const double cutoff = 1.5;
-    nonbonded->setCutoffDistance(cutoff);
-    system.addForce(nonbonded);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(2);
-    OpenMM_SFMT::SFMT sfmt;
-    init_gen_rand(0, sfmt);
-    const double eps = 78.3;
-    const double krf = (1.0/(cutoff*cutoff*cutoff))*(eps-1.0)/(2.0*eps+1.0);
-    const double crf = (1.0/cutoff)*(3.0*eps)/(2.0*eps+1.0);
-    for (int iteration = 0; iteration < 50; iteration++) {
-        // Generate random positions for the two particles.
-
-        positions[0] = a*genrand_real2(sfmt) + b*genrand_real2(sfmt) + c*genrand_real2(sfmt);
-        positions[1] = a*genrand_real2(sfmt) + b*genrand_real2(sfmt) + c*genrand_real2(sfmt);
-        context.setPositions(positions);
-
-        // Loop over all possible periodic copies and find the nearest one.
-
-        Vec3 delta;
-        double distance2 = 100.0;
-        for (int i = -1; i < 2; i++)
-            for (int j = -1; j < 2; j++)
-                for (int k = -1; k < 2; k++) {
-                    Vec3 d = positions[1]-positions[0]+a*i+b*j+c*k;
-                    if (d.dot(d) < distance2) {
-                        delta = d;
-                        distance2 = d.dot(d);
-                    }
-                }
-        double distance = sqrt(distance2);
-
-        // See if the force and energy are correct.
-
-        State state = context.getState(State::Forces | State::Energy);
-        if (distance >= cutoff) {
-            ASSERT_EQUAL(0.0, state.getPotentialEnergy());
-            ASSERT_EQUAL_VEC(Vec3(0, 0, 0), state.getForces()[0], 0);
-            ASSERT_EQUAL_VEC(Vec3(0, 0, 0), state.getForces()[1], 0);
-        }
-        else {
-            const Vec3 force = delta*ONE_4PI_EPS0*(-1.0/(distance*distance*distance)+2.0*krf);
-            ASSERT_EQUAL_TOL(ONE_4PI_EPS0*(1.0/distance+krf*distance*distance-crf), state.getPotentialEnergy(), 1e-4);
-            ASSERT_EQUAL_VEC(force, state.getForces()[0], 2e-5);
-            ASSERT_EQUAL_VEC(-force, state.getForces()[1], 2e-5);
-        }
-    }
-}
-
-void testLargeSystem() {
-    const int numMolecules = 600;
-    const int numParticles = numMolecules*2;
-    const double cutoff = 2.0;
-    const double boxSize = 20.0;
-    const double tol = 2e-3;
-    ReferencePlatform reference;
-    System system;
-    for (int i = 0; i < numParticles; i++)
-        system.addParticle(1.0);
-    NonbondedForce* nonbonded = new NonbondedForce();
-    HarmonicBondForce* bonds = new HarmonicBondForce();
-    vector<Vec3> positions(numParticles);
-    vector<Vec3> velocities(numParticles);
-    OpenMM_SFMT::SFMT sfmt;
-    init_gen_rand(0, sfmt);
-
-    for (int i = 0; i < numMolecules; i++) {
-        if (i < numMolecules/2) {
-            nonbonded->addParticle(-1.0, 0.2, 0.1);
-            nonbonded->addParticle(1.0, 0.1, 0.1);
-        }
-        else {
-            nonbonded->addParticle(-1.0, 0.2, 0.2);
-            nonbonded->addParticle(1.0, 0.1, 0.2);
-        }
-        positions[2*i] = Vec3(boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt));
-        positions[2*i+1] = Vec3(positions[2*i][0]+1.0, positions[2*i][1], positions[2*i][2]);
-        velocities[2*i] = Vec3(genrand_real2(sfmt), genrand_real2(sfmt), genrand_real2(sfmt));
-        velocities[2*i+1] = Vec3(genrand_real2(sfmt), genrand_real2(sfmt), genrand_real2(sfmt));
-        bonds->addBond(2*i, 2*i+1, 1.0, 0.1);
-        nonbonded->addException(2*i, 2*i+1, 0.0, 0.15, 0.0);
-    }
-
-    // Try with cutoffs but not periodic boundary conditions, and make sure the cl and Reference
-    // platforms agree.
-
-    nonbonded->setNonbondedMethod(NonbondedForce::CutoffNonPeriodic);
-    nonbonded->setCutoffDistance(cutoff);
-    system.addForce(nonbonded);
-    system.addForce(bonds);
-    VerletIntegrator integrator1(0.01);
-    VerletIntegrator integrator2(0.01);
-    Context cpuContext(system, integrator1, platform);
-    Context referenceContext(system, integrator2, reference);
-    cpuContext.setPositions(positions);
-    cpuContext.setVelocities(velocities);
-    referenceContext.setPositions(positions);
-    referenceContext.setVelocities(velocities);
-    State cpuState = cpuContext.getState(State::Positions | State::Velocities | State::Forces | State::Energy);
-    State referenceState = referenceContext.getState(State::Positions | State::Velocities | State::Forces | State::Energy);
-    for (int i = 0; i < numParticles; i++) {
-        ASSERT_EQUAL_VEC(cpuState.getPositions()[i], referenceState.getPositions()[i], tol);
-        ASSERT_EQUAL_VEC(cpuState.getVelocities()[i], referenceState.getVelocities()[i], tol);
-        ASSERT_EQUAL_VEC(cpuState.getForces()[i], referenceState.getForces()[i], tol);
-    }
-    ASSERT_EQUAL_TOL(cpuState.getPotentialEnergy(), referenceState.getPotentialEnergy(), tol);
-
-    // Now do the same thing with periodic boundary conditions.
-
-    nonbonded->setNonbondedMethod(NonbondedForce::CutoffPeriodic);
-    system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize));
-    cpuContext.reinitialize();
-    referenceContext.reinitialize();
-    cpuContext.setPositions(positions);
-    cpuContext.setVelocities(velocities);
-    referenceContext.setPositions(positions);
-    referenceContext.setVelocities(velocities);
-    cpuState = cpuContext.getState(State::Positions | State::Velocities | State::Forces | State::Energy);
-    referenceState = referenceContext.getState(State::Positions | State::Velocities | State::Forces | State::Energy);
-    for (int i = 0; i < numParticles; i++) {
-        double dx = cpuState.getPositions()[i][0]-referenceState.getPositions()[i][0];
-        double dy = cpuState.getPositions()[i][1]-referenceState.getPositions()[i][1];
-        double dz = cpuState.getPositions()[i][2]-referenceState.getPositions()[i][2];
-        ASSERT_EQUAL_TOL(fmod(cpuState.getPositions()[i][0]-referenceState.getPositions()[i][0], boxSize), 0, tol);
-        ASSERT_EQUAL_TOL(fmod(cpuState.getPositions()[i][1]-referenceState.getPositions()[i][1], boxSize), 0, tol);
-        ASSERT_EQUAL_TOL(fmod(cpuState.getPositions()[i][2]-referenceState.getPositions()[i][2], boxSize), 0, tol);
-        ASSERT_EQUAL_VEC(cpuState.getVelocities()[i], referenceState.getVelocities()[i], tol);
-        ASSERT_EQUAL_VEC(cpuState.getForces()[i], referenceState.getForces()[i], tol);
-    }
-    ASSERT_EQUAL_TOL(cpuState.getPotentialEnergy(), referenceState.getPotentialEnergy(), tol);
-}
-
-void testDispersionCorrection() {
-    // Create a box full of identical particles.
-
-    int gridSize = 5;
-    int numParticles = gridSize*gridSize*gridSize;
-    double boxSize = gridSize*0.7;
-    double cutoff = boxSize/3;
-    System system;
-    VerletIntegrator integrator(0.01);
-    NonbondedForce* nonbonded = new NonbondedForce();
-    vector<Vec3> positions(numParticles);
-    int index = 0;
-    for (int i = 0; i < gridSize; i++)
-        for (int j = 0; j < gridSize; j++)
-            for (int k = 0; k < gridSize; k++) {
-                system.addParticle(1.0);
-                nonbonded->addParticle(0, 1.1, 0.5);
-                positions[index] = Vec3(i*boxSize/gridSize, j*boxSize/gridSize, k*boxSize/gridSize);
-                index++;
-            }
-    nonbonded->setNonbondedMethod(NonbondedForce::CutoffPeriodic);
-    nonbonded->setCutoffDistance(cutoff);
-    system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize));
-    system.addForce(nonbonded);
-
-    // See if the correction has the correct value.
-
-    Context context(system, integrator, platform);
-    context.setPositions(positions);
-    double energy1 = context.getState(State::Energy).getPotentialEnergy();
-    nonbonded->setUseDispersionCorrection(false);
-    context.reinitialize();
-    context.setPositions(positions);
-    double energy2 = context.getState(State::Energy).getPotentialEnergy();
-    double term1 = (0.5*pow(1.1, 12)/pow(cutoff, 9))/9;
-    double term2 = (0.5*pow(1.1, 6)/pow(cutoff, 3))/3;
-    double expected = 8*M_PI*numParticles*numParticles*(term1-term2)/(boxSize*boxSize*boxSize);
-    ASSERT_EQUAL_TOL(expected, energy1-energy2, 1e-4);
-
-    // Now modify half the particles to be different, and see if it is still correct.
-
-    int numType2 = 0;
-    for (int i = 0; i < numParticles; i += 2) {
-        nonbonded->setParticleParameters(i, 0, 1, 1);
-        numType2++;
-    }
-    int numType1 = numParticles-numType2;
-    nonbonded->updateParametersInContext(context);
-    energy2 = context.getState(State::Energy).getPotentialEnergy();
-    nonbonded->setUseDispersionCorrection(true);
-    context.reinitialize();
-    context.setPositions(positions);
-    energy1 = context.getState(State::Energy).getPotentialEnergy();
-    term1 = ((numType1*(numType1+1))/2)*(0.5*pow(1.1, 12)/pow(cutoff, 9))/9;
-    term2 = ((numType1*(numType1+1))/2)*(0.5*pow(1.1, 6)/pow(cutoff, 3))/3;
-    term1 += ((numType2*(numType2+1))/2)*(1*pow(1.0, 12)/pow(cutoff, 9))/9;
-    term2 += ((numType2*(numType2+1))/2)*(1*pow(1.0, 6)/pow(cutoff, 3))/3;
-    double combinedSigma = 0.5*(1+1.1);
-    double combinedEpsilon = sqrt(1*0.5);
-    term1 += (numType1*numType2)*(combinedEpsilon*pow(combinedSigma, 12)/pow(cutoff, 9))/9;
-    term2 += (numType1*numType2)*(combinedEpsilon*pow(combinedSigma, 6)/pow(cutoff, 3))/3;
-    term1 /= (numParticles*(numParticles+1))/2;
-    term2 /= (numParticles*(numParticles+1))/2;
-    expected = 8*M_PI*numParticles*numParticles*(term1-term2)/(boxSize*boxSize*boxSize);
-    ASSERT_EQUAL_TOL(expected, energy1-energy2, 1e-4);
-}
-
-void testChangingParameters() {
-    const int numMolecules = 600;
-    const int numParticles = numMolecules*2;
-    const double cutoff = 2.0;
-    const double boxSize = 20.0;
-    const double tol = 2e-3;
-    ReferencePlatform reference;
-    System system;
-    for (int i = 0; i < numParticles; i++)
-        system.addParticle(1.0);
-    NonbondedForce* nonbonded = new NonbondedForce();
-    vector<Vec3> positions(numParticles);
-    OpenMM_SFMT::SFMT sfmt;
-    init_gen_rand(0, sfmt);
-
-    for (int i = 0; i < numMolecules; i++) {
-        if (i < numMolecules/2) {
-            nonbonded->addParticle(-1.0, 0.2, 0.1);
-            nonbonded->addParticle(1.0, 0.1, 0.1);
-        }
-        else {
-            nonbonded->addParticle(-1.0, 0.2, 0.2);
-            nonbonded->addParticle(1.0, 0.1, 0.2);
-        }
-        positions[2*i] = Vec3(boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt));
-        positions[2*i+1] = Vec3(positions[2*i][0]+1.0, positions[2*i][1], positions[2*i][2]);
-        system.addConstraint(2*i, 2*i+1, 1.0);
-        nonbonded->addException(2*i, 2*i+1, 0.0, 0.15, 0.0);
-    }
-    nonbonded->setNonbondedMethod(NonbondedForce::PME);
-    nonbonded->setCutoffDistance(cutoff);
-    system.addForce(nonbonded);
-    system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize));
-    
-    // See if Reference and CPU give the same forces and energies.
-    
-    VerletIntegrator integrator1(0.01);
-    VerletIntegrator integrator2(0.01);
-    Context cpuContext(system, integrator1, platform);
-    Context referenceContext(system, integrator2, reference);
-    cpuContext.setPositions(positions);
-    referenceContext.setPositions(positions);
-    State cpuState = cpuContext.getState(State::Forces | State::Energy);
-    State referenceState = referenceContext.getState(State::Forces | State::Energy);
-    for (int i = 0; i < numParticles; i++)
-        ASSERT_EQUAL_VEC(cpuState.getForces()[i], referenceState.getForces()[i], tol);
-    ASSERT_EQUAL_TOL(cpuState.getPotentialEnergy(), referenceState.getPotentialEnergy(), tol);
-    
-    // Now modify parameters and see if they still agree.
-
-    for (int i = 0; i < numParticles; i += 5) {
-        double charge, sigma, epsilon;
-        nonbonded->getParticleParameters(i, charge, sigma, epsilon);
-        nonbonded->setParticleParameters(i, 1.5*charge, 1.1*sigma, 1.7*epsilon);
-    }
-    nonbonded->updateParametersInContext(cpuContext);
-    nonbonded->updateParametersInContext(referenceContext);
-    cpuState = cpuContext.getState(State::Forces | State::Energy);
-    referenceState = referenceContext.getState(State::Forces | State::Energy);
-    for (int i = 0; i < numParticles; i++)
-        ASSERT_EQUAL_VEC(cpuState.getForces()[i], referenceState.getForces()[i], tol);
-    ASSERT_EQUAL_TOL(cpuState.getPotentialEnergy(), referenceState.getPotentialEnergy(), tol);
-}
-
-void testSwitchingFunction(NonbondedForce::NonbondedMethod method) {
-    System system;
-    system.setDefaultPeriodicBoxVectors(Vec3(6, 0, 0), Vec3(0, 6, 0), Vec3(0, 0, 6));
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    VerletIntegrator integrator(0.01);
-    NonbondedForce* nonbonded = new NonbondedForce();
-    nonbonded->addParticle(0, 1.2, 1);
-    nonbonded->addParticle(0, 1.4, 2);
-    nonbonded->setNonbondedMethod(method);
-    nonbonded->setCutoffDistance(2.0);
-    nonbonded->setUseSwitchingFunction(true);
-    nonbonded->setSwitchingDistance(1.5);
-    nonbonded->setUseDispersionCorrection(false);
-    system.addForce(nonbonded);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(2);
-    positions[0] = Vec3(0, 0, 0);
-    double eps = SQRT_TWO;
-    
-    // Compute the interaction at various distances.
-    
-    for (double r = 1.0; r < 2.5; r += 0.1) {
-        positions[1] = Vec3(r, 0, 0);
-        context.setPositions(positions);
-        State state = context.getState(State::Forces | State::Energy);
-        
-        // See if the energy is correct.
-        
-        double x = 1.3/r;
-        double expectedEnergy = 4.0*eps*(std::pow(x, 12.0)-std::pow(x, 6.0));
-        double switchValue;
-        if (r <= 1.5)
-            switchValue = 1;
-        else if (r >= 2.0)
-            switchValue = 0;
-        else {
-            double t = (r-1.5)/0.5;
-            switchValue = 1+t*t*t*(-10+t*(15-t*6));
-        }
-        ASSERT_EQUAL_TOL(switchValue*expectedEnergy, state.getPotentialEnergy(), TOL);
-        
-        // See if the force is the gradient of the energy.
-        
-        double delta = 1e-3;
-        positions[1] = Vec3(r-delta, 0, 0);
-        context.setPositions(positions);
-        double e1 = context.getState(State::Energy).getPotentialEnergy();
-        positions[1] = Vec3(r+delta, 0, 0);
-        context.setPositions(positions);
-        double e2 = context.getState(State::Energy).getPotentialEnergy();
-        ASSERT_EQUAL_TOL((e2-e1)/(2*delta), state.getForces()[0][0], 1e-3);
-    }
-}
-
-int main(int argc, char* argv[]) {
-    try {
-        if (!CpuPlatform::isProcessorSupported()) {
-            cout << "CPU is not supported.  Exiting." << endl;
-            return 0;
-        }
-        testCoulomb();
-        testLJ();
-        testExclusionsAnd14();
-        testCutoff();
-        testCutoff14();
-        testPeriodic();
-        testTriclinic();
-        testLargeSystem();
-        testDispersionCorrection();
-        testChangingParameters();
-        testSwitchingFunction(NonbondedForce::CutoffNonPeriodic);
-        testSwitchingFunction(NonbondedForce::PME);
-    }
-    catch(const exception& e) {
-        cout << "exception: " << e.what() << endl;
-        return 1;
-    }
-    cout << "Done" << endl;
-    return 0;
+void runPlatformTests() {
 }

platforms/cpu/tests/TestCpuPeriodicTorsionForce.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) 2008-2014 Stanford University and the Authors.      *
+ * Portions copyright (c) 2008-2015 Stanford University and the Authors.      *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -29,69 +29,8 @@
  * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
  * -------------------------------------------------------------------------- */
 
-/**
- * This tests the CPU implementation of PeriodicTorsionForce.
- */
-
-#include "openmm/internal/AssertionUtilities.h"
-#include "openmm/Context.h"
-#include "CpuPlatform.h"
-#include "openmm/PeriodicTorsionForce.h"
-#include "openmm/System.h"
-#include "openmm/VerletIntegrator.h"
-#include "SimTKOpenMMRealType.h"
-#include <iostream>
-#include <vector>
-
-using namespace OpenMM;
-using namespace std;
-
-CpuPlatform platform;
-
-const double TOL = 1e-5;
-
-void testPeriodicTorsions() {
-    System system;
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    VerletIntegrator integrator(0.01);
-    PeriodicTorsionForce* forceField = new PeriodicTorsionForce();
-    forceField->addTorsion(0, 1, 2, 3, 2, PI_M/3, 1.1);
-    system.addForce(forceField);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(4);
-    positions[0] = Vec3(0, 1, 0);
-    positions[1] = Vec3(0, 0, 0);
-    positions[2] = Vec3(1, 0, 0);
-    positions[3] = Vec3(1, 0, 2);
-    context.setPositions(positions);
-    State state = context.getState(State::Forces | State::Energy);
-    {
-        const vector<Vec3>& forces = state.getForces();
-        double torque = -2*1.1*std::sin(2*PI_M/3);
-        ASSERT_EQUAL_VEC(Vec3(0, 0, torque), forces[0], TOL);
-        ASSERT_EQUAL_VEC(Vec3(0, 0.5*torque, 0), forces[3], TOL);
-        ASSERT_EQUAL_VEC(Vec3(forces[0][0]+forces[1][0]+forces[2][0]+forces[3][0], forces[0][1]+forces[1][1]+forces[2][1]+forces[3][1], forces[0][2]+forces[1][2]+forces[2][2]+forces[3][2]), Vec3(0, 0, 0), TOL);
-        ASSERT_EQUAL_TOL(1.1*(1+std::cos(2*PI_M/3)), state.getPotentialEnergy(), TOL);
-    }
-    
-    // Try changing the torsion parameters and make sure it's still correct.
-    
-    forceField->setTorsionParameters(0, 0, 1, 2, 3, 3, PI_M/3.2, 1.3);
-    forceField->updateParametersInContext(context);
-    state = context.getState(State::Forces | State::Energy);
-    {
-        const vector<Vec3>& forces = state.getForces();
-        double dtheta = (3*PI_M/2)-(PI_M/3.2);
-        double torque = -3*1.3*std::sin(dtheta);
-        ASSERT_EQUAL_VEC(Vec3(0, 0, torque), forces[0], TOL);
-        ASSERT_EQUAL_VEC(Vec3(0, 0.5*torque, 0), forces[3], TOL);
-        ASSERT_EQUAL_VEC(Vec3(forces[0][0]+forces[1][0]+forces[2][0]+forces[3][0], forces[0][1]+forces[1][1]+forces[2][1]+forces[3][1], forces[0][2]+forces[1][2]+forces[2][2]+forces[3][2]), Vec3(0, 0, 0), TOL);
-        ASSERT_EQUAL_TOL(1.3*(1+std::cos(dtheta)), state.getPotentialEnergy(), TOL);
-    }
-}
+#include "CpuTests.h"
+#include "TestPeriodicTorsionForce.h"
 
 void testParallelComputation() {
     System system;
@@ -119,15 +58,6 @@ void testParallelComputation() {
         ASSERT_EQUAL_VEC(state1.getForces()[i], state2.getForces()[i], 1e-5);
 }
 
-int main(int argc, char* argv[]) {
-    try {
-        testPeriodicTorsions();
-        testParallelComputation();
-    }
-    catch(const exception& e) {
-        cout << "exception: " << e.what() << endl;
-        return 1;
-    }
-    cout << "Done" << endl;
-    return 0;
+void runPlatformTests() {
+    testParallelComputation();
 }

platforms/cpu/tests/TestCpuRBTorsionForce.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) 2008-2014 Stanford University and the Authors.      *
+ * Portions copyright (c) 2008-2015 Stanford University and the Authors.      *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -29,88 +29,8 @@
  * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
  * -------------------------------------------------------------------------- */
 
-/**
- * This tests the CUDA implementation of RBTorsionForce.
- */
-
-#include "openmm/internal/AssertionUtilities.h"
-#include "openmm/Context.h"
-#include "CpuPlatform.h"
-#include "openmm/RBTorsionForce.h"
-#include "openmm/System.h"
-#include "openmm/VerletIntegrator.h"
-#include "SimTKOpenMMRealType.h"
-#include <iostream>
-#include <vector>
-
-using namespace OpenMM;
-using namespace std;
-
-CpuPlatform platform;
-
-const double TOL = 1e-5;
-
-void testRBTorsions() {
-    System system;
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    system.addParticle(1.0);
-    VerletIntegrator integrator(0.01);
-    RBTorsionForce* forceField = new RBTorsionForce();
-    forceField->addTorsion(0, 1, 2, 3, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6);
-    system.addForce(forceField);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(4);
-    positions[0] = Vec3(0, 1, 0);
-    positions[1] = Vec3(0, 0, 0);
-    positions[2] = Vec3(1, 0, 0);
-    positions[3] = Vec3(1, 1, 1);
-    context.setPositions(positions);
-    State state = context.getState(State::Forces | State::Energy);
-    {
-        const vector<Vec3>& forces = state.getForces();
-        double psi = 0.25*PI_M - PI_M;
-        double torque = 0.0;
-        for (int i = 1; i < 6; ++i) {
-            double c = 0.1*(i+1);
-            torque += -c*i*std::pow(std::cos(psi), i-1)*std::sin(psi);
-        }
-        ASSERT_EQUAL_VEC(Vec3(0, 0, torque), forces[0], TOL);
-        ASSERT_EQUAL_VEC(Vec3(0, 0.5*torque, -0.5*torque), forces[3], TOL);
-        ASSERT_EQUAL_VEC(Vec3(forces[0][0]+forces[1][0]+forces[2][0]+forces[3][0], forces[0][1]+forces[1][1]+forces[2][1]+forces[3][1], forces[0][2]+forces[1][2]+forces[2][2]+forces[3][2]), Vec3(0, 0, 0), TOL);
-        double energy = 0.0;
-        for (int i = 0; i < 6; ++i) {
-            double c = 0.1*(i+1);
-            energy += c*std::pow(std::cos(psi), i);
-        }
-        ASSERT_EQUAL_TOL(energy, state.getPotentialEnergy(), TOL);
-    }
-    
-    // Try changing the torsion parameters and make sure it's still correct.
-    
-    forceField->setTorsionParameters(0, 0, 1, 2, 3, 0.11, 0.22, 0.33, 0.44, 0.55, 0.66);
-    forceField->updateParametersInContext(context);
-    state = context.getState(State::Forces | State::Energy);
-    {
-        const vector<Vec3>& forces = state.getForces();
-        double psi = 0.25*PI_M - PI_M;
-        double torque = 0.0;
-        for (int i = 1; i < 6; ++i) {
-            double c = 0.11*(i+1);
-            torque += -c*i*std::pow(std::cos(psi), i-1)*std::sin(psi);
-        }
-        ASSERT_EQUAL_VEC(Vec3(0, 0, torque), forces[0], TOL);
-        ASSERT_EQUAL_VEC(Vec3(0, 0.5*torque, -0.5*torque), forces[3], TOL);
-        ASSERT_EQUAL_VEC(Vec3(forces[0][0]+forces[1][0]+forces[2][0]+forces[3][0], forces[0][1]+forces[1][1]+forces[2][1]+forces[3][1], forces[0][2]+forces[1][2]+forces[2][2]+forces[3][2]), Vec3(0, 0, 0), TOL);
-        double energy = 0.0;
-        for (int i = 0; i < 6; ++i) {
-            double c = 0.11*(i+1);
-            energy += c*std::pow(std::cos(psi), i);
-        }
-        ASSERT_EQUAL_TOL(energy, state.getPotentialEnergy(), TOL);
-    }
-}
+#include "CpuTests.h"
+#include "TestRBTorsionForce.h"
 
 void testParallelComputation() {
     System system;
@@ -138,15 +58,6 @@ void testParallelComputation() {
         ASSERT_EQUAL_VEC(state1.getForces()[i], state2.getForces()[i], 1e-5);
 }
 
-int main(int argc, char* argv[]) {
-    try {
-        testRBTorsions();
-        testParallelComputation();
-    }
-    catch(const exception& e) {
-        cout << "exception: " << e.what() << endl;
-        return 1;
-    }
-    cout << "Done" << endl;
-    return 0;
+void runPlatformTests() {
+    testParallelComputation();
 }

platforms/cpu/tests/TestCpuSettle.cpp

-
 /* -------------------------------------------------------------------------- *
  *                                   OpenMM                                   *
  * -------------------------------------------------------------------------- *
@@ -7,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) 2008-2013 Stanford University and the Authors.      *
+ * Portions copyright (c) 2015 Stanford University and the Authors.           *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -30,91 +29,8 @@
  * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
  * -------------------------------------------------------------------------- */
 
-/**
- * This tests the CPU implementation of the SETTLE algorithm.
- */
-
-#include "openmm/internal/AssertionUtilities.h"
-#include "openmm/Context.h"
-#include "CpuPlatform.h"
-#include "openmm/NonbondedForce.h"
-#include "openmm/System.h"
-#include "openmm/LangevinIntegrator.h"
-#include "sfmt/SFMT.h"
-#include <iostream>
-#include <vector>
-
-using namespace OpenMM;
-using namespace std;
-
-void testConstraints() {
-    const int numMolecules = 10;
-    const int numParticles = numMolecules*3;
-    const int numConstraints = numMolecules*3;
-    const double temp = 100.0;
-    CpuPlatform platform;
-    System system;
-    LangevinIntegrator integrator(temp, 2.0, 0.001);
-    integrator.setConstraintTolerance(1e-5);
-    NonbondedForce* forceField = new NonbondedForce();
-    for (int i = 0; i < numMolecules; ++i) {
-        system.addParticle(16.0);
-        system.addParticle(1.0);
-        system.addParticle(1.0);
-        forceField->addParticle(-0.82, 0.317, 0.65);
-        forceField->addParticle(0.41, 1.0, 0.0);
-        forceField->addParticle(0.41, 1.0, 0.0);
-        system.addConstraint(i*3, i*3+1, 0.1);
-        system.addConstraint(i*3, i*3+2, 0.1);
-        system.addConstraint(i*3+1, i*3+2, 0.163);
-    }
-    system.addForce(forceField);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions(numParticles);
-    vector<Vec3> velocities(numParticles);
-    OpenMM_SFMT::SFMT sfmt;
-    init_gen_rand(0, sfmt);
-
-    for (int i = 0; i < numMolecules; ++i) {
-        positions[i*3] = Vec3((i%4)*0.4, (i/4)*0.4, 0);
-        positions[i*3+1] = positions[i*3]+Vec3(0.1, 0, 0);
-        positions[i*3+2] = positions[i*3]+Vec3(-0.03333, 0.09428, 0);
-        velocities[i*3] = Vec3(genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5);
-        velocities[i*3+1] = Vec3(genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5);
-        velocities[i*3+2] = Vec3(genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5);
-    }
-    context.setPositions(positions);
-    context.setVelocities(velocities);
-
-    // Simulate it and see whether the constraints remain satisfied.
-
-    for (int i = 0; i < 1000; ++i) {
-        integrator.step(1);
-        State state = context.getState(State::Positions | State::Forces);
-        for (int j = 0; j < numConstraints; ++j) {
-            int particle1, particle2;
-            double distance;
-            system.getConstraintParameters(j, particle1, particle2, distance);
-            Vec3 p1 = state.getPositions()[particle1];
-            Vec3 p2 = state.getPositions()[particle2];
-            double dist = std::sqrt((p1[0]-p2[0])*(p1[0]-p2[0])+(p1[1]-p2[1])*(p1[1]-p2[1])+(p1[2]-p2[2])*(p1[2]-p2[2]));
-            ASSERT_EQUAL_TOL(distance, dist, 1e-5);
-        }
-    }
-}
+#include "CpuTests.h"
+#include "TestSettle.h"
 
-int main(int argc, char* argv[]) {
-    try {
-        if (!CpuPlatform::isProcessorSupported()) {
-            cout << "CPU is not supported.  Exiting." << endl;
-            return 0;
-        }
-        testConstraints();
-    }
-    catch(const exception& e) {
-        cout << "exception: " << e.what() << endl;
-        return 1;
-    }
-    cout << "Done" << endl;
-    return 0;
+void runPlatformTests() {
 }

platforms/cuda/CMakeLists.txt

@@ -13,9 +13,9 @@
 #----------------------------------------------------
 
 set(OPENMM_BUILD_CUDA_TESTS TRUE CACHE BOOL "Whether to build CUDA test cases")
-if(OPENMM_BUILD_CUDA_TESTS)
+if(BUILD_TESTING AND OPENMM_BUILD_CUDA_TESTS)
     SUBDIRS (tests)
-endif(OPENMM_BUILD_CUDA_TESTS)
+endif(BUILD_TESTING AND OPENMM_BUILD_CUDA_TESTS)
 
 # The source is organized into subdirectories, but we handle them all from
 # this CMakeLists file rather than letting CMake visit them as SUBDIRS.

platforms/cuda/include/CudaExpressionUtilities.h

@@ -9,7 +9,7 @@
  * Biological Structures at Stanford, funded under the NIH Roadmap for        *
  * Medical Research, grant U54 GM072970. See https://simtk.org.               *
  *                                                                            *
- * Portions copyright (c) 2009-2014 Stanford University and the Authors.      *
+ * Portions copyright (c) 2009-2015 Stanford University and the Authors.      *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -89,6 +89,10 @@ public:
      * @param function   the function for which to get a placeholder
      */
     Lepton::CustomFunction* getFunctionPlaceholder(const TabulatedFunction& function);
+    /**
+     * Get a Lepton::CustomFunction that can be used to represent the periodicdistance() function when parsing expressions.
+     */
+    Lepton::CustomFunction* getPeriodicDistancePlaceholder();
 private:
     class FunctionPlaceholder : public Lepton::CustomFunction {
         public:
@@ -114,13 +118,13 @@ private:
             const std::vector<const TabulatedFunction*>& functions, const std::vector<std::pair<std::string, std::string> >& functionNames,
             const std::string& prefix, const std::vector<std::vector<double> >& functionParams, const std::vector<Lepton::ParsedExpression>& allExpressions, const std::string& tempType);
     std::string getTempName(const Lepton::ExpressionTreeNode& node, const std::vector<std::pair<Lepton::ExpressionTreeNode, std::string> >& temps);
-    void findRelatedTabulatedFunctions(const Lepton::ExpressionTreeNode& node, const Lepton::ExpressionTreeNode& searchNode,
+    void findRelatedCustomFunctions(const Lepton::ExpressionTreeNode& node, const Lepton::ExpressionTreeNode& searchNode,
             std::vector<const Lepton::ExpressionTreeNode*>& nodes);
     void findRelatedPowers(const Lepton::ExpressionTreeNode& node, const Lepton::ExpressionTreeNode& searchNode,
             std::map<int, const Lepton::ExpressionTreeNode*>& powers);
     std::vector<std::vector<double> > computeFunctionParameters(const std::vector<const TabulatedFunction*>& functions);
     CudaContext& context;
-    FunctionPlaceholder fp1, fp2, fp3;
+    FunctionPlaceholder fp1, fp2, fp3, periodicDistance;
 };
 
 } // namespace OpenMM

platforms/cuda/include/CudaNonbondedUtilities.h

@@ -138,8 +138,12 @@ public:
     void prepareInteractions(int forceGroups);
     /**
      * Compute the nonbonded interactions.
+     * 
+     * @param forceGroups    the flags specifying which force groups to include
+     * @param includeForces  whether to compute forces
+     * @param includeEnergy  whether to compute the potential energy
      */
-    void computeInteractions(int forceGroups);
+    void computeInteractions(int forceGroups, bool includeForces, bool includeEnergy);
     /**
      * Check to see if the neighbor list arrays are large enough, and make them bigger if necessary.
      *
@@ -235,8 +239,10 @@ public:
      * @param useExclusions specifies whether exclusions are applied to this interaction
      * @param isSymmetric   specifies whether the interaction is symmetric
      * @param groups        the set of force groups this kernel is for
+     * @param includeForces whether this kernel should compute forces
+     * @param includeEnergy whether this kernel should compute potential energy
      */
-    CUfunction createInteractionKernel(const std::string& source, std::vector<ParameterInfo>& params, std::vector<ParameterInfo>& arguments, bool useExclusions, bool isSymmetric, int groups);
+    CUfunction createInteractionKernel(const std::string& source, std::vector<ParameterInfo>& params, std::vector<ParameterInfo>& arguments, bool useExclusions, bool isSymmetric, int groups, bool includeForces, bool includeEnergy);
     /**
      * Create the set of kernels that will be needed for a particular combination of force groups.
      * 
@@ -282,7 +288,8 @@ class CudaNonbondedUtilities::KernelSet {
 public:
     bool hasForces;
     double cutoffDistance;
-    CUfunction forceKernel;
+    std::string source;
+    CUfunction forceKernel, energyKernel, forceEnergyKernel;
     CUfunction findBlockBoundsKernel;
     CUfunction sortBoxDataKernel;
     CUfunction findInteractingBlocksKernel;

platforms/cuda/src/CudaBondedUtilities.cpp

@@ -99,7 +99,7 @@ void CudaBondedUtilities::initialize(const System& system) {
     s<<CudaKernelSources::vectorOps;
     for (int i = 0; i < (int) prefixCode.size(); i++)
         s<<prefixCode[i];
-    s<<"extern \"C\" __global__ void computeBondedForces(unsigned long long* __restrict__ forceBuffer, real* __restrict__ energyBuffer, const real4* __restrict__ posq, int groups";
+    s<<"extern \"C\" __global__ void computeBondedForces(unsigned long long* __restrict__ forceBuffer, real* __restrict__ energyBuffer, const real4* __restrict__ posq, int groups, real4 periodicBoxSize, real4 invPeriodicBoxSize, real4 periodicBoxVecX, real4 periodicBoxVecY, real4 periodicBoxVecZ";
     for (int force = 0; force < numForces; force++) {
         for (int i = 0; i < (int) atomIndices[force].size(); i++) {
             int indexWidth = atomIndices[force][i]->getElementSize()/4;
@@ -161,6 +161,11 @@ void CudaBondedUtilities::computeInteractions(int groups) {
         kernelArgs.push_back(&context.getEnergyBuffer().getDevicePointer());
         kernelArgs.push_back(&context.getPosq().getDevicePointer());
         kernelArgs.push_back(NULL);
+        kernelArgs.push_back(context.getPeriodicBoxSizePointer());
+        kernelArgs.push_back(context.getInvPeriodicBoxSizePointer());
+        kernelArgs.push_back(context.getPeriodicBoxVecXPointer());
+        kernelArgs.push_back(context.getPeriodicBoxVecYPointer());
+        kernelArgs.push_back(context.getPeriodicBoxVecZPointer());
         for (int i = 0; i < (int) atomIndices.size(); i++)
             for (int j = 0; j < (int) atomIndices[i].size(); j++)
                 kernelArgs.push_back(&atomIndices[i][j]->getDevicePointer());