Renamed BAOABLangevinIntegrator to LangevinMiddleIntegrator

platforms/cpu/src/CpuKernelFactory.cpp

@@ -61,7 +61,7 @@ KernelImpl* CpuKernelFactory::createKernelImpl(std::string name, const Platform&
         return new CpuCalcGayBerneForceKernel(name, platform, data);
     if (name == IntegrateLangevinStepKernel::Name())
         return new CpuIntegrateLangevinStepKernel(name, platform, data);
-    if (name == IntegrateBAOABStepKernel::Name())
-        return new CpuIntegrateBAOABStepKernel(name, platform, data);
+    if (name == IntegrateLangevinMiddleStepKernel::Name())
+        return new CpuIntegrateLangevinMiddleStepKernel(name, platform, data);
     throw OpenMMException((std::string("Tried to create kernel with illegal kernel name '") + name + "'").c_str());
 }

platforms/cpu/src/CpuKernels.cpp

@@ -1353,12 +1353,12 @@ double CpuIntegrateLangevinStepKernel::computeKineticEnergy(ContextImpl& context
     return computeShiftedKineticEnergy(context, masses, 0.5*integrator.getStepSize());
 }
 
-CpuIntegrateBAOABStepKernel::~CpuIntegrateBAOABStepKernel() {
+CpuIntegrateLangevinMiddleStepKernel::~CpuIntegrateLangevinMiddleStepKernel() {
     if (dynamics)
         delete dynamics;
 }
 
-void CpuIntegrateBAOABStepKernel::initialize(const System& system, const BAOABLangevinIntegrator& integrator) {
+void CpuIntegrateLangevinMiddleStepKernel::initialize(const System& system, const LangevinMiddleIntegrator& integrator) {
     int numParticles = system.getNumParticles();
     masses.resize(numParticles);
     for (int i = 0; i < numParticles; ++i)
@@ -1366,7 +1366,7 @@ void CpuIntegrateBAOABStepKernel::initialize(const System& system, const BAOABLa
     data.random.initialize(integrator.getRandomNumberSeed(), data.threads.getNumThreads());
 }
 
-void CpuIntegrateBAOABStepKernel::execute(ContextImpl& context, const BAOABLangevinIntegrator& integrator) {
+void CpuIntegrateLangevinMiddleStepKernel::execute(ContextImpl& context, const LangevinMiddleIntegrator& integrator) {
     double temperature = integrator.getTemperature();
     double friction = integrator.getFriction();
     double stepSize = integrator.getStepSize();
@@ -1377,7 +1377,7 @@ void CpuIntegrateBAOABStepKernel::execute(ContextImpl& context, const BAOABLange
         
         if (dynamics)
             delete dynamics;
-        dynamics = new CpuBAOABDynamics(context.getSystem().getNumParticles(), stepSize, friction, temperature, data.threads, data.random);
+        dynamics = new CpuLangevinMiddleDynamics(context.getSystem().getNumParticles(), stepSize, friction, temperature, data.threads, data.random);
         dynamics->setReferenceConstraintAlgorithm(&extractConstraints(context));
         prevTemp = temperature;
         prevFriction = friction;
@@ -1389,6 +1389,6 @@ void CpuIntegrateBAOABStepKernel::execute(ContextImpl& context, const BAOABLange
     refData->stepCount++;
 }
 
-double CpuIntegrateBAOABStepKernel::computeKineticEnergy(ContextImpl& context, const BAOABLangevinIntegrator& integrator) {
+double CpuIntegrateLangevinMiddleStepKernel::computeKineticEnergy(ContextImpl& context, const LangevinMiddleIntegrator& integrator) {
     return computeShiftedKineticEnergy(context, masses, 0.0);
 }

platforms/cpu/src/CpuBAOABDynamics.cpp → platforms/cpu/src/CpuLangevinMiddleDynamics.cpp

@@ -23,19 +23,19 @@
  */
 
 #include "SimTKOpenMMUtilities.h"
-#include "CpuBAOABDynamics.h"
+#include "CpuLangevinMiddleDynamics.h"
 
 using namespace OpenMM;
 using namespace std;
 
-CpuBAOABDynamics::CpuBAOABDynamics(int numberOfAtoms, double deltaT, double friction, double temperature, ThreadPool& threads, CpuRandom& random) : 
-           ReferenceBAOABDynamics(numberOfAtoms, deltaT, friction, temperature), threads(threads), random(random) {
+CpuLangevinMiddleDynamics::CpuLangevinMiddleDynamics(int numberOfAtoms, double deltaT, double friction, double temperature, ThreadPool& threads, CpuRandom& random) : 
+           ReferenceLangevinMiddleDynamics(numberOfAtoms, deltaT, friction, temperature), threads(threads), random(random) {
 }
 
-CpuBAOABDynamics::~CpuBAOABDynamics() {
+CpuLangevinMiddleDynamics::~CpuLangevinMiddleDynamics() {
 }
 
-void CpuBAOABDynamics::updatePart1(int numberOfAtoms, vector<Vec3>& velocities, vector<Vec3>& forces, vector<double>& inverseMasses) {
+void CpuLangevinMiddleDynamics::updatePart1(int numberOfAtoms, vector<Vec3>& velocities, vector<Vec3>& forces, vector<double>& inverseMasses) {
     // Record the parameters for the threads.
     
     this->numberOfAtoms = numberOfAtoms;
@@ -49,7 +49,7 @@ void CpuBAOABDynamics::updatePart1(int numberOfAtoms, vector<Vec3>& velocities,
     threads.waitForThreads();
 }
 
-void CpuBAOABDynamics::updatePart2(int numberOfAtoms, vector<Vec3>& atomCoordinates, vector<Vec3>& velocities,
+void CpuLangevinMiddleDynamics::updatePart2(int numberOfAtoms, vector<Vec3>& atomCoordinates, vector<Vec3>& velocities,
                                    vector<double>& inverseMasses, vector<Vec3>& xPrime) {
     // Record the parameters for the threads.
     
@@ -65,7 +65,7 @@ void CpuBAOABDynamics::updatePart2(int numberOfAtoms, vector<Vec3>& atomCoordina
     threads.waitForThreads();
 }
 
-void CpuBAOABDynamics::updatePart3(ContextImpl& context, int numberOfAtoms, vector<Vec3>& atomCoordinates, vector<Vec3>& velocities,
+void CpuLangevinMiddleDynamics::updatePart3(ContextImpl& context, int numberOfAtoms, vector<Vec3>& atomCoordinates, vector<Vec3>& velocities,
                                    vector<double>& inverseMasses, vector<Vec3>& xPrime) {
     // Record the parameters for the threads.
     
@@ -81,7 +81,7 @@ void CpuBAOABDynamics::updatePart3(ContextImpl& context, int numberOfAtoms, vect
     threads.waitForThreads();
 }
 
-void CpuBAOABDynamics::threadUpdate1(int threadIndex) {
+void CpuLangevinMiddleDynamics::threadUpdate1(int threadIndex) {
     int start = threadIndex*numberOfAtoms/threads.getNumThreads();
     int end = (threadIndex+1)*numberOfAtoms/threads.getNumThreads();
 
@@ -90,7 +90,7 @@ void CpuBAOABDynamics::threadUpdate1(int threadIndex) {
             velocities[i] += (getDeltaT()*inverseMasses[i])*forces[i];
 }
 
-void CpuBAOABDynamics::threadUpdate2(int threadIndex) {
+void CpuLangevinMiddleDynamics::threadUpdate2(int threadIndex) {
     const double halfdt = 0.5*getDeltaT();
     const double kT = BOLTZ*getTemperature();
     const double friction = getFriction();
@@ -110,7 +110,7 @@ void CpuBAOABDynamics::threadUpdate2(int threadIndex) {
     }
 }
 
-void CpuBAOABDynamics::threadUpdate3(int threadIndex) {
+void CpuLangevinMiddleDynamics::threadUpdate3(int threadIndex) {
     int start = threadIndex*numberOfAtoms/threads.getNumThreads();
     int end = (threadIndex+1)*numberOfAtoms/threads.getNumThreads();
 

platforms/cpu/src/CpuPlatform.cpp

@@ -74,7 +74,7 @@ CpuPlatform::CpuPlatform() {
     registerKernelFactory(CalcCustomGBForceKernel::Name(), factory);
     registerKernelFactory(CalcGayBerneForceKernel::Name(), factory);
     registerKernelFactory(IntegrateLangevinStepKernel::Name(), factory);
-    registerKernelFactory(IntegrateBAOABStepKernel::Name(), factory);
+    registerKernelFactory(IntegrateLangevinMiddleStepKernel::Name(), factory);
     platformProperties.push_back(CpuThreads());
     platformProperties.push_back(CpuDeterministicForces());
     int threads = getNumProcessors();

platforms/cpu/tests/TestCpuBAOABLangevinIntegrator.cpp → platforms/cpu/tests/TestCpuLangevinMiddleIntegrator.cpp

@@ -30,7 +30,7 @@
  * -------------------------------------------------------------------------- */
 
 #include "CpuTests.h"
-#include "TestBAOABLangevinIntegrator.h"
+#include "TestLangevinMiddleIntegrator.h"
 
 void runPlatformTests() {
 }

platforms/cuda/src/CudaKernelFactory.cpp

@@ -121,8 +121,8 @@ KernelImpl* CudaKernelFactory::createKernelImpl(std::string name, const Platform
         return new CommonIntegrateVerletStepKernel(name, platform, cu);
     if (name == IntegrateLangevinStepKernel::Name())
         return new CommonIntegrateLangevinStepKernel(name, platform, cu);
-    if (name == IntegrateBAOABStepKernel::Name())
-        return new CommonIntegrateBAOABStepKernel(name, platform, cu);
+    if (name == IntegrateLangevinMiddleStepKernel::Name())
+        return new CommonIntegrateLangevinMiddleStepKernel(name, platform, cu);
     if (name == IntegrateBrownianStepKernel::Name())
         return new CommonIntegrateBrownianStepKernel(name, platform, cu);
     if (name == IntegrateVariableVerletStepKernel::Name())

platforms/cuda/src/CudaPlatform.cpp

@@ -98,7 +98,7 @@ CudaPlatform::CudaPlatform() {
     registerKernelFactory(IntegrateVerletStepKernel::Name(), factory);
     registerKernelFactory(IntegrateVelocityVerletStepKernel::Name(), factory);
     registerKernelFactory(IntegrateLangevinStepKernel::Name(), factory);
-    registerKernelFactory(IntegrateBAOABStepKernel::Name(), factory);
+    registerKernelFactory(IntegrateLangevinMiddleStepKernel::Name(), factory);
     registerKernelFactory(IntegrateBrownianStepKernel::Name(), factory);
     registerKernelFactory(IntegrateVariableVerletStepKernel::Name(), factory);
     registerKernelFactory(IntegrateVariableLangevinStepKernel::Name(), factory);

platforms/cuda/tests/TestCudaBAOABLangevinIntegrator.cpp → platforms/cuda/tests/TestCudaLangevinMiddleIntegrator.cpp

@@ -30,7 +30,7 @@
  * -------------------------------------------------------------------------- */
 
 #include "CudaTests.h"
-#include "TestBAOABLangevinIntegrator.h"
+#include "TestLangevinMiddleIntegrator.h"
 
 void runPlatformTests() {
 }

platforms/opencl/src/OpenCLKernelFactory.cpp

@@ -119,8 +119,8 @@ KernelImpl* OpenCLKernelFactory::createKernelImpl(std::string name, const Platfo
         return new CommonIntegrateVerletStepKernel(name, platform, cl);
     if (name == IntegrateLangevinStepKernel::Name())
         return new CommonIntegrateLangevinStepKernel(name, platform, cl);
-    if (name == IntegrateBAOABStepKernel::Name())
-        return new CommonIntegrateBAOABStepKernel(name, platform, cl);
+    if (name == IntegrateLangevinMiddleStepKernel::Name())
+        return new CommonIntegrateLangevinMiddleStepKernel(name, platform, cl);
     if (name == IntegrateBrownianStepKernel::Name())
         return new CommonIntegrateBrownianStepKernel(name, platform, cl);
     if (name == IntegrateVariableVerletStepKernel::Name())

platforms/opencl/src/OpenCLPlatform.cpp

@@ -89,7 +89,7 @@ OpenCLPlatform::OpenCLPlatform() {
     registerKernelFactory(IntegrateVerletStepKernel::Name(), factory);
     registerKernelFactory(IntegrateVelocityVerletStepKernel::Name(), factory);
     registerKernelFactory(IntegrateLangevinStepKernel::Name(), factory);
-    registerKernelFactory(IntegrateBAOABStepKernel::Name(), factory);
+    registerKernelFactory(IntegrateLangevinMiddleStepKernel::Name(), factory);
     registerKernelFactory(IntegrateBrownianStepKernel::Name(), factory);
     registerKernelFactory(IntegrateVariableVerletStepKernel::Name(), factory);
     registerKernelFactory(IntegrateVariableLangevinStepKernel::Name(), factory);

platforms/opencl/tests/TestOpenCLBAOABLangevinIntegrator.cpp → platforms/opencl/tests/TestOpenCLLangevinMiddleIntegrator.cpp

@@ -30,7 +30,7 @@
  * -------------------------------------------------------------------------- */
 
 #include "OpenCLTests.h"
-#include "TestBAOABLangevinIntegrator.h"
+#include "TestLangevinMiddleIntegrator.h"
 
 void runPlatformTests() {
 }

platforms/reference/include/ReferenceKernels.h

@@ -45,7 +45,7 @@ namespace OpenMM {
 
 class ReferenceObc;
 class ReferenceAndersenThermostat;
-class ReferenceBAOABDynamics;
+class ReferenceLangevinMiddleDynamics;
 class ReferenceCustomBondIxn;
 class ReferenceCustomAngleIxn;
 class ReferenceCustomTorsionIxn;
@@ -1213,38 +1213,38 @@ private:
 };
 
 /**
- * This kernel is invoked by BAOABLangevinIntegrator to take one time step.
+ * This kernel is invoked by LangevinMiddleIntegrator to take one time step.
  */
-class ReferenceIntegrateBAOABStepKernel : public IntegrateBAOABStepKernel {
+class ReferenceIntegrateLangevinMiddleStepKernel : public IntegrateLangevinMiddleStepKernel {
 public:
-    ReferenceIntegrateBAOABStepKernel(std::string name, const Platform& platform, ReferencePlatform::PlatformData& data) : IntegrateBAOABStepKernel(name, platform),
+    ReferenceIntegrateLangevinMiddleStepKernel(std::string name, const Platform& platform, ReferencePlatform::PlatformData& data) : IntegrateLangevinMiddleStepKernel(name, platform),
         data(data), dynamics(0) {
     }
-    ~ReferenceIntegrateBAOABStepKernel();
+    ~ReferenceIntegrateLangevinMiddleStepKernel();
     /**
      * Initialize the kernel, setting up the particle masses.
      * 
      * @param system     the System this kernel will be applied to
-     * @param integrator the BAOABLangevinIntegrator this kernel will be used for
+     * @param integrator the LangevinMiddleIntegrator this kernel will be used for
      */
-    void initialize(const System& system, const BAOABLangevinIntegrator& integrator);
+    void initialize(const System& system, const LangevinMiddleIntegrator& integrator);
     /**
      * Execute the kernel.
      * 
      * @param context    the context in which to execute this kernel
-     * @param integrator the BAOABLangevinIntegrator this kernel is being used for
+     * @param integrator the LangevinMiddleIntegrator this kernel is being used for
      */
-    void execute(ContextImpl& context, const BAOABLangevinIntegrator& integrator);
+    void execute(ContextImpl& context, const LangevinMiddleIntegrator& integrator);
     /**
      * Compute the kinetic energy.
      * 
      * @param context    the context in which to execute this kernel
-     * @param integrator the BAOABLangevinIntegrator this kernel is being used for
+     * @param integrator the LangevinMiddleIntegrator this kernel is being used for
      */
-    double computeKineticEnergy(ContextImpl& context, const BAOABLangevinIntegrator& integrator);
+    double computeKineticEnergy(ContextImpl& context, const LangevinMiddleIntegrator& integrator);
 private:
     ReferencePlatform::PlatformData& data;
-    ReferenceBAOABDynamics* dynamics;
+    ReferenceLangevinMiddleDynamics* dynamics;
     std::vector<double> masses;
     double prevTemp, prevFriction, prevStepSize;
 };

platforms/reference/include/ReferenceBAOABDynamics.h → platforms/reference/include/ReferenceLangevinMiddleDynamics.h

@@ -22,8 +22,8 @@
  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef __ReferenceBAOABDynamics_H__
-#define __ReferenceBAOABDynamics_H__
+#ifndef __ReferenceLangevinMiddleDynamics_H__
+#define __ReferenceLangevinMiddleDynamics_H__
 
 #include "ReferenceDynamics.h"
 #include "openmm/internal/ContextImpl.h"
@@ -31,7 +31,7 @@
 
 namespace OpenMM {
 
-class OPENMM_EXPORT ReferenceBAOABDynamics : public ReferenceDynamics {
+class OPENMM_EXPORT ReferenceLangevinMiddleDynamics : public ReferenceDynamics {
 
    protected:
 
@@ -52,7 +52,7 @@ class OPENMM_EXPORT ReferenceBAOABDynamics : public ReferenceDynamics {
       
          --------------------------------------------------------------------------------------- */
 
-       ReferenceBAOABDynamics(int numberOfAtoms, double deltaT, double friction, double temperature);
+       ReferenceLangevinMiddleDynamics(int numberOfAtoms, double deltaT, double friction, double temperature);
 
       /**---------------------------------------------------------------------------------------
       
@@ -60,7 +60,7 @@ class OPENMM_EXPORT ReferenceBAOABDynamics : public ReferenceDynamics {
       
          --------------------------------------------------------------------------------------- */
 
-       ~ReferenceBAOABDynamics();
+       ~ReferenceLangevinMiddleDynamics();
 
       /**---------------------------------------------------------------------------------------
       
@@ -133,4 +133,4 @@ class OPENMM_EXPORT ReferenceBAOABDynamics : public ReferenceDynamics {
 
 } // namespace OpenMM
 
-#endif // __ReferenceBAOABDynamics_H__
+#endif // __ReferenceLangevinMiddleDynamics_H__

platforms/reference/src/ReferenceKernelFactory.cpp

@@ -94,8 +94,8 @@ KernelImpl* ReferenceKernelFactory::createKernelImpl(std::string name, const Pla
         return new ReferenceNoseHooverChainKernel(name, platform);
     if (name == IntegrateLangevinStepKernel::Name())
         return new ReferenceIntegrateLangevinStepKernel(name, platform, data);
-    if (name == IntegrateBAOABStepKernel::Name())
-        return new ReferenceIntegrateBAOABStepKernel(name, platform, data);
+    if (name == IntegrateLangevinMiddleStepKernel::Name())
+        return new ReferenceIntegrateLangevinMiddleStepKernel(name, platform, data);
     if (name == IntegrateBrownianStepKernel::Name())
         return new ReferenceIntegrateBrownianStepKernel(name, platform, data);
     if (name == IntegrateVariableLangevinStepKernel::Name())

platforms/reference/src/ReferenceKernels.cpp

@@ -33,7 +33,6 @@
 #include "ReferenceObc.h"
 #include "ReferenceAndersenThermostat.h"
 #include "ReferenceAngleBondIxn.h"
-#include "ReferenceBAOABDynamics.h"
 #include "ReferenceBondForce.h"
 #include "ReferenceBrownianDynamics.h"
 #include "ReferenceCCMAAlgorithm.h"
@@ -53,6 +52,7 @@
 #include "ReferenceCustomTorsionIxn.h"
 #include "ReferenceGayBerneForce.h"
 #include "ReferenceHarmonicBondIxn.h"
+#include "ReferenceLangevinMiddleDynamics.h"
 #include "ReferenceLJCoulomb14.h"
 #include "ReferenceLJCoulombIxn.h"
 #include "ReferenceMonteCarloBarostat.h"
@@ -2225,12 +2225,12 @@ double ReferenceIntegrateLangevinStepKernel::computeKineticEnergy(ContextImpl& c
     return computeShiftedKineticEnergy(context, masses, 0.5*integrator.getStepSize());
 }
 
-ReferenceIntegrateBAOABStepKernel::~ReferenceIntegrateBAOABStepKernel() {
+ReferenceIntegrateLangevinMiddleStepKernel::~ReferenceIntegrateLangevinMiddleStepKernel() {
     if (dynamics)
         delete dynamics;
 }
 
-void ReferenceIntegrateBAOABStepKernel::initialize(const System& system, const BAOABLangevinIntegrator& integrator) {
+void ReferenceIntegrateLangevinMiddleStepKernel::initialize(const System& system, const LangevinMiddleIntegrator& integrator) {
     int numParticles = system.getNumParticles();
     masses.resize(numParticles);
     for (int i = 0; i < numParticles; ++i)
@@ -2238,7 +2238,7 @@ void ReferenceIntegrateBAOABStepKernel::initialize(const System& system, const B
     SimTKOpenMMUtilities::setRandomNumberSeed((unsigned int) integrator.getRandomNumberSeed());
 }
 
-void ReferenceIntegrateBAOABStepKernel::execute(ContextImpl& context, const BAOABLangevinIntegrator& integrator) {
+void ReferenceIntegrateLangevinMiddleStepKernel::execute(ContextImpl& context, const LangevinMiddleIntegrator& integrator) {
     double temperature = integrator.getTemperature();
     double friction = integrator.getFriction();
     double stepSize = integrator.getStepSize();
@@ -2249,7 +2249,7 @@ void ReferenceIntegrateBAOABStepKernel::execute(ContextImpl& context, const BAOA
         
         if (dynamics)
             delete dynamics;
-        dynamics = new ReferenceBAOABDynamics(
+        dynamics = new ReferenceLangevinMiddleDynamics(
                 context.getSystem().getNumParticles(), 
                 stepSize, 
                 friction, 
@@ -2264,7 +2264,7 @@ void ReferenceIntegrateBAOABStepKernel::execute(ContextImpl& context, const BAOA
     data.stepCount++;
 }
 
-double ReferenceIntegrateBAOABStepKernel::computeKineticEnergy(ContextImpl& context, const BAOABLangevinIntegrator& integrator) {
+double ReferenceIntegrateLangevinMiddleStepKernel::computeKineticEnergy(ContextImpl& context, const LangevinMiddleIntegrator& integrator) {
     return computeShiftedKineticEnergy(context, masses, 0.0);
 }
 

platforms/reference/src/ReferencePlatform.cpp

@@ -69,7 +69,7 @@ ReferencePlatform::ReferencePlatform() {
     registerKernelFactory(IntegrateVelocityVerletStepKernel::Name(), factory);
     registerKernelFactory(NoseHooverChainKernel::Name(), factory);
     registerKernelFactory(IntegrateLangevinStepKernel::Name(), factory);
-    registerKernelFactory(IntegrateBAOABStepKernel::Name(), factory);
+    registerKernelFactory(IntegrateLangevinMiddleStepKernel::Name(), factory);
     registerKernelFactory(IntegrateBrownianStepKernel::Name(), factory);
     registerKernelFactory(IntegrateVariableLangevinStepKernel::Name(), factory);
     registerKernelFactory(IntegrateVariableVerletStepKernel::Name(), factory);

platforms/reference/src/SimTKReference/ReferenceBAOABDynamics.cpp → platforms/reference/src/SimTKReference/ReferenceLangevinMiddleDynamics.cpp

@@ -26,7 +26,7 @@
 #include <sstream>
 
 #include "SimTKOpenMMUtilities.h"
-#include "ReferenceBAOABDynamics.h"
+#include "ReferenceLangevinMiddleDynamics.h"
 #include "ReferencePlatform.h"
 #include "ReferenceVirtualSites.h"
 #include "openmm/OpenMMException.h"
@@ -35,7 +35,7 @@
 using std::vector;
 using namespace OpenMM;
 
-ReferenceBAOABDynamics::ReferenceBAOABDynamics(int numberOfAtoms,
+ReferenceLangevinMiddleDynamics::ReferenceLangevinMiddleDynamics(int numberOfAtoms,
                                                double deltaT, double friction,
                                                double temperature) : 
            ReferenceDynamics(numberOfAtoms, deltaT, temperature), friction(friction) {
@@ -44,20 +44,20 @@ ReferenceBAOABDynamics::ReferenceBAOABDynamics(int numberOfAtoms,
    inverseMasses.resize(numberOfAtoms);
 }
 
-ReferenceBAOABDynamics::~ReferenceBAOABDynamics() {
+ReferenceLangevinMiddleDynamics::~ReferenceLangevinMiddleDynamics() {
 }
 
-double ReferenceBAOABDynamics::getFriction() const {
+double ReferenceLangevinMiddleDynamics::getFriction() const {
    return friction;
 }
 
-void ReferenceBAOABDynamics::updatePart1(int numberOfAtoms, vector<Vec3>& velocities, vector<Vec3>& forces, vector<double>& inverseMasses) {
+void ReferenceLangevinMiddleDynamics::updatePart1(int numberOfAtoms, vector<Vec3>& velocities, vector<Vec3>& forces, vector<double>& inverseMasses) {
     for (int i = 0; i < numberOfAtoms; i++)
         if (inverseMasses[i] != 0.0)
             velocities[i] += (getDeltaT()*inverseMasses[i])*forces[i];
 }
 
-void ReferenceBAOABDynamics::updatePart2(int numberOfAtoms, vector<Vec3>& atomCoordinates,
+void ReferenceLangevinMiddleDynamics::updatePart2(int numberOfAtoms, vector<Vec3>& atomCoordinates,
                                          vector<Vec3>& velocities, vector<double>& inverseMasses,
                                          vector<Vec3>& xPrime) {
     const double halfdt = 0.5*getDeltaT();
@@ -79,7 +79,7 @@ void ReferenceBAOABDynamics::updatePart2(int numberOfAtoms, vector<Vec3>& atomCo
     }
 }
 
-void ReferenceBAOABDynamics::updatePart3(OpenMM::ContextImpl& context, int numberOfAtoms, vector<Vec3>& atomCoordinates,
+void ReferenceLangevinMiddleDynamics::updatePart3(OpenMM::ContextImpl& context, int numberOfAtoms, vector<Vec3>& atomCoordinates,
                                          vector<Vec3>& velocities, vector<double>& inverseMasses, vector<Vec3>& xPrime) {
     for (int i = 0; i < numberOfAtoms; i++) {
         if (inverseMasses[i] != 0.0) {
@@ -89,7 +89,7 @@ void ReferenceBAOABDynamics::updatePart3(OpenMM::ContextImpl& context, int numbe
     }
 }
 
-void ReferenceBAOABDynamics::update(ContextImpl& context, vector<Vec3>& atomCoordinates,
+void ReferenceLangevinMiddleDynamics::update(ContextImpl& context, vector<Vec3>& atomCoordinates,
                                     vector<Vec3>& velocities, vector<double>& masses, double tolerance) {
     int numberOfAtoms = context.getSystem().getNumParticles();
     ReferenceConstraintAlgorithm* referenceConstraintAlgorithm = getReferenceConstraintAlgorithm();

platforms/reference/tests/TestReferenceBAOABLangevinIntegrator.cpp → platforms/reference/tests/TestReferenceLangevinMiddleIntegrator.cpp

@@ -30,7 +30,7 @@
  * -------------------------------------------------------------------------- */
 
 #include "ReferenceTests.h"
-#include "TestBAOABLangevinIntegrator.h"
+#include "TestLangevinMiddleIntegrator.h"
 
 void runPlatformTests() {
 }

serialization/include/openmm/serialization/BAOABLangevinIntegratorProxy.h → serialization/include/openmm/serialization/LangevinMiddleIntegratorProxy.h

-#ifndef OPENMM_BAOAB_LANGEVIN_INTEGRATOR_PROXY_H_
-#define OPENMM_BAOAB_LANGEVIN_INTEGRATOR_PROXY_H_
+#ifndef OPENMM_LANGEVIN_MIDDLE_INTEGRATOR_PROXY_H_
+#define OPENMM_LANGEVIN_MIDDLE_INTEGRATOR_PROXY_H_
 
 #include "openmm/serialization/XmlSerializer.h"
 
 namespace OpenMM {
 
-class BAOABLangevinIntegratorProxy : public SerializationProxy {
+class LangevinMiddleIntegratorProxy : public SerializationProxy {
 public:
-    BAOABLangevinIntegratorProxy();
+    LangevinMiddleIntegratorProxy();
     void serialize(const void* object, SerializationNode& node) const;
     void* deserialize(const SerializationNode& node) const;
 };
 
 }
 
-#endif /*OPENMM_BAOAB_LANGEVIN_INTEGRATOR_PROXY_H_*/
\ No newline at end of file
+#endif /*OPENMM_LANGEVIN_MIDDLE_INTEGRATOR_PROXY_H_*/
\ No newline at end of file

serialization/src/BAOABLangevinIntegratorProxy.cpp → serialization/src/LangevinMiddleIntegratorProxy.cpp

@@ -29,19 +29,19 @@
  * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
  * -------------------------------------------------------------------------- */
 
-#include "openmm/serialization/BAOABLangevinIntegratorProxy.h"
+#include "openmm/serialization/LangevinMiddleIntegratorProxy.h"
 #include <OpenMM.h>
 
 using namespace std;
 using namespace OpenMM;
 
-BAOABLangevinIntegratorProxy::BAOABLangevinIntegratorProxy() : SerializationProxy("BAOABLangevinIntegrator") {
+LangevinMiddleIntegratorProxy::LangevinMiddleIntegratorProxy() : SerializationProxy("LangevinMiddleIntegrator") {
 
 }
 
-void BAOABLangevinIntegratorProxy::serialize(const void* object, SerializationNode& node) const {
+void LangevinMiddleIntegratorProxy::serialize(const void* object, SerializationNode& node) const {
     node.setIntProperty("version", 1);
-    const BAOABLangevinIntegrator& integrator = *reinterpret_cast<const BAOABLangevinIntegrator*>(object);
+    const LangevinMiddleIntegrator& integrator = *reinterpret_cast<const LangevinMiddleIntegrator*>(object);
     node.setDoubleProperty("stepSize", integrator.getStepSize());
     node.setDoubleProperty("constraintTolerance", integrator.getConstraintTolerance());
     node.setDoubleProperty("temperature", integrator.getTemperature());
@@ -49,10 +49,10 @@ void BAOABLangevinIntegratorProxy::serialize(const void* object, SerializationNo
     node.setIntProperty("randomSeed", integrator.getRandomNumberSeed());
 }
 
-void* BAOABLangevinIntegratorProxy::deserialize(const SerializationNode& node) const {
+void* LangevinMiddleIntegratorProxy::deserialize(const SerializationNode& node) const {
     if (node.getIntProperty("version") != 1)
         throw OpenMMException("Unsupported version number");
-    BAOABLangevinIntegrator *integrator = new BAOABLangevinIntegrator(node.getDoubleProperty("temperature"),
+    LangevinMiddleIntegrator *integrator = new LangevinMiddleIntegrator(node.getDoubleProperty("temperature"),
             node.getDoubleProperty("friction"), node.getDoubleProperty("stepSize"));
     integrator->setConstraintTolerance(node.getDoubleProperty("constraintTolerance"));
     integrator->setRandomNumberSeed(node.getIntProperty("randomSeed"));