Merge remote-tracking branch 'upstream/master'

platforms/opencl/src/kernels/nonbonded.cl

@@ -269,7 +269,7 @@ __kernel void computeNonbonded(
             LOAD_ATOM1_PARAMETERS
             const unsigned int localAtomIndex = get_local_id(0);
 #ifdef USE_CUTOFF
-            unsigned int j = (numTiles <= maxTiles ? interactingAtoms[pos*TILE_SIZE+tgx] : y*TILE_SIZE + tgx);
+            unsigned int j = interactingAtoms[pos*TILE_SIZE+tgx];
 #else
             unsigned int j = y*TILE_SIZE + tgx;
 #endif

platforms/opencl/src/kernels/nonbonded_cpu.cl

@@ -269,7 +269,7 @@ __kernel void computeNonbonded(
 
             for (int localAtomIndex = 0; localAtomIndex < TILE_SIZE; localAtomIndex++) {
 #ifdef USE_CUTOFF
-                unsigned int j = (numTiles <= maxTiles ? interactingAtoms[pos*TILE_SIZE+localAtomIndex] : y*TILE_SIZE+localAtomIndex);
+                unsigned int j = interactingAtoms[pos*TILE_SIZE+localAtomIndex];
 #else
                 unsigned int j = y*TILE_SIZE+localAtomIndex;
 #endif

platforms/opencl/src/kernels/pme.cl

 __kernel void updateBsplines(__global const real4* restrict posq, __global real4* restrict pmeBsplineTheta, __local real4* restrict bsplinesCache,
         __global int2* restrict pmeAtomGridIndex, real4 periodicBoxSize, real4 invPeriodicBoxSize, real4 periodicBoxVecX, real4 periodicBoxVecY, real4 periodicBoxVecZ,
-        real4 recipBoxVecX, real4 recipBoxVecY, real4 recipBoxVecZ) {
+        real4 recipBoxVecX, real4 recipBoxVecY, real4 recipBoxVecZ
+#ifdef USE_LJPME
+        , __global const float2* restrict sigmaEpsilon
+#endif
+    ) {
     const real4 scale = 1/(real) (PME_ORDER-1);
     for (int i = get_global_id(0); i < NUM_ATOMS; i += get_global_size(0)) {
         __local real4* data = &bsplinesCache[get_local_id(0)*PME_ORDER];
@@ -33,7 +37,13 @@ __kernel void updateBsplines(__global const real4* restrict posq, __global real4
             data[PME_ORDER-j-1] = scale*((dr+(real4) j)*data[PME_ORDER-j-2] + (-dr+(real4) (PME_ORDER-j))*data[PME_ORDER-j-1]);
         data[0] = scale*(-dr+1.0f)*data[0];
         for (int j = 0; j < PME_ORDER; j++) {
-            data[j].w = pos.w; // Storing the charge here improves cache coherency in the charge spreading kernel
+#ifdef USE_LJPME
+            const float2 sigEps = sigmaEpsilon[i];
+            const real charge = 8*sigEps.x*sigEps.x*sigEps.x*sigEps.y;
+#else
+            const real charge = pos.w;
+#endif
+            data[j].w = charge; // Storing the charge here improves cache coherency in the charge spreading kernel
             pmeBsplineTheta[i+j*NUM_ATOMS] = data[j];
         }
 #endif
@@ -86,7 +96,11 @@ __kernel void recordZIndex(__global int2* restrict pmeAtomGridIndex, __global co
 
 __kernel void gridSpreadCharge(__global const real4* restrict posq, __global const int2* restrict pmeAtomGridIndex, __global const int* restrict pmeAtomRange,
         __global long* restrict pmeGrid, __global const real4* restrict pmeBsplineTheta, real4 periodicBoxSize, real4 invPeriodicBoxSize,
-        real4 periodicBoxVecX, real4 periodicBoxVecY, real4 periodicBoxVecZ, real4 recipBoxVecX, real4 recipBoxVecY, real4 recipBoxVecZ) {
+        real4 periodicBoxVecX, real4 periodicBoxVecY, real4 periodicBoxVecZ, real4 recipBoxVecX, real4 recipBoxVecY, real4 recipBoxVecZ
+#ifdef USE_LJPME
+        , __global const float2* restrict sigmaEpsilon
+#endif
+    ) {
     const real scale = 1/(real) (PME_ORDER-1);
     real4 data[PME_ORDER];
     
@@ -128,6 +142,12 @@ __kernel void gridSpreadCharge(__global const real4* restrict posq, __global con
 
         // Spread the charge from this atom onto each grid point.
 
+#ifdef USE_LJPME
+        const float2 sigEps = sigmaEpsilon[atom];
+        const real charge = 8*sigEps.x*sigEps.x*sigEps.x*sigEps.y;
+#else
+        const real charge = pos.w;
+#endif
         for (int ix = 0; ix < PME_ORDER; ix++) {
             int xindex = gridIndex.x+ix;
             xindex -= (xindex >= GRID_SIZE_X ? GRID_SIZE_X : 0);
@@ -138,7 +158,7 @@ __kernel void gridSpreadCharge(__global const real4* restrict posq, __global con
                     int zindex = gridIndex.z+iz;
                     zindex -= (zindex >= GRID_SIZE_Z ? GRID_SIZE_Z : 0);
                     int index = xindex*GRID_SIZE_Y*GRID_SIZE_Z + yindex*GRID_SIZE_Z + zindex;
-                    real add = pos.w*data[ix].x*data[iy].y*data[iz].z;
+                    real add = charge*data[ix].x*data[iy].y*data[iz].z;
 #ifdef USE_ALTERNATE_MEMORY_ACCESS_PATTERN
                     // On Nvidia devices (at least Maxwell anyway), this split ordering produces much higher performance.  Why?
                     // I have no idea!  And of course on AMD it produces slower performance.  GPUs are not meant to be understood.
@@ -167,7 +187,11 @@ __kernel void finishSpreadCharge(__global long* restrict fixedGrid, __global rea
 #elif defined(DEVICE_IS_CPU)
 __kernel void gridSpreadCharge(__global const real4* restrict posq, __global const int2* restrict pmeAtomGridIndex, __global const int* restrict pmeAtomRange,
         __global real* restrict pmeGrid, __global const real4* restrict pmeBsplineTheta, real4 periodicBoxSize, real4 invPeriodicBoxSize,
-        real4 periodicBoxVecX, real4 periodicBoxVecY, real4 periodicBoxVecZ, real4 recipBoxVecX, real4 recipBoxVecY, real4 recipBoxVecZ) {
+        real4 periodicBoxVecX, real4 periodicBoxVecY, real4 periodicBoxVecZ, real4 recipBoxVecX, real4 recipBoxVecY, real4 recipBoxVecZ
+#ifdef USE_LJPME
+        , __global const float2* restrict sigmaEpsilon
+#endif
+    ) {
     const int firstx = get_global_id(0)*GRID_SIZE_X/get_global_size(0);
     const int lastx = (get_global_id(0)+1)*GRID_SIZE_X/get_global_size(0);
     if (firstx == lastx)
@@ -194,6 +218,12 @@ __kernel void gridSpreadCharge(__global const real4* restrict posq, __global con
 
         // Spread the charge from this atom onto each grid point.
 
+#ifdef USE_LJPME
+        const float2 sigEps = sigmaEpsilon[atom];
+        const real charge = 8*sigEps.x*sigEps.x*sigEps.x*sigEps.y;
+#else
+        const real charge = pos.w;
+#endif
         bool hasComputedThetas = false;
         for (int ix = 0; ix < PME_ORDER; ix++) {
             int xindex = gridIndex.x+ix;
@@ -229,7 +259,7 @@ __kernel void gridSpreadCharge(__global const real4* restrict posq, __global con
                     int zindex = gridIndex.z+iz;
                     zindex -= (zindex >= GRID_SIZE_Z ? GRID_SIZE_Z : 0);
                     int index = xindex*GRID_SIZE_Y*GRID_SIZE_Z + yindex*GRID_SIZE_Z + zindex;
-                    pmeGrid[index] += EPSILON_FACTOR*pos.w*data[ix].x*data[iy].y*data[iz].z;
+                    pmeGrid[index] += EPSILON_FACTOR*charge*data[ix].x*data[iy].y*data[iz].z;
                 }
             }
         }
@@ -237,7 +267,11 @@ __kernel void gridSpreadCharge(__global const real4* restrict posq, __global con
 }
 #else
 __kernel void gridSpreadCharge(__global const real4* restrict posq, __global const int2* restrict pmeAtomGridIndex, __global const int* restrict pmeAtomRange,
-        __global real* restrict pmeGrid, __global const real4* restrict pmeBsplineTheta) {
+        __global real* restrict pmeGrid, __global const real4* restrict pmeBsplineTheta
+#ifdef USE_LJPME
+        , __global const float2* restrict sigmaEpsilon
+#endif
+    ) {
     unsigned int numGridPoints = GRID_SIZE_X*GRID_SIZE_Y*GRID_SIZE_Z;
     for (int gridIndex = get_global_id(0); gridIndex < numGridPoints; gridIndex += get_global_size(0)) {
         // Compute the charge on a grid point.
@@ -298,7 +332,15 @@ __kernel void reciprocalConvolution(__global real2* restrict pmeGrid, __global c
         __global const real* restrict pmeBsplineModuliY, __global const real* restrict pmeBsplineModuliZ, real4 recipBoxVecX, real4 recipBoxVecY, real4 recipBoxVecZ) {
     // R2C stores into a half complex matrix where the last dimension is cut by half
     const unsigned int gridSize = GRID_SIZE_X*GRID_SIZE_Y*(GRID_SIZE_Z/2+1);
+#ifdef USE_LJPME
+    const real recipScaleFactor = -(2*M_PI/6)*SQRT(M_PI)*recipBoxVecX.x*recipBoxVecY.y*recipBoxVecZ.z;
+    real bfac = M_PI / EWALD_ALPHA;
+    real fac1 = 2*M_PI*M_PI*M_PI*SQRT(M_PI);
+    real fac2 = EWALD_ALPHA*EWALD_ALPHA*EWALD_ALPHA;
+    real fac3 = -2*EWALD_ALPHA*M_PI*M_PI;
+#else
     const real recipScaleFactor = (1.0f/M_PI)*recipBoxVecX.x*recipBoxVecY.y*recipBoxVecZ.z;
+#endif
 
     for (int index = get_global_id(0); index < gridSize; index += get_global_size(0)) {
         // real indices
@@ -317,11 +359,23 @@ __kernel void reciprocalConvolution(__global real2* restrict pmeGrid, __global c
         real bz = pmeBsplineModuliZ[kz];
         real2 grid = pmeGrid[index];
         real m2 = mhx*mhx+mhy*mhy+mhz*mhz;
+#ifdef USE_LJPME
+        real denom = recipScaleFactor/(bx*by*bz);
+        real m = SQRT(m2);
+        real m3 = m*m2;
+        real b = bfac*m;
+        real expfac = -b*b;
+        real expterm = EXP(expfac);
+        real erfcterm = erfc(b);
+        real eterm = (fac1*erfcterm*m3 + expterm*(fac2 + fac3*m2)) * denom;
+        pmeGrid[index] = (real2) (grid.x*eterm, grid.y*eterm);
+#else
         real denom = m2*bx*by*bz;
         real eterm = recipScaleFactor*EXP(-RECIP_EXP_FACTOR*m2)/denom;
         if (kx != 0 || ky != 0 || kz != 0) {
             pmeGrid[index] = (real2) (grid.x*eterm, grid.y*eterm);
         }
+#endif
     }
 }
 
@@ -330,7 +384,15 @@ __kernel void gridEvaluateEnergy(__global real2* restrict pmeGrid, __global mixe
                       real4 recipBoxVecX, real4 recipBoxVecY, real4 recipBoxVecZ) {
     // R2C stores into a half complex matrix where the last dimension is cut by half
     const unsigned int gridSize = GRID_SIZE_X*GRID_SIZE_Y*GRID_SIZE_Z;
+ #ifdef USE_LJPME
+    const real recipScaleFactor = -(2*M_PI/6)*SQRT(M_PI)*recipBoxVecX.x*recipBoxVecY.y*recipBoxVecZ.z;
+    real bfac = M_PI / EWALD_ALPHA;
+    real fac1 = 2*M_PI*M_PI*M_PI*SQRT(M_PI);
+    real fac2 = EWALD_ALPHA*EWALD_ALPHA*EWALD_ALPHA;
+    real fac3 = -2*EWALD_ALPHA*M_PI*M_PI;
+#else
     const real recipScaleFactor = (1.0f/M_PI)*recipBoxVecX.x*recipBoxVecY.y*recipBoxVecZ.z;
+#endif
  
     mixed energy = 0;
     for (int index = get_global_id(0); index < gridSize; index += get_global_size(0)) {
@@ -349,8 +411,19 @@ __kernel void gridEvaluateEnergy(__global real2* restrict pmeGrid, __global mixe
         real bx = pmeBsplineModuliX[kx];
         real by = pmeBsplineModuliY[ky];
         real bz = pmeBsplineModuliZ[kz];
+#ifdef USE_LJPME
+        real denom = recipScaleFactor/(bx*by*bz);
+        real m = SQRT(m2);
+        real m3 = m*m2;
+        real b = bfac*m;
+        real expfac = -b*b;
+        real expterm = EXP(expfac);
+        real erfcterm = erfc(b);
+        real eterm = (fac1*erfcterm*m3 + expterm*(fac2 + fac3*m2)) * denom;
+#else
         real denom = m2*bx*by*bz;
         real eterm = recipScaleFactor*EXP(-RECIP_EXP_FACTOR*m2)/denom;
+#endif
         if (kz >= (GRID_SIZE_Z/2+1)) {
             kx = ((kx == 0) ? kx : GRID_SIZE_X-kx);
             ky = ((ky == 0) ? ky : GRID_SIZE_Y-ky);
@@ -358,11 +431,12 @@ __kernel void gridEvaluateEnergy(__global real2* restrict pmeGrid, __global mixe
         } 
         int indexInHalfComplexGrid = kz + ky*(GRID_SIZE_Z/2+1)+kx*(GRID_SIZE_Y*(GRID_SIZE_Z/2+1));
         real2 grid = pmeGrid[indexInHalfComplexGrid];
-        if (kx != 0 || ky != 0 || kz != 0) {
+#ifndef USE_LJPME
+        if (kx != 0 || ky != 0 || kz != 0)
+#endif
             energy += eterm*(grid.x*grid.x + grid.y*grid.y);
-        }
     }
-#ifdef USE_PME_STREAM
+#if defined(USE_PME_STREAM) && !defined(USE_LJPME)
     energyBuffer[get_global_id(0)] = 0.5f*energy;
 #else
     energyBuffer[get_global_id(0)] += 0.5f*energy;
@@ -371,7 +445,11 @@ __kernel void gridEvaluateEnergy(__global real2* restrict pmeGrid, __global mixe
 
 __kernel void gridInterpolateForce(__global const real4* restrict posq, __global real4* restrict forceBuffers, __global const real* restrict pmeGrid,
         real4 periodicBoxSize, real4 invPeriodicBoxSize, real4 periodicBoxVecX, real4 periodicBoxVecY, real4 periodicBoxVecZ, real4 recipBoxVecX,
-        real4 recipBoxVecY, real4 recipBoxVecZ, __global int2* restrict pmeAtomGridIndex) {
+        real4 recipBoxVecY, real4 recipBoxVecZ, __global int2* restrict pmeAtomGridIndex
+#ifdef USE_LJPME
+        , __global const float2* restrict sigmaEpsilon
+#endif
+    ) {
     const real scale = 1/(real) (PME_ORDER-1);
     real4 data[PME_ORDER];
     real4 ddata[PME_ORDER];
@@ -436,7 +514,12 @@ __kernel void gridInterpolateForce(__global const real4* restrict posq, __global
             }
         }
         real4 totalForce = forceBuffers[atom];
+#ifdef USE_LJPME
+        const float2 sigEps = sigmaEpsilon[atom];
+        real q = 8*sigEps.x*sigEps.x*sigEps.x*sigEps.y;
+#else
         real q = pos.w*EPSILON_FACTOR;
+#endif
         totalForce.x -= q*(force.x*GRID_SIZE_X*recipBoxVecX.x);
         totalForce.y -= q*(force.x*GRID_SIZE_X*recipBoxVecY.x+force.y*GRID_SIZE_Y*recipBoxVecY.y);
         totalForce.z -= q*(force.x*GRID_SIZE_X*recipBoxVecZ.x+force.y*GRID_SIZE_Y*recipBoxVecZ.y+force.z*GRID_SIZE_Z*recipBoxVecZ.z);

platforms/opencl/src/kernels/sort.cl

@@ -8,7 +8,7 @@ KEY_TYPE getValue(DATA_TYPE value) {
  * Sort a list that is short enough to entirely fit in local memory.  This is executed as
  * a single thread block.
  */
-__kernel void sortShortList(__global DATA_TYPE* __restrict__ data, uint length, __local DATA_TYPE* dataBuffer) {
+__kernel void sortShortList(__global DATA_TYPE* restrict data, uint length, __local DATA_TYPE* dataBuffer) {
     // Load the data into local memory.
     
     for (int index = get_local_id(0); index < length; index += get_local_size(0))
@@ -49,8 +49,8 @@ __kernel void sortShortList(__global DATA_TYPE* __restrict__ data, uint length,
  * Calculate the minimum and maximum value in the array to be sorted.  This kernel
  * is executed as a single work group.
  */
-__kernel void computeRange(__global const DATA_TYPE* restrict data, uint length, __global KEY_TYPE* restrict range, __local KEY_TYPE* restrict buffer,
-        uint numBuckets, __global uint* restrict bucketOffset) {
+__kernel void computeRange(__global const DATA_TYPE* restrict data, uint length, __global KEY_TYPE* restrict range, __local KEY_TYPE* restrict minBuffer,
+        __local KEY_TYPE* restrict maxBuffer, uint numBuckets, __global uint* restrict bucketOffset) {
     KEY_TYPE minimum = MAX_KEY;
     KEY_TYPE maximum = MIN_KEY;
 
@@ -64,23 +64,18 @@ __kernel void computeRange(__global const DATA_TYPE* restrict data, uint length,
 
     // Now reduce them.
 
-    buffer[get_local_id(0)] = minimum;
+    minBuffer[get_local_id(0)] = minimum;
+    maxBuffer[get_local_id(0)] = maximum;
     barrier(CLK_LOCAL_MEM_FENCE);
     for (uint step = 1; step < get_local_size(0); step *= 2) {
-        if (get_local_id(0)+step < get_local_size(0) && get_local_id(0)%(2*step) == 0)
-            buffer[get_local_id(0)] = min(buffer[get_local_id(0)], buffer[get_local_id(0)+step]);
-        barrier(CLK_LOCAL_MEM_FENCE);
-    }
-    minimum = buffer[0];
-    barrier(CLK_LOCAL_MEM_FENCE);
-    buffer[get_local_id(0)] = maximum;
-    barrier(CLK_LOCAL_MEM_FENCE);
-    for (uint step = 1; step < get_local_size(0); step *= 2) {
-        if (get_local_id(0)+step < get_local_size(0) && get_local_id(0)%(2*step) == 0)
-            buffer[get_local_id(0)] = max(buffer[get_local_id(0)], buffer[get_local_id(0)+step]);
+        if (get_local_id(0)+step < get_local_size(0) && get_local_id(0)%(2*step) == 0) {
+            minBuffer[get_local_id(0)] = min(minBuffer[get_local_id(0)], minBuffer[get_local_id(0)+step]);
+            maxBuffer[get_local_id(0)] = max(maxBuffer[get_local_id(0)], maxBuffer[get_local_id(0)+step]);
+        }
         barrier(CLK_LOCAL_MEM_FENCE);
     }
-    maximum = buffer[0];
+    minimum = minBuffer[0];
+    maximum = maxBuffer[0];
     if (get_local_id(0) == 0) {
         range[0] = minimum;
         range[1] = maximum;
@@ -96,7 +91,7 @@ __kernel void computeRange(__global const DATA_TYPE* restrict data, uint length,
  * Assign elements to buckets.
  */
 __kernel void assignElementsToBuckets(__global const DATA_TYPE* restrict data, uint length, uint numBuckets, __global const KEY_TYPE* restrict range,
-        __global uint* bucketOffset, __global uint* restrict bucketOfElement, __global uint* restrict offsetInBucket) {
+        __global uint* restrict bucketOffset, __global uint* restrict bucketOfElement, __global uint* restrict offsetInBucket) {
 #ifdef AMD_ATOMIC_WORK_AROUND
     // Do a byte write to force all memory accesses to interactionCount to use the complete path.
     // This avoids the atomic access from causing all word accesses to other buffers from using the slow complete path.

platforms/opencl/src/kernels/utilities.cl

@@ -107,3 +107,11 @@ __kernel void determineNativeAccuracy(__global float8* restrict values, int numV
         values[i] = (float8) (v, native_sqrt(v), native_rsqrt(v), native_recip(v), native_exp(v), native_log(v), 0.0f, 0.0f);
     }
 }
+
+/**
+ * Record the atomic charges into the posq array.
+ */
+__kernel void setCharges(__global real* restrict charges, __global real4* restrict posq, __global int* restrict atomOrder, int numAtoms) {
+    for (int i = get_global_id(0); i < numAtoms; i += get_global_size(0))
+        posq[i].w = charges[atomOrder[i]];
+}
\ No newline at end of file

platforms/opencl/staticTarget/CMakeLists.txt

@@ -14,7 +14,6 @@ SET_SOURCE_FILES_PROPERTIES(${CL_KERNELS_CPP} ${CL_KERNELS_H} PROPERTIES GENERAT
 ADD_LIBRARY(${STATIC_TARGET} STATIC ${SOURCE_FILES} ${SOURCE_INCLUDE_FILES} ${API_ABS_INCLUDE_FILES})
 
 TARGET_LINK_LIBRARIES(${STATIC_TARGET} ${OPENMM_LIBRARY_NAME}  ${OPENCL_LIBRARIES} ${PTHREADS_LIB_STATIC})
-#-DPTW32_STATIC_LIB only works for the windows pthreads.
-SET_TARGET_PROPERTIES(${STATIC_TARGET} PROPERTIES LINK_FLAGS "${EXTRA_LINK_FLAGS}" COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_OPENCL_BUILDING_STATIC_LIBRARY -DPTW32_STATIC_LIB")
+SET_TARGET_PROPERTIES(${STATIC_TARGET} PROPERTIES LINK_FLAGS "${EXTRA_LINK_FLAGS}" COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_OPENCL_BUILDING_STATIC_LIBRARY")
 
 INSTALL_TARGETS(/lib/plugins RUNTIME_DIRECTORY /lib/plugins ${STATIC_TARGET})

platforms/opencl/tests/TestOpenCLDispersionPME.cpp

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

platforms/reference/include/ObcParameters.h

@@ -25,7 +25,7 @@
 #ifndef __ObcParameters_H__
 #define __ObcParameters_H__
 
-#include "RealVec.h"
+#include "openmm/Vec3.h"
 #include <vector>
 
 namespace OpenMM {
@@ -44,29 +44,29 @@ class ObcParameters {
    
       int _numberOfAtoms;
 
-      RealOpenMM _solventDielectric;
-      RealOpenMM _soluteDielectric;
-      RealOpenMM _electricConstant;
-      RealOpenMM _probeRadius;
-      RealOpenMM _pi4Asolv;
+      double _solventDielectric;
+      double _soluteDielectric;
+      double _electricConstant;
+      double _probeRadius;
+      double _pi4Asolv;
 
-      RealOpenMM _dielectricOffset;
-      RealOpenMM _alphaObc;
-      RealOpenMM _betaObc;
-      RealOpenMM _gammaObc;
+      double _dielectricOffset;
+      double _alphaObc;
+      double _betaObc;
+      double _gammaObc;
       ObcType _obcType;
 
       // scaled radius factors (S_kk in HCT paper)
 
-      std::vector<RealOpenMM> _atomicRadii;
-      std::vector<RealOpenMM> _scaledRadiusFactors;
+      std::vector<double> _atomicRadii;
+      std::vector<double> _scaledRadiusFactors;
 
       // cutoff and periodic boundary conditions
       
       bool _cutoff;
       bool _periodic;
-      OpenMM::RealVec _periodicBoxVectors[3];
-      RealOpenMM _cutoffDistance;
+      OpenMM::Vec3 _periodicBoxVectors[3];
+      double _cutoffDistance;
 
       /**---------------------------------------------------------------------------------------
       
@@ -76,7 +76,7 @@ class ObcParameters {
 
          --------------------------------------------------------------------------------------- */
       
-      void setDielectricOffset(RealOpenMM dielectricOffset);
+      void setDielectricOffset(double dielectricOffset);
 
    public:
 
@@ -116,7 +116,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      RealOpenMM getElectricConstant() const;
+      double getElectricConstant() const;
 
       /**---------------------------------------------------------------------------------------
       
@@ -126,7 +126,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      RealOpenMM getProbeRadius() const;
+      double getProbeRadius() const;
 
       /**---------------------------------------------------------------------------------------
       
@@ -136,18 +136,18 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      void setProbeRadius(RealOpenMM probeRadius);
+      void setProbeRadius(double probeRadius);
 
       /**---------------------------------------------------------------------------------------
       
          Get pi4Asolv:  used in ACE approximation for nonpolar term  
-            ((RealOpenMM) M_PI)*4.0f*0.0049f*1000.0f; (Simbios) 
+            M_PI*4.0f*0.0049f*1000.0f; (Simbios) 
       
          @return pi4Asolv
       
          --------------------------------------------------------------------------------------- */
 
-      RealOpenMM getPi4Asolv() const;
+      double getPi4Asolv() const;
 
       /**---------------------------------------------------------------------------------------
       
@@ -155,7 +155,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      void setPi4Asolv(RealOpenMM pi4Asolv);
+      void setPi4Asolv(double pi4Asolv);
 
       /**---------------------------------------------------------------------------------------
       
@@ -165,7 +165,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      RealOpenMM getSolventDielectric() const;
+      double getSolventDielectric() const;
 
       /**---------------------------------------------------------------------------------------
       
@@ -175,7 +175,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      void setSolventDielectric(RealOpenMM solventDielectric);
+      void setSolventDielectric(double solventDielectric);
 
       /**---------------------------------------------------------------------------------------
       
@@ -185,7 +185,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      RealOpenMM getSoluteDielectric() const;
+      double getSoluteDielectric() const;
 
       /**---------------------------------------------------------------------------------------
       
@@ -195,7 +195,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      void setSoluteDielectric(RealOpenMM soluteDielectric);
+      void setSoluteDielectric(double soluteDielectric);
 
       /**---------------------------------------------------------------------------------------
       
@@ -225,7 +225,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
       
-      RealOpenMM getAlphaObc() const;
+      double getAlphaObc() const;
       
       /**---------------------------------------------------------------------------------------
       
@@ -235,7 +235,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
       
-      RealOpenMM getBetaObc() const;
+      double getBetaObc() const;
       
       /**---------------------------------------------------------------------------------------
       
@@ -245,7 +245,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
       
-      RealOpenMM getGammaObc() const;
+      double getGammaObc() const;
       
       /**---------------------------------------------------------------------------------------
       
@@ -255,7 +255,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
       
-      RealOpenMM getDielectricOffset() const;
+      double getDielectricOffset() const;
 
       /**---------------------------------------------------------------------------------------
       
@@ -265,7 +265,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
       
-      const std::vector<RealOpenMM>& getScaledRadiusFactors() const;
+      const std::vector<double>& getScaledRadiusFactors() const;
         
       /**---------------------------------------------------------------------------------------
       
@@ -275,7 +275,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
       
-      void setScaledRadiusFactors(const std::vector<RealOpenMM>& scaledRadiusFactors);
+      void setScaledRadiusFactors(const std::vector<double>& scaledRadiusFactors);
         
       /**---------------------------------------------------------------------------------------
       
@@ -285,7 +285,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      const std::vector<RealOpenMM>& getAtomicRadii() const;
+      const std::vector<double>& getAtomicRadii() const;
 
       /**---------------------------------------------------------------------------------------
       
@@ -295,7 +295,7 @@ class ObcParameters {
       
          --------------------------------------------------------------------------------------- */
 
-      void setAtomicRadii(const std::vector<RealOpenMM>& atomicRadii);
+      void setAtomicRadii(const std::vector<double>& atomicRadii);
 
 
       /**---------------------------------------------------------------------------------------
@@ -306,7 +306,7 @@ class ObcParameters {
 
          --------------------------------------------------------------------------------------- */
 
-      void setUseCutoff(RealOpenMM distance);
+      void setUseCutoff(double distance);
 
       /**---------------------------------------------------------------------------------------
 
@@ -322,7 +322,7 @@ class ObcParameters {
 
          --------------------------------------------------------------------------------------- */
 
-      RealOpenMM getCutoffDistance() const;
+      double getCutoffDistance() const;
 
       /**---------------------------------------------------------------------------------------
 
@@ -334,7 +334,7 @@ class ObcParameters {
 
          --------------------------------------------------------------------------------------- */
 
-      void setPeriodic(OpenMM::RealVec* vectors);
+      void setPeriodic(OpenMM::Vec3* vectors);
 
       /**---------------------------------------------------------------------------------------
 
@@ -350,7 +350,7 @@ class ObcParameters {
 
          --------------------------------------------------------------------------------------- */
 
-      const OpenMM::RealVec* getPeriodicBox();
+      const OpenMM::Vec3* getPeriodicBox();
 
 };
 

platforms/reference/include/RealVec.h

@@ -9,7 +9,7 @@
  * Biological Structures at Stanford, funded under the NIH Roadmap for        *
  * Medical Research, grant U54 GM072970. See https://simtk.org.               *
  *                                                                            *
- * Portions copyright (c) 2008-2013 Stanford University and the Authors.      *
+ * Portions copyright (c) 2008-2017 Stanford University and the Authors.      *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -34,143 +34,14 @@
 
 #include "SimTKOpenMMRealType.h"
 #include "openmm/Vec3.h"
-#include <cassert>
-#include <iosfwd>
-
-namespace OpenMM {
 
 /**
- * This is identical to Vec3, except that the components are of type RealOpenMM, so
- * it can be compiled in either single or double precision.  Automatic conversion
- * between this class and Vec3 is supported.
+ * This file exists only for backward compatibility.  RealVec is now just a typedef for Vec3.
  */
 
-class RealVec {
-public:
-    /**
-     * Create a RealVec whose elements are all 0.
-     */
-    RealVec() {
-        data[0] = data[1] = data[2] = 0.0;
-    }
-    /**
-     * Create a RealVec with specified x, y, and z components.
-     */
-    RealVec(RealOpenMM x, RealOpenMM y, RealOpenMM z) {
-        data[0] = x;
-        data[1] = y;
-        data[2] = z;
-    }
-    /**
-     * Create a RealVec from a Vec3.
-     */
-    RealVec(Vec3 v) {
-        data[0] = v[0];
-        data[1] = v[1];
-        data[2] = v[2];
-    }
-    /**
-     * Create a Vec3 from a RealVec.
-     */
-    operator Vec3() const {
-        return Vec3(data[0], data[1], data[2]);
-    }
-    RealOpenMM operator[](int index) const {
-        assert(index >= 0 && index < 3);
-        return data[index];
-    }
-    RealOpenMM& operator[](int index) {
-        assert(index >= 0 && index < 3);
-        return data[index];
-    }
-
-    // Arithmetic operators
-
-    // unary plus
-    RealVec operator+() const {
-        return RealVec(*this);
-    }
-
-    // plus
-    RealVec operator+(const RealVec& rhs) const {
-        const RealVec& lhs = *this;
-        return RealVec(lhs[0] + rhs[0], lhs[1] + rhs[1], lhs[2] + rhs[2]);
-    }
-
-    RealVec& operator+=(const RealVec& rhs) {
-        data[0] += rhs[0];
-        data[1] += rhs[1];
-        data[2] += rhs[2];
-        return *this;
-    }
-
-    // unary minus
-    RealVec operator-() const {
-        const RealVec& lhs = *this;
-        return RealVec(-lhs[0], -lhs[1], -lhs[2]);
-    }
-
-    // minus
-    RealVec operator-(const RealVec& rhs) const {
-        const RealVec& lhs = *this;
-        return RealVec(lhs[0] - rhs[0], lhs[1] - rhs[1], lhs[2] - rhs[2]);
-    }
-
-    RealVec& operator-=(const RealVec& rhs) {
-        data[0] -= rhs[0];
-        data[1] -= rhs[1];
-        data[2] -= rhs[2];
-        return *this;
-    }
-
-    // scalar product
-    RealVec operator*(RealOpenMM rhs) const {
-        const RealVec& lhs = *this;
-        return RealVec(lhs[0]*rhs, lhs[1]*rhs, lhs[2]*rhs);
-    }
-
-    RealVec& operator*=(RealOpenMM rhs) {
-        data[0] *= rhs;
-        data[1] *= rhs;
-        data[2] *= rhs;
-        return *this;
-    }
-
-    // scalar division
-    RealVec operator/(double rhs) const {
-        const RealVec& lhs = *this;
-        double scale = 1.0/rhs;
-        return RealVec(lhs[0]*scale, lhs[1]*scale, lhs[2]*scale);
-    }
-
-    RealVec& operator/=(double rhs) {
-        double scale = 1.0/rhs;
-        data[0] *= scale;
-        data[1] *= scale;
-        data[2] *= scale;
-        return *this;
-    }
-
-    // dot product
-    RealOpenMM dot(const RealVec& rhs) const {
-        const RealVec& lhs = *this;
-        return lhs[0]*rhs[0] + lhs[1]*rhs[1] + lhs[2]*rhs[2];
-    }
-
-    // cross product
-    RealVec cross(const RealVec& rhs) const {
-        return RealVec(data[1]*rhs[2]-data[2]*rhs[1], data[2]*rhs[0]-data[0]*rhs[2], data[0]*rhs[1]-data[1]*rhs[0]);
-    }
-
-private:
-    RealOpenMM data[3];
-};
+namespace OpenMM {
 
-template <class CHAR, class TRAITS>
-std::basic_ostream<CHAR,TRAITS>& operator<<(std::basic_ostream<CHAR,TRAITS>& o, const RealVec& v) {
-    o<<'['<<v[0]<<", "<<v[1]<<", "<<v[2]<<']';
-    return o;
-}
+typedef Vec3 RealVec;
 
 } // namespace OpenMM
 

platforms/reference/include/ReferenceAndersenThermostat.h

@@ -25,6 +25,7 @@
 #ifndef __ReferenceAndersenThermostat_H__
 #define __ReferenceAndersenThermostat_H__
 
+#include "openmm/Vec3.h"
 #include <vector>
 
 namespace OpenMM {
@@ -64,8 +65,8 @@ 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::Vec3>& atomVelocities, std::vector<double>& atomMasses,
+              double temperature, double collisionFrequency, double stepSize) const;
       
 };
 

platforms/reference/include/ReferenceAngleBondIxn.h

@@ -26,6 +26,7 @@
 #define __ReferenceAngleBondIxn_H__
 
 #include "ReferenceBondIxn.h"
+#include "openmm/Vec3.h"
 
 namespace OpenMM {
 
@@ -34,7 +35,7 @@ class OPENMM_EXPORT ReferenceAngleBondIxn : public ReferenceBondIxn {
    private:
 
         bool usePeriodic;
-        RealVec boxVectors[3];
+        Vec3 boxVectors[3];
 
    public:
 
@@ -62,7 +63,7 @@ class OPENMM_EXPORT ReferenceAngleBondIxn : public ReferenceBondIxn {
       
          --------------------------------------------------------------------------------------- */
       
-      void setPeriodic(OpenMM::RealVec* vectors);
+      void setPeriodic(OpenMM::Vec3* vectors);
 
       /**---------------------------------------------------------------------------------------
 
@@ -76,8 +77,8 @@ class OPENMM_EXPORT ReferenceAngleBondIxn : public ReferenceBondIxn {
       
          --------------------------------------------------------------------------------------- */
       
-      void getPrefactorsGivenAngleCosine(RealOpenMM cosine, RealOpenMM* angleParameters,
-                                         RealOpenMM* dEdR, RealOpenMM* energyTerm) const;
+      void getPrefactorsGivenAngleCosine(double cosine, double* angleParameters,
+                                         double* dEdR, double* energyTerm) const;
       
       /**---------------------------------------------------------------------------------------
 
@@ -92,9 +93,9 @@ class OPENMM_EXPORT ReferenceAngleBondIxn : public ReferenceBondIxn {
       
          --------------------------------------------------------------------------------------- */
       
-      void calculateBondIxn(int* atomIndices, std::vector<OpenMM::RealVec>& atomCoordinates,
-                            RealOpenMM* parameters, std::vector<OpenMM::RealVec>& forces,
-                            RealOpenMM* totalEnergy, double* energyParamDerivs);
+      void calculateBondIxn(int* atomIndices, std::vector<OpenMM::Vec3>& atomCoordinates,
+                            double* parameters, std::vector<OpenMM::Vec3>& forces,
+                            double* totalEnergy, double* energyParamDerivs);
       
 
 };

platforms/reference/include/ReferenceBondForce.h

@@ -68,9 +68,9 @@ class OPENMM_EXPORT ReferenceBondForce : public ReferenceForce {
          --------------------------------------------------------------------------------------- */
       
        void calculateForce(int numberOfBonds, int** atomIndices,
-                           std::vector<OpenMM::RealVec>& atomCoordinates,
-                           RealOpenMM** parameters, std::vector<OpenMM::RealVec>& forces, 
-                           RealOpenMM* totalEnergy, ReferenceBondIxn& referenceBondIxn);
+                           std::vector<OpenMM::Vec3>& atomCoordinates,
+                           double** parameters, std::vector<OpenMM::Vec3>& forces, 
+                           double* totalEnergy, ReferenceBondIxn& referenceBondIxn);
 
 };
 

platforms/reference/include/ReferenceBondIxn.h

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

platforms/reference/include/ReferenceBrownianDynamics.h

@@ -33,9 +33,9 @@ class ReferenceBrownianDynamics : public ReferenceDynamics {
 
    private:
 
-      std::vector<OpenMM::RealVec> xPrime;
-      std::vector<RealOpenMM> inverseMasses;
-      RealOpenMM friction;
+      std::vector<OpenMM::Vec3> xPrime;
+      std::vector<double> inverseMasses;
+      double friction;
       
    public:
 
@@ -50,7 +50,7 @@ class ReferenceBrownianDynamics : public ReferenceDynamics {
       
          --------------------------------------------------------------------------------------- */
 
-       ReferenceBrownianDynamics(int numberOfAtoms, RealOpenMM deltaT, RealOpenMM friction, RealOpenMM temperature);
+       ReferenceBrownianDynamics(int numberOfAtoms, double deltaT, double friction, double temperature);
 
       /**---------------------------------------------------------------------------------------
       
@@ -68,7 +68,7 @@ class ReferenceBrownianDynamics : public ReferenceDynamics {
       
          --------------------------------------------------------------------------------------- */
       
-      RealOpenMM getFriction() const;
+      double getFriction() const;
       
       /**---------------------------------------------------------------------------------------
       
@@ -83,8 +83,8 @@ class ReferenceBrownianDynamics : public ReferenceDynamics {
       
          --------------------------------------------------------------------------------------- */
      
-      void update(const OpenMM::System& system, std::vector<OpenMM::RealVec>& atomCoordinates,
-                  std::vector<OpenMM::RealVec>& velocities, std::vector<OpenMM::RealVec>& forces, std::vector<RealOpenMM>& masses, RealOpenMM tolerance);
+      void update(const OpenMM::System& system, std::vector<OpenMM::Vec3>& atomCoordinates,
+                  std::vector<OpenMM::Vec3>& velocities, std::vector<OpenMM::Vec3>& forces, std::vector<double>& masses, double tolerance);
       
 };
 

platforms/reference/include/ReferenceCCMAAlgorithm.h

@@ -37,23 +37,23 @@ class OPENMM_EXPORT ReferenceCCMAAlgorithm : public ReferenceConstraintAlgorithm
 protected:
 
     int _maximumNumberOfIterations;
-    RealOpenMM _elementCutoff;
+    double _elementCutoff;
 
     int _numberOfConstraints;
     std::vector<std::pair<int, int> > _atomIndices;
-    std::vector<RealOpenMM> _distance;
+    std::vector<double> _distance;
 
-    std::vector<OpenMM::RealVec> _r_ij;
-    RealOpenMM* _d_ij2;
-    RealOpenMM* _distanceTolerance;
-    RealOpenMM* _reducedMasses;
+    std::vector<OpenMM::Vec3> _r_ij;
+    double* _d_ij2;
+    double* _distanceTolerance;
+    double* _reducedMasses;
     bool _hasInitializedMasses;
-    std::vector<std::vector<std::pair<int, RealOpenMM> > > _matrix;
+    std::vector<std::vector<std::pair<int, double> > > _matrix;
 
 private:
 
-    void applyConstraints(std::vector<OpenMM::RealVec>& atomCoordinates,
-                       std::vector<OpenMM::RealVec>& atomCoordinatesP, std::vector<RealOpenMM>& inverseMasses, bool constrainingVelocities, RealOpenMM tolerance);
+    void applyConstraints(std::vector<OpenMM::Vec3>& atomCoordinates,
+                       std::vector<OpenMM::Vec3>& atomCoordinatesP, std::vector<double>& inverseMasses, bool constrainingVelocities, double tolerance);
           
 public:
     class AngleInfo;
@@ -69,7 +69,7 @@ public:
      * @param angles                   angle force field terms
      * @param elementCutoff            the cutoff for which elements of the inverse matrix to keep
      */
-    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 elementCutoff);
+    ReferenceCCMAAlgorithm(int numberOfAtoms, int numberOfConstraints, const std::vector<std::pair<int, int> >& atomIndices, const std::vector<double>& distance, std::vector<double>& masses, std::vector<AngleInfo>& angles, double elementCutoff);
 
     ~ReferenceCCMAAlgorithm();
 
@@ -96,8 +96,8 @@ public:
      * @param inverseMasses    1/mass
      * @param tolerance        the constraint tolerance
      */
-    void apply(std::vector<OpenMM::RealVec>& atomCoordinates,
-                       std::vector<OpenMM::RealVec>& atomCoordinatesP, std::vector<RealOpenMM>& inverseMasses, RealOpenMM tolerance);
+    void apply(std::vector<OpenMM::Vec3>& atomCoordinates,
+                       std::vector<OpenMM::Vec3>& atomCoordinatesP, std::vector<double>& inverseMasses, double tolerance);
 
     /**
      * Apply the constraint algorithm to velocities.
@@ -107,14 +107,14 @@ public:
      * @param inverseMasses    1/mass
      * @param tolerance        the constraint tolerance
      */
-    void applyToVelocities(std::vector<OpenMM::RealVec>& atomCoordinates,
-                     std::vector<OpenMM::RealVec>& velocities, std::vector<RealOpenMM>& inverseMasses, RealOpenMM tolerance);
+    void applyToVelocities(std::vector<OpenMM::Vec3>& atomCoordinates,
+                     std::vector<OpenMM::Vec3>& velocities, std::vector<double>& inverseMasses, double tolerance);
 
     /**
      * Get the inverse constraint matrix.  Each element represents one column, and contains a list
      * of all non-zero elements in the form (index, value).
      */
-    const std::vector<std::vector<std::pair<int, RealOpenMM> > >& getMatrix() const;
+    const std::vector<std::vector<std::pair<int, double> > >& getMatrix() const;
 
 };
 
@@ -122,8 +122,8 @@ class ReferenceCCMAAlgorithm::AngleInfo
 {
 public:
     int atom1, atom2, atom3;
-    RealOpenMM angle;
-    AngleInfo(int atom1, int atom2, int atom3, RealOpenMM angle) :
+    double angle;
+    AngleInfo(int atom1, int atom2, int atom3, double angle) :
         atom1(atom1), atom2(atom2), atom3(atom3), angle(angle)
     {
     }

platforms/reference/include/ReferenceCMAPTorsionIxn.h

@@ -35,11 +35,11 @@ class ReferenceCMAPTorsionIxn : public ReferenceBondIxn {
 
 private:
 
-    std::vector<std::vector<std::vector<RealOpenMM> > > coeff;
+    std::vector<std::vector<std::vector<double> > > coeff;
     std::vector<int> torsionMaps;
     std::vector<std::vector<int> > torsionIndices;
     bool usePeriodic;
-    RealVec boxVectors[3];
+    Vec3 boxVectors[3];
 
     /**---------------------------------------------------------------------------------------
 
@@ -52,8 +52,8 @@ private:
 
          --------------------------------------------------------------------------------------- */
 
-    void calculateOneIxn(int index, std::vector<OpenMM::RealVec>& atomCoordinates, std::vector<OpenMM::RealVec>& forces,
-                         RealOpenMM* totalEnergy) const;
+    void calculateOneIxn(int index, std::vector<OpenMM::Vec3>& atomCoordinates, std::vector<OpenMM::Vec3>& forces,
+                         double* totalEnergy) const;
 
 public:
 
@@ -63,7 +63,7 @@ public:
 
        --------------------------------------------------------------------------------------- */
 
-    ReferenceCMAPTorsionIxn(const std::vector<std::vector<std::vector<RealOpenMM> > >& coeff,
+    ReferenceCMAPTorsionIxn(const std::vector<std::vector<std::vector<double> > >& coeff,
                             const std::vector<int>& torsionMaps,
                             const std::vector<std::vector<int> >& torsionIndices);
 
@@ -75,7 +75,7 @@ public:
       
          --------------------------------------------------------------------------------------- */
       
-       void setPeriodic(OpenMM::RealVec* vectors);
+       void setPeriodic(OpenMM::Vec3* vectors);
 
     /**---------------------------------------------------------------------------------------
 
@@ -87,7 +87,7 @@ public:
 
          --------------------------------------------------------------------------------------- */
 
-    void calculateIxn(std::vector<OpenMM::RealVec>& atomCoordinates, std::vector<OpenMM::RealVec>& forces, RealOpenMM* totalEnergy) const;
+    void calculateIxn(std::vector<OpenMM::Vec3>& atomCoordinates, std::vector<OpenMM::Vec3>& forces, double* totalEnergy) const;
 
     /**---------------------------------------------------------------------------------------
 
@@ -95,9 +95,9 @@ public:
 
        --------------------------------------------------------------------------------------- */
 
-    void calculateBondIxn(int* atomIndices, std::vector<OpenMM::RealVec>& atomCoordinates,
-                         RealOpenMM* parameters, std::vector<OpenMM::RealVec>& forces,
-                         RealOpenMM* totalEnergy, double* energyParamDerivs);
+    void calculateBondIxn(int* atomIndices, std::vector<OpenMM::Vec3>& atomCoordinates,
+                         double* parameters, std::vector<OpenMM::Vec3>& forces,
+                         double* totalEnergy, double* energyParamDerivs);
 
 // ---------------------------------------------------------------------------------------
 

platforms/reference/include/ReferenceConstraintAlgorithm.h

@@ -25,8 +25,9 @@
 #ifndef __ReferenceConstraintAlgorithm_H__
 #define __ReferenceConstraintAlgorithm_H__
 
-#include "RealVec.h"
+#include "openmm/Vec3.h"
 #include "openmm/internal/windowsExport.h"
+#include "SimTKOpenMMRealType.h"
 #include <vector>
 
 namespace OpenMM {
@@ -47,8 +48,8 @@ public:
      * @param inverseMasses    1/mass
      * @param tolerance        the constraint tolerance
      */
-    virtual void apply(std::vector<OpenMM::RealVec>& atomCoordinates,
-                     std::vector<OpenMM::RealVec>& atomCoordinatesP, std::vector<RealOpenMM>& inverseMasses, RealOpenMM tolerance) = 0;
+    virtual void apply(std::vector<OpenMM::Vec3>& atomCoordinates,
+                     std::vector<OpenMM::Vec3>& atomCoordinatesP, std::vector<double>& inverseMasses, double tolerance) = 0;
 
     /**
      * Apply the constraint algorithm to velocities.
@@ -58,8 +59,8 @@ public:
      * @param inverseMasses    1/mass
      * @param tolerance        the constraint tolerance
      */
-    virtual void applyToVelocities(std::vector<OpenMM::RealVec>& atomCoordinates,
-                     std::vector<OpenMM::RealVec>& velocities, std::vector<RealOpenMM>& inverseMasses, RealOpenMM tolerance) = 0;
+    virtual void applyToVelocities(std::vector<OpenMM::Vec3>& atomCoordinates,
+                     std::vector<OpenMM::Vec3>& velocities, std::vector<double>& inverseMasses, double tolerance) = 0;
 };
 
 } // namespace OpenMM

platforms/reference/include/ReferenceConstraints.h

@@ -55,7 +55,7 @@ public:
      * @param inverseMasses    1/mass
      * @param tolerance        the constraint tolerance
      */
-    void apply(std::vector<OpenMM::RealVec>& atomCoordinates, std::vector<OpenMM::RealVec>& atomCoordinatesP, std::vector<RealOpenMM>& inverseMasses, RealOpenMM tolerance);
+    void apply(std::vector<OpenMM::Vec3>& atomCoordinates, std::vector<OpenMM::Vec3>& atomCoordinatesP, std::vector<double>& inverseMasses, double tolerance);
 
     /**
      * Apply the constraint algorithm to velocities.
@@ -65,7 +65,7 @@ public:
      * @param inverseMasses    1/mass
      * @param tolerance        the constraint tolerance
      */
-    void applyToVelocities(std::vector<OpenMM::RealVec>& atomCoordinates, std::vector<OpenMM::RealVec>& velocities, std::vector<RealOpenMM>& inverseMasses, RealOpenMM tolerance);
+    void applyToVelocities(std::vector<OpenMM::Vec3>& atomCoordinates, std::vector<OpenMM::Vec3>& velocities, std::vector<double>& inverseMasses, double tolerance);
     ReferenceConstraintAlgorithm* ccma;
     ReferenceConstraintAlgorithm* settle;
 };

platforms/reference/include/ReferenceCustomAngleIxn.h

@@ -40,7 +40,7 @@ class ReferenceCustomAngleIxn : public ReferenceBondIxn {
       int thetaIndex;
       int numParameters;
       bool usePeriodic;
-      RealVec boxVectors[3];
+      Vec3 boxVectors[3];
 
    public:
 
@@ -70,7 +70,7 @@ class ReferenceCustomAngleIxn : public ReferenceBondIxn {
       
          --------------------------------------------------------------------------------------- */
       
-      void setPeriodic(OpenMM::RealVec* vectors);
+      void setPeriodic(OpenMM::Vec3* vectors);
 
       /**---------------------------------------------------------------------------------------
 
@@ -84,9 +84,9 @@ class ReferenceCustomAngleIxn : public ReferenceBondIxn {
 
          --------------------------------------------------------------------------------------- */
 
-      void calculateBondIxn(int* atomIndices, std::vector<OpenMM::RealVec>& atomCoordinates,
-                            RealOpenMM* parameters, std::vector<OpenMM::RealVec>& forces,
-                            RealOpenMM* totalEnergy, double* energyParamDerivs);
+      void calculateBondIxn(int* atomIndices, std::vector<OpenMM::Vec3>& atomCoordinates,
+                            double* parameters, std::vector<OpenMM::Vec3>& forces,
+                            double* totalEnergy, double* energyParamDerivs);
 
 
 };

platforms/reference/include/ReferenceCustomBondIxn.h

@@ -41,7 +41,7 @@ class ReferenceCustomBondIxn : public ReferenceBondIxn {
       int rIndex;
       int numParameters;
       bool usePeriodic;
-      RealVec boxVectors[3];
+      Vec3 boxVectors[3];
 
    public:
 
@@ -71,7 +71,7 @@ class ReferenceCustomBondIxn : public ReferenceBondIxn {
       
          --------------------------------------------------------------------------------------- */
       
-      void setPeriodic(OpenMM::RealVec* vectors);
+      void setPeriodic(OpenMM::Vec3* vectors);
 
       /**---------------------------------------------------------------------------------------
 
@@ -85,9 +85,9 @@ class ReferenceCustomBondIxn : public ReferenceBondIxn {
 
          --------------------------------------------------------------------------------------- */
 
-      void calculateBondIxn(int* atomIndices, std::vector<OpenMM::RealVec>& atomCoordinates,
-                            RealOpenMM* parameters, std::vector<OpenMM::RealVec>& forces,
-                            RealOpenMM* totalEnergy, double* energyParamDerivs);
+      void calculateBondIxn(int* atomIndices, std::vector<OpenMM::Vec3>& atomCoordinates,
+                            double* parameters, std::vector<OpenMM::Vec3>& forces,
+                            double* totalEnergy, double* energyParamDerivs);
 
 
 };