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

platforms/cuda/tests/TestCudaCustomGBForce.cpp

@@ -56,6 +56,7 @@ void testOBC(GBSAOBCForce::NonbondedMethod obcMethod, CustomGBForce::NonbondedMe
     const int numMolecules = 70;
     const int numParticles = numMolecules*2;
     const double boxSize = 10.0;
+    const double cutoff = 2.0;
 
     // Create two systems: one with a GBSAOBCForce, and one using a CustomGBForce to implement the same interaction.
 
@@ -69,8 +70,8 @@ void testOBC(GBSAOBCForce::NonbondedMethod obcMethod, CustomGBForce::NonbondedMe
     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(2.0);
-    custom->setCutoffDistance(2.0);
+    obc->setCutoffDistance(cutoff);
+    custom->setCutoffDistance(cutoff);
     custom->addPerParticleParameter("q");
     custom->addPerParticleParameter("radius");
     custom->addPerParticleParameter("scale");
@@ -86,7 +87,13 @@ void testOBC(GBSAOBCForce::NonbondedMethod obcMethod, CustomGBForce::NonbondedMe
     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.935456*(1/soluteDielectric-1/solventDielectric)*q^2/B", CustomGBForce::SingleParticle);
-    custom->addEnergyTerm("-138.935456*(1/soluteDielectric-1/solventDielectric)*q1*q2/f;"
+    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);

platforms/cuda/tests/TestCudaCustomIntegrator.cpp

@@ -233,6 +233,43 @@ void testVelocityConstraints() {
     }
 }
 
+void testConstrainedMasslessParticles() {
+    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);
+    CustomIntegrator integrator(0.002);
+    integrator.addPerDofVariable("oldx", 0);
+    integrator.addComputePerDof("v", "v+dt*f/m");
+    integrator.addComputePerDof("oldx", "x");
+    integrator.addComputePerDof("x", "x+dt*v");
+    integrator.addConstrainPositions();
+    integrator.addComputePerDof("v", "(x-oldx)/dt");
+    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]);
+}
+
 /**
  * Test an integrator with an AndersenThermostat to see if updateContextState()
  * is being handled correctly.
@@ -724,6 +761,7 @@ int main(int argc, char* argv[]) {
         testSingleBond();
         testConstraints();
         testVelocityConstraints();
+        testConstrainedMasslessParticles();
         testWithThermostat();
         testMonteCarlo();
         testSum();

platforms/cuda/tests/TestCudaLangevinIntegrator.cpp

@@ -177,6 +177,37 @@ void testConstraints() {
     }
 }
 
+void testConstrainedMasslessParticles() {
+    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);
+    ASSERT_EQUAL(0.0, state.getVelocities()[0][0]);
+}
+
 void testRandomSeed() {
     const int numParticles = 8;
     const double temp = 100.0;
@@ -241,6 +272,7 @@ int main(int argc, char* argv[]) {
         testSingleBond();
         testTemperature();
         testConstraints();
+        testConstrainedMasslessParticles();
         testRandomSeed();
     }
     catch(const exception& e) {

platforms/cuda/tests/TestCudaVariableLangevinIntegrator.cpp

@@ -172,6 +172,37 @@ void testConstraints() {
     }
 }
 
+void testConstrainedMasslessParticles() {
+    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);
+    VariableLangevinIntegrator 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);
+    ASSERT_EQUAL(0.0, state.getVelocities()[0][0]);
+}
+
 void testRandomSeed() {
     const int numParticles = 8;
     const double temp = 100.0;
@@ -295,6 +326,7 @@ int main(int argc, char* argv[]) {
         testSingleBond();
         testTemperature();
         testConstraints();
+        testConstrainedMasslessParticles();
         testRandomSeed();
         testArgonBox();
     }

platforms/cuda/tests/TestCudaVariableVerletIntegrator.cpp

@@ -211,6 +211,37 @@ void testConstrainedClusters() {
     ASSERT(context.getState(State::Positions).getTime() > 0.1);
 }
 
+void testConstrainedMasslessParticles() {
+    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);
+    VariableVerletIntegrator integrator(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);
+    ASSERT_EQUAL(0.0, state.getVelocities()[0][0]);
+}
+
 void testArgonBox() {
     const int gridSize = 8;
     const double mass = 40.0;            // Ar atomic mass
@@ -274,6 +305,7 @@ int main(int argc, char* argv[]) {
         testSingleBond();
         testConstraints();
         testConstrainedClusters();
+        testConstrainedMasslessParticles();
         testArgonBox();
     }
     catch(const exception& e) {

platforms/cuda/tests/TestCudaVerletIntegrator.cpp

@@ -203,6 +203,37 @@ void testConstrainedClusters() {
     }
 }
 
+void testConstrainedMasslessParticles() {
+    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);
+    VerletIntegrator integrator(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);
+    ASSERT_EQUAL(0.0, state.getVelocities()[0][0]);
+}
+
 int main(int argc, char* argv[]) {
     try {
         if (argc > 1)
@@ -210,6 +241,7 @@ int main(int argc, char* argv[]) {
         testSingleBond();
         testConstraints();
         testConstrainedClusters();
+        testConstrainedMasslessParticles();
     }
     catch(const exception& e) {
         cout << "exception: " << e.what() << endl;

platforms/opencl/src/OpenCLFFT3D.cpp

@@ -227,10 +227,10 @@ cl::Kernel OpenCLFFT3D::createKernel(int xsize, int ysize, int zsize, int& threa
         source<<"for (int z = get_local_id(0); z < ZSIZE; z += get_local_size(0))\n";
         source<<"out[y*(ZSIZE*XSIZE)+z*XSIZE+x] = data"<<(stage%2)<<"[z];\n";
     }
-	else {
-		source<<"if (index < XSIZE*YSIZE)\n";
+    else {
+        source<<"if (index < XSIZE*YSIZE)\n";
         source<<"out[y*(ZSIZE*XSIZE)+(get_local_id(0)%ZSIZE)*XSIZE+x] = data"<<(stage%2)<<"[get_local_id(0)];\n";
-	}
+    }
     source<<"barrier(CLK_GLOBAL_MEM_FENCE);";
     map<string, string> replacements;
     replacements["XSIZE"] = context.intToString(xsize);

platforms/opencl/src/OpenCLIntegrationUtilities.cpp

@@ -141,15 +141,21 @@ OpenCLIntegrationUtilities::OpenCLIntegrationUtilities(OpenCLContext& context, c
 
     // Record the set of constraints and how many constraints each atom is involved in.
 
-    int numConstraints = system.getNumConstraints();
-    vector<int> atom1(numConstraints);
-    vector<int> atom2(numConstraints);
-    vector<double> distance(numConstraints);
+    vector<int> atom1;
+    vector<int> atom2;
+    vector<double> distance;
     vector<int> constraintCount(context.getNumAtoms(), 0);
-    for (int i = 0; i < numConstraints; i++) {
-        system.getConstraintParameters(i, atom1[i], atom2[i], distance[i]);
-        constraintCount[atom1[i]]++;
-        constraintCount[atom2[i]]++;
+    for (int i = 0; i < system.getNumConstraints(); i++) {
+        int p1, p2;
+        double d;
+        system.getConstraintParameters(i, p1, p2, d);
+        if (system.getParticleMass(p1) != 0 || system.getParticleMass(p2) != 0) {
+            atom1.push_back(p1);
+            atom2.push_back(p2);
+            distance.push_back(d);
+            constraintCount[p1]++;
+            constraintCount[p2]++;
+        }
     }
 
     // Identify clusters of three atoms that can be treated with SETTLE.  First, for every

platforms/opencl/src/OpenCLKernels.cpp

@@ -5978,7 +5978,7 @@ void OpenCLRemoveCMMotionKernel::initialize(const System& system, const CMMotion
     for (int i = 0; i < numAtoms; i++)
         totalMass += system.getParticleMass(i);
     map<string, string> defines;
-    defines["INVERSE_TOTAL_MASS"] = cl.doubleToString(1.0/totalMass);
+    defines["INVERSE_TOTAL_MASS"] = cl.doubleToString(totalMass == 0 ? 0.0 : 1.0/totalMass);
     cl::Program program = cl.createProgram(OpenCLKernelSources::removeCM, defines);
     kernel1 = cl::Kernel(program, "calcCenterOfMassMomentum");
     kernel1.setArg<cl_int>(0, numAtoms);

platforms/opencl/src/kernels/fft.cl

@@ -12,19 +12,18 @@ __kernel void execFFT(__global const real2* restrict in, __global real2* restric
         w[i] = (real2) (cos(-sign*i*2*M_PI/ZSIZE), sin(-sign*i*2*M_PI/ZSIZE));
     barrier(CLK_LOCAL_MEM_FENCE);
     
-	for (int baseIndex = get_group_id(0)*BLOCKS_PER_GROUP; baseIndex < XSIZE*YSIZE; baseIndex += get_num_groups(0)*BLOCKS_PER_GROUP) {
-		int index = baseIndex+get_local_id(0)/ZSIZE;
+    for (int baseIndex = get_group_id(0)*BLOCKS_PER_GROUP; baseIndex < XSIZE*YSIZE; baseIndex += get_num_groups(0)*BLOCKS_PER_GROUP) {
+        int index = baseIndex+get_local_id(0)/ZSIZE;
         int x = index/YSIZE;
         int y = index-x*YSIZE;
 #if LOOP_REQUIRED
         for (int z = get_local_id(0); z < ZSIZE; z += get_local_size(0))
             data0[z] = in[x*(YSIZE*ZSIZE)+y*ZSIZE+z];
 #else
-		if (index < XSIZE*YSIZE)
+        if (index < XSIZE*YSIZE)
             data0[get_local_id(0)] = in[x*(YSIZE*ZSIZE)+y*ZSIZE+get_local_id(0)%ZSIZE];
 #endif
         barrier(CLK_LOCAL_MEM_FENCE);
         COMPUTE_FFT
     }
-
 }

platforms/opencl/src/kernels/gbsaObc.cl

@@ -444,11 +444,16 @@ __kernel void computeGBSAForce1(
                         real expTerm = EXP(-D_ij);
                         real denominator2 = r2 + alpha2_ij*expTerm;
                         real denominator = SQRT(denominator2);
-                        real tempEnergy = (PREFACTOR*posq1.w*posq2.w)*RECIP(denominator);
+                        real scaledChargeProduct = PREFACTOR*posq1.w*posq2.w;
+                        real tempEnergy = scaledChargeProduct*RECIP(denominator);
                         real Gpol = tempEnergy*RECIP(denominator2);
                         real dGpol_dalpha2_ij = -0.5f*Gpol*expTerm*(1.0f+D_ij);
                         real dEdR = Gpol*(1.0f - 0.25f*expTerm);
                         force.w += dGpol_dalpha2_ij*bornRadius2;
+#ifdef USE_CUTOFF
+                        if (atom1 != y*TILE_SIZE+j)
+                            tempEnergy -= scaledChargeProduct/CUTOFF;
+#endif
                         energy += 0.5f*tempEnergy;
                         delta.xyz *= dEdR;
                         force.xyz -= delta.xyz;
@@ -494,11 +499,15 @@ __kernel void computeGBSAForce1(
                         real expTerm = EXP(-D_ij);
                         real denominator2 = r2 + alpha2_ij*expTerm;
                         real denominator = SQRT(denominator2);
-                        real tempEnergy = (PREFACTOR*posq1.w*posq2.w)*RECIP(denominator);
+                        real scaledChargeProduct = PREFACTOR*posq1.w*posq2.w;
+                        real tempEnergy = scaledChargeProduct*RECIP(denominator);
                         real Gpol = tempEnergy*RECIP(denominator2);
                         real dGpol_dalpha2_ij = -0.5f*Gpol*expTerm*(1.0f+D_ij);
                         real dEdR = Gpol*(1.0f - 0.25f*expTerm);
                         force.w += dGpol_dalpha2_ij*bornRadius2;
+#ifdef USE_CUTOFF
+                        tempEnergy -= scaledChargeProduct/CUTOFF;
+#endif
                         energy += tempEnergy;
                         delta.xyz *= dEdR;
                         force.xyz -= delta.xyz;
@@ -657,11 +666,15 @@ __kernel void computeGBSAForce1(
                             real expTerm = EXP(-D_ij);
                             real denominator2 = r2 + alpha2_ij*expTerm;
                             real denominator = SQRT(denominator2);
-                            real tempEnergy = (PREFACTOR*posq1.w*posq2.w)*RECIP(denominator);
+                            real scaledChargeProduct = PREFACTOR*posq1.w*posq2.w;
+                            real tempEnergy = scaledChargeProduct*RECIP(denominator);
                             real Gpol = tempEnergy*RECIP(denominator2);
                             real dGpol_dalpha2_ij = -0.5f*Gpol*expTerm*(1.0f+D_ij);
                             real dEdR = Gpol*(1.0f - 0.25f*expTerm);
                             force.w += dGpol_dalpha2_ij*bornRadius2;
+#ifdef USE_CUTOFF
+                            tempEnergy -= scaledChargeProduct/CUTOFF;
+#endif
                             energy += tempEnergy;
                             delta.xyz *= dEdR;
                             force.xyz -= delta.xyz;
@@ -701,11 +714,15 @@ __kernel void computeGBSAForce1(
                             real expTerm = EXP(-D_ij);
                             real denominator2 = r2 + alpha2_ij*expTerm;
                             real denominator = SQRT(denominator2);
-                            real tempEnergy = (PREFACTOR*posq1.w*posq2.w)*RECIP(denominator);
+                            real scaledChargeProduct = PREFACTOR*posq1.w*posq2.w;
+                            real tempEnergy = scaledChargeProduct*RECIP(denominator);
                             real Gpol = tempEnergy*RECIP(denominator2);
                             real dGpol_dalpha2_ij = -0.5f*Gpol*expTerm*(1.0f+D_ij);
                             real dEdR = Gpol*(1.0f - 0.25f*expTerm);
                             force.w += dGpol_dalpha2_ij*bornRadius2;
+#ifdef USE_CUTOFF
+                            tempEnergy -= scaledChargeProduct/CUTOFF;
+#endif
                             energy += tempEnergy;
                             delta.xyz *= dEdR;
                             force.xyz -= delta.xyz;

platforms/opencl/tests/TestOpenCLBrownianIntegrator.cpp

@@ -172,6 +172,37 @@ void testConstraints() {
     }
 }
 
+void testConstrainedMasslessParticles() {
+    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);
+    BrownianIntegrator 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);
+    ASSERT_EQUAL(0.0, state.getVelocities()[0][0]);
+}
+
 void testRandomSeed() {
     const int numParticles = 8;
     const double temp = 100.0;
@@ -237,6 +268,7 @@ int main(int argc, char* argv[]) {
         testSingleBond();
         testTemperature();
         testConstraints();
+        testConstrainedMasslessParticles();
         testRandomSeed();
     }
     catch(const exception& e) {

platforms/opencl/tests/TestOpenCLCustomGBForce.cpp

@@ -56,6 +56,7 @@ void testOBC(GBSAOBCForce::NonbondedMethod obcMethod, CustomGBForce::NonbondedMe
     const int numMolecules = 70;
     const int numParticles = numMolecules*2;
     const double boxSize = 10.0;
+    const double cutoff = 2.0;
 
     // Create two systems: one with a GBSAOBCForce, and one using a CustomGBForce to implement the same interaction.
 
@@ -69,8 +70,8 @@ void testOBC(GBSAOBCForce::NonbondedMethod obcMethod, CustomGBForce::NonbondedMe
     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(2.0);
-    custom->setCutoffDistance(2.0);
+    obc->setCutoffDistance(cutoff);
+    custom->setCutoffDistance(cutoff);
     custom->addPerParticleParameter("q");
     custom->addPerParticleParameter("radius");
     custom->addPerParticleParameter("scale");
@@ -86,7 +87,13 @@ void testOBC(GBSAOBCForce::NonbondedMethod obcMethod, CustomGBForce::NonbondedMe
     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.935456*(1/soluteDielectric-1/solventDielectric)*q^2/B", CustomGBForce::SingleParticle);
-    custom->addEnergyTerm("-138.935456*(1/soluteDielectric-1/solventDielectric)*q1*q2/f;"
+    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);

platforms/opencl/tests/TestOpenCLCustomIntegrator.cpp

@@ -233,6 +233,43 @@ void testVelocityConstraints() {
     }
 }
 
+void testConstrainedMasslessParticles() {
+    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);
+    CustomIntegrator integrator(0.002);
+    integrator.addPerDofVariable("oldx", 0);
+    integrator.addComputePerDof("v", "v+dt*f/m");
+    integrator.addComputePerDof("oldx", "x");
+    integrator.addComputePerDof("x", "x+dt*v");
+    integrator.addConstrainPositions();
+    integrator.addComputePerDof("v", "(x-oldx)/dt");
+    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]);
+}
+
 /**
  * Test an integrator with an AndersenThermostat to see if updateContextState()
  * is being handled correctly.
@@ -724,6 +761,7 @@ int main(int argc, char* argv[]) {
         testSingleBond();
         testConstraints();
         testVelocityConstraints();
+        testConstrainedMasslessParticles();
         testWithThermostat();
         testMonteCarlo();
         testSum();

platforms/opencl/tests/TestOpenCLLangevinIntegrator.cpp

@@ -177,6 +177,37 @@ void testConstraints() {
     }
 }
 
+void testConstrainedMasslessParticles() {
+    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);
+    ASSERT_EQUAL(0.0, state.getVelocities()[0][0]);
+}
+
 void testRandomSeed() {
     const int numParticles = 8;
     const double temp = 100.0;
@@ -241,6 +272,7 @@ int main(int argc, char* argv[]) {
         testSingleBond();
         testTemperature();
         testConstraints();
+        testConstrainedMasslessParticles();
         testRandomSeed();
     }
     catch(const exception& e) {

platforms/opencl/tests/TestOpenCLVariableLangevinIntegrator.cpp

@@ -172,6 +172,37 @@ void testConstraints() {
     }
 }
 
+void testConstrainedMasslessParticles() {
+    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);
+    VariableLangevinIntegrator 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);
+    ASSERT_EQUAL(0.0, state.getVelocities()[0][0]);
+}
+
 void testRandomSeed() {
     const int numParticles = 8;
     const double temp = 100.0;
@@ -295,6 +326,7 @@ int main(int argc, char* argv[]) {
         testSingleBond();
         testTemperature();
         testConstraints();
+        testConstrainedMasslessParticles();
         testRandomSeed();
         testArgonBox();
     }

platforms/opencl/tests/TestOpenCLVariableVerletIntegrator.cpp

@@ -210,6 +210,38 @@ void testConstrainedClusters() {
     ASSERT(context.getState(State::Positions).getTime() > 0.1);
 }
 
+void testConstrainedMasslessParticles() {
+    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);
+    VariableVerletIntegrator integrator(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);
+    ASSERT_EQUAL(0.0, state.getVelocities()[0][0]);
+}
+
+
 void testArgonBox() {
     const int gridSize = 8;
     const double mass = 40.0;            // Ar atomic mass
@@ -273,6 +305,7 @@ int main(int argc, char* argv[]) {
         testSingleBond();
         testConstraints();
         testConstrainedClusters();
+        testConstrainedMasslessParticles();
         testArgonBox();
     }
     catch(const exception& e) {

platforms/opencl/tests/TestOpenCLVerletIntegrator.cpp

@@ -201,6 +201,37 @@ void testConstrainedClusters() {
     }
 }
 
+void testConstrainedMasslessParticles() {
+    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);
+    VerletIntegrator integrator(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);
+    ASSERT_EQUAL(0.0, state.getVelocities()[0][0]);
+}
+
 int main(int argc, char* argv[]) {
     try {
         if (argc > 1)
@@ -208,6 +239,7 @@ int main(int argc, char* argv[]) {
         testSingleBond();
         testConstraints();
         testConstrainedClusters();
+        testConstrainedMasslessParticles();
     }
     catch(const exception& e) {
         cout << "exception: " << e.what() << endl;

platforms/reference/include/ObcParameters.h

@@ -305,7 +305,7 @@ class ObcParameters {
 
          --------------------------------------------------------------------------------------- */
 
-      bool getUseCutoff();
+      bool getUseCutoff() const;
 
       /**---------------------------------------------------------------------------------------
 
@@ -313,7 +313,7 @@ class ObcParameters {
 
          --------------------------------------------------------------------------------------- */
 
-      RealOpenMM getCutoffDistance();
+      RealOpenMM getCutoffDistance() const;
 
       /**---------------------------------------------------------------------------------------
 

platforms/reference/include/ReferenceCCMAAlgorithm.h

 
-/* Portions copyright (c) 2006-2009 Stanford University and Simbios.
+/* Portions copyright (c) 2006-2013 Stanford University and Simbios.
  * Contributors: Pande Group
  *
  * Permission is hereby granted, free of charge, to any person obtaining
@@ -34,151 +34,89 @@
 
 class OPENMM_EXPORT ReferenceCCMAAlgorithm : public ReferenceConstraintAlgorithm {
 
-   protected:
+protected:
 
-      int _maximumNumberOfIterations;
-      RealOpenMM _tolerance;
+    int _maximumNumberOfIterations;
+    RealOpenMM _tolerance;
 
-      int _numberOfConstraints;
-      std::vector<std::pair<int, int> > _atomIndices;
-      std::vector<RealOpenMM> _distance;
+    int _numberOfConstraints;
+    std::vector<std::pair<int, int> > _atomIndices;
+    std::vector<RealOpenMM> _distance;
 
-      std::vector<OpenMM::RealVec> _r_ij;
-      RealOpenMM* _d_ij2;
-      RealOpenMM* _distanceTolerance;
-      RealOpenMM* _reducedMasses;
-      bool _hasInitializedMasses;
-      std::vector<std::vector<std::pair<int, RealOpenMM> > > _matrix;
+    std::vector<OpenMM::RealVec> _r_ij;
+    RealOpenMM* _d_ij2;
+    RealOpenMM* _distanceTolerance;
+    RealOpenMM* _reducedMasses;
+    bool _hasInitializedMasses;
+    std::vector<std::vector<std::pair<int, RealOpenMM> > > _matrix;
 
-   private:
+private:
 
-      int applyConstraints(int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates,
+    void applyConstraints(std::vector<OpenMM::RealVec>& atomCoordinates,
                        std::vector<OpenMM::RealVec>& atomCoordinatesP, std::vector<RealOpenMM>& inverseMasses, bool constrainingVelocities);
           
-   public:
-      class AngleInfo;
-
-      /**---------------------------------------------------------------------------------------
-
-         ReferenceCCMAAlgorithm constructor
-
-         @param numberOfAtoms    number of atoms
-         @param numberOfConstraints      number of constraints
-         @param atomIndices              atom indices for contraints
-         @param distance                 distances for constraints
-         @param masses                   atom masses
-         @param angles                   angle force field terms
-         @param tolerance                constraint tolerance
-
-         --------------------------------------------------------------------------------------- */
-
-      ReferenceCCMAAlgorithm( int numberOfAtoms, int numberOfConstraints, const std::vector<std::pair<int, int> >& atomIndices, const std::vector<RealOpenMM>& distance, std::vector<RealOpenMM>& masses, std::vector<AngleInfo>& angles, RealOpenMM tolerance );
-
-      /**---------------------------------------------------------------------------------------
-
-         Destructor
-
-         --------------------------------------------------------------------------------------- */
-
-       ~ReferenceCCMAAlgorithm( );
-
-      /**---------------------------------------------------------------------------------------
-
-         Get number of constraints
-
-         @return number of constraints
-
-         --------------------------------------------------------------------------------------- */
-
-      int getNumberOfConstraints( void ) const;
-
-      /**---------------------------------------------------------------------------------------
-
-         Get maximum number of iterations
-
-         @return maximum number of iterations
-
-         --------------------------------------------------------------------------------------- */
-
-      int getMaximumNumberOfIterations( void ) const;
-
-      /**---------------------------------------------------------------------------------------
-
-         Set maximum number of iterations
-
-         @param maximumNumberOfIterations   new maximum number of iterations
-
-         --------------------------------------------------------------------------------------- */
-
-      void setMaximumNumberOfIterations( int maximumNumberOfIterations );
-
-      /**---------------------------------------------------------------------------------------
-
-         Get tolerance
-
-         @return tolerance
-
-         --------------------------------------------------------------------------------------- */
-
-      RealOpenMM getTolerance( void ) const;
-
-      /**---------------------------------------------------------------------------------------
-
-         Set tolerance
-
-         @param tolerance new tolerance
-
-         --------------------------------------------------------------------------------------- */
-
-      void setTolerance( RealOpenMM tolerance );
-
-      /**---------------------------------------------------------------------------------------
-
-         Apply CCMA algorithm
-
-         @param numberOfAtoms    number of atoms
-         @param atomCoordinates  atom coordinates
-         @param atomCoordinatesP atom coordinates prime
-         @param inverseMasses    1/mass
-
-         @return SimTKOpenMMCommon::DefaultReturn if converge; else
-          return SimTKOpenMMCommon::ErrorReturn
-
-         --------------------------------------------------------------------------------------- */
-
-      int apply( int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates,
-                       std::vector<OpenMM::RealVec>& atomCoordinatesP, std::vector<RealOpenMM>& inverseMasses );
-
-      /**---------------------------------------------------------------------------------------
-
-         Apply constraint algorithm to velocities.
-
-         @param numberOfAtoms    number of atoms
-         @param atomCoordinates  atom coordinates
-         @param velocities       atom velocities
-         @param inverseMasses    1/mass
-
-         @return SimTKOpenMMCommon::DefaultReturn if converge; else
-          return SimTKOpenMMCommon::ErrorReturn
-
-         --------------------------------------------------------------------------------------- */
-
-      int applyToVelocities(int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates,
+public:
+    class AngleInfo;
+
+    /**
+     * Create a ReferenceCCMAAlgorithm object.
+     * 
+     * @param numberOfAtoms            the number of atoms in the system
+     * @param numberOfConstraints      the number of constraints
+     * @param atomIndices              atom indices for contraints
+     * @param distance                 distances for constraints
+     * @param masses                   atom masses
+     * @param angles                   angle force field terms
+     * @param tolerance                constraint tolerance
+     */
+    ReferenceCCMAAlgorithm( int numberOfAtoms, int numberOfConstraints, const std::vector<std::pair<int, int> >& atomIndices, const std::vector<RealOpenMM>& distance, std::vector<RealOpenMM>& masses, std::vector<AngleInfo>& angles, RealOpenMM tolerance );
+
+    ~ReferenceCCMAAlgorithm( );
+
+    /**
+     * Get the number of constraints.
+     */
+    int getNumberOfConstraints( void ) const;
+
+    /**
+     * Get the maximum number of iterations to perform.
+     */
+    int getMaximumNumberOfIterations( void ) const;
+
+    /**
+     * Set the maximum number of iterations to perform.
+     */
+    void setMaximumNumberOfIterations( int maximumNumberOfIterations );
+
+    /**
+     * Get the constraint tolerance.
+     */
+    RealOpenMM getTolerance( void ) const;
+
+    /**
+     * Set the constraint tolerance.
+     */
+    void setTolerance( RealOpenMM tolerance );
+
+    /**
+     * Apply the constraint algorithm.
+     * 
+     * @param atomCoordinates  the original atom coordinates
+     * @param atomCoordinatesP the new atom coordinates
+     * @param inverseMasses    1/mass
+     */
+    void apply(std::vector<OpenMM::RealVec>& atomCoordinates,
+                       std::vector<OpenMM::RealVec>& atomCoordinatesP, std::vector<RealOpenMM>& inverseMasses);
+
+    /**
+     * Apply the constraint algorithm to velocities.
+     * 
+     * @param atomCoordinates  the atom coordinates
+     * @param atomCoordinatesP the velocities to modify
+     * @param inverseMasses    1/mass
+     */
+    void applyToVelocities(std::vector<OpenMM::RealVec>& atomCoordinates,
                      std::vector<OpenMM::RealVec>& velocities, std::vector<RealOpenMM>& inverseMasses);
-
-      /**---------------------------------------------------------------------------------------
-
-         Report any violated constraints
-
-         @param numberOfAtoms    number of atoms
-         @param atomCoordinates  atom coordinates
-         @param message          report
-
-         @return number of violated constraints
-
-         --------------------------------------------------------------------------------------- */
-
-      int reportCCMA( int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, std::stringstream& message );
 };
 
 class ReferenceCCMAAlgorithm::AngleInfo