Merge remote-tracking branch 'upstream/master'

platforms/opencl/include/OpenCLParallelKernels.h

@@ -69,11 +69,13 @@ public:
      * @param includeForce  true if forces should be computed
      * @param includeEnergy true if potential energy should be computed
      * @param groups        a set of bit flags for which force groups to include
+     * @param valid         the method may set this to false to indicate the results are invalid and the force/energy
+     *                      calculation should be repeated
      * @return the potential energy of the system.  This value is added to all values returned by ForceImpls'
      * calcForcesAndEnergy() methods.  That is, each force kernel may <i>either</i> return its contribution to the
      * energy directly, <i>or</i> add it to an internal buffer so that it will be included here.
      */
-    double finishComputation(ContextImpl& context, bool includeForce, bool includeEnergy, int groups);
+    double finishComputation(ContextImpl& context, bool includeForce, bool includeEnergy, int groups, bool& valid);
 private:
     class BeginComputationTask;
     class FinishComputationTask;
@@ -81,6 +83,7 @@ private:
     std::vector<Kernel> kernels;
     std::vector<long long> completionTimes;
     std::vector<double> contextNonbondedFractions;
+    std::vector<int> tileCounts;
     OpenCLArray* contextForces;
     cl::Buffer* pinnedPositionBuffer;
     cl::Buffer* pinnedForceBuffer;

platforms/opencl/src/OpenCLKernels.cpp

@@ -127,7 +127,7 @@ void OpenCLCalcForcesAndEnergyKernel::beginComputation(ContextImpl& context, boo
         nb.prepareInteractions();
 }
 
-double OpenCLCalcForcesAndEnergyKernel::finishComputation(ContextImpl& context, bool includeForces, bool includeEnergy, int groups) {
+double OpenCLCalcForcesAndEnergyKernel::finishComputation(ContextImpl& context, bool includeForces, bool includeEnergy, int groups, bool& valid) {
     cl.getBondedUtilities().computeInteractions(groups);
     if ((groups&(1<<cl.getNonbondedUtilities().getForceGroup())) != 0)
         cl.getNonbondedUtilities().computeInteractions();

platforms/opencl/src/OpenCLNonbondedUtilities.cpp

@@ -54,7 +54,7 @@ private:
     bool useDouble;
 };
 
-OpenCLNonbondedUtilities::OpenCLNonbondedUtilities(OpenCLContext& context) : context(context), cutoff(-1.0), useCutoff(false), anyExclusions(false), usePadding(true),
+OpenCLNonbondedUtilities::OpenCLNonbondedUtilities(OpenCLContext& context) : context(context), cutoff(-1.0), useCutoff(false), usePeriodic(false), anyExclusions(false), usePadding(true),
         numForceBuffers(0), exclusionIndices(NULL), exclusionRowIndices(NULL), exclusionTiles(NULL), exclusions(NULL), interactingTiles(NULL), interactingAtoms(NULL),
         interactionCount(NULL), blockCenter(NULL), blockBoundingBox(NULL), sortedBlocks(NULL), sortedBlockCenter(NULL), sortedBlockBoundingBox(NULL),
         oldPositions(NULL), rebuildNeighborList(NULL), blockSorter(NULL), nonbondedForceGroup(0) {
@@ -282,14 +282,6 @@ void OpenCLNonbondedUtilities::initialize(const System& system) {
         sortedBlockCenter = new OpenCLArray(context, numAtomBlocks+1, 4*elementSize, "sortedBlockCenter");
         sortedBlockBoundingBox = new OpenCLArray(context, numAtomBlocks+1, 4*elementSize, "sortedBlockBoundingBox");
         oldPositions = new OpenCLArray(context, numAtoms, 4*elementSize, "oldPositions");
-        if (context.getUseDoublePrecision()) {
-            vector<mm_double4> oldPositionsVec(numAtoms, mm_double4(1e30, 1e30, 1e30, 0));
-            oldPositions->upload(oldPositionsVec);
-        }
-        else {
-            vector<mm_float4> oldPositionsVec(numAtoms, mm_float4(1e30f, 1e30f, 1e30f, 0));
-            oldPositions->upload(oldPositionsVec);
-        }
         rebuildNeighborList = OpenCLArray::create<int>(context, 1, "rebuildNeighborList");
         blockSorter = new OpenCLSort(context, new BlockSortTrait(context.getUseDoublePrecision()), numAtomBlocks);
         vector<cl_uint> count(1, 0);
@@ -340,6 +332,7 @@ void OpenCLNonbondedUtilities::initialize(const System& system) {
             sortBoxDataKernel.setArg<cl::Buffer>(6, oldPositions->getDeviceBuffer());
             sortBoxDataKernel.setArg<cl::Buffer>(7, interactionCount->getDeviceBuffer());
             sortBoxDataKernel.setArg<cl::Buffer>(8, rebuildNeighborList->getDeviceBuffer());
+            sortBoxDataKernel.setArg<cl_int>(9, true);
             findInteractingBlocksKernel = cl::Kernel(interactingBlocksProgram, "findBlocksWithInteractions");
             findInteractingBlocksKernel.setArg<cl::Buffer>(5, interactionCount->getDeviceBuffer());
             findInteractingBlocksKernel.setArg<cl::Buffer>(6, interactingTiles->getDeviceBuffer());
@@ -406,6 +399,7 @@ void OpenCLNonbondedUtilities::prepareInteractions() {
     context.executeKernel(sortBoxDataKernel, context.getNumAtoms());
     setPeriodicBoxArgs(context, findInteractingBlocksKernel, 0);
     context.executeKernel(findInteractingBlocksKernel, context.getNumAtoms(), interactingBlocksThreadBlockSize);
+    sortBoxDataKernel.setArg<cl_int>(9, false);
 }
 
 void OpenCLNonbondedUtilities::computeInteractions() {
@@ -445,15 +439,7 @@ void OpenCLNonbondedUtilities::updateNeighborListSize() {
     findInteractingBlocksKernel.setArg<cl::Buffer>(6, interactingTiles->getDeviceBuffer());
     findInteractingBlocksKernel.setArg<cl::Buffer>(7, interactingAtoms->getDeviceBuffer());
     findInteractingBlocksKernel.setArg<cl_uint>(9, maxTiles);
-    int numAtoms = context.getNumAtoms();
-    if (context.getUseDoublePrecision()) {
-        vector<mm_double4> oldPositionsVec(numAtoms, mm_double4(1e30, 1e30, 1e30, 0));
-        oldPositions->upload(oldPositionsVec);
-    }
-    else {
-        vector<mm_float4> oldPositionsVec(numAtoms, mm_float4(1e30f, 1e30f, 1e30f, 0));
-        oldPositions->upload(oldPositionsVec);
-    }
+    sortBoxDataKernel.setArg<cl_int>(9, true);
 }
 
 void OpenCLNonbondedUtilities::setUsePadding(bool padding) {
@@ -474,6 +460,7 @@ void OpenCLNonbondedUtilities::setAtomBlockRange(double startFraction, double en
         forceKernel.setArg<cl_uint>(6, numTiles);
         findInteractingBlocksKernel.setArg<cl_uint>(10, startBlockIndex);
         findInteractingBlocksKernel.setArg<cl_uint>(11, numBlocks);
+        sortBoxDataKernel.setArg<cl_int>(9, true);
     }
 }
 

platforms/opencl/src/OpenCLParallelKernels.cpp

@@ -6,7 +6,7 @@
  * Biological Structures at Stanford, funded under the NIH Roadmap for        *
  * Medical Research, grant U54 GM072970. See https://simtk.org.               *
  *                                                                            *
- * Portions copyright (c) 2011-2013 Stanford University and the Authors.      *
+ * Portions copyright (c) 2011-2015 Stanford University and the Authors.      *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -54,8 +54,8 @@ using namespace std;
 class OpenCLParallelCalcForcesAndEnergyKernel::BeginComputationTask : public OpenCLContext::WorkTask {
 public:
     BeginComputationTask(ContextImpl& context, OpenCLContext& cl, OpenCLCalcForcesAndEnergyKernel& kernel,
-            bool includeForce, bool includeEnergy, int groups, void* pinnedMemory) : context(context), cl(cl), kernel(kernel),
-            includeForce(includeForce), includeEnergy(includeEnergy), groups(groups), pinnedMemory(pinnedMemory) {
+            bool includeForce, bool includeEnergy, int groups, void* pinnedMemory, int& numTiles) : context(context), cl(cl), kernel(kernel),
+            includeForce(includeForce), includeEnergy(includeEnergy), groups(groups), pinnedMemory(pinnedMemory), numTiles(numTiles) {
     }
     void execute() {
         // Copy coordinates over to this device and execute the kernel.
@@ -63,6 +63,8 @@ public:
         if (cl.getContextIndex() > 0)
             cl.getQueue().enqueueWriteBuffer(cl.getPosq().getDeviceBuffer(), CL_FALSE, 0, cl.getPaddedNumAtoms()*cl.getPosq().getElementSize(), pinnedMemory);
         kernel.beginComputation(context, includeForce, includeEnergy, groups);
+        if (cl.getNonbondedUtilities().getUsePeriodic())
+            cl.getNonbondedUtilities().getInteractionCount().download(&numTiles, false);
     }
 private:
     ContextImpl& context;
@@ -71,19 +73,20 @@ private:
     bool includeForce, includeEnergy;
     int groups;
     void* pinnedMemory;
+    int& numTiles;
 };
 
 class OpenCLParallelCalcForcesAndEnergyKernel::FinishComputationTask : public OpenCLContext::WorkTask {
 public:
     FinishComputationTask(ContextImpl& context, OpenCLContext& cl, OpenCLCalcForcesAndEnergyKernel& kernel,
-            bool includeForce, bool includeEnergy, int groups, double& energy, long long& completionTime, void* pinnedMemory) :
+            bool includeForce, bool includeEnergy, int groups, double& energy, long long& completionTime, void* pinnedMemory, bool& valid, int& numTiles) :
             context(context), cl(cl), kernel(kernel), includeForce(includeForce), includeEnergy(includeEnergy), groups(groups), energy(energy),
-            completionTime(completionTime), pinnedMemory(pinnedMemory) {
+            completionTime(completionTime), pinnedMemory(pinnedMemory), valid(valid), numTiles(numTiles) {
     }
     void execute() {
         // Execute the kernel, then download forces.
         
-        energy += kernel.finishComputation(context, includeForce, includeEnergy, groups);
+        energy += kernel.finishComputation(context, includeForce, includeEnergy, groups, valid);
         if (includeForce) {
             if (cl.getContextIndex() > 0) {
                 int numAtoms = cl.getPaddedNumAtoms();
@@ -95,6 +98,10 @@ public:
                 cl.getQueue().finish();
         }
         completionTime = getTime();
+        if (cl.getNonbondedUtilities().getUsePeriodic() && numTiles > cl.getNonbondedUtilities().getInteractingTiles().getSize()) {
+            valid = false;
+            cl.getNonbondedUtilities().updateNeighborListSize();
+        }
     }
 private:
     ContextImpl& context;
@@ -105,11 +112,13 @@ private:
     double& energy;
     long long& completionTime;
     void* pinnedMemory;
+    bool& valid;
+    int& numTiles;
 };
 
 OpenCLParallelCalcForcesAndEnergyKernel::OpenCLParallelCalcForcesAndEnergyKernel(string name, const Platform& platform, OpenCLPlatform::PlatformData& data) :
-        CalcForcesAndEnergyKernel(name, platform), data(data), completionTimes(data.contexts.size()), contextNonbondedFractions(data.contexts.size()), contextForces(NULL),
-        pinnedPositionBuffer(NULL), pinnedPositionMemory(NULL), pinnedForceBuffer(NULL), pinnedForceMemory(NULL) {
+        CalcForcesAndEnergyKernel(name, platform), data(data), completionTimes(data.contexts.size()), contextNonbondedFractions(data.contexts.size()),
+        tileCounts(data.contexts.size()), contextForces(NULL), pinnedPositionBuffer(NULL), pinnedPositionMemory(NULL), pinnedForceBuffer(NULL), pinnedForceMemory(NULL) {
     for (int i = 0; i < (int) data.contexts.size(); i++)
         kernels.push_back(Kernel(new OpenCLCalcForcesAndEnergyKernel(name, platform, *data.contexts[i])));
 }
@@ -150,21 +159,21 @@ void OpenCLParallelCalcForcesAndEnergyKernel::beginComputation(ContextImpl& cont
         data.contextEnergy[i] = 0.0;
         OpenCLContext& cl = *data.contexts[i];
         OpenCLContext::WorkThread& thread = cl.getWorkThread();
-        thread.addTask(new BeginComputationTask(context, cl, getKernel(i), includeForce, includeEnergy, groups, pinnedPositionMemory));
+        thread.addTask(new BeginComputationTask(context, cl, getKernel(i), includeForce, includeEnergy, groups, pinnedPositionMemory, tileCounts[i]));
     }
 }
 
-double OpenCLParallelCalcForcesAndEnergyKernel::finishComputation(ContextImpl& context, bool includeForce, bool includeEnergy, int groups) {
+double OpenCLParallelCalcForcesAndEnergyKernel::finishComputation(ContextImpl& context, bool includeForce, bool includeEnergy, int groups, bool& valid) {
     for (int i = 0; i < (int) data.contexts.size(); i++) {
         OpenCLContext& cl = *data.contexts[i];
         OpenCLContext::WorkThread& thread = cl.getWorkThread();
-        thread.addTask(new FinishComputationTask(context, cl, getKernel(i), includeForce, includeEnergy, groups, data.contextEnergy[i], completionTimes[i], pinnedForceMemory));
+        thread.addTask(new FinishComputationTask(context, cl, getKernel(i), includeForce, includeEnergy, groups, data.contextEnergy[i], completionTimes[i], pinnedForceMemory, valid, tileCounts[i]));
     }
     data.syncContexts();
     double energy = 0.0;
     for (int i = 0; i < (int) data.contextEnergy.size(); i++)
         energy += data.contextEnergy[i];
-    if (includeForce) {
+    if (includeForce && valid) {
         // Sum the forces from all devices.
         
         OpenCLContext& cl = *data.contexts[0];
@@ -177,23 +186,25 @@ double OpenCLParallelCalcForcesAndEnergyKernel::finishComputation(ContextImpl& c
         // Balance work between the contexts by transferring a little nonbonded work from the context that
         // finished last to the one that finished first.
         
-        int firstIndex = 0, lastIndex = 0;
-        for (int i = 0; i < (int) completionTimes.size(); i++) {
-            if (completionTimes[i] < completionTimes[firstIndex])
-                firstIndex = i;
-            if (completionTimes[i] > completionTimes[lastIndex])
-                lastIndex = i;
-        }
-        double fractionToTransfer = min(0.001, contextNonbondedFractions[lastIndex]);
-        contextNonbondedFractions[firstIndex] += fractionToTransfer;
-        contextNonbondedFractions[lastIndex] -= fractionToTransfer;
-        double startFraction = 0.0;
-        for (int i = 0; i < (int) contextNonbondedFractions.size(); i++) {
-            double endFraction = startFraction+contextNonbondedFractions[i];
-            if (i == contextNonbondedFractions.size()-1)
-                endFraction = 1.0; // Avoid roundoff error
-            data.contexts[i]->getNonbondedUtilities().setAtomBlockRange(startFraction, endFraction);
-            startFraction = endFraction;
+        if (cl.getComputeForceCount() < 200) {
+            int firstIndex = 0, lastIndex = 0;
+            for (int i = 0; i < (int) completionTimes.size(); i++) {
+                if (completionTimes[i] < completionTimes[firstIndex])
+                    firstIndex = i;
+                if (completionTimes[i] > completionTimes[lastIndex])
+                    lastIndex = i;
+            }
+            double fractionToTransfer = min(0.001, contextNonbondedFractions[lastIndex]);
+            contextNonbondedFractions[firstIndex] += fractionToTransfer;
+            contextNonbondedFractions[lastIndex] -= fractionToTransfer;
+            double startFraction = 0.0;
+            for (int i = 0; i < (int) contextNonbondedFractions.size(); i++) {
+                double endFraction = startFraction+contextNonbondedFractions[i];
+                if (i == contextNonbondedFractions.size()-1)
+                    endFraction = 1.0; // Avoid roundoff error
+                data.contexts[i]->getNonbondedUtilities().setAtomBlockRange(startFraction, endFraction);
+                startFraction = endFraction;
+            }
         }
     }
     return energy;

platforms/opencl/src/kernels/findInteractingBlocks.cl

@@ -44,7 +44,7 @@ __kernel void findBlockBounds(int numAtoms, real4 periodicBoxSize, real4 invPeri
 __kernel void sortBoxData(__global const real2* restrict sortedBlock, __global const real4* restrict blockCenter,
         __global const real4* restrict blockBoundingBox, __global real4* restrict sortedBlockCenter,
         __global real4* restrict sortedBlockBoundingBox, __global const real4* restrict posq, __global const real4* restrict oldPositions,
-        __global unsigned int* restrict interactionCount, __global int* restrict rebuildNeighborList) {
+        __global unsigned int* restrict interactionCount, __global int* restrict rebuildNeighborList, int forceRebuild) {
     for (int i = get_global_id(0); i < NUM_BLOCKS; i += get_global_size(0)) {
         int index = (int) sortedBlock[i].y;
         sortedBlockCenter[i] = blockCenter[index];
@@ -53,7 +53,7 @@ __kernel void sortBoxData(__global const real2* restrict sortedBlock, __global c
     
     // Also check whether any atom has moved enough so that we really need to rebuild the neighbor list.
 
-    bool rebuild = false;
+    bool rebuild = forceRebuild;
     for (int i = get_global_id(0); i < NUM_ATOMS; i += get_global_size(0)) {
         real4 delta = oldPositions[i]-posq[i];
         if (delta.x*delta.x + delta.y*delta.y + delta.z*delta.z > 0.25f*PADDING*PADDING)

platforms/opencl/tests/TestOpenCLLocalEnergyMinimizer.cpp

@@ -77,10 +77,10 @@ void testHarmonicBonds() {
 }
 
 void testLargeSystem() {
-    const int numMolecules = 50;
+    const int numMolecules = 25;
     const int numParticles = numMolecules*2;
     const double cutoff = 2.0;
-    const double boxSize = 5.0;
+    const double boxSize = 4.0;
     const double tolerance = 5;
     System system;
     system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize));
@@ -134,10 +134,10 @@ void testLargeSystem() {
 }
 
 void testVirtualSites() {
-    const int numMolecules = 50;
+    const int numMolecules = 25;
     const int numParticles = numMolecules*3;
     const double cutoff = 2.0;
-    const double boxSize = 5.0;
+    const double boxSize = 4.0;
     const double tolerance = 5;
     System system;
     system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize));

platforms/opencl/tests/TestOpenCLVariableLangevinIntegrator.cpp

@@ -296,7 +296,7 @@ void testArgonBox() {
     system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize));
     system.addForce(nonbonded);
 
-    VariableLangevinIntegrator integrator(temp, 6.0, 1e-5);
+    VariableLangevinIntegrator integrator(temp, 6.0, 1e-4);
     Context context(system, integrator, platform);
     context.setPositions(positions);
     context.setVelocitiesToTemperature(temp);
@@ -308,13 +308,13 @@ void testArgonBox() {
     // Make sure the temperature is correct.
     
     double ke = 0.0;
-    for (int i = 0; i < 2000; ++i) {
-        double t = 2.0 + 0.01 * (i + 1);
+    for (int i = 0; i < 1000; ++i) {
+        double t = 2.0 + 0.02 * (i + 1);
         integrator.stepTo(t);
         State state = context.getState(State::Energy);
         ke += state.getKineticEnergy();
     }
-    ke /= 2000;
+    ke /= 1000;
     double expected = 1.5 * numParticles * BOLTZ * temp;
     ASSERT_USUALLY_EQUAL_TOL(expected, ke, 0.01);
 }

platforms/reference/include/GBVIParameters.h

@@ -25,9 +25,10 @@
 #ifndef __GBVIParameters_H__
 #define __GBVIParameters_H__
 
-#include "SimTKOpenMMCommon.h"
+#include "RealVec.h"
+#include <vector>
 
-// ---------------------------------------------------------------------------------------
+namespace OpenMM {
 
 class GBVIParameters {
 
@@ -57,9 +58,9 @@ class GBVIParameters {
 
       // parameter vectors
 
-      RealOpenMMVector _atomicRadii;
-      RealOpenMMVector _scaledRadii;
-      RealOpenMMVector _gammaParameters;
+      std::vector<RealOpenMM> _atomicRadii;
+      std::vector<RealOpenMM> _scaledRadii;
+      std::vector<RealOpenMM> _gammaParameters;
 
       // cutoff and periodic boundary conditions
       
@@ -82,7 +83,7 @@ class GBVIParameters {
       
          --------------------------------------------------------------------------------------- */
       
-       GBVIParameters( int numberOfAtoms );
+       GBVIParameters(int numberOfAtoms);
 
       /**---------------------------------------------------------------------------------------
       
@@ -90,7 +91,7 @@ class GBVIParameters {
       
          --------------------------------------------------------------------------------------- */
       
-       ~GBVIParameters( );
+       ~GBVIParameters();
 
       /**---------------------------------------------------------------------------------------
       
@@ -100,7 +101,7 @@ class GBVIParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      int getNumberOfAtoms( void ) const;
+      int getNumberOfAtoms() const;
 
       /**---------------------------------------------------------------------------------------
       
@@ -110,7 +111,7 @@ class GBVIParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      RealOpenMM getElectricConstant( void ) const;
+      RealOpenMM getElectricConstant() const;
 
       /**---------------------------------------------------------------------------------------
       
@@ -120,7 +121,7 @@ class GBVIParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      RealOpenMM getSolventDielectric( void ) const;
+      RealOpenMM getSolventDielectric() const;
 
       /**---------------------------------------------------------------------------------------
       
@@ -130,7 +131,7 @@ class GBVIParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      void setSolventDielectric( RealOpenMM solventDielectric );
+      void setSolventDielectric(RealOpenMM solventDielectric);
 
       /**---------------------------------------------------------------------------------------
       
@@ -140,7 +141,7 @@ class GBVIParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      RealOpenMM getSoluteDielectric( void ) const;
+      RealOpenMM getSoluteDielectric() const;
 
       /**---------------------------------------------------------------------------------------
       
@@ -150,7 +151,7 @@ class GBVIParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      void setSoluteDielectric( RealOpenMM soluteDielectric );
+      void setSoluteDielectric(RealOpenMM soluteDielectric);
 
       /**---------------------------------------------------------------------------------------
       
@@ -160,7 +161,7 @@ class GBVIParameters {
       
          --------------------------------------------------------------------------------------- */
       
-      const RealOpenMMVector& getScaledRadii( void ) const;
+      const std::vector<RealOpenMM>& getScaledRadii() const;
         
       /**---------------------------------------------------------------------------------------
       
@@ -170,7 +171,7 @@ class GBVIParameters {
       
          --------------------------------------------------------------------------------------- */
       
-      void setScaledRadii( const RealOpenMMVector& scaledRadii );
+      void setScaledRadii(const std::vector<RealOpenMM>& scaledRadii);
         
       /**---------------------------------------------------------------------------------------
       
@@ -180,7 +181,7 @@ class GBVIParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      const RealOpenMMVector& getAtomicRadii( void ) const;
+      const std::vector<RealOpenMM>& getAtomicRadii() const;
 
       /**---------------------------------------------------------------------------------------
       
@@ -190,7 +191,7 @@ class GBVIParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      void setAtomicRadii( const RealOpenMMVector& atomicRadii );
+      void setAtomicRadii(const std::vector<RealOpenMM>& atomicRadii);
 
       /**---------------------------------------------------------------------------------------
       
@@ -200,7 +201,7 @@ class GBVIParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      const RealOpenMMVector& getGammaParameters( void ) const;
+      const std::vector<RealOpenMM>& getGammaParameters() const;
 
       /**---------------------------------------------------------------------------------------
       
@@ -210,7 +211,7 @@ class GBVIParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      void setGammaParameters( const RealOpenMMVector& gammaParameters );
+      void setGammaParameters(const std::vector<RealOpenMM>& gammaParameters);
 
       /**---------------------------------------------------------------------------------------
 
@@ -220,7 +221,7 @@ class GBVIParameters {
 
          --------------------------------------------------------------------------------------- */
 
-      void setUseCutoff( RealOpenMM distance );
+      void setUseCutoff(RealOpenMM distance);
 
       /**---------------------------------------------------------------------------------------
 
@@ -274,7 +275,7 @@ class GBVIParameters {
       
          --------------------------------------------------------------------------------------- */
       
-      RealOpenMM getTau( void ) const;
+      RealOpenMM getTau() const;
       
     /**---------------------------------------------------------------------------------------
     
@@ -284,7 +285,7 @@ class GBVIParameters {
     
        --------------------------------------------------------------------------------------- */
     
-    int getBornRadiusScalingMethod( void ) const;
+    int getBornRadiusScalingMethod() const;
     
     /**---------------------------------------------------------------------------------------
     
@@ -294,7 +295,7 @@ class GBVIParameters {
     
        --------------------------------------------------------------------------------------- */
     
-    void setBornRadiusScalingMethod( int bornRadiusScalingMethod );
+    void setBornRadiusScalingMethod(int bornRadiusScalingMethod);
     
     /**---------------------------------------------------------------------------------------
     
@@ -304,7 +305,7 @@ class GBVIParameters {
     
        --------------------------------------------------------------------------------------- */
     
-    RealOpenMM getQuinticLowerLimitFactor( void ) const;
+    RealOpenMM getQuinticLowerLimitFactor() const;
     
     /**---------------------------------------------------------------------------------------
     
@@ -314,7 +315,7 @@ class GBVIParameters {
     
        --------------------------------------------------------------------------------------- */
     
-    void setQuinticLowerLimitFactor( RealOpenMM quinticLowerLimitFactor );
+    void setQuinticLowerLimitFactor(RealOpenMM quinticLowerLimitFactor);
     
     /**---------------------------------------------------------------------------------------
     
@@ -324,7 +325,7 @@ class GBVIParameters {
     
        --------------------------------------------------------------------------------------- */
     
-    RealOpenMM getQuinticUpperBornRadiusLimit( void ) const;
+    RealOpenMM getQuinticUpperBornRadiusLimit() const;
     
     /**---------------------------------------------------------------------------------------
     
@@ -334,8 +335,10 @@ class GBVIParameters {
     
        --------------------------------------------------------------------------------------- */
     
-    void setQuinticUpperBornRadiusLimit( RealOpenMM quinticUpperSplineLimit );
+    void setQuinticUpperBornRadiusLimit(RealOpenMM quinticUpperSplineLimit);
 
 };
-   
+
+} // namespace OpenMM
+
 #endif // __GBVIParameters_H__

platforms/reference/include/ObcParameters.h

@@ -25,9 +25,10 @@
 #ifndef __ObcParameters_H__
 #define __ObcParameters_H__
 
-#include "SimTKOpenMMCommon.h"
+#include "RealVec.h"
+#include <vector>
 
-// ---------------------------------------------------------------------------------------
+namespace OpenMM {
 
 class ObcParameters {
 
@@ -57,8 +58,8 @@ class ObcParameters {
 
       // scaled radius factors (S_kk in HCT paper)
 
-      RealOpenMMVector _atomicRadii;
-      RealOpenMMVector _scaledRadiusFactors;
+      std::vector<RealOpenMM> _atomicRadii;
+      std::vector<RealOpenMM> _scaledRadiusFactors;
 
       // cutoff and periodic boundary conditions
       
@@ -75,7 +76,7 @@ class ObcParameters {
 
          --------------------------------------------------------------------------------------- */
       
-      void setDielectricOffset( RealOpenMM dielectricOffset );
+      void setDielectricOffset(RealOpenMM dielectricOffset);
 
    public:
 
@@ -87,7 +88,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
       
-       ObcParameters( int numberOfAtoms, ObcParameters::ObcType obcType = ObcTypeII );
+       ObcParameters(int numberOfAtoms, ObcParameters::ObcType obcType = ObcTypeII);
 
       /**---------------------------------------------------------------------------------------
       
@@ -95,7 +96,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
       
-       ~ObcParameters( );
+       ~ObcParameters();
 
       /**---------------------------------------------------------------------------------------
       
@@ -105,7 +106,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      int getNumberOfAtoms( void ) const;
+      int getNumberOfAtoms() const;
 
       /**---------------------------------------------------------------------------------------
       
@@ -115,7 +116,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      RealOpenMM getElectricConstant( void ) const;
+      RealOpenMM getElectricConstant() const;
 
       /**---------------------------------------------------------------------------------------
       
@@ -125,7 +126,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      RealOpenMM getProbeRadius( void ) const;
+      RealOpenMM getProbeRadius() const;
 
       /**---------------------------------------------------------------------------------------
       
@@ -135,7 +136,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      void setProbeRadius( RealOpenMM probeRadius );
+      void setProbeRadius(RealOpenMM probeRadius);
 
       /**---------------------------------------------------------------------------------------
       
@@ -146,7 +147,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      RealOpenMM getPi4Asolv( void ) const;
+      RealOpenMM getPi4Asolv() const;
 
       /**---------------------------------------------------------------------------------------
       
@@ -154,7 +155,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      void setPi4Asolv( RealOpenMM pi4Asolv );
+      void setPi4Asolv(RealOpenMM pi4Asolv);
 
       /**---------------------------------------------------------------------------------------
       
@@ -164,7 +165,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      RealOpenMM getSolventDielectric( void ) const;
+      RealOpenMM getSolventDielectric() const;
 
       /**---------------------------------------------------------------------------------------
       
@@ -174,7 +175,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      void setSolventDielectric( RealOpenMM solventDielectric );
+      void setSolventDielectric(RealOpenMM solventDielectric);
 
       /**---------------------------------------------------------------------------------------
       
@@ -184,7 +185,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      RealOpenMM getSoluteDielectric( void ) const;
+      RealOpenMM getSoluteDielectric() const;
 
       /**---------------------------------------------------------------------------------------
       
@@ -194,7 +195,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      void setSoluteDielectric( RealOpenMM soluteDielectric );
+      void setSoluteDielectric(RealOpenMM soluteDielectric);
 
       /**---------------------------------------------------------------------------------------
       
@@ -204,7 +205,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
       
-      ObcParameters::ObcType getObcType( void ) const;
+      ObcParameters::ObcType getObcType() const;
       
       /**---------------------------------------------------------------------------------------
       
@@ -214,7 +215,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
       
-      void setObcTypeParameters( ObcParameters::ObcType obcType );
+      void setObcTypeParameters(ObcParameters::ObcType obcType);
       
       /**---------------------------------------------------------------------------------------
       
@@ -224,7 +225,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
       
-      RealOpenMM getAlphaObc( void ) const;
+      RealOpenMM getAlphaObc() const;
       
       /**---------------------------------------------------------------------------------------
       
@@ -234,7 +235,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
       
-      RealOpenMM getBetaObc( void ) const;
+      RealOpenMM getBetaObc() const;
       
       /**---------------------------------------------------------------------------------------
       
@@ -244,7 +245,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
       
-      RealOpenMM getGammaObc( void ) const;
+      RealOpenMM getGammaObc() const;
       
       /**---------------------------------------------------------------------------------------
       
@@ -254,7 +255,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
       
-      RealOpenMM getDielectricOffset( void ) const;
+      RealOpenMM getDielectricOffset() const;
 
       /**---------------------------------------------------------------------------------------
       
@@ -264,7 +265,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
       
-      const RealOpenMMVector& getScaledRadiusFactors( void ) const;
+      const std::vector<RealOpenMM>& getScaledRadiusFactors() const;
         
       /**---------------------------------------------------------------------------------------
       
@@ -274,7 +275,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
       
-      void setScaledRadiusFactors( const RealOpenMMVector& scaledRadiusFactors );
+      void setScaledRadiusFactors(const std::vector<RealOpenMM>& scaledRadiusFactors);
         
       /**---------------------------------------------------------------------------------------
       
@@ -284,7 +285,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      const RealOpenMMVector& getAtomicRadii( void ) const;
+      const std::vector<RealOpenMM>& getAtomicRadii() const;
 
       /**---------------------------------------------------------------------------------------
       
@@ -294,7 +295,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      void setAtomicRadii( const RealOpenMMVector& atomicRadii );
+      void setAtomicRadii(const std::vector<RealOpenMM>& atomicRadii);
 
 
       /**---------------------------------------------------------------------------------------
@@ -305,7 +306,7 @@ class ObcParameters {
 
          --------------------------------------------------------------------------------------- */
 
-      void setUseCutoff( RealOpenMM distance );
+      void setUseCutoff(RealOpenMM distance);
 
       /**---------------------------------------------------------------------------------------
 
@@ -352,7 +353,7 @@ class ObcParameters {
       const OpenMM::RealVec* getPeriodicBox();
 
 };
-   
-// ---------------------------------------------------------------------------------------
+
+} // namespace OpenMM
 
 #endif // __ObcParameters_H__

platforms/reference/include/ReferenceAndersenThermostat.h

@@ -25,10 +25,9 @@
 #ifndef __ReferenceAndersenThermostat_H__
 #define __ReferenceAndersenThermostat_H__
 
-#include "SimTKOpenMMCommon.h"
 #include <vector>
 
-// ---------------------------------------------------------------------------------------
+namespace OpenMM {
 
 class ReferenceAndersenThermostat {
 
@@ -42,7 +41,7 @@ class ReferenceAndersenThermostat {
       
          --------------------------------------------------------------------------------------- */
 
-       ReferenceAndersenThermostat( );
+       ReferenceAndersenThermostat();
 
       /**---------------------------------------------------------------------------------------
       
@@ -50,7 +49,7 @@ class ReferenceAndersenThermostat {
       
          --------------------------------------------------------------------------------------- */
 
-       ~ReferenceAndersenThermostat( );
+       ~ReferenceAndersenThermostat();
 
       /**---------------------------------------------------------------------------------------
       
@@ -65,11 +64,11 @@ class ReferenceAndersenThermostat {
                   
          --------------------------------------------------------------------------------------- */
           
-      void applyThermostat( const std::vector<std::vector<int> >& atomGroups, std::vector<OpenMM::RealVec>& atomVelocities, std::vector<RealOpenMM>& atomMasses,
-              RealOpenMM temperature, RealOpenMM collisionFrequency, RealOpenMM stepSize ) const;
+      void applyThermostat(const std::vector<std::vector<int> >& atomGroups, std::vector<OpenMM::RealVec>& atomVelocities, std::vector<RealOpenMM>& atomMasses,
+              RealOpenMM temperature, RealOpenMM collisionFrequency, RealOpenMM stepSize) const;
       
 };
 
-// ---------------------------------------------------------------------------------------
+} // namespace OpenMM
 
 #endif // __ReferenceAndersenThermostat_H__

platforms/reference/include/ReferenceAngleBondIxn.h

@@ -27,7 +27,7 @@
 
 #include "ReferenceBondIxn.h"
 
-// ---------------------------------------------------------------------------------------
+namespace OpenMM {
 
 class ReferenceAngleBondIxn : public ReferenceBondIxn {
 
@@ -41,7 +41,7 @@ class ReferenceAngleBondIxn : public ReferenceBondIxn {
       
          --------------------------------------------------------------------------------------- */
 
-       ReferenceAngleBondIxn( );
+       ReferenceAngleBondIxn();
 
       /**---------------------------------------------------------------------------------------
       
@@ -49,7 +49,7 @@ class ReferenceAngleBondIxn : public ReferenceBondIxn {
       
          --------------------------------------------------------------------------------------- */
 
-       ~ReferenceAngleBondIxn( );
+       ~ReferenceAngleBondIxn();
 
       /**---------------------------------------------------------------------------------------
 
@@ -63,8 +63,8 @@ class ReferenceAngleBondIxn : public ReferenceBondIxn {
       
          --------------------------------------------------------------------------------------- */
       
-      void getPrefactorsGivenAngleCosine( RealOpenMM cosine, RealOpenMM* angleParameters,
-                                         RealOpenMM* dEdR, RealOpenMM* energyTerm ) const;
+      void getPrefactorsGivenAngleCosine(RealOpenMM cosine, RealOpenMM* angleParameters,
+                                         RealOpenMM* dEdR, RealOpenMM* energyTerm) const;
       
       /**---------------------------------------------------------------------------------------
 
@@ -79,13 +79,13 @@ class ReferenceAngleBondIxn : public ReferenceBondIxn {
       
          --------------------------------------------------------------------------------------- */
       
-      void calculateBondIxn( int* atomIndices, std::vector<OpenMM::RealVec>& atomCoordinates,
+      void calculateBondIxn(int* atomIndices, std::vector<OpenMM::RealVec>& atomCoordinates,
                             RealOpenMM* parameters, std::vector<OpenMM::RealVec>& forces,
-                            RealOpenMM* totalEnergy ) const;
+                            RealOpenMM* totalEnergy) const;
       
 
 };
 
-// ---------------------------------------------------------------------------------------
+} // namespace OpenMM
 
 #endif // __ReferenceAngleBondIxn_H__

platforms/reference/include/ReferenceBondForce.h

@@ -28,7 +28,7 @@
 #include "ReferenceForce.h"
 #include "ReferenceBondIxn.h"
 
-// ---------------------------------------------------------------------------------------
+namespace OpenMM {
 
 class OPENMM_EXPORT ReferenceBondForce : public ReferenceForce {
 
@@ -42,7 +42,7 @@ class OPENMM_EXPORT ReferenceBondForce : public ReferenceForce {
       
          --------------------------------------------------------------------------------------- */
 
-       ReferenceBondForce( );
+       ReferenceBondForce();
 
       /**---------------------------------------------------------------------------------------
       
@@ -50,7 +50,7 @@ class OPENMM_EXPORT ReferenceBondForce : public ReferenceForce {
       
          --------------------------------------------------------------------------------------- */
 
-       ~ReferenceBondForce( );
+       ~ReferenceBondForce();
 
       /**---------------------------------------------------------------------------------------
       
@@ -67,13 +67,13 @@ class OPENMM_EXPORT ReferenceBondForce : public ReferenceForce {
       
          --------------------------------------------------------------------------------------- */
       
-       void calculateForce( int numberOfBonds, int** atomIndices,
+       void calculateForce(int numberOfBonds, int** atomIndices,
                            std::vector<OpenMM::RealVec>& atomCoordinates,
                            RealOpenMM** parameters, std::vector<OpenMM::RealVec>& forces, 
-                           RealOpenMM* totalEnergy, ReferenceBondIxn& referenceBondIxn );
+                           RealOpenMM* totalEnergy, ReferenceBondIxn& referenceBondIxn);
 
 };
 
-// ---------------------------------------------------------------------------------------
+} // namespace OpenMM
 
 #endif // __ReferenceBondForce_H__

platforms/reference/include/ReferenceBondIxn.h

@@ -29,7 +29,7 @@
 #include "openmm/internal/windowsExport.h"
 #include <vector>
 
-// ---------------------------------------------------------------------------------------
+namespace OpenMM {
 
 class OPENMM_EXPORT ReferenceBondIxn {
 
@@ -43,7 +43,7 @@ class OPENMM_EXPORT ReferenceBondIxn {
       
          --------------------------------------------------------------------------------------- */
 
-       ReferenceBondIxn( );
+       ReferenceBondIxn();
 
       /**---------------------------------------------------------------------------------------
       
@@ -51,7 +51,7 @@ class OPENMM_EXPORT ReferenceBondIxn {
       
          --------------------------------------------------------------------------------------- */
 
-       ~ReferenceBondIxn( );
+       ~ReferenceBondIxn();
 
       /**---------------------------------------------------------------------------------------
       
@@ -65,9 +65,9 @@ class OPENMM_EXPORT ReferenceBondIxn {
       
          --------------------------------------------------------------------------------------- */
       
-      virtual void calculateBondIxn( int* atomIndices, std::vector<OpenMM::RealVec>& atomCoordinates,
+      virtual void calculateBondIxn(int* atomIndices, std::vector<OpenMM::RealVec>& atomCoordinates,
                                     RealOpenMM* parameters, std::vector<OpenMM::RealVec>& forces,
-                                    RealOpenMM* totalEnergy ) const;
+                                    RealOpenMM* totalEnergy) const;
       
       /**---------------------------------------------------------------------------------------
       
@@ -82,7 +82,7 @@ class OPENMM_EXPORT ReferenceBondIxn {
       
          --------------------------------------------------------------------------------------- */
       
-      static RealOpenMM getNormedDotProduct( RealOpenMM* vector1, RealOpenMM* vector2, int hasREntry );
+      static RealOpenMM getNormedDotProduct(RealOpenMM* vector1, RealOpenMM* vector2, int hasREntry);
       
       /**---------------------------------------------------------------------------------------
       
@@ -98,8 +98,8 @@ class OPENMM_EXPORT ReferenceBondIxn {
       
          --------------------------------------------------------------------------------------- */
       
-      static RealOpenMM getAngleBetweenTwoVectors( RealOpenMM* vector1, RealOpenMM* vector2, 
-                                                   RealOpenMM* outputDotProduct, int hasREntry );
+      static RealOpenMM getAngleBetweenTwoVectors(RealOpenMM* vector1, RealOpenMM* vector2, 
+                                                   RealOpenMM* outputDotProduct, int hasREntry);
       
       /**---------------------------------------------------------------------------------------
       
@@ -119,13 +119,13 @@ class OPENMM_EXPORT ReferenceBondIxn {
       
          --------------------------------------------------------------------------------------- */
       
-      static RealOpenMM getDihedralAngleBetweenThreeVectors( RealOpenMM* vector1, RealOpenMM* vector2, 
-                                                             RealOpenMM* vector3, RealOpenMM** outputCrossProduct, 
-                                                             RealOpenMM* cosineOfAngle, RealOpenMM* signVector, 
-                                                             RealOpenMM* signOfAngle, int hasREntry );
+      static RealOpenMM getDihedralAngleBetweenThreeVectors(RealOpenMM* vector1, RealOpenMM* vector2, 
+                                                            RealOpenMM* vector3, RealOpenMM** outputCrossProduct, 
+                                                            RealOpenMM* cosineOfAngle, RealOpenMM* signVector, 
+                                                            RealOpenMM* signOfAngle, int hasREntry);
       
 };
 
-// ---------------------------------------------------------------------------------------
+} // namespace OpenMM
 
 #endif // __ReferenceBondIxn_H__

platforms/reference/include/ReferenceBrownianDynamics.h

@@ -27,7 +27,7 @@
 
 #include "ReferenceDynamics.h"
 
-// ---------------------------------------------------------------------------------------
+namespace OpenMM {
 
 class ReferenceBrownianDynamics : public ReferenceDynamics {
 
@@ -50,7 +50,7 @@ class ReferenceBrownianDynamics : public ReferenceDynamics {
       
          --------------------------------------------------------------------------------------- */
 
-       ReferenceBrownianDynamics( int numberOfAtoms, RealOpenMM deltaT, RealOpenMM friction, RealOpenMM temperature );
+       ReferenceBrownianDynamics(int numberOfAtoms, RealOpenMM deltaT, RealOpenMM friction, RealOpenMM temperature);
 
       /**---------------------------------------------------------------------------------------
       
@@ -58,7 +58,7 @@ class ReferenceBrownianDynamics : public ReferenceDynamics {
       
          --------------------------------------------------------------------------------------- */
 
-       ~ReferenceBrownianDynamics( );
+       ~ReferenceBrownianDynamics();
 
       /**---------------------------------------------------------------------------------------
       
@@ -68,7 +68,7 @@ class ReferenceBrownianDynamics : public ReferenceDynamics {
       
          --------------------------------------------------------------------------------------- */
       
-      RealOpenMM getFriction( void ) const;
+      RealOpenMM getFriction() const;
       
       /**---------------------------------------------------------------------------------------
       
@@ -88,6 +88,6 @@ class ReferenceBrownianDynamics : public ReferenceDynamics {
       
 };
 
-// ---------------------------------------------------------------------------------------
+} // namespace OpenMM
 
 #endif // __ReferenceBrownianDynamics_H__

platforms/reference/include/ReferenceCCMAAlgorithm.h

@@ -30,7 +30,7 @@
 #include <vector>
 #include <set>
 
-// ---------------------------------------------------------------------------------------
+namespace OpenMM {
 
 class OPENMM_EXPORT ReferenceCCMAAlgorithm : public ReferenceConstraintAlgorithm {
 
@@ -69,22 +69,22 @@ public:
      */
     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);
 
-    ~ReferenceCCMAAlgorithm( );
+    ~ReferenceCCMAAlgorithm();
 
     /**
      * Get the number of constraints.
      */
-    int getNumberOfConstraints( void ) const;
+    int getNumberOfConstraints() const;
 
     /**
      * Get the maximum number of iterations to perform.
      */
-    int getMaximumNumberOfIterations( void ) const;
+    int getMaximumNumberOfIterations() const;
 
     /**
      * Set the maximum number of iterations to perform.
      */
-    void setMaximumNumberOfIterations( int maximumNumberOfIterations );
+    void setMaximumNumberOfIterations(int maximumNumberOfIterations);
 
     /**
      * Apply the constraint algorithm.
@@ -120,6 +120,6 @@ public:
     }
 };
 
-// ---------------------------------------------------------------------------------------
+} // namespace OpenMM
 
 #endif // __ReferenceCCMAAlgorithm_H__

platforms/reference/include/ReferenceCMAPTorsionIxn.h

@@ -25,12 +25,11 @@
 #ifndef __ReferenceCMAPTorsionIxn_H__
 #define __ReferenceCMAPTorsionIxn_H__
 
-#include "SimTKOpenMMCommon.h"
 #include "SimTKOpenMMUtilities.h"
 #include "ReferenceBondIxn.h"
 #include <vector>
 
-// ---------------------------------------------------------------------------------------
+namespace OpenMM {
 
 class ReferenceCMAPTorsionIxn : public ReferenceBondIxn {
 
@@ -92,4 +91,6 @@ public:
 
 };
 
+} // namespace OpenMM
+
 #endif // __ReferenceCMAPTorsionIxn_H__

platforms/reference/include/ReferenceConstraintAlgorithm.h

@@ -25,8 +25,11 @@
 #ifndef __ReferenceConstraintAlgorithm_H__
 #define __ReferenceConstraintAlgorithm_H__
 
-#include "SimTKOpenMMCommon.h"
+#include "RealVec.h"
 #include "openmm/internal/windowsExport.h"
+#include <vector>
+
+namespace OpenMM {
 
 /**
  * This abstract class defines the interface which constraint algorithms must implement.
@@ -59,6 +62,6 @@ public:
                      std::vector<OpenMM::RealVec>& velocities, std::vector<RealOpenMM>& inverseMasses, RealOpenMM tolerance) = 0;
 };
 
-// ---------------------------------------------------------------------------------------
+} // namespace OpenMM
 
 #endif // __ReferenceConstraintAlgorithm_H__

platforms/reference/include/ReferenceCustomAngleIxn.h

@@ -27,7 +27,7 @@
 #include "ReferenceBondIxn.h"
 #include "lepton/CompiledExpression.h"
 
-// ---------------------------------------------------------------------------------------
+namespace OpenMM {
 
 class ReferenceCustomAngleIxn : public ReferenceBondIxn {
 
@@ -57,7 +57,7 @@ class ReferenceCustomAngleIxn : public ReferenceBondIxn {
 
          --------------------------------------------------------------------------------------- */
 
-       ~ReferenceCustomAngleIxn( );
+       ~ReferenceCustomAngleIxn();
 
       /**---------------------------------------------------------------------------------------
 
@@ -71,13 +71,13 @@ class ReferenceCustomAngleIxn : public ReferenceBondIxn {
 
          --------------------------------------------------------------------------------------- */
 
-      void calculateBondIxn( int* atomIndices, std::vector<OpenMM::RealVec>& atomCoordinates,
+      void calculateBondIxn(int* atomIndices, std::vector<OpenMM::RealVec>& atomCoordinates,
                             RealOpenMM* parameters, std::vector<OpenMM::RealVec>& forces,
                             RealOpenMM* totalEnergy) const;
 
 
 };
 
-// ---------------------------------------------------------------------------------------
+} // namespace OpenMM
 
 #endif // _ReferenceCustomAngleIxn___

platforms/reference/include/ReferenceCustomBondIxn.h

@@ -28,7 +28,7 @@
 #include "ReferenceBondIxn.h"
 #include "lepton/CompiledExpression.h"
 
-// ---------------------------------------------------------------------------------------
+namespace OpenMM {
 
 class ReferenceCustomBondIxn : public ReferenceBondIxn {
 
@@ -58,7 +58,7 @@ class ReferenceCustomBondIxn : public ReferenceBondIxn {
 
          --------------------------------------------------------------------------------------- */
 
-       ~ReferenceCustomBondIxn( );
+       ~ReferenceCustomBondIxn();
 
       /**---------------------------------------------------------------------------------------
 
@@ -72,13 +72,13 @@ class ReferenceCustomBondIxn : public ReferenceBondIxn {
 
          --------------------------------------------------------------------------------------- */
 
-      void calculateBondIxn( int* atomIndices, std::vector<OpenMM::RealVec>& atomCoordinates,
+      void calculateBondIxn(int* atomIndices, std::vector<OpenMM::RealVec>& atomCoordinates,
                             RealOpenMM* parameters, std::vector<OpenMM::RealVec>& forces,
-                            RealOpenMM* totalEnergy ) const;
+                            RealOpenMM* totalEnergy) const;
 
 
 };
 
-// ---------------------------------------------------------------------------------------
+} // namespace OpenMM
 
 #endif // _ReferenceCustomBondIxn___

platforms/reference/include/ReferenceCustomCompoundBondIxn.h

@@ -31,7 +31,7 @@
 #include <map>
 #include <vector>
 
-// ---------------------------------------------------------------------------------------
+namespace OpenMM {
 
 class ReferenceCustomCompoundBondIxn : public ReferenceBondIxn {
 
@@ -169,4 +169,6 @@ public:
     }
 };
 
+} // namespace OpenMM
+
 #endif // __ReferenceCustomCompoundBondIxn_H__