Merge branch 'master' of github.com:leeping/openmm

platforms/opencl/src/OpenCLPlatform.cpp

@@ -133,7 +133,7 @@ void OpenCLPlatform::contextDestroyed(ContextImpl& context) const {
 
 OpenCLPlatform::PlatformData::PlatformData(const System& system, const string& platformPropValue, const string& deviceIndexProperty,
         const string& precisionProperty, const string& cpuPmeProperty) : removeCM(false), stepCount(0), computeForceCount(0), time(0.0)  {
-    int platformIndex = 0;
+    int platformIndex = -1;
     if (platformPropValue.length() > 0)
         stringstream(platformPropValue) >> platformIndex;
     vector<string> devices;
@@ -161,6 +161,8 @@ OpenCLPlatform::PlatformData::PlatformData(const System& system, const string& p
         deviceIndex << contexts[i]->getDeviceIndex();
         deviceName << contexts[i]->getDevice().getInfo<CL_DEVICE_NAME>();
     }
+    platformIndex = contexts[0]->getPlatformIndex();
+
     useCpuPme = (cpuPmeProperty == "true" && !contexts[0]->getUseDoublePrecision());
     propertyValues[OpenCLPlatform::OpenCLDeviceIndex()] = deviceIndex.str();
     propertyValues[OpenCLPlatform::OpenCLDeviceName()] = deviceName.str();

platforms/opencl/src/kernels/coulombLennardJones.cl

@@ -22,8 +22,11 @@ if ((!isExcluded && r2 < CUTOFF_SQUARED) || needCorrection) {
     if (needCorrection) {
         // Subtract off the part of this interaction that was included in the reciprocal space contribution.
 
-        tempForce = -prefactor*((1.0f-erfcAlphaR)-alphaR*expAlphaRSqr*TWO_OVER_SQRT_PI);
-        tempEnergy += -prefactor*(1.0f-erfcAlphaR);
+        if (1-erfcAlphaR > 1e-6) {
+            real erfAlphaR = erf(alphaR); // Our erfc approximation is not accurate enough when r is very small, which happens with Drude particles.
+            tempForce = -prefactor*(erfAlphaR-alphaR*expAlphaRSqr*TWO_OVER_SQRT_PI);
+            tempEnergy += -prefactor*erfAlphaR;
+        }
     }
     else {
 #if HAS_LENNARD_JONES

platforms/opencl/src/kernels/customNonbondedGroups.cl

+#ifdef SUPPORTS_64_BIT_ATOMICS
+#pragma OPENCL EXTENSION cl_khr_int64_base_atomics : enable
+#endif
+
+#define WARPS_PER_GROUP (THREAD_BLOCK_SIZE/TILE_SIZE)
+
+typedef struct {
+    real x, y, z;
+    real q;
+    real fx, fy, fz;
+    ATOM_PARAMETER_DATA
+#ifndef PARAMETER_SIZE_IS_EVEN
+    real padding;
+#endif
+} AtomData;
+
+/**
+ * This function is used on devices that don't support 64 bit atomics.  Multiple threads within
+ * a single tile might have computed forces on the same atom.  This loops over them and makes sure
+ * that only one thread updates the force on any given atom.
+ */
+void writeForces(__global real4* forceBuffers,__local AtomData* localData, int atomIndex) {
+    localData[get_local_id(0)].x = atomIndex;
+    SYNC_WARPS;
+    real4 forceSum = (real4) 0;
+    int start = (get_local_id(0)/TILE_SIZE)*TILE_SIZE;
+    int end = start+32;
+    bool isFirst = true;
+    for (int i = start; i < end; i++)
+        if (localData[i].x == atomIndex) {
+            forceSum += (real4) (localData[i].fx, localData[i].fy, localData[i].fz, 0);
+            isFirst &= (i >= get_local_id(0));
+        }
+    const unsigned int warp = get_global_id(0)/TILE_SIZE;
+    unsigned int offset = atomIndex + warp*PADDED_NUM_ATOMS;
+    if (isFirst)
+        forceBuffers[offset] += forceSum;
+    SYNC_WARPS;
+}
+
+__kernel void computeInteractionGroups(
+#ifdef SUPPORTS_64_BIT_ATOMICS
+        __global long* restrict forceBuffers,
+#else
+        __global real4* restrict forceBuffers,
+#endif
+        __global real* restrict energyBuffer, __global const real4* restrict posq,
+        __global const int4* restrict groupData, real4 periodicBoxSize, real4 invPeriodicBoxSize
+        PARAMETER_ARGUMENTS) {
+    const unsigned int totalWarps = get_global_size(0)/TILE_SIZE;
+    const unsigned int warp = get_global_id(0)/TILE_SIZE; // global warpIndex
+    const unsigned int tgx = get_local_id(0) & (TILE_SIZE-1); // index within the warp
+    const unsigned int tbx = get_local_id(0) - tgx;           // block warpIndex
+    real energy = 0.0f;
+    __local AtomData localData[THREAD_BLOCK_SIZE];
+
+    const unsigned int startTile = FIRST_TILE+warp*(LAST_TILE-FIRST_TILE)/totalWarps;
+    const unsigned int endTile = FIRST_TILE+(warp+1)*(LAST_TILE-FIRST_TILE)/totalWarps;
+    for (int tile = startTile; tile < endTile; tile++) {
+        const int4 atomData = groupData[TILE_SIZE*tile+tgx];
+        const int atom1 = atomData.x;
+        const int atom2 = atomData.y;
+        const int rangeStart = atomData.z&0xFFFF;
+        const int rangeEnd = (atomData.z>>16)&0xFFFF;
+        const int exclusions = atomData.w;
+        real4 posq1 = posq[atom1];
+        LOAD_ATOM1_PARAMETERS
+        real4 force = (real4) (0);
+        real4 posq2 = posq[atom2];
+        localData[get_local_id(0)].x = posq2.x;
+        localData[get_local_id(0)].y = posq2.y;
+        localData[get_local_id(0)].z = posq2.z;
+        localData[get_local_id(0)].q = posq2.w;
+        LOAD_LOCAL_PARAMETERS
+        localData[get_local_id(0)].fx = 0.0f;
+        localData[get_local_id(0)].fy = 0.0f;
+        localData[get_local_id(0)].fz = 0.0f;
+        int tj = tgx;
+        SYNC_WARPS;
+        for (int j = rangeStart; j < rangeEnd; j++) {
+            if (tj < rangeEnd) {
+                bool isExcluded = (((exclusions>>tj)&1) == 0);
+                int localIndex = tbx+tj;
+                posq2 = (real4) (localData[localIndex].x, localData[localIndex].y, localData[localIndex].z, localData[localIndex].q);
+                real4 delta = (real4) (posq2.xyz - posq1.xyz, 0);
+#ifdef USE_PERIODIC
+                delta.xyz -= floor(delta.xyz*invPeriodicBoxSize.xyz+0.5f)*periodicBoxSize.xyz;
+#endif
+                real r2 = delta.x*delta.x + delta.y*delta.y + delta.z*delta.z;
+#ifdef USE_CUTOFF
+                if (!isExcluded && r2 < CUTOFF_SQUARED) {
+#endif
+                    real invR = RSQRT(r2);
+                    real r = RECIP(invR);
+                    LOAD_ATOM2_PARAMETERS
+                    real dEdR = 0.0f;
+                    real tempEnergy = 0.0f;
+                    COMPUTE_INTERACTION
+                    energy += tempEnergy;
+                    delta *= dEdR;
+                    force.xyz -= delta.xyz;
+                    localData[localIndex].fx += delta.x;
+                    localData[localIndex].fy += delta.y;
+                    localData[localIndex].fz += delta.z;
+#ifdef USE_CUTOFF
+                }
+#endif
+            }
+            tj = (tj == rangeEnd-1 ? rangeStart : tj+1);
+            SYNC_WARPS;
+        }
+#ifdef SUPPORTS_64_BIT_ATOMICS
+        if (exclusions != 0) {
+            atom_add(&forceBuffers[atom1], (long) (force.x*0x100000000));
+            atom_add(&forceBuffers[atom1+PADDED_NUM_ATOMS], (long) (force.y*0x100000000));
+            atom_add(&forceBuffers[atom1+2*PADDED_NUM_ATOMS], (long) (force.z*0x100000000));
+        }
+        atom_add(&forceBuffers[atom2], (long) (localData[get_local_id(0)].fx*0x100000000));
+        atom_add(&forceBuffers[atom2+PADDED_NUM_ATOMS], (long) (localData[get_local_id(0)].fy*0x100000000));
+        atom_add(&forceBuffers[atom2+2*PADDED_NUM_ATOMS], (long) (localData[get_local_id(0)].fz*0x100000000));
+#else
+        writeForces(forceBuffers, localData, atom2);
+        localData[get_local_id(0)].fx = force.x;
+        localData[get_local_id(0)].fy = force.y;
+        localData[get_local_id(0)].fz = force.z;
+        writeForces(forceBuffers, localData, atom1);
+#endif
+    }
+    energyBuffer[get_global_id(0)] += energy;
+}
\ No newline at end of file

platforms/opencl/tests/CMakeLists.txt

@@ -39,13 +39,13 @@ FOREACH(TEST_PROG ${TEST_PROGS})
         SET(NONBOND_TEST "TestOpenCLNonbondedForce2")
         ADD_EXECUTABLE(${NONBOND_TEST} ${TEST_PROG})
 
-        SET_TARGET_PROPERTIES(${NONBOND_TEST} PROPERTIES COMPILE_FLAGS ${NONBOND_DEFINE_STRING} )
+        SET_TARGET_PROPERTIES(${NONBOND_TEST} PROPERTIES COMPILE_FLAGS "-msse2 ${NONBOND_DEFINE_STRING}" )
         ADD_TEST(${NONBOND_TEST} ${EXECUTABLE_OUTPUT_PATH}/${NONBOND_TEST})
 
         # OBC
 
         SET(DEFINE_STRING "${DEFINE_STRING} -DIMPLICIT_SOLVENT=1")
-        SET_TARGET_PROPERTIES(${TEST_ROOT} PROPERTIES COMPILE_FLAGS ${DEFINE_STRING} )
+        SET_TARGET_PROPERTIES(${TEST_ROOT} PROPERTIES COMPILE_FLAGS "-msse2 ${DEFINE_STRING}" )
 
         IF( INCLUDE_SERIALIZATION )
             TARGET_LINK_LIBRARIES(${NONBOND_TEST} ${SHARED_TARGET} ${SHARED_OPENMM_SERIALIZATION} )
@@ -54,6 +54,8 @@ FOREACH(TEST_PROG ${TEST_PROGS})
             TARGET_LINK_LIBRARIES(${NONBOND_TEST} ${SHARED_TARGET})
         ENDIF( INCLUDE_SERIALIZATION )
 
+    ELSE( ${TEST_ROOT} STREQUAL "TestOpenCLGBSAOBCForce2" )
+        SET_TARGET_PROPERTIES(${TEST_ROOT} PROPERTIES COMPILE_FLAGS -msse2)
     ENDIF( ${TEST_ROOT} STREQUAL "TestOpenCLGBSAOBCForce2" )
     ADD_TEST(${TEST_ROOT}Single ${EXECUTABLE_OUTPUT_PATH}/${TEST_ROOT} single)
     IF (OPENMM_BUILD_OPENCL_DOUBLE_PRECISION_TESTS)

platforms/opencl/tests/TestOpenCLCustomNonbondedForce.cpp

@@ -34,6 +34,9 @@
  * This tests all the different force terms in the OpenCL implementation of CustomNonbondedForce.
  */
 
+#ifdef WIN32
+  #define _USE_MATH_DEFINES // Needed to get M_PI
+#endif
 #include "openmm/internal/AssertionUtilities.h"
 #include "sfmt/SFMT.h"
 #include "openmm/Context.h"
@@ -42,6 +45,7 @@
 #include "openmm/NonbondedForce.h"
 #include "openmm/System.h"
 #include "openmm/VerletIntegrator.h"
+#include <cmath>
 #include <iostream>
 #include <vector>
 
@@ -538,6 +542,179 @@ void testLongRangeCorrection() {
     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);
+}
+
 int main(int argc, char* argv[]) {
     try {
         if (argc > 1)
@@ -553,6 +730,9 @@ int main(int argc, char* argv[]) {
         testParallelComputation();
         testSwitchingFunction();
         testLongRangeCorrection();
+        testInteractionGroups();
+        testLargeInteractionGroup();
+        testInteractionGroupLongRangeCorrection();
     }
     catch(const exception& e) {
         cout << "exception: " << e.what() << endl;

platforms/opencl/tests/TestOpenCLMonteCarloAnisotropicBarostat.cpp

@@ -53,44 +53,6 @@ using namespace std;
 
 OpenCLPlatform platform;
 
-void testChangingBoxSize() {
-    System system;
-    system.setDefaultPeriodicBoxVectors(Vec3(4, 0, 0), Vec3(0, 5, 0), Vec3(0, 0, 6));
-    system.addParticle(1.0);
-    NonbondedForce* nb = new NonbondedForce();
-    nb->setNonbondedMethod(NonbondedForce::CutoffPeriodic);
-    nb->setCutoffDistance(2.0);
-    nb->addParticle(1, 0.5, 0.5);
-    system.addForce(nb);
-    LangevinIntegrator integrator(300.0, 1.0, 0.01);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions;
-    positions.push_back(Vec3());
-    context.setPositions(positions);
-    Vec3 x, y, z;
-    context.getState(State::Forces).getPeriodicBoxVectors(x, y, z);
-    ASSERT_EQUAL_VEC(Vec3(4, 0, 0), x, 0);
-    ASSERT_EQUAL_VEC(Vec3(0, 5, 0), y, 0);
-    ASSERT_EQUAL_VEC(Vec3(0, 0, 6), z, 0);
-    context.setPeriodicBoxVectors(Vec3(7, 0, 0), Vec3(0, 8, 0), Vec3(0, 0, 9));
-    context.getState(State::Forces).getPeriodicBoxVectors(x, y, z);
-    ASSERT_EQUAL_VEC(Vec3(7, 0, 0), x, 0);
-    ASSERT_EQUAL_VEC(Vec3(0, 8, 0), y, 0);
-    ASSERT_EQUAL_VEC(Vec3(0, 0, 9), z, 0);
-    
-    // Shrinking the box too small should produce an exception.
-    
-    context.setPeriodicBoxVectors(Vec3(7, 0, 0), Vec3(0, 3.9, 0), Vec3(0, 0, 9));
-    bool ok = true;
-    try {
-        context.getState(State::Forces).getPeriodicBoxVectors(x, y, z);
-        ok = false;
-    }
-    catch (exception& ex) {
-    }
-    ASSERT(ok);
-}
-
 void testIdealGas() {
     const int numParticles = 64;
     const int frequency = 10;
@@ -112,7 +74,7 @@ void testIdealGas() {
         system.addParticle(1.0);
         positions[i] = Vec3(initialLength*genrand_real2(sfmt), 0.5*initialLength*genrand_real2(sfmt), 2*initialLength*genrand_real2(sfmt));
     }
-    MonteCarloAnisotropicBarostat* barostat = new MonteCarloAnisotropicBarostat(Vec3(pressure, pressure, pressure), temp[0], frequency);
+    MonteCarloAnisotropicBarostat* barostat = new MonteCarloAnisotropicBarostat(Vec3(pressure, pressure, pressure), temp[0], true, true, true, frequency);
     system.addForce(barostat);
     
     // Test it for three different temperatures.
@@ -170,7 +132,7 @@ void testIdealGasAxis(int axis) {
         system.addParticle(1.0);
         positions[i] = Vec3(initialLength*genrand_real2(sfmt), 0.5*initialLength*genrand_real2(sfmt), 2*initialLength*genrand_real2(sfmt));
     }
-    MonteCarloAnisotropicBarostat* barostat = new MonteCarloAnisotropicBarostat(Vec3(pressure, pressure, pressure), temp[0], frequency, scaleX, scaleY, scaleZ);
+    MonteCarloAnisotropicBarostat* barostat = new MonteCarloAnisotropicBarostat(Vec3(pressure, pressure, pressure), temp[0], scaleX, scaleY, scaleZ, frequency);
     system.addForce(barostat);
     
     // Test it for three different temperatures.
@@ -226,7 +188,7 @@ void testRandomSeed() {
         forceField->addParticle((i%2 == 0 ? 1.0 : -1.0), 1.0, 5.0);
     }
     system.addForce(forceField);
-    MonteCarloAnisotropicBarostat* barostat = new MonteCarloAnisotropicBarostat(Vec3(pressure, pressure, pressure), temp, 1);
+    MonteCarloAnisotropicBarostat* barostat = new MonteCarloAnisotropicBarostat(Vec3(pressure, pressure, pressure), temp, true, true, true, 1);
     system.addForce(barostat);
     vector<Vec3> positions(numParticles);
     vector<Vec3> velocities(numParticles);
@@ -332,7 +294,7 @@ void testEinsteinCrystal() {
             system.addForce(force);
             system.addForce(nb);
             // Create the barostat.
-            MonteCarloAnisotropicBarostat* barostat = new MonteCarloAnisotropicBarostat(Vec3(pres3[p], pres3[p], pres3[p]), temp, frequency, (a==0||a==3), (a==1||a==3), (a==2||a==3));
+            MonteCarloAnisotropicBarostat* barostat = new MonteCarloAnisotropicBarostat(Vec3(pres3[p], pres3[p], pres3[p]), temp, (a==0||a==3), (a==1||a==3), (a==2||a==3), frequency);
             system.addForce(barostat);
             barostat->setTemperature(temp);
             LangevinIntegrator integrator(temp, 0.1, 0.01);
@@ -422,7 +384,6 @@ int main(int argc, char* argv[]) {
     try {
         if (argc > 1)
             platform.setPropertyDefaultValue("OpenCLPrecision", string(argv[1]));
-        testChangingBoxSize();
         testIdealGas();
         testIdealGasAxis(0);
         testIdealGasAxis(1);

platforms/reference/include/ReferenceCustomHbondIxn.h

@@ -29,6 +29,7 @@
 #include "lepton/ExpressionProgram.h"
 #include "lepton/ParsedExpression.h"
 #include <map>
+#include <set>
 #include <vector>
 
 // ---------------------------------------------------------------------------------------
@@ -143,10 +144,8 @@ class ReferenceCustomHbondIxn : public ReferenceBondIxn {
          @param atomCoordinates    atom coordinates
          @param donorParameters    donor parameters values       donorParameters[donorIndex][parameterIndex]
          @param acceptorParameters acceptor parameters values    acceptorParameters[acceptorIndex][parameterIndex]
-         @param exclusions         exclusion indices             exclusions[donorIndex][acceptorToExcludeIndex]
-                                   exclusions[donorIndex][0] = number of exclusions
-                                   exclusions[donorIndex][no.-1] = indices of acceptors to excluded from
-                                   interacting w/ donor donorIndex
+         @param exclusions         exclusion indices
+                                   exclusions[donorIndex] contains the list of excluded acceptors for that donor
          @param globalParameters   the values of global parameters
          @param forces             force array (forces added)
          @param totalEnergy        total energy
@@ -154,7 +153,7 @@ class ReferenceCustomHbondIxn : public ReferenceBondIxn {
          --------------------------------------------------------------------------------------- */
 
       void calculatePairIxn(std::vector<OpenMM::RealVec>& atomCoordinates, RealOpenMM** donorParameters, RealOpenMM** acceptorParameters,
-                            int** exclusions, const std::map<std::string, double>& globalParameters,
+                            std::vector<std::set<int> >& exclusions, const std::map<std::string, double>& globalParameters,
                             std::vector<OpenMM::RealVec>& forces, RealOpenMM* totalEnergy) const;
 
 // ---------------------------------------------------------------------------------------

platforms/reference/include/ReferenceCustomNonbondedIxn.h

@@ -29,6 +29,8 @@
 #include "ReferenceNeighborList.h"
 #include "lepton/ExpressionProgram.h"
 #include <map>
+#include <set>
+#include <utility>
 #include <vector>
 
 // ---------------------------------------------------------------------------------------
@@ -47,6 +49,7 @@ class ReferenceCustomNonbondedIxn {
       Lepton::ExpressionProgram forceExpression;
       std::vector<std::string> paramNames;
       std::vector<std::string> particleParamNames;
+      std::vector<std::pair<std::set<int>, std::set<int> > > interactionGroups;
 
       /**---------------------------------------------------------------------------------------
 
@@ -97,6 +100,17 @@ class ReferenceCustomNonbondedIxn {
 
       void setUseCutoff( RealOpenMM distance, const OpenMM::NeighborList& neighbors );
 
+      /**---------------------------------------------------------------------------------------
+
+         Restrict the force to a list of interaction groups.
+
+         @param distance            the cutoff distance
+         @param neighbors           the neighbor list to use
+
+         --------------------------------------------------------------------------------------- */
+
+      void setInteractionGroups(const std::vector<std::pair<std::set<int>, std::set<int> > >& groups);
+
       /**---------------------------------------------------------------------------------------
       
          Set the force to use a switching function.
@@ -126,10 +140,8 @@ class ReferenceCustomNonbondedIxn {
          @param numberOfAtoms    number of atoms
          @param atomCoordinates  atom coordinates
          @param atomParameters   atom parameters (charges, c6, c12, ...)     atomParameters[atomIndex][paramterIndex]
-         @param exclusions       atom exclusion indices                      exclusions[atomIndex][atomToExcludeIndex]
-                                 exclusions[atomIndex][0] = number of exclusions
-                                 exclusions[atomIndex][1-no.] = atom indices of atoms to excluded from
-                                 interacting w/ atom atomIndex
+         @param exclusions       atom exclusion indices
+                                 exclusions[atomIndex] contains the list of exclusions for that atom
          @param fixedParameters  non atom parameters (not currently used)
          @param globalParameters the values of global parameters
          @param forces           force array (forces added)
@@ -139,7 +151,7 @@ class ReferenceCustomNonbondedIxn {
          --------------------------------------------------------------------------------------- */
 
       void calculatePairIxn( int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates,
-                            RealOpenMM** atomParameters, int** exclusions,
+                            RealOpenMM** atomParameters, std::vector<std::set<int> >& exclusions,
                             RealOpenMM* fixedParameters, const std::map<std::string, double>& globalParameters,
                             std::vector<OpenMM::RealVec>& forces, RealOpenMM* energyByAtom, RealOpenMM* totalEnergy ) const;
 

platforms/reference/include/ReferenceKernels.h

@@ -572,7 +572,7 @@ public:
     void copyParametersToContext(ContextImpl& context, const NonbondedForce& force);
 private:
     int numParticles, num14;
-    int **exclusionArray, **bonded14IndexArray;
+    int **bonded14IndexArray;
     RealOpenMM **particleParamArray, **bonded14ParamArray;
     RealOpenMM nonbondedCutoff, switchingDistance, rfDielectric, ewaldAlpha, dispersionCoefficient;
     int kmax[3], gridSize[3];
@@ -615,7 +615,6 @@ public:
     void copyParametersToContext(ContextImpl& context, const CustomNonbondedForce& force);
 private:
     int numParticles;
-    int **exclusionArray;
     RealOpenMM **particleParamArray;
     RealOpenMM nonbondedCutoff, switchingDistance, periodicBoxSize[3], longRangeCoefficient;
     bool useSwitchingFunction, hasInitializedLongRangeCorrection;
@@ -624,6 +623,7 @@ private:
     std::vector<std::set<int> > exclusions;
     Lepton::ExpressionProgram energyExpression, forceExpression;
     std::vector<std::string> parameterNames, globalParameterNames;
+    std::vector<std::pair<std::set<int>, std::set<int> > > interactionGroups;
     NonbondedMethod nonbondedMethod;
     NeighborList* neighborList;
 };
@@ -819,7 +819,6 @@ public:
 private:
     int numDonors, numAcceptors, numParticles;
     bool isPeriodic;
-    int **exclusionArray;
     RealOpenMM **donorParamArray, **acceptorParamArray;
     RealOpenMM nonbondedCutoff;
     ReferenceCustomHbondIxn* ixn;

platforms/reference/include/ReferenceLJCoulombIxn.h

@@ -156,10 +156,8 @@ class ReferenceLJCoulombIxn {
          @param numberOfAtoms    number of atoms
          @param atomCoordinates  atom coordinates
          @param atomParameters   atom parameters (charges, c6, c12, ...)     atomParameters[atomIndex][paramterIndex]
-         @param exclusions       atom exclusion indices                      exclusions[atomIndex][atomToExcludeIndex]
-                                 exclusions[atomIndex][0] = number of exclusions
-                                 exclusions[atomIndex][1-no.] = atom indices of atoms to excluded from
-                                 interacting w/ atom atomIndex
+         @param exclusions       atom exclusion indices
+                                 exclusions[atomIndex] contains the list of exclusions for that atom
          @param fixedParameters  non atom parameters (not currently used)
          @param forces           force array (forces added)
          @param energyByAtom     atom energy
@@ -170,7 +168,7 @@ class ReferenceLJCoulombIxn {
          --------------------------------------------------------------------------------------- */
           
       void calculatePairIxn(int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates,
-                            RealOpenMM** atomParameters, int** exclusions,
+                            RealOpenMM** atomParameters, std::vector<std::set<int> >& exclusions,
                             RealOpenMM* fixedParameters, std::vector<OpenMM::RealVec>& forces,
                             RealOpenMM* energyByAtom, RealOpenMM* totalEnergy, bool includeDirect, bool includeReciprocal) const;
 
@@ -182,10 +180,8 @@ private:
          @param numberOfAtoms    number of atoms
          @param atomCoordinates  atom coordinates
          @param atomParameters   atom parameters (charges, c6, c12, ...)     atomParameters[atomIndex][paramterIndex]
-         @param exclusions       atom exclusion indices                      exclusions[atomIndex][atomToExcludeIndex]
-                                 exclusions[atomIndex][0] = number of exclusions
-                                 exclusions[atomIndex][1-no.] = atom indices of atoms to excluded from
-                                 interacting w/ atom atomIndex
+         @param exclusions       atom exclusion indices
+                                 exclusions[atomIndex] contains the list of exclusions for that atom
          @param fixedParameters  non atom parameters (not currently used)
          @param forces           force array (forces added)
          @param energyByAtom     atom energy
@@ -196,7 +192,7 @@ private:
          --------------------------------------------------------------------------------------- */
           
       void calculateEwaldIxn(int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates,
-                            RealOpenMM** atomParameters, int** exclusions,
+                            RealOpenMM** atomParameters, std::vector<std::set<int> >& exclusions,
                             RealOpenMM* fixedParameters, std::vector<OpenMM::RealVec>& forces,
                             RealOpenMM* energyByAtom, RealOpenMM* totalEnergy, bool includeDirect, bool includeReciprocal) const;
 };

platforms/reference/src/ReferenceKernels.cpp

@@ -805,7 +805,6 @@ void ReferenceCalcCustomTorsionForceKernel::copyParametersToContext(ContextImpl&
 
 ReferenceCalcNonbondedForceKernel::~ReferenceCalcNonbondedForceKernel() {
     disposeRealArray(particleParamArray, numParticles);
-    disposeIntArray(exclusionArray, numParticles);
     disposeIntArray(bonded14IndexArray, num14);
     disposeRealArray(bonded14ParamArray, num14);
     if (neighborList != NULL)
@@ -843,14 +842,6 @@ void ReferenceCalcNonbondedForceKernel::initialize(const System& system, const N
         particleParamArray[i][2] = static_cast<RealOpenMM>(charge);
     }
     this->exclusions = exclusions;
-    exclusionArray = new int*[numParticles];
-    for (int i = 0; i < numParticles; ++i) {
-        exclusionArray[i] = new int[exclusions[i].size()+1];
-        exclusionArray[i][0] = exclusions[i].size();
-        int index = 0;
-        for (set<int>::const_iterator iter = exclusions[i].begin(); iter != exclusions[i].end(); ++iter)
-            exclusionArray[i][++index] = *iter;
-    }
     for (int i = 0; i < num14; ++i) {
         int particle1, particle2;
         double charge, radius, depth;
@@ -914,7 +905,7 @@ double ReferenceCalcNonbondedForceKernel::execute(ContextImpl& context, bool inc
         clj.setUsePME(ewaldAlpha, gridSize);
     if (useSwitchingFunction)
         clj.setUseSwitchingFunction(switchingDistance);
-    clj.calculatePairIxn(numParticles, posData, particleParamArray, exclusionArray, 0, forceData, 0, includeEnergy ? &energy : NULL, includeDirect, includeReciprocal);
+    clj.calculatePairIxn(numParticles, posData, particleParamArray, exclusions, 0, forceData, 0, includeEnergy ? &energy : NULL, includeDirect, includeReciprocal);
     if (includeDirect) {
         ReferenceBondForce refBondForce;
         ReferenceLJCoulomb14 nonbonded14;
@@ -1002,7 +993,6 @@ public:
 
 ReferenceCalcCustomNonbondedForceKernel::~ReferenceCalcCustomNonbondedForceKernel() {
     disposeRealArray(particleParamArray, numParticles);
-    disposeIntArray(exclusionArray, numParticles);
     if (neighborList != NULL)
         delete neighborList;
     if (forceCopy != NULL)
@@ -1032,14 +1022,6 @@ void ReferenceCalcCustomNonbondedForceKernel::initialize(const System& system, c
         for (int j = 0; j < numParameters; j++)
             particleParamArray[i][j] = static_cast<RealOpenMM>(parameters[j]);
     }
-    exclusionArray = new int*[numParticles];
-    for (int i = 0; i < numParticles; ++i) {
-        exclusionArray[i] = new int[exclusions[i].size()+1];
-        exclusionArray[i][0] = exclusions[i].size();
-        int index = 0;
-        for (set<int>::const_iterator iter = exclusions[i].begin(); iter != exclusions[i].end(); ++iter)
-            exclusionArray[i][++index] = *iter;
-    }
     nonbondedMethod = CalcCustomNonbondedForceKernel::NonbondedMethod(force.getNonbondedMethod());
     nonbondedCutoff = (RealOpenMM) force.getCutoffDistance();
     if (nonbondedMethod == NoCutoff) {
@@ -1090,6 +1072,14 @@ void ReferenceCalcCustomNonbondedForceKernel::initialize(const System& system, c
         longRangeCoefficient = 0.0;
         hasInitializedLongRangeCorrection = true;
     }
+    
+    // Record the interaction groups.
+    
+    for (int i = 0; i < force.getNumInteractionGroups(); i++) {
+        set<int> set1, set2;
+        force.getInteractionGroupParameters(i, set1, set2);
+        interactionGroups.push_back(make_pair(set1, set2));
+    }
 }
 
 double ReferenceCalcCustomNonbondedForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
@@ -1109,6 +1099,8 @@ double ReferenceCalcCustomNonbondedForceKernel::execute(ContextImpl& context, bo
             throw OpenMMException("The periodic box size has decreased to less than twice the nonbonded cutoff.");
         ixn.setPeriodic(box);
     }
+    if (interactionGroups.size() > 0)
+        ixn.setInteractionGroups(interactionGroups);
     bool globalParamsChanged = false;
     for (int i = 0; i < (int) globalParameterNames.size(); i++) {
         double value = context.getParameter(globalParameterNames[i]);
@@ -1118,7 +1110,7 @@ double ReferenceCalcCustomNonbondedForceKernel::execute(ContextImpl& context, bo
     }
     if (useSwitchingFunction)
         ixn.setUseSwitchingFunction(switchingDistance);
-    ixn.calculatePairIxn(numParticles, posData, particleParamArray, exclusionArray, 0, globalParamValues, forceData, 0, includeEnergy ? &energy : NULL);
+    ixn.calculatePairIxn(numParticles, posData, particleParamArray, exclusions, 0, globalParamValues, forceData, 0, includeEnergy ? &energy : NULL);
     
     // Add in the long range correction.
     
@@ -1499,7 +1491,6 @@ void ReferenceCalcCustomExternalForceKernel::copyParametersToContext(ContextImpl
 ReferenceCalcCustomHbondForceKernel::~ReferenceCalcCustomHbondForceKernel() {
     disposeRealArray(donorParamArray, numDonors);
     disposeRealArray(acceptorParamArray, numAcceptors);
-    disposeIntArray(exclusionArray, numDonors);
     if (ixn != NULL)
         delete ixn;
 }
@@ -1546,14 +1537,6 @@ void ReferenceCalcCustomHbondForceKernel::initialize(const System& system, const
         for (int j = 0; j < numAcceptorParameters; j++)
             acceptorParamArray[i][j] = static_cast<RealOpenMM>(parameters[j]);
     }
-    exclusionArray = new int*[numDonors];
-    for (int i = 0; i < numDonors; ++i) {
-        exclusionArray[i] = new int[exclusions[i].size()+1];
-        exclusionArray[i][0] = exclusions[i].size();
-        int index = 0;
-        for (set<int>::const_iterator iter = exclusions[i].begin(); iter != exclusions[i].end(); ++iter)
-            exclusionArray[i][++index] = *iter;
-    }
     NonbondedMethod nonbondedMethod = CalcCustomHbondForceKernel::NonbondedMethod(force.getNonbondedMethod());
     nonbondedCutoff = (RealOpenMM) force.getCutoffDistance();
 
@@ -1602,7 +1585,7 @@ double ReferenceCalcCustomHbondForceKernel::execute(ContextImpl& context, bool i
     map<string, double> globalParameters;
     for (int i = 0; i < (int) globalParameterNames.size(); i++)
         globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
-    ixn->calculatePairIxn(posData, donorParamArray, acceptorParamArray, exclusionArray, globalParameters, forceData, includeEnergy ? &energy : NULL);
+    ixn->calculatePairIxn(posData, donorParamArray, acceptorParamArray, exclusions, globalParameters, forceData, includeEnergy ? &energy : NULL);
     return energy;
 }
 

platforms/reference/src/SimTKReference/ReferenceCustomHbondIxn.cpp

@@ -34,6 +34,7 @@
 
 using std::map;
 using std::pair;
+using std::set;
 using std::string;
 using std::stringstream;
 using std::vector;
@@ -109,10 +110,8 @@ void ReferenceCustomHbondIxn::setPeriodic(RealVec& boxSize) {
    @param atomCoordinates    atom coordinates
    @param donorParameters    donor parameters values       donorParameters[donorIndex][parameterIndex]
    @param acceptorParameters acceptor parameters values    acceptorParameters[acceptorIndex][parameterIndex]
-   @param exclusions         exclusion indices             exclusions[donorIndex][acceptorToExcludeIndex]
-                             exclusions[donorIndex][0] = number of exclusions
-                             exclusions[donorIndex][no.-1] = indices of acceptors to excluded from
-                             interacting w/ donor donorIndex
+   @param exclusions         exclusion indices
+                             exclusions[donorIndex] contains the list of excluded acceptors for that donor
    @param globalParameters   the values of global parameters
    @param forces             force array (forces added)
    @param totalEnergy        total energy
@@ -120,7 +119,7 @@ void ReferenceCustomHbondIxn::setPeriodic(RealVec& boxSize) {
    --------------------------------------------------------------------------------------- */
 
 void ReferenceCustomHbondIxn::calculatePairIxn(vector<RealVec>& atomCoordinates, RealOpenMM** donorParameters, RealOpenMM** acceptorParameters,
-                                             int** exclusions, const map<string, double>& globalParameters, vector<RealVec>& forces,
+                                             vector<set<int> >& exclusions, const map<string, double>& globalParameters, vector<RealVec>& forces,
                                              RealOpenMM* totalEnergy) const {
 
    map<string, double> variables = globalParameters;
@@ -129,18 +128,8 @@ void ReferenceCustomHbondIxn::calculatePairIxn(vector<RealVec>& atomCoordinates,
 
    int numDonors = donorAtoms.size();
    int numAcceptors = acceptorAtoms.size();
-   int* exclusionIndices = new int[numAcceptors];
-   for( int ii = 0; ii < numAcceptors; ii++ ){
-      exclusionIndices[ii] = -1;
-   }
 
    for( int donor = 0; donor < numDonors; donor++ ){
-
-      // set exclusions
-
-      for (int j = 1; j <= exclusions[donor][0]; j++)
-         exclusionIndices[exclusions[donor][j]] = donor;
-
       // Initialize per-donor parameters.
 
       for (int j = 0; j < (int) donorParamNames.size(); j++)
@@ -149,16 +138,13 @@ void ReferenceCustomHbondIxn::calculatePairIxn(vector<RealVec>& atomCoordinates,
       // loop over atom pairs
 
       for( int acceptor = 0; acceptor < numAcceptors; acceptor++ ){
-
-         if( exclusionIndices[acceptor] != donor ){
+         if (exclusions[donor].find(acceptor) == exclusions[donor].end()) {
              for (int j = 0; j < (int) acceptorParamNames.size(); j++)
                  variables[acceptorParamNames[j]] = acceptorParameters[acceptor][j];
              calculateOneIxn(donor, acceptor, atomCoordinates, variables, forces, totalEnergy);
          }
       }
    }
-
-   delete[] exclusionIndices;
 }
 
   /**---------------------------------------------------------------------------------------

platforms/reference/src/SimTKReference/ReferenceCustomNonbondedIxn.cpp

@@ -32,8 +32,10 @@
 #include "ReferenceCustomNonbondedIxn.h"
 
 using std::map;
+using std::pair;
 using std::string;
 using std::stringstream;
+using std::set;
 using std::vector;
 using OpenMM::RealVec;
 
@@ -94,6 +96,19 @@ ReferenceCustomNonbondedIxn::~ReferenceCustomNonbondedIxn( ){
     neighborList = &neighbors;
   }
 
+/**---------------------------------------------------------------------------------------
+
+   Restrict the force to a list of interaction groups.
+
+   @param distance            the cutoff distance
+   @param neighbors           the neighbor list to use
+
+   --------------------------------------------------------------------------------------- */
+
+void ReferenceCustomNonbondedIxn::setInteractionGroups(const vector<pair<set<int>, set<int> > >& groups) {
+    interactionGroups = groups;
+}
+
 /**---------------------------------------------------------------------------------------
 
    Set the force to use a switching function.
@@ -138,10 +153,8 @@ void ReferenceCustomNonbondedIxn::setUseSwitchingFunction( RealOpenMM distance )
    @param numberOfAtoms    number of atoms
    @param atomCoordinates  atom coordinates
    @param atomParameters   atom parameters                             atomParameters[atomIndex][paramterIndex]
-   @param exclusions       atom exclusion indices                      exclusions[atomIndex][atomToExcludeIndex]
-                           exclusions[atomIndex][0] = number of exclusions
-                           exclusions[atomIndex][1-no.] = atom indices of atoms to excluded from
-                           interacting w/ atom atomIndex
+   @param exclusions       atom exclusion indices
+                           exclusions[atomIndex] contains the list of exclusions for that atom
    @param fixedParameters  non atom parameters (not currently used)
    @param globalParameters the values of global parameters
    @param forces           force array (forces added)
@@ -151,53 +164,59 @@ void ReferenceCustomNonbondedIxn::setUseSwitchingFunction( RealOpenMM distance )
    --------------------------------------------------------------------------------------- */
 
 void ReferenceCustomNonbondedIxn::calculatePairIxn( int numberOfAtoms, vector<RealVec>& atomCoordinates,
-                                             RealOpenMM** atomParameters, int** exclusions,
+                                             RealOpenMM** atomParameters, vector<set<int> >& exclusions,
                                              RealOpenMM* fixedParameters, const map<string, double>& globalParameters, vector<RealVec>& forces,
                                              RealOpenMM* energyByAtom, RealOpenMM* totalEnergy ) const {
 
-   map<string, double> variables = globalParameters;
-   if (cutoff) {
-       for (int i = 0; i < (int) neighborList->size(); i++) {
-           OpenMM::AtomPair pair = (*neighborList)[i];
-           for (int j = 0; j < (int) paramNames.size(); j++) {
-               variables[particleParamNames[j*2]] = atomParameters[pair.first][j];
-               variables[particleParamNames[j*2+1]] = atomParameters[pair.second][j];
-           }
-           calculateOneIxn(pair.first, pair.second, atomCoordinates, variables, forces, energyByAtom, totalEnergy);
-       }
-   }
-   else {
-       // allocate and initialize exclusion array
-
-       int* exclusionIndices = new int[numberOfAtoms];
-       for( int ii = 0; ii < numberOfAtoms; ii++ ){
-          exclusionIndices[ii] = -1;
-       }
-
-       for( int ii = 0; ii < numberOfAtoms; ii++ ){
-
-          // set exclusions
-
-          for( int jj = 1; jj <= exclusions[ii][0]; jj++ ){
-             exclusionIndices[exclusions[ii][jj]] = ii;
-          }
-
-          // loop over atom pairs
-
-          for( int jj = ii+1; jj < numberOfAtoms; jj++ ){
-
-             if( exclusionIndices[jj] != ii ){
-                 for (int j = 0; j < (int) paramNames.size(); j++) {
-                     variables[particleParamNames[j*2]] = atomParameters[ii][j];
-                     variables[particleParamNames[j*2+1]] = atomParameters[jj][j];
-                 }
-                 calculateOneIxn(ii, jj, atomCoordinates, variables, forces, energyByAtom, totalEnergy);
-             }
-          }
-       }
-
-       delete[] exclusionIndices;
-   }
+    map<string, double> variables = globalParameters;
+    if (interactionGroups.size() > 0) {
+        // The user has specified interaction groups, so compute only the requested interactions.
+        
+        for (int group = 0; group < (int) interactionGroups.size(); group++) {
+            const set<int>& set1 = interactionGroups[group].first;
+            const set<int>& set2 = interactionGroups[group].second;
+            for (set<int>::const_iterator atom1 = set1.begin(); atom1 != set1.end(); ++atom1) {
+                for (set<int>::const_iterator atom2 = set2.begin(); atom2 != set2.end(); ++atom2) {
+                    if (*atom1 == *atom2 || exclusions[*atom1].find(*atom2) != exclusions[*atom1].end())
+                        continue; // This is an excluded interaction.
+                    if (*atom1 > *atom2 && set1.find(*atom2) != set1.end() && set2.find(*atom1) != set2.end())
+                        continue; // Both atoms are in both sets, so skip duplicate interactions.
+                    for (int j = 0; j < (int) paramNames.size(); j++) {
+                        variables[particleParamNames[j*2]] = atomParameters[*atom1][j];
+                        variables[particleParamNames[j*2+1]] = atomParameters[*atom2][j];
+                    }
+                    calculateOneIxn(*atom1, *atom2, atomCoordinates, variables, forces, energyByAtom, totalEnergy);
+                }
+            }
+        }
+    }
+    else if (cutoff) {
+        // We are using a cutoff, so get the interactions from the neighbor list.
+        
+        for (int i = 0; i < (int) neighborList->size(); i++) {
+            OpenMM::AtomPair pair = (*neighborList)[i];
+            for (int j = 0; j < (int) paramNames.size(); j++) {
+                variables[particleParamNames[j*2]] = atomParameters[pair.first][j];
+                variables[particleParamNames[j*2+1]] = atomParameters[pair.second][j];
+            }
+            calculateOneIxn(pair.first, pair.second, atomCoordinates, variables, forces, energyByAtom, totalEnergy);
+        }
+    }
+    else {
+        // Every particle interacts with every other one.
+        
+        for (int ii = 0; ii < numberOfAtoms; ii++) {
+            for (int jj = ii+1; jj < numberOfAtoms; jj++) {
+                if (exclusions[jj].find(ii) == exclusions[jj].end()) {
+                    for (int j = 0; j < (int) paramNames.size(); j++) {
+                        variables[particleParamNames[j*2]] = atomParameters[ii][j];
+                        variables[particleParamNames[j*2+1]] = atomParameters[jj][j];
+                    }
+                    calculateOneIxn(ii, jj, atomCoordinates, variables, forces, energyByAtom, totalEnergy);
+                }
+            }
+        }
+    }
 }
 
   /**---------------------------------------------------------------------------------------

platforms/reference/src/SimTKReference/ReferenceLJCoulombIxn.cpp

@@ -37,6 +37,7 @@
 // make sure that erf() and erfc() are defined.
 #include "openmm/internal/MSVC_erfc.h"
 
+using std::set;
 using std::vector;
 using OpenMM::RealVec;
 
@@ -169,10 +170,8 @@ void ReferenceLJCoulombIxn::setUseSwitchingFunction( RealOpenMM distance ) {
    @param numberOfAtoms    number of atoms
    @param atomCoordinates  atom coordinates
    @param atomParameters   atom parameters                             atomParameters[atomIndex][paramterIndex]
-   @param exclusions       atom exclusion indices                      exclusions[atomIndex][atomToExcludeIndex]
-                           exclusions[atomIndex][0] = number of exclusions
-                           exclusions[atomIndex][1-no.] = atom indices of atoms to excluded from
-                           interacting w/ atom atomIndex
+   @param exclusions       atom exclusion indices
+                           exclusions[atomIndex] contains the list of exclusions for that atom
    @param fixedParameters  non atom parameters (not currently used)
    @param forces           force array (forces added)
    @param energyByAtom     atom energy
@@ -183,7 +182,7 @@ void ReferenceLJCoulombIxn::setUseSwitchingFunction( RealOpenMM distance ) {
    --------------------------------------------------------------------------------------- */
 
 void ReferenceLJCoulombIxn::calculateEwaldIxn(int numberOfAtoms, vector<RealVec>& atomCoordinates,
-                                             RealOpenMM** atomParameters, int** exclusions,
+                                             RealOpenMM** atomParameters, vector<set<int> >& exclusions,
                                              RealOpenMM* fixedParameters, vector<RealVec>& forces,
                                              RealOpenMM* energyByAtom, RealOpenMM* totalEnergy, bool includeDirect, bool includeReciprocal) const {
     typedef std::complex<RealOpenMM> d_complex;
@@ -423,37 +422,40 @@ void ReferenceLJCoulombIxn::calculateEwaldIxn(int numberOfAtoms, vector<RealVec>
 
     RealOpenMM totalExclusionEnergy = 0.0f;
     for (int i = 0; i < numberOfAtoms; i++)
-        for (int j = 1; j <= exclusions[i][0]; j++)
-            if (exclusions[i][j] > i) {
+        for (set<int>::const_iterator iter = exclusions[i].begin(); iter != exclusions[i].end(); ++iter) {
+            if (*iter > i) {
                int ii = i;
-               int jj = exclusions[i][j];
+               int jj = *iter;
 
                RealOpenMM deltaR[2][ReferenceForce::LastDeltaRIndex];
                ReferenceForce::getDeltaR( atomCoordinates[jj], atomCoordinates[ii], deltaR[0] );
                RealOpenMM r         = deltaR[0][ReferenceForce::RIndex];
                RealOpenMM inverseR  = one/(deltaR[0][ReferenceForce::RIndex]);
                RealOpenMM alphaR    = alphaEwald * r;
-               RealOpenMM dEdR      = (RealOpenMM) (ONE_4PI_EPS0 * atomParameters[ii][QIndex] * atomParameters[jj][QIndex] * inverseR * inverseR * inverseR);
-                          dEdR      = (RealOpenMM) (dEdR * (erf(alphaR) - 2 * alphaR * exp ( - alphaR * alphaR) / SQRT_PI ));
+               if (erf(alphaR) > 1e-6) {
+                   RealOpenMM dEdR      = (RealOpenMM) (ONE_4PI_EPS0 * atomParameters[ii][QIndex] * atomParameters[jj][QIndex] * inverseR * inverseR * inverseR);
+                              dEdR      = (RealOpenMM) (dEdR * (erf(alphaR) - 2 * alphaR * exp ( - alphaR * alphaR) / SQRT_PI ));
 
-               // accumulate forces
+                   // accumulate forces
 
-               for( int kk = 0; kk < 3; kk++ ){
-                  RealOpenMM force  = dEdR*deltaR[0][kk];
-                  forces[ii][kk]   -= force;
-                  forces[jj][kk]   += force;
-               }
+                   for( int kk = 0; kk < 3; kk++ ){
+                      RealOpenMM force  = dEdR*deltaR[0][kk];
+                      forces[ii][kk]   -= force;
+                      forces[jj][kk]   += force;
+                   }
 
-               // accumulate energies
+                   // accumulate energies
 
-               realSpaceEwaldEnergy = (RealOpenMM) (ONE_4PI_EPS0*atomParameters[ii][QIndex]*atomParameters[jj][QIndex]*inverseR*erf(alphaR));
+                   realSpaceEwaldEnergy = (RealOpenMM) (ONE_4PI_EPS0*atomParameters[ii][QIndex]*atomParameters[jj][QIndex]*inverseR*erf(alphaR));
 
-               totalExclusionEnergy += realSpaceEwaldEnergy;
-               if( energyByAtom ){
-                   energyByAtom[ii] -= realSpaceEwaldEnergy;
-                   energyByAtom[jj] -= realSpaceEwaldEnergy;
+                   totalExclusionEnergy += realSpaceEwaldEnergy;
+                   if( energyByAtom ){
+                       energyByAtom[ii] -= realSpaceEwaldEnergy;
+                       energyByAtom[jj] -= realSpaceEwaldEnergy;
+                   }
                }
             }
+        }
 
     if( totalEnergy )
         *totalEnergy -= totalExclusionEnergy;
@@ -467,10 +469,8 @@ void ReferenceLJCoulombIxn::calculateEwaldIxn(int numberOfAtoms, vector<RealVec>
    @param numberOfAtoms    number of atoms
    @param atomCoordinates  atom coordinates
    @param atomParameters   atom parameters                             atomParameters[atomIndex][paramterIndex]
-   @param exclusions       atom exclusion indices                      exclusions[atomIndex][atomToExcludeIndex]
-                           exclusions[atomIndex][0] = number of exclusions
-                           exclusions[atomIndex][1-no.] = atom indices of atoms to excluded from
-                           interacting w/ atom atomIndex
+   @param exclusions       atom exclusion indices
+                           exclusions[atomIndex] contains the list of exclusions for that atom
    @param fixedParameters  non atom parameters (not currently used)
    @param forces           force array (forces added)
    @param energyByAtom     atom energy
@@ -481,7 +481,7 @@ void ReferenceLJCoulombIxn::calculateEwaldIxn(int numberOfAtoms, vector<RealVec>
    --------------------------------------------------------------------------------------- */
 
 void ReferenceLJCoulombIxn::calculatePairIxn(int numberOfAtoms, vector<RealVec>& atomCoordinates,
-                                             RealOpenMM** atomParameters, int** exclusions,
+                                             RealOpenMM** atomParameters, vector<set<int> >& exclusions,
                                              RealOpenMM* fixedParameters, vector<RealVec>& forces,
                                              RealOpenMM* energyByAtom, RealOpenMM* totalEnergy, bool includeDirect, bool includeReciprocal) const {
 
@@ -499,32 +499,13 @@ void ReferenceLJCoulombIxn::calculatePairIxn(int numberOfAtoms, vector<RealVec>&
        }
    }
    else {
-       // allocate and initialize exclusion array
-
-       int* exclusionIndices = new int[numberOfAtoms];
        for( int ii = 0; ii < numberOfAtoms; ii++ ){
-          exclusionIndices[ii] = -1;
-       }
-
-       for( int ii = 0; ii < numberOfAtoms; ii++ ){
-
-          // set exclusions
-
-          for( int jj = 1; jj <= exclusions[ii][0]; jj++ ){
-             exclusionIndices[exclusions[ii][jj]] = ii;
-          }
-
           // loop over atom pairs
 
-          for( int jj = ii+1; jj < numberOfAtoms; jj++ ){
-
-             if( exclusionIndices[jj] != ii ){
-                 calculateOneIxn(ii, jj, atomCoordinates, atomParameters, forces, energyByAtom, totalEnergy);
-             }
-          }
+          for( int jj = ii+1; jj < numberOfAtoms; jj++ )
+              if (exclusions[jj].find(ii) == exclusions[jj].end())
+                  calculateOneIxn(ii, jj, atomCoordinates, atomParameters, forces, energyByAtom, totalEnergy);
        }
-
-       delete[] exclusionIndices;
    }
 }
 

platforms/reference/tests/TestReferenceCustomNonbondedForce.cpp

@@ -34,6 +34,9 @@
  * 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 "openmm/internal/AssertionUtilities.h"
 #include "sfmt/SFMT.h"
 #include "openmm/Context.h"
@@ -42,7 +45,9 @@
 #include "openmm/NonbondedForce.h"
 #include "openmm/System.h"
 #include "openmm/VerletIntegrator.h"
+#include <cmath>
 #include <iostream>
+#include <set>
 #include <vector>
 
 using namespace OpenMM;
@@ -470,6 +475,182 @@ void testLongRangeCorrection() {
     ASSERT_EQUAL_TOL(standardEnergy1-standardEnergy2, customEnergy1-customEnergy2, 1e-4);
 }
 
+void testInteractionGroups() {
+    const int numParticles = 6;
+    ReferencePlatform platform;
+    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.
+    
+    ReferencePlatform platform;
+    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;
+    ReferencePlatform platform;
+    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);
+}
+
 int main() {
     try {
         testSimpleExpression();
@@ -481,6 +662,9 @@ int main() {
         testCoulombLennardJones();
         testSwitchingFunction();
         testLongRangeCorrection();
+        testInteractionGroups();
+        testLargeInteractionGroup();
+        testInteractionGroupLongRangeCorrection();
     }
     catch(const exception& e) {
         cout << "exception: " << e.what() << endl;

platforms/reference/tests/TestReferenceMonteCarloAnisotropicBarostat.cpp

@@ -51,45 +51,6 @@
 using namespace OpenMM;
 using namespace std;
 
-void testChangingBoxSize() {
-    ReferencePlatform platform;
-    System system;
-    system.setDefaultPeriodicBoxVectors(Vec3(4, 0, 0), Vec3(0, 5, 0), Vec3(0, 0, 6));
-    system.addParticle(1.0);
-    NonbondedForce* nb = new NonbondedForce();
-    nb->setNonbondedMethod(NonbondedForce::CutoffPeriodic);
-    nb->setCutoffDistance(2.0);
-    nb->addParticle(1, 0.5, 0.5);
-    system.addForce(nb);
-    LangevinIntegrator integrator(300.0, 1.0, 0.01);
-    Context context(system, integrator, platform);
-    vector<Vec3> positions;
-    positions.push_back(Vec3());
-    context.setPositions(positions);
-    Vec3 x, y, z;
-    context.getState(State::Forces).getPeriodicBoxVectors(x, y, z);
-    ASSERT_EQUAL_VEC(Vec3(4, 0, 0), x, 0);
-    ASSERT_EQUAL_VEC(Vec3(0, 5, 0), y, 0);
-    ASSERT_EQUAL_VEC(Vec3(0, 0, 6), z, 0);
-    context.setPeriodicBoxVectors(Vec3(7, 0, 0), Vec3(0, 8, 0), Vec3(0, 0, 9));
-    context.getState(State::Forces).getPeriodicBoxVectors(x, y, z);
-    ASSERT_EQUAL_VEC(Vec3(7, 0, 0), x, 0);
-    ASSERT_EQUAL_VEC(Vec3(0, 8, 0), y, 0);
-    ASSERT_EQUAL_VEC(Vec3(0, 0, 9), z, 0);
-    
-    // Shrinking the box too small should produce an exception.
-    
-    context.setPeriodicBoxVectors(Vec3(7, 0, 0), Vec3(0, 3.9, 0), Vec3(0, 0, 9));
-    bool ok = true;
-    try {
-        context.getState(State::Forces).getPeriodicBoxVectors(x, y, z);
-        ok = false;
-    }
-    catch (exception& ex) {
-    }
-    ASSERT(ok);
-}
-
 void testIdealGas() {
     const int numParticles = 64;
     const int frequency = 10;
@@ -112,7 +73,7 @@ void testIdealGas() {
         system.addParticle(1.0);
         positions[i] = Vec3(initialLength*genrand_real2(sfmt), 0.5*initialLength*genrand_real2(sfmt), 2*initialLength*genrand_real2(sfmt));
     }
-    MonteCarloAnisotropicBarostat* barostat = new MonteCarloAnisotropicBarostat(Vec3(pressure, pressure, pressure), temp[0], frequency);
+    MonteCarloAnisotropicBarostat* barostat = new MonteCarloAnisotropicBarostat(Vec3(pressure, pressure, pressure), temp[0], true, true, true, frequency);
     system.addForce(barostat);
     
     // Test it for three different temperatures.
@@ -171,7 +132,7 @@ void testIdealGasAxis(int axis) {
         system.addParticle(1.0);
         positions[i] = Vec3(initialLength*genrand_real2(sfmt), 0.5*initialLength*genrand_real2(sfmt), 2*initialLength*genrand_real2(sfmt));
     }
-    MonteCarloAnisotropicBarostat* barostat = new MonteCarloAnisotropicBarostat(Vec3(pressure, pressure, pressure), temp[0], frequency, scaleX, scaleY, scaleZ);
+    MonteCarloAnisotropicBarostat* barostat = new MonteCarloAnisotropicBarostat(Vec3(pressure, pressure, pressure), temp[0], scaleX, scaleY, scaleZ, frequency);
     system.addForce(barostat);
     
     // Test it for three different temperatures.
@@ -228,7 +189,7 @@ void testRandomSeed() {
         forceField->addParticle((i%2 == 0 ? 1.0 : -1.0), 1.0, 5.0);
     }
     system.addForce(forceField);
-    MonteCarloAnisotropicBarostat* barostat = new MonteCarloAnisotropicBarostat(Vec3(pressure, pressure, pressure), temp, 1);
+    MonteCarloAnisotropicBarostat* barostat = new MonteCarloAnisotropicBarostat(Vec3(pressure, pressure, pressure), temp, true, true, true, 1);
     system.addForce(barostat);
     vector<Vec3> positions(numParticles);
     vector<Vec3> velocities(numParticles);
@@ -335,7 +296,7 @@ void testEinsteinCrystal() {
             system.addForce(force);
             system.addForce(nb);
             // Create the barostat.
-            MonteCarloAnisotropicBarostat* barostat = new MonteCarloAnisotropicBarostat(Vec3(pres3[p], pres3[p], pres3[p]), temp, frequency, (a==0||a==3), (a==1||a==3), (a==2||a==3));
+            MonteCarloAnisotropicBarostat* barostat = new MonteCarloAnisotropicBarostat(Vec3(pres3[p], pres3[p], pres3[p]), temp, (a==0||a==3), (a==1||a==3), (a==2||a==3), frequency);
             system.addForce(barostat);
             barostat->setTemperature(temp);
             LangevinIntegrator integrator(temp, 0.1, 0.01);

plugins/cpupme/src/CpuPmeKernels.cpp

@@ -95,6 +95,7 @@ static int getNumProcessors() {
 #define cpuid __cpuid
 #else
 static void cpuid(int cpuInfo[4], int infoType){
+#ifdef __LP64__
     __asm__ __volatile__ (
         "cpuid":
         "=a" (cpuInfo[0]),
@@ -103,6 +104,19 @@ static void cpuid(int cpuInfo[4], int infoType){
         "=d" (cpuInfo[3]) :
         "a" (infoType)
     );
+#else
+    __asm__ __volatile__ (
+        "pushl %%ebx\n"
+        "cpuid\n"
+        "movl %%ebx, %1\n"
+        "popl %%ebx\n" :
+        "=a" (cpuInfo[0]),
+        "=r" (cpuInfo[1]),
+        "=c" (cpuInfo[2]),
+        "=d" (cpuInfo[3]) :
+        "a" (infoType)
+    );
+#endif
 }
 #endif
 

plugins/drude/platforms/cuda/src/CudaDrudeKernels.cpp

@@ -406,6 +406,7 @@ void CudaIntegrateDrudeSCFStepKernel::execute(ContextImpl& context, const DrudeS
     cu.setAsCurrent();
     CudaIntegrationUtilities& integration = cu.getIntegrationUtilities();
     int numAtoms = cu.getNumAtoms();
+    int paddedNumAtoms = cu.getPaddedNumAtoms();
     double dt = integrator.getStepSize();
     if (dt != prevStepSize) {
         if (cu.getUseDoublePrecision() || cu.getUseMixedPrecision()) {
@@ -424,7 +425,7 @@ void CudaIntegrateDrudeSCFStepKernel::execute(ContextImpl& context, const DrudeS
     // Call the first integration kernel.
 
     CUdeviceptr posCorrection = (cu.getUseMixedPrecision() ? cu.getPosqCorrection().getDevicePointer() : 0);
-    void* args1[] = {&cu.getIntegrationUtilities().getStepSize().getDevicePointer(), &cu.getPosq().getDevicePointer(), &posCorrection,
+    void* args1[] = {&numAtoms, &paddedNumAtoms, &cu.getIntegrationUtilities().getStepSize().getDevicePointer(), &cu.getPosq().getDevicePointer(), &posCorrection,
             &cu.getVelm().getDevicePointer(), &cu.getForce().getDevicePointer(), &integration.getPosDelta().getDevicePointer()};
     cu.executeKernel(kernel1, args1, numAtoms);
 
@@ -434,7 +435,7 @@ void CudaIntegrateDrudeSCFStepKernel::execute(ContextImpl& context, const DrudeS
 
     // Call the second integration kernel.
 
-    void* args2[] = {&cu.getIntegrationUtilities().getStepSize().getDevicePointer(), &cu.getPosq().getDevicePointer(), &posCorrection,
+    void* args2[] = {&numAtoms, &cu.getIntegrationUtilities().getStepSize().getDevicePointer(), &cu.getPosq().getDevicePointer(), &posCorrection,
             &cu.getVelm().getDevicePointer(), &integration.getPosDelta().getDevicePointer()};
     cu.executeKernel(kernel2, args2, numAtoms);
 

plugins/drude/platforms/opencl/CMakeLists.txt

@@ -113,7 +113,7 @@ ENDIF (UNIX AND CMAKE_BUILD_TYPE MATCHES Debug)
 TARGET_LINK_LIBRARIES(${SHARED_TARGET} ${MAIN_OPENMM_LIB}  ${OPENCL_LIBRARIES} ${PTHREADS_LIB})
 TARGET_LINK_LIBRARIES(${SHARED_TARGET} debug ${OPENMM_LIBRARY_NAME}OpenCL_d optimized ${OPENMM_LIBRARY_NAME}OpenCL)
 TARGET_LINK_LIBRARIES(${SHARED_TARGET} debug ${SHARED_DRUDE_TARGET} optimized ${SHARED_DRUDE_TARGET})
-SET_TARGET_PROPERTIES(${SHARED_TARGET} PROPERTIES COMPILE_FLAGS "-DOPENMM_BUILDING_SHARED_LIBRARY")
+SET_TARGET_PROPERTIES(${SHARED_TARGET} PROPERTIES COMPILE_FLAGS "-msse2 -DOPENMM_BUILDING_SHARED_LIBRARY")
 
 INSTALL(TARGETS ${SHARED_TARGET} DESTINATION ${CMAKE_INSTALL_PREFIX}/lib/plugins)
 # Ensure that links to the main OpenCL library will be resolved.