Renamed OpenMMContext to Context

openmmapi/src/HarmonicBondForceImpl.cpp

@@ -29,7 +29,7 @@
  * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
  * -------------------------------------------------------------------------- */
 
-#include "openmm/internal/OpenMMContextImpl.h"
+#include "openmm/internal/ContextImpl.h"
 #include "openmm/internal/HarmonicBondForceImpl.h"
 #include "openmm/kernels.h"
 
@@ -44,16 +44,16 @@ HarmonicBondForceImpl::HarmonicBondForceImpl(HarmonicBondForce& owner) : owner(o
 HarmonicBondForceImpl::~HarmonicBondForceImpl() {
 }
 
-void HarmonicBondForceImpl::initialize(OpenMMContextImpl& context) {
+void HarmonicBondForceImpl::initialize(ContextImpl& context) {
     kernel = context.getPlatform().createKernel(CalcHarmonicBondForceKernel::Name(), context);
     dynamic_cast<CalcHarmonicBondForceKernel&>(kernel.getImpl()).initialize(context.getSystem(), owner);
 }
 
-void HarmonicBondForceImpl::calcForces(OpenMMContextImpl& context, Stream& forces) {
+void HarmonicBondForceImpl::calcForces(ContextImpl& context, Stream& forces) {
     dynamic_cast<CalcHarmonicBondForceKernel&>(kernel.getImpl()).executeForces(context);
 }
 
-double HarmonicBondForceImpl::calcEnergy(OpenMMContextImpl& context) {
+double HarmonicBondForceImpl::calcEnergy(ContextImpl& context) {
     return dynamic_cast<CalcHarmonicBondForceKernel&>(kernel.getImpl()).executeEnergy(context);
 }
 

openmmapi/src/LangevinIntegrator.cpp

@@ -30,8 +30,8 @@
  * -------------------------------------------------------------------------- */
 
 #include "openmm/LangevinIntegrator.h"
-#include "openmm/OpenMMContext.h"
-#include "openmm/internal/OpenMMContextImpl.h"
+#include "openmm/Context.h"
+#include "openmm/internal/ContextImpl.h"
 #include "openmm/kernels.h"
 #include <ctime>
 #include <string>
@@ -48,7 +48,7 @@ LangevinIntegrator::LangevinIntegrator(double temperature, double frictionCoeff,
     setRandomNumberSeed((int) time(NULL));
 }
 
-void LangevinIntegrator::initialize(OpenMMContextImpl& contextRef) {
+void LangevinIntegrator::initialize(ContextImpl& contextRef) {
     context = &contextRef;
     kernel = context->getPlatform().createKernel(IntegrateLangevinStepKernel::Name(), contextRef);
     dynamic_cast<IntegrateLangevinStepKernel&>(kernel.getImpl()).initialize(contextRef.getSystem(), *this);

openmmapi/src/NonbondedForceImpl.cpp

@@ -30,7 +30,7 @@
  * -------------------------------------------------------------------------- */
 
 #include "openmm/OpenMMException.h"
-#include "openmm/internal/OpenMMContextImpl.h"
+#include "openmm/internal/ContextImpl.h"
 #include "openmm/internal/NonbondedForceImpl.h"
 #include "openmm/kernels.h"
 #include <sstream>
@@ -47,7 +47,7 @@ NonbondedForceImpl::NonbondedForceImpl(NonbondedForce& owner) : owner(owner) {
 NonbondedForceImpl::~NonbondedForceImpl() {
 }
 
-void NonbondedForceImpl::initialize(OpenMMContextImpl& context) {
+void NonbondedForceImpl::initialize(ContextImpl& context) {
     kernel = context.getPlatform().createKernel(CalcNonbondedForceKernel::Name(), context);
 
     // Check for errors in the specification of exceptions.
@@ -86,11 +86,11 @@ void NonbondedForceImpl::initialize(OpenMMContextImpl& context) {
     dynamic_cast<CalcNonbondedForceKernel&>(kernel.getImpl()).initialize(context.getSystem(), owner);
 }
 
-void NonbondedForceImpl::calcForces(OpenMMContextImpl& context, Stream& forces) {
+void NonbondedForceImpl::calcForces(ContextImpl& context, Stream& forces) {
     dynamic_cast<CalcNonbondedForceKernel&>(kernel.getImpl()).executeForces(context);
 }
 
-double NonbondedForceImpl::calcEnergy(OpenMMContextImpl& context) {
+double NonbondedForceImpl::calcEnergy(ContextImpl& context) {
     return dynamic_cast<CalcNonbondedForceKernel&>(kernel.getImpl()).executeEnergy(context);
 }
 

openmmapi/src/OpenMMContext.cpp

@@ -29,51 +29,51 @@
  * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
  * -------------------------------------------------------------------------- */
 
-#include "openmm/OpenMMContext.h"
-#include "openmm/internal/OpenMMContextImpl.h"
+#include "openmm/Context.h"
+#include "openmm/internal/ContextImpl.h"
 #include "openmm/OpenMMException.h"
 
 using namespace OpenMM;
 using namespace std;
 
-OpenMMContext::OpenMMContext(System& system, Integrator& integrator) {
-    impl = new OpenMMContextImpl(*this, system, integrator, 0);
+Context::Context(System& system, Integrator& integrator) {
+    impl = new ContextImpl(*this, system, integrator, 0);
 }
 
-OpenMMContext::OpenMMContext(System& system, Integrator& integrator, Platform& platform) {
-    impl = new OpenMMContextImpl(*this, system, integrator, &platform);
+Context::Context(System& system, Integrator& integrator, Platform& platform) {
+    impl = new ContextImpl(*this, system, integrator, &platform);
 }
 
-OpenMMContext::~OpenMMContext() {
+Context::~Context() {
 	delete impl;
 }
 
-const System& OpenMMContext::getSystem() const {
+const System& Context::getSystem() const {
     return impl->getSystem();
 
 }
 
-System& OpenMMContext::getSystem() {
+System& Context::getSystem() {
     return impl->getSystem();
 }
 
-const Integrator& OpenMMContext::getIntegrator() const {
+const Integrator& Context::getIntegrator() const {
     return impl->getIntegrator();
 }
 
-Integrator& OpenMMContext::getIntegrator() {
+Integrator& Context::getIntegrator() {
     return impl->getIntegrator();
 }
 
-const Platform& OpenMMContext::getPlatform() const {
+const Platform& Context::getPlatform() const {
     return impl->getPlatform();
 }
 
-Platform& OpenMMContext::getPlatform() {
+Platform& Context::getPlatform() {
     return impl->getPlatform();
 }
 
-State OpenMMContext::getState(int types) const {
+State Context::getState(int types) const {
     State state(impl->getTime(), impl->getSystem().getNumParticles(), State::DataType(types));
     if (types&State::Energy)
         state.setEnergy(impl->calcKineticEnergy(), impl->calcPotentialEnergy());
@@ -92,34 +92,34 @@ State OpenMMContext::getState(int types) const {
     return state;
 }
 
-void OpenMMContext::setTime(double time) {
+void Context::setTime(double time) {
     impl->setTime(time);
 }
 
-void OpenMMContext::setPositions(const vector<Vec3>& positions) {
+void Context::setPositions(const vector<Vec3>& positions) {
     if ((int) positions.size() != impl->getSystem().getNumParticles())
-        throw OpenMMException("Called setPositions() on an OpenMMContext with the wrong number of positions");
+        throw OpenMMException("Called setPositions() on a Context with the wrong number of positions");
     impl->getPositions().loadFromArray(&positions[0]);
 }
 
-void OpenMMContext::setVelocities(const vector<Vec3>& velocities) {
+void Context::setVelocities(const vector<Vec3>& velocities) {
     if ((int) velocities.size() != impl->getSystem().getNumParticles())
-        throw OpenMMException("Called setVelocities() on an OpenMMContext with the wrong number of velocities");
+        throw OpenMMException("Called setVelocities() on a Context with the wrong number of velocities");
     impl->getVelocities().loadFromArray(&velocities[0]);
 }
 
-double OpenMMContext::getParameter(const string& name) {
+double Context::getParameter(const string& name) {
     return impl->getParameter(name);
 }
 
-void OpenMMContext::setParameter(const string& name, double value) {
+void Context::setParameter(const string& name, double value) {
     impl->setParameter(name, value);
 }
 
-void OpenMMContext::reinitialize() {
+void Context::reinitialize() {
     System& system = impl->getSystem();
     Integrator& integrator = impl->getIntegrator();
     Platform& platform = impl->getPlatform();
     delete impl;
-    impl = new OpenMMContextImpl(*this, system, integrator, &platform);
+    impl = new ContextImpl(*this, system, integrator, &platform);
 }

openmmapi/src/OpenMMContextImpl.cpp

@@ -35,7 +35,7 @@
 #include "openmm/System.h"
 #include "openmm/kernels.h"
 #include "openmm/internal/ForceImpl.h"
-#include "openmm/internal/OpenMMContextImpl.h"
+#include "openmm/internal/ContextImpl.h"
 #include <map>
 #include <vector>
 
@@ -44,7 +44,7 @@ using std::map;
 using std::vector;
 using std::string;
 
-OpenMMContextImpl::OpenMMContextImpl(OpenMMContext& owner, System& system, Integrator& integrator, Platform* platform) :
+ContextImpl::ContextImpl(Context& owner, System& system, Integrator& integrator, Platform* platform) :
 				owner(owner), system(system), 
 				integrator(integrator), platform(platform), 
 				platformData(NULL)
@@ -65,7 +65,7 @@ OpenMMContextImpl::OpenMMContextImpl(OpenMMContext& owner, System& system, Integ
     if (platform == 0)
         this->platform = platform = &Platform::findPlatform(kernelNames);
     else if (!platform->supportsKernels(kernelNames))
-        throw OpenMMException("Specified a Platform for an OpenMMContext which does not support all required kernels");
+        throw OpenMMException("Specified a Platform for a Context which does not support all required kernels");
     platform->contextCreated(*this);
     initializeForcesKernel = platform->createKernel(InitializeForcesKernel::Name(), *this);
     dynamic_cast<InitializeForcesKernel&>(initializeForcesKernel.getImpl()).initialize(system);
@@ -83,58 +83,58 @@ OpenMMContextImpl::OpenMMContextImpl(OpenMMContext& owner, System& system, Integ
     velocities.fillWithValue(&zero);
 }
 
-OpenMMContextImpl::~OpenMMContextImpl() {
+ContextImpl::~ContextImpl() {
     for (int i = 0; i < (int) forceImpls.size(); ++i)
         delete forceImpls[i];
     platform->contextDestroyed(*this);
 }
 
-double OpenMMContextImpl::getTime() const {
+double ContextImpl::getTime() const {
     return dynamic_cast<const UpdateTimeKernel&>(updateTimeKernel.getImpl()).getTime(*this);
 }
 
-void OpenMMContextImpl::setTime(double t) {
+void ContextImpl::setTime(double t) {
     dynamic_cast<UpdateTimeKernel&>(updateTimeKernel.getImpl()).setTime(*this, t);
 }
 
-double OpenMMContextImpl::getParameter(std::string name) {
+double ContextImpl::getParameter(std::string name) {
     if (parameters.find(name) == parameters.end())
         throw OpenMMException("Called getParameter() with invalid parameter name");
     return parameters[name];
 }
 
-void OpenMMContextImpl::setParameter(std::string name, double value) {
+void ContextImpl::setParameter(std::string name, double value) {
     if (parameters.find(name) == parameters.end())
         throw OpenMMException("Called setParameter() with invalid parameter name");
     parameters[name] = value;
 }
 
-void OpenMMContextImpl::calcForces() {
+void ContextImpl::calcForces() {
     dynamic_cast<InitializeForcesKernel&>(initializeForcesKernel.getImpl()).execute(*this);
     for (int i = 0; i < (int) forceImpls.size(); ++i)
         forceImpls[i]->calcForces(*this, forces);
 }
 
-double OpenMMContextImpl::calcKineticEnergy() {
+double ContextImpl::calcKineticEnergy() {
     return dynamic_cast<CalcKineticEnergyKernel&>(kineticEnergyKernel.getImpl()).execute(*this);
 }
 
-double OpenMMContextImpl::calcPotentialEnergy() {
+double ContextImpl::calcPotentialEnergy() {
     double energy = 0.0;
     for (int i = 0; i < (int) forceImpls.size(); ++i)
         energy += forceImpls[i]->calcEnergy(*this);
     return energy;
 }
 
-void OpenMMContextImpl::updateContextState() {
+void ContextImpl::updateContextState() {
     for (int i = 0; i < (int) forceImpls.size(); ++i)
         forceImpls[i]->updateContextState(*this);
 }
 
-void* OpenMMContextImpl::getPlatformData() {
+void* ContextImpl::getPlatformData() {
     return platformData;
 }
 
-void OpenMMContextImpl::setPlatformData(void* data) {
+void ContextImpl::setPlatformData(void* data) {
     platformData = data;
 }

openmmapi/src/PeriodicTorsionForceImpl.cpp

@@ -29,7 +29,7 @@
  * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
  * -------------------------------------------------------------------------- */
 
-#include "openmm/internal/OpenMMContextImpl.h"
+#include "openmm/internal/ContextImpl.h"
 #include "openmm/internal/PeriodicTorsionForceImpl.h"
 #include "openmm/kernels.h"
 
@@ -44,16 +44,16 @@ PeriodicTorsionForceImpl::PeriodicTorsionForceImpl(PeriodicTorsionForce& owner)
 PeriodicTorsionForceImpl::~PeriodicTorsionForceImpl() {
 }
 
-void PeriodicTorsionForceImpl::initialize(OpenMMContextImpl& context) {
+void PeriodicTorsionForceImpl::initialize(ContextImpl& context) {
     kernel = context.getPlatform().createKernel(CalcPeriodicTorsionForceKernel::Name(), context);
     dynamic_cast<CalcPeriodicTorsionForceKernel&>(kernel.getImpl()).initialize(context.getSystem(), owner);
 }
 
-void PeriodicTorsionForceImpl::calcForces(OpenMMContextImpl& context, Stream& forces) {
+void PeriodicTorsionForceImpl::calcForces(ContextImpl& context, Stream& forces) {
     dynamic_cast<CalcPeriodicTorsionForceKernel&>(kernel.getImpl()).executeForces(context);
 }
 
-double PeriodicTorsionForceImpl::calcEnergy(OpenMMContextImpl& context) {
+double PeriodicTorsionForceImpl::calcEnergy(ContextImpl& context) {
     return dynamic_cast<CalcPeriodicTorsionForceKernel&>(kernel.getImpl()).executeEnergy(context);
 }
 

openmmapi/src/RBTorsionForceImpl.cpp

@@ -29,7 +29,7 @@
  * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
  * -------------------------------------------------------------------------- */
 
-#include "openmm/internal/OpenMMContextImpl.h"
+#include "openmm/internal/ContextImpl.h"
 #include "openmm/internal/RBTorsionForceImpl.h"
 #include "openmm/kernels.h"
 
@@ -44,16 +44,16 @@ RBTorsionForceImpl::RBTorsionForceImpl(RBTorsionForce& owner) : owner(owner) {
 RBTorsionForceImpl::~RBTorsionForceImpl() {
 }
 
-void RBTorsionForceImpl::initialize(OpenMMContextImpl& context) {
+void RBTorsionForceImpl::initialize(ContextImpl& context) {
     kernel = context.getPlatform().createKernel(CalcRBTorsionForceKernel::Name(), context);
     dynamic_cast<CalcRBTorsionForceKernel&>(kernel.getImpl()).initialize(context.getSystem(), owner);
 }
 
-void RBTorsionForceImpl::calcForces(OpenMMContextImpl& context, Stream& forces) {
+void RBTorsionForceImpl::calcForces(ContextImpl& context, Stream& forces) {
     dynamic_cast<CalcRBTorsionForceKernel&>(kernel.getImpl()).executeForces(context);
 }
 
-double RBTorsionForceImpl::calcEnergy(OpenMMContextImpl& context) {
+double RBTorsionForceImpl::calcEnergy(ContextImpl& context) {
     return dynamic_cast<CalcRBTorsionForceKernel&>(kernel.getImpl()).executeEnergy(context);
 }
 

openmmapi/src/VariableLangevinIntegrator.cpp

@@ -30,8 +30,8 @@
  * -------------------------------------------------------------------------- */
 
 #include "openmm/VariableLangevinIntegrator.h"
-#include "openmm/OpenMMContext.h"
-#include "openmm/internal/OpenMMContextImpl.h"
+#include "openmm/Context.h"
+#include "openmm/internal/ContextImpl.h"
 #include "openmm/kernels.h"
 #include <limits>
 #include <string>
@@ -48,7 +48,7 @@ VariableLangevinIntegrator::VariableLangevinIntegrator(double temperature, doubl
     setRandomNumberSeed((int) time(NULL));
 }
 
-void VariableLangevinIntegrator::initialize(OpenMMContextImpl& contextRef) {
+void VariableLangevinIntegrator::initialize(ContextImpl& contextRef) {
     context = &contextRef;
     kernel = context->getPlatform().createKernel(IntegrateVariableLangevinStepKernel::Name(), contextRef);
     dynamic_cast<IntegrateVariableLangevinStepKernel&>(kernel.getImpl()).initialize(contextRef.getSystem(), *this);

openmmapi/src/VariableVerletIntegrator.cpp

@@ -30,8 +30,8 @@
  * -------------------------------------------------------------------------- */
 
 #include "openmm/VariableVerletIntegrator.h"
-#include "openmm/OpenMMContext.h"
-#include "openmm/internal/OpenMMContextImpl.h"
+#include "openmm/Context.h"
+#include "openmm/internal/ContextImpl.h"
 #include "openmm/kernels.h"
 #include <limits>
 #include <string>
@@ -44,7 +44,7 @@ VariableVerletIntegrator::VariableVerletIntegrator(double errorTol) : errorTol(e
     setConstraintTolerance(1e-4);
 }
 
-void VariableVerletIntegrator::initialize(OpenMMContextImpl& contextRef) {
+void VariableVerletIntegrator::initialize(ContextImpl& contextRef) {
     context = &contextRef;
     kernel = context->getPlatform().createKernel(IntegrateVariableVerletStepKernel::Name(), contextRef);
     dynamic_cast<IntegrateVariableVerletStepKernel&>(kernel.getImpl()).initialize(contextRef.getSystem(), *this);

openmmapi/src/VerletIntegrator.cpp

@@ -30,8 +30,8 @@
  * -------------------------------------------------------------------------- */
 
 #include "openmm/VerletIntegrator.h"
-#include "openmm/OpenMMContext.h"
-#include "openmm/internal/OpenMMContextImpl.h"
+#include "openmm/Context.h"
+#include "openmm/internal/ContextImpl.h"
 #include "openmm/kernels.h"
 #include <string>
 
@@ -44,7 +44,7 @@ VerletIntegrator::VerletIntegrator(double stepSize) {
     setConstraintTolerance(1e-4);
 }
 
-void VerletIntegrator::initialize(OpenMMContextImpl& contextRef) {
+void VerletIntegrator::initialize(ContextImpl& contextRef) {
     context = &contextRef;
     kernel = context->getPlatform().createKernel(IntegrateVerletStepKernel::Name(), contextRef);
     dynamic_cast<IntegrateVerletStepKernel&>(kernel.getImpl()).initialize(contextRef.getSystem(), *this);

platforms/brook/include/BrookKernelFactory.h

@@ -44,7 +44,7 @@ class BrookKernelFactory : public KernelFactory {
 
    public:
 
-      KernelImpl* createKernelImpl( std::string name, const Platform& platform, OpenMMContextImpl& context ) const;
+      KernelImpl* createKernelImpl( std::string name, const Platform& platform, ContextImpl& context ) const;
 };
 
 } // namespace OpenMM

platforms/brook/include/BrookPlatform.h

@@ -278,17 +278,17 @@ class OPENMM_EXPORT BrookPlatform : public Platform {
       FILE* getLog( void ) const;
       
       /** 
-       * This is called whenever a new OpenMMContext is created.  It gives the Platform a chance to initialize
+       * This is called whenever a new Context is created.  It gives the Platform a chance to initialize
        * the context and store platform-specific data in it.
        */
-      void contextCreated( OpenMMContextImpl& context ) const;
+      void contextCreated( ContextImpl& context ) const;
 
       /** 
-       * This is called whenever an OpenMMContext is deleted.  It gives the Platform a chance to clean up
+       * This is called whenever a Context is deleted.  It gives the Platform a chance to clean up
        * any platform-specific data that was stored in it.
        */
 
-      void contextDestroyed( OpenMMContextImpl& context ) const;
+      void contextDestroyed( ContextImpl& context ) const;
 
       /** 
        * Get minSuggestedThreads

platforms/brook/include/BrookStreamFactory.h

@@ -77,7 +77,7 @@ class OPENMM_EXPORT BrookStreamFactory : public StreamFactory {
        * @return StreamImpl
        */
       
-      StreamImpl* createStreamImpl( std::string name, int size, Stream::DataType type, const Platform& platform, OpenMMContextImpl& context ) const;
+      StreamImpl* createStreamImpl( std::string name, int size, Stream::DataType type, const Platform& platform, ContextImpl& context ) const;
 
       /** 
        * Create StreamImpl

platforms/brook/src/BrookBonded.h

@@ -31,7 +31,7 @@
 
 #include "BrookStreamImpl.h"
 #include "BrookCommon.h"
-#include "openmm/OpenMMContext.h"
+#include "openmm/Context.h"
 #include "BrookBondParameters.h"
 
 namespace OpenMM {

platforms/brook/src/BrookCalcGBSAOBCForceKernel.cpp

@@ -172,11 +172,11 @@ void BrookCalcGBSAOBCForceKernel::initialize( const System& system, const GBSAOB
 /** 
  * Compute forces given particle coordinates
  * 
- * @param context OpenMMContextImpl context
+ * @param context ContextImpl context
  *
  */
 
-void BrookCalcGBSAOBCForceKernel::executeForces( OpenMMContextImpl& context ){
+void BrookCalcGBSAOBCForceKernel::executeForces( ContextImpl& context ){
 
 // ---------------------------------------------------------------------------------------
 
@@ -193,13 +193,13 @@ void BrookCalcGBSAOBCForceKernel::executeForces( OpenMMContextImpl& context ){
 /**
  * Execute the kernel to calculate the OBC energy
  * 
- * @param context OpenMMContextImpl context
+ * @param context ContextImpl context
  *
  * @return energy
  *
  */
 
-double BrookCalcGBSAOBCForceKernel::executeEnergy( OpenMMContextImpl& context ){
+double BrookCalcGBSAOBCForceKernel::executeEnergy( ContextImpl& context ){
 
 // ---------------------------------------------------------------------------------------
 

platforms/brook/src/BrookCalcGBSAOBCForceKernel.h

@@ -72,7 +72,7 @@ class BrookCalcGBSAOBCForceKernel : public CalcGBSAOBCForceKernel {
        *
        */
 
-      void executeForces( OpenMMContextImpl& context );
+      void executeForces( ContextImpl& context );
   
       /**
        * Execute the kernel to calculate the energy.
@@ -84,7 +84,7 @@ class BrookCalcGBSAOBCForceKernel : public CalcGBSAOBCForceKernel {
        *
        */
 
-      double executeEnergy( OpenMMContextImpl& context );
+      double executeEnergy( ContextImpl& context );
 
       /** 
        * Set log file reference

platforms/brook/src/BrookCalcHarmonicAngleForceKernel.cpp

@@ -171,11 +171,11 @@ void BrookCalcHarmonicAngleForceKernel::initialize( const System& system, const
 /** 
  * Compute forces given particle coordinates
  * 
- * @param context OpenMMContextImpl context
+ * @param context ContextImpl context
  *
  */
 
-void BrookCalcHarmonicAngleForceKernel::executeForces( OpenMMContextImpl& context ){
+void BrookCalcHarmonicAngleForceKernel::executeForces( ContextImpl& context ){
 
 // ---------------------------------------------------------------------------------------
 
@@ -195,13 +195,13 @@ void BrookCalcHarmonicAngleForceKernel::executeForces( OpenMMContextImpl& contex
 /**
  * Execute the kernel to calculate the energy
  * 
- * @param context OpenMMContextImpl context
+ * @param context ContextImpl context
  *
  * @return  potential energy
  *
  */
 
-double BrookCalcHarmonicAngleForceKernel::executeEnergy( OpenMMContextImpl& context ){
+double BrookCalcHarmonicAngleForceKernel::executeEnergy( ContextImpl& context ){
 
 // ---------------------------------------------------------------------------------------
 

platforms/brook/src/BrookCalcHarmonicAngleForceKernel.h

@@ -72,7 +72,7 @@ class BrookCalcHarmonicAngleForceKernel : public CalcHarmonicAngleForceKernel {
        *
        */
 
-      void executeForces( OpenMMContextImpl& context );
+      void executeForces( ContextImpl& context );
   
       /**
        * Execute the kernel to calculate the energy.
@@ -83,7 +83,7 @@ class BrookCalcHarmonicAngleForceKernel : public CalcHarmonicAngleForceKernel {
        *
        */
 
-      double executeEnergy( OpenMMContextImpl& context );
+      double executeEnergy( ContextImpl& context );
 
       /** 
        * Set log file reference

platforms/brook/src/BrookCalcHarmonicBondForceKernel.cpp

@@ -177,11 +177,11 @@ void BrookCalcHarmonicBondForceKernel::initialize( const System& system, const H
 /** 
  * Compute forces given particle coordinates
  * 
- * @param context OpenMMContextImpl context
+ * @param context ContextImpl context
  *
  */
 
-void BrookCalcHarmonicBondForceKernel::executeForces( OpenMMContextImpl& context ){
+void BrookCalcHarmonicBondForceKernel::executeForces( ContextImpl& context ){
 
 // ---------------------------------------------------------------------------------------
 
@@ -201,13 +201,13 @@ void BrookCalcHarmonicBondForceKernel::executeForces( OpenMMContextImpl& context
 /**
  * Execute the kernel to calculate the energy
  * 
- * @param context OpenMMContextImpl context
+ * @param context ContextImpl context
  *
  * @return  potential energy
  *
  */
 
-double BrookCalcHarmonicBondForceKernel::executeEnergy( OpenMMContextImpl& context ){
+double BrookCalcHarmonicBondForceKernel::executeEnergy( ContextImpl& context ){
 
 // ---------------------------------------------------------------------------------------
 

platforms/brook/src/BrookCalcHarmonicBondForceKernel.h

@@ -72,7 +72,7 @@ class BrookCalcHarmonicBondForceKernel : public CalcHarmonicBondForceKernel {
        *
        */
 
-      void executeForces( OpenMMContextImpl& context );
+      void executeForces( ContextImpl& context );
   
       /**
        * Execute the kernel to calculate the energy.
@@ -83,7 +83,7 @@ class BrookCalcHarmonicBondForceKernel : public CalcHarmonicBondForceKernel {
        *
        */
 
-      double executeEnergy( OpenMMContextImpl& context );
+      double executeEnergy( ContextImpl& context );
 
       /** 
        * Set log file reference