Conflict resolution in TestSplineFilter.cpp

platforms/opencl/src/OpenCLPlatform.cpp

@@ -87,7 +87,7 @@ OpenCLPlatform::OpenCLPlatform() {
     registerKernelFactory(CalcCustomManyParticleForceKernel::Name(), factory);
     registerKernelFactory(CalcGayBerneForceKernel::Name(), factory);
     registerKernelFactory(IntegrateVerletStepKernel::Name(), factory);
-    registerKernelFactory(IntegrateVelocityVerletStepKernel::Name(), factory);
+    registerKernelFactory(IntegrateNoseHooverStepKernel::Name(), factory);
     registerKernelFactory(IntegrateLangevinStepKernel::Name(), factory);
     registerKernelFactory(IntegrateLangevinMiddleStepKernel::Name(), factory);
     registerKernelFactory(IntegrateBrownianStepKernel::Name(), factory);
@@ -95,7 +95,6 @@ OpenCLPlatform::OpenCLPlatform() {
     registerKernelFactory(IntegrateVariableLangevinStepKernel::Name(), factory);
     registerKernelFactory(IntegrateCustomStepKernel::Name(), factory);
     registerKernelFactory(ApplyAndersenThermostatKernel::Name(), factory);
-    registerKernelFactory(NoseHooverChainKernel::Name(), factory);
     registerKernelFactory(ApplyMonteCarloBarostatKernel::Name(), factory);
     registerKernelFactory(RemoveCMMotionKernel::Name(), factory);
     platformProperties.push_back(OpenCLDeviceIndex());

platforms/opencl/src/OpenCLSort.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) 2010-2018 Stanford University and the Authors.      *
+ * Portions copyright (c) 2010-2020 Stanford University and the Authors.      *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -64,10 +64,11 @@ OpenCLSort::OpenCLSort(OpenCLContext& context, SortTrait* trait, unsigned int le
     unsigned int maxPositionsSize = std::min(maxGroupSize, (unsigned int) computeBucketPositionsKernel.getWorkGroupInfo<CL_KERNEL_WORK_GROUP_SIZE>(context.getDevice()));
     int maxLocalBuffer = (maxSharedMem/trait->getDataSize())/2;
     unsigned int maxShortList = min(8192, max(maxLocalBuffer, (int) OpenCLContext::ThreadBlockSize*context.getNumThreadBlocks()));
-    // On Qualcomm's OpenCL, it's essential to check against CL_KERNEL_WORK_GROUP_SIZE.  Otherwise you get a crash.
-    // But AMD's OpenCL returns an inappropriately small value for it that is much shorter than the actual
-    // maximum, so including the check hurts performance.  For the moment I'm going to just comment it out.
-    // If we officially support Qualcomm in the future, we'll need to do something better.
+    // The following line checks CL_KERNEL_WORK_GROUP_SIZE to make sure we don't create too large a workgroup.
+    // Unfortunately, AMD's OpenCL returns an inappropriately small value for it that is much shorter than the actual
+    // maximum, so including the check hurts performance.  For the moment I'm just leaving it commented out.
+    // If the workgroup size turns out to be too large, we catch the exception and switch back to the standard
+    // sorting kernels.
     //maxShortList = min(maxShortList, shortListKernel.getWorkGroupInfo<CL_KERNEL_WORK_GROUP_SIZE>(context.getDevice()));
     isShortList = (length <= maxShortList);
     string vendor = context.getDevice().getInfo<CL_DEVICE_VENDOR>();
@@ -92,12 +93,10 @@ OpenCLSort::OpenCLSort(OpenCLContext& context, SortTrait* trait, unsigned int le
 
     // Create workspace arrays.
 
-    if (!isShortList) {
-        dataRange.initialize(context, 2, trait->getKeySize(), "sortDataRange");
-        bucketOffset.initialize<cl_uint>(context, numBuckets, "bucketOffset");
-        bucketOfElement.initialize<cl_uint>(context, length, "bucketOfElement");
-        offsetInBucket.initialize<cl_uint>(context, length, "offsetInBucket");
-    }
+    dataRange.initialize(context, 2, trait->getKeySize(), "sortDataRange");
+    bucketOffset.initialize<cl_uint>(context, numBuckets, "bucketOffset");
+    bucketOfElement.initialize<cl_uint>(context, length, "bucketOfElement");
+    offsetInBucket.initialize<cl_uint>(context, length, "offsetInBucket");
     buckets.initialize(context, length, trait->getDataSize(), "buckets");
 }
 
@@ -113,68 +112,76 @@ void OpenCLSort::sort(OpenCLArray& data) {
     if (isShortList) {
         // We can use a simpler sort kernel that does the entire operation in one kernel.
         
-        if (useShortList2) {
-            shortList2Kernel.setArg<cl::Buffer>(0, data.getDeviceBuffer());
-            shortList2Kernel.setArg<cl::Buffer>(1, buckets.getDeviceBuffer());
-            shortList2Kernel.setArg<cl_int>(2, dataLength);
-            context.executeKernel(shortList2Kernel, dataLength);
-            buckets.copyTo(data);
+        try {
+            if (useShortList2) {
+                shortList2Kernel.setArg<cl::Buffer>(0, data.getDeviceBuffer());
+                shortList2Kernel.setArg<cl::Buffer>(1, buckets.getDeviceBuffer());
+                shortList2Kernel.setArg<cl_int>(2, dataLength);
+                context.executeKernel(shortList2Kernel, dataLength);
+                buckets.copyTo(data);
+            }
+            else {
+                shortListKernel.setArg<cl::Buffer>(0, data.getDeviceBuffer());
+                shortListKernel.setArg<cl_uint>(1, dataLength);
+                shortListKernel.setArg(2, dataLength*trait->getDataSize(), NULL);
+                context.executeKernel(shortListKernel, sortKernelSize, sortKernelSize);
+            }
+            return;
         }
-        else {
-            shortListKernel.setArg<cl::Buffer>(0, data.getDeviceBuffer());
-            shortListKernel.setArg<cl_uint>(1, dataLength);
-            shortListKernel.setArg(2, dataLength*trait->getDataSize(), NULL);
-            context.executeKernel(shortListKernel, sortKernelSize, sortKernelSize);
+        catch (exception& ex) {
+            // This can happen if we chose too large a size for the kernel.  Switch
+            // over to the standard sorting method.
+            
+            isShortList = false;
         }
     }
-    else {
-        // Compute the range of data values.
-
-        unsigned int numBuckets = bucketOffset.getSize();
-        computeRangeKernel.setArg<cl::Buffer>(0, data.getDeviceBuffer());
-        computeRangeKernel.setArg<cl_uint>(1, data.getSize());
-        computeRangeKernel.setArg<cl::Buffer>(2, dataRange.getDeviceBuffer());
-        computeRangeKernel.setArg(3, rangeKernelSize*trait->getKeySize(), NULL);
-        computeRangeKernel.setArg(4, rangeKernelSize*trait->getKeySize(), NULL);
-        computeRangeKernel.setArg<cl_int>(5, numBuckets);
-        computeRangeKernel.setArg<cl::Buffer>(6, bucketOffset.getDeviceBuffer());
-        context.executeKernel(computeRangeKernel, rangeKernelSize, rangeKernelSize);
-
-        // Assign array elements to buckets.
-
-        assignElementsKernel.setArg<cl::Buffer>(0, data.getDeviceBuffer());
-        assignElementsKernel.setArg<cl_int>(1, data.getSize());
-        assignElementsKernel.setArg<cl_int>(2, numBuckets);
-        assignElementsKernel.setArg<cl::Buffer>(3, dataRange.getDeviceBuffer());
-        assignElementsKernel.setArg<cl::Buffer>(4, bucketOffset.getDeviceBuffer());
-        assignElementsKernel.setArg<cl::Buffer>(5, bucketOfElement.getDeviceBuffer());
-        assignElementsKernel.setArg<cl::Buffer>(6, offsetInBucket.getDeviceBuffer());
-        context.executeKernel(assignElementsKernel, data.getSize());
-
-        // Compute the position of each bucket.
-
-        computeBucketPositionsKernel.setArg<cl_int>(0, numBuckets);
-        computeBucketPositionsKernel.setArg<cl::Buffer>(1, bucketOffset.getDeviceBuffer());
-        computeBucketPositionsKernel.setArg(2, positionsKernelSize*sizeof(cl_int), NULL);
-        context.executeKernel(computeBucketPositionsKernel, positionsKernelSize, positionsKernelSize);
-
-        // Copy the data into the buckets.
-
-        copyToBucketsKernel.setArg<cl::Buffer>(0, data.getDeviceBuffer());
-        copyToBucketsKernel.setArg<cl::Buffer>(1, buckets.getDeviceBuffer());
-        copyToBucketsKernel.setArg<cl_int>(2, data.getSize());
-        copyToBucketsKernel.setArg<cl::Buffer>(3, bucketOffset.getDeviceBuffer());
-        copyToBucketsKernel.setArg<cl::Buffer>(4, bucketOfElement.getDeviceBuffer());
-        copyToBucketsKernel.setArg<cl::Buffer>(5, offsetInBucket.getDeviceBuffer());
-        context.executeKernel(copyToBucketsKernel, data.getSize());
-
-        // Sort each bucket.
-
-        sortBucketsKernel.setArg<cl::Buffer>(0, data.getDeviceBuffer());
-        sortBucketsKernel.setArg<cl::Buffer>(1, buckets.getDeviceBuffer());
-        sortBucketsKernel.setArg<cl_int>(2, numBuckets);
-        sortBucketsKernel.setArg<cl::Buffer>(3, bucketOffset.getDeviceBuffer());
-        sortBucketsKernel.setArg(4, sortKernelSize*trait->getDataSize(), NULL);
-        context.executeKernel(sortBucketsKernel, ((data.getSize()+sortKernelSize-1)/sortKernelSize)*sortKernelSize, sortKernelSize);
-    }
+
+    // Compute the range of data values.
+
+    unsigned int numBuckets = bucketOffset.getSize();
+    computeRangeKernel.setArg<cl::Buffer>(0, data.getDeviceBuffer());
+    computeRangeKernel.setArg<cl_uint>(1, data.getSize());
+    computeRangeKernel.setArg<cl::Buffer>(2, dataRange.getDeviceBuffer());
+    computeRangeKernel.setArg(3, rangeKernelSize*trait->getKeySize(), NULL);
+    computeRangeKernel.setArg(4, rangeKernelSize*trait->getKeySize(), NULL);
+    computeRangeKernel.setArg<cl_int>(5, numBuckets);
+    computeRangeKernel.setArg<cl::Buffer>(6, bucketOffset.getDeviceBuffer());
+    context.executeKernel(computeRangeKernel, rangeKernelSize, rangeKernelSize);
+
+    // Assign array elements to buckets.
+
+    assignElementsKernel.setArg<cl::Buffer>(0, data.getDeviceBuffer());
+    assignElementsKernel.setArg<cl_int>(1, data.getSize());
+    assignElementsKernel.setArg<cl_int>(2, numBuckets);
+    assignElementsKernel.setArg<cl::Buffer>(3, dataRange.getDeviceBuffer());
+    assignElementsKernel.setArg<cl::Buffer>(4, bucketOffset.getDeviceBuffer());
+    assignElementsKernel.setArg<cl::Buffer>(5, bucketOfElement.getDeviceBuffer());
+    assignElementsKernel.setArg<cl::Buffer>(6, offsetInBucket.getDeviceBuffer());
+    context.executeKernel(assignElementsKernel, data.getSize());
+
+    // Compute the position of each bucket.
+
+    computeBucketPositionsKernel.setArg<cl_int>(0, numBuckets);
+    computeBucketPositionsKernel.setArg<cl::Buffer>(1, bucketOffset.getDeviceBuffer());
+    computeBucketPositionsKernel.setArg(2, positionsKernelSize*sizeof(cl_int), NULL);
+    context.executeKernel(computeBucketPositionsKernel, positionsKernelSize, positionsKernelSize);
+
+    // Copy the data into the buckets.
+
+    copyToBucketsKernel.setArg<cl::Buffer>(0, data.getDeviceBuffer());
+    copyToBucketsKernel.setArg<cl::Buffer>(1, buckets.getDeviceBuffer());
+    copyToBucketsKernel.setArg<cl_int>(2, data.getSize());
+    copyToBucketsKernel.setArg<cl::Buffer>(3, bucketOffset.getDeviceBuffer());
+    copyToBucketsKernel.setArg<cl::Buffer>(4, bucketOfElement.getDeviceBuffer());
+    copyToBucketsKernel.setArg<cl::Buffer>(5, offsetInBucket.getDeviceBuffer());
+    context.executeKernel(copyToBucketsKernel, data.getSize());
+
+    // Sort each bucket.
+
+    sortBucketsKernel.setArg<cl::Buffer>(0, data.getDeviceBuffer());
+    sortBucketsKernel.setArg<cl::Buffer>(1, buckets.getDeviceBuffer());
+    sortBucketsKernel.setArg<cl_int>(2, numBuckets);
+    sortBucketsKernel.setArg<cl::Buffer>(3, bucketOffset.getDeviceBuffer());
+    sortBucketsKernel.setArg(4, sortKernelSize*trait->getDataSize(), NULL);
+    context.executeKernel(sortBucketsKernel, ((data.getSize()+sortKernelSize-1)/sortKernelSize)*sortKernelSize, sortKernelSize);
 }

platforms/opencl/tests/TestOpenCLNoseHooverThermostat.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) 2019 Stanford University and the Authors.           *
- * Authors: Andreas Krämer and Andrew C. Simmonett                            *
- * 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 "TestNoseHooverThermostat.h"
-
-void runPlatformTests() {
-}

platforms/reference/include/ReferenceKernels.h

@@ -61,7 +61,7 @@ class ReferenceStochasticDynamics;
 class ReferenceConstraintAlgorithm;
 class ReferenceNoseHooverChain;
 class ReferenceMonteCarloBarostat;
-class ReferenceVelocityVerletDynamics;
+class ReferenceNoseHooverDynamics;
 class ReferenceVariableStochasticDynamics;
 class ReferenceVariableVerletDynamics;
 class ReferenceVerletDynamics;
@@ -1139,12 +1139,12 @@ private:
 /**
  * This kernel is invoked by NoseHooverIntegrator to take one time step.
  */
-class ReferenceIntegrateVelocityVerletStepKernel : public IntegrateVelocityVerletStepKernel {
+class ReferenceIntegrateNoseHooverStepKernel : public IntegrateNoseHooverStepKernel {
 public:
-    ReferenceIntegrateVelocityVerletStepKernel(std::string name, const Platform& platform, ReferencePlatform::PlatformData& data) : IntegrateVelocityVerletStepKernel(name, platform),
+    ReferenceIntegrateNoseHooverStepKernel(std::string name, const Platform& platform, ReferencePlatform::PlatformData& data) : IntegrateNoseHooverStepKernel(name, platform),
         data(data), dynamics(0) {
     }
-    ~ReferenceIntegrateVelocityVerletStepKernel();
+    ~ReferenceIntegrateNoseHooverStepKernel();
     /**
      * Initialize the kernel.
      * 
@@ -1168,10 +1168,56 @@ public:
      * @param integrator the NoseHooverIntegrator this kernel is being used for
      */
     double computeKineticEnergy(ContextImpl& context, const NoseHooverIntegrator& integrator);
+    /**
+     * Execute the kernel that propagates the Nose Hoover chain and determines the velocity scale factor.
+     * 
+     * @param context  the context in which to execute this kernel
+     * @param noseHooverChain the object describing the chain to be propagated.
+     * @param kineticEnergy the {center of mass, relative} kineticEnergies of the particles being thermostated by this chain.
+     * @param timeStep the time step used by the integrator.
+     * @return the velocity scale factor to apply to the particles associated with this heat bath.
+     */
+    std::pair<double, double> propagateChain(ContextImpl& context, const NoseHooverChain &noseHooverChain, std::pair<double, double> kineticEnergy, double timeStep);
+    /**
+     * Execute the kernal that computes the total (kinetic + potential) heat bath energy.
+     *
+     * @param context the context in which to execute this kernel
+     * @param noseHooverChain the chain whose energy is to be determined.
+     * @return the total heat bath energy.
+     */
+    double computeHeatBathEnergy(ContextImpl& context, const NoseHooverChain &noseHooverChain);
+    /**
+     * Execute the kernel that computes the kinetic energy for a subset of atoms,
+     * or the relative kinetic energy of Drude particles with respect to their parent atoms
+     *
+     * @param context the context in which to execute this kernel
+     * @param noseHooverChain the chain whose energy is to be determined.
+     * @param downloadValue whether the computed value should be downloaded and returned.
+     */
+    std::pair<double, double> computeMaskedKineticEnergy(ContextImpl& context, const NoseHooverChain &noseHooverChain, bool downloadValue);
+    /**
+     * Execute the kernel that scales the velocities of particles associated with a nose hoover chain
+     *
+     * @param context the context in which to execute this kernel
+     * @param noseHooverChain the chain whose energy is to be determined.
+     * @param scaleFactor the multiplicative factor by which {absolute, relative} velocities are scaled.
+     */
+    void scaleVelocities(ContextImpl& context, const NoseHooverChain &noseHooverChain, std::pair<double, double> scaleFactor);
+    /**
+     * Write the chain states to a checkpoint.
+     */
+    void createCheckpoint(ContextImpl& context, std::ostream& stream) const;
+    /**
+     * Load the chain states from a checkpoint.
+     */
+    void loadCheckpoint(ContextImpl& context, std::istream& stream);
 private:
     ReferencePlatform::PlatformData& data;
-    ReferenceVelocityVerletDynamics* dynamics;
+    ReferenceNoseHooverChain* chainPropagator;
+    ReferenceNoseHooverDynamics* dynamics;
     std::vector<double> masses;
+    std::vector<std::vector<double> > chainPositions;
+    std::vector<std::vector<double> > chainVelocities;
     double prevStepSize;
 };
 
@@ -1466,62 +1512,6 @@ private:
     std::vector<double> masses;
 };
 
-/**
- * This kernel is invoked by NoseHooverChain at the start of each time step to adjust the thermostat
- * and update the associated particle velocities.
- */
-class ReferenceNoseHooverChainKernel : public NoseHooverChainKernel {
-public:
-    ReferenceNoseHooverChainKernel(std::string name, const Platform& platform) : NoseHooverChainKernel(name, platform), chainPropagator(0) {
-    }
-    ~ReferenceNoseHooverChainKernel();
-    /**
-     * Initialize the kernel.
-     */
-    virtual void initialize();
-    /**
-     * Execute the kernel that propagates the Nose Hoover chain and determines the velocity scale factor.
-     * 
-     * @param context  the context in which to execute this kernel
-     * @param noseHooverChain the object describing the chain to be propagated.
-     * @param kineticEnergy the {absolute, relative} kinetic energies of the particles being thermostated by this chain.
-     * @param timeStep the time step used by the integrator.
-     * @return the velocity scale factors to apply to the {absolute, relative} motion of particles associated with this heat bath.
-     */
-    virtual std::pair<double, double> propagateChain(ContextImpl& context, const NoseHooverChain &nhc, std::pair<double, double> kineticEnergy, double timeStep);
-    /**
-     * Execute the kernal that computes the total (kinetic + potential) heat bath energy.
-     *
-     * @param context the context in which to execute this kernel
-     * @param noseHooverChain the chain whose energy is to be determined.
-     * @return the total heat bath energy.
-     */
-    virtual double computeHeatBathEnergy(ContextImpl& context, const NoseHooverChain &nhc);
-    /**
-     * Execute the kernel that computes the kinetic energy for a subset of atoms,
-     * or the relative kinetic energy of Drude particles with respect to their parent atoms
-     *
-     * @param context the context in which to execute this kernel
-     * @param noseHooverChain the chain whose energy is to be determined.
-     * @param downloadValue whether the computed value should be downloaded and returned.
-     *
-     */
-     virtual std::pair<double, double> computeMaskedKineticEnergy(ContextImpl& context, const NoseHooverChain &noseHooverChain, bool downloadValue);
-
-    /**
-     * Execute the kernel that scales the velocities of particles associated with a nose hoover chain
-     *
-     * @param context the context in which to execute this kernel
-     * @param noseHooverChain the chain whose energy is to be determined.
-     * @param scaleFactor the multiplicative factor by which {absolute, relative} velocities are scaled.
-     */
-    virtual void scaleVelocities(ContextImpl& context, const NoseHooverChain &noseHooverChain, std::pair<double, double> scaleFactor);
-
-
-private:
-    ReferenceNoseHooverChain* chainPropagator;
-};
-
 /**
  * This kernel is invoked by MonteCarloBarostat to adjust the periodic box volume
  */

platforms/reference/include/ReferenceVelocityVerletDynamics.h → platforms/reference/include/ReferenceNoseHooverDynamics.h

 
-/* Portions copyright (c) 2006-2012 Stanford University and Simbios.
- * Contributors: Pande Group
+/* Portions copyright (c) 2006-2020 Stanford University and Simbios.
+ * Contributors: Andy Simmonett, Peter Eastman, Pande Group
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the
@@ -22,21 +22,24 @@
  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef __ReferenceVelocityVerletDynamics_H__
-#define __ReferenceVelocityVerletDynamics_H__
+#ifndef __ReferenceNoseHooverDynamics_H__
+#define __ReferenceNoseHooverDynamics_H__
 
 #include "ReferenceDynamics.h"
+#include <tuple>
 
 namespace OpenMM {
 
 class ContextImpl;
 
-class ReferenceVelocityVerletDynamics : public ReferenceDynamics {
+class ReferenceNoseHooverDynamics : public ReferenceDynamics {
 
    private:
       std::vector<OpenMM::Vec3> xPrime;
+      std::vector<OpenMM::Vec3> oldx;
       std::vector<double> inverseMasses;
-      
+      int numberOfAtoms;
+
    public:
 
       /**---------------------------------------------------------------------------------------
@@ -50,7 +53,7 @@ class ReferenceVelocityVerletDynamics : public ReferenceDynamics {
       
          --------------------------------------------------------------------------------------- */
 
-       ReferenceVelocityVerletDynamics(int numberOfAtoms, double deltaT);
+       ReferenceNoseHooverDynamics(int numberOfAtoms, double deltaT);
 
       /**---------------------------------------------------------------------------------------
       
@@ -58,11 +61,11 @@ class ReferenceVelocityVerletDynamics : public ReferenceDynamics {
       
          --------------------------------------------------------------------------------------- */
 
-       ~ReferenceVelocityVerletDynamics();
+       ~ReferenceNoseHooverDynamics();
 
       /**---------------------------------------------------------------------------------------
       
-         Update
+         Perform the first half of a step using the leapfrog LF-Middle scheme
       
          @param system              the System to be integrated
          @param atomCoordinates     atom coordinates
@@ -77,12 +80,31 @@ class ReferenceVelocityVerletDynamics : public ReferenceDynamics {
       
          --------------------------------------------------------------------------------------- */
      
-      void update(OpenMM::ContextImpl &context, 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, bool &forcesAreValid,
-                  const std::vector<int> & allAtoms, const std::vector<std::tuple<int, int, double>> & allPairs, double maxPairDistance);
+      void step1(OpenMM::ContextImpl &context, 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, bool &forcesAreValid,
+                 const std::vector<int> & allAtoms, const std::vector<std::tuple<int, int, double>> & allPairs, double maxPairDistance);
+      /**---------------------------------------------------------------------------------------
+      
+         Perform the second half of a step using the leapfrog LF-Middle scheme
+      
+         @param system              the System to be integrated
+         @param atomCoordinates     atom coordinates
+         @param velocities          velocities
+         @param forces              forces
+         @param masses              atom masses
+         @param tolerance           the constraint tolerance
+         @param forcesAreValid      whether the forces are valid (duh!)
+         @param allAtoms            a list of all atoms not involved in a Drude-like pair
+         @param allPairs            a list of all Drude-like pairs, and their KT values, in the system
+         @param maxPairDistance     the maximum separation allowed for a Drude-like pair
+      
+         --------------------------------------------------------------------------------------- */
+      void step2(OpenMM::ContextImpl &context, 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, bool &forcesAreValid,
+                 const std::vector<int> & allAtoms, const std::vector<std::tuple<int, int, double>> & allPairs, double maxPairDistance);
       
 };
 
 } // namespace OpenMM
 
-#endif // __ReferenceVelocityVerletDynamics_H__
+#endif // __ReferenceNoseHooverDynamics_H__

platforms/reference/include/ReferencePlatform.h

@@ -72,8 +72,6 @@ public:
     Vec3* periodicBoxVectors;
     ReferenceConstraints* constraints;
     std::map<std::string, double>* energyParameterDerivatives;
-    std::vector<std::vector<double>>* noseHooverPositions;
-    std::vector<std::vector<double>>* noseHooverVelocities;
 };
 } // namespace OpenMM
 

platforms/reference/src/ReferenceKernelFactory.cpp

@@ -88,10 +88,8 @@ KernelImpl* ReferenceKernelFactory::createKernelImpl(std::string name, const Pla
         return new ReferenceCalcGayBerneForceKernel(name, platform);
     if (name == IntegrateVerletStepKernel::Name())
         return new ReferenceIntegrateVerletStepKernel(name, platform, data);
-    if (name == IntegrateVelocityVerletStepKernel::Name())
-        return new ReferenceIntegrateVelocityVerletStepKernel(name, platform, data);
-    if (name == NoseHooverChainKernel::Name())
-        return new ReferenceNoseHooverChainKernel(name, platform);
+    if (name == IntegrateNoseHooverStepKernel::Name())
+        return new ReferenceIntegrateNoseHooverStepKernel(name, platform, data);
     if (name == IntegrateLangevinStepKernel::Name())
         return new ReferenceIntegrateLangevinStepKernel(name, platform, data);
     if (name == IntegrateLangevinMiddleStepKernel::Name())