Common compute framework to unify CUDA and OpenCL code (#2488)

* Began creating common compute framework to unify code between CUDA and OpenCL

* Began OpenCL implementation of common compute framework

* Common implementation of CMMotionRemover

* CUDA implementation of common compute interface

* Converted HarmonicBondForce to common compute API

* Converted standard bonded forces to common compute API

* Converted ExpressionUtilities to common compute API

* Created ComputeParameterSet

* Converted custom bonded forces to common compute API

* Converted CustomCentroidBondForce to common compute API

* Converted CustomManyParticleForce to common compute API

* Moved lots of duplicate code from CudaContext and OpenCLContext to ComputeContext

* Converted GayBerneForce to common compute API

* Removed obsolete kernels

* Converted verlet integrators to common compute API

* Converted Langevin and Brownian integrators to common compute API

* Converted CustomIntegrator to common compute API

* Converted CustomNonbondedForce to common compute API

* Removed uses of a deprecated API

* Fixed failing test cases

* Converted GBSAOBCForce to common compute API

* Began converting CustomGBForce to common compute API

* Finished converting CustomGBForce to common compute API

* Merged duplicated code in CudaIntegrationUtilities and OpenCLIntegrationUtilities

* Converted RMSDForce and AndersenThermostat to common compute API

* Converted CustomHbondForce to common compute API

* Merged scripts for encoding kernel sources

* Converted Drude plugin to common compute API

* Fixed errors in CMake scripts

* Attempt at fixing errors on Windows

* Added discussion of common compute API to developer guide

* Added Windows export macro for common classes

* Fixed error in CMMotionRemover

* Ubdated travis to newer Ubuntu version

* Fixed errors on CPU OpenCL

* Fixed Windows linking errors

* Added missing pragma for 32 bit atomics

* Replaced long long with mm_long

* More fixes to Windows linking

* Bug fix

platforms/common/include/openmm/common/NonbondedUtilities.h

+#ifndef OPENMM_NONBONDEDUTILITIES_H_
+#define OPENMM_NONBONDEDUTILITIES_H_
+
+/* -------------------------------------------------------------------------- *
+ *                                   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) 2009-2019 Stanford University and the Authors.      *
+ * Authors: Peter Eastman                                                     *
+ * Contributors:                                                              *
+ *                                                                            *
+ * This program is free software: you can redistribute it and/or modify       *
+ * it under the terms of the GNU Lesser General Public License as published   *
+ * by the Free Software Foundation, either version 3 of the License, or       *
+ * (at your option) any later version.                                        *
+ *                                                                            *
+ * This program is distributed in the hope that it will be useful,            *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of             *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *
+ * GNU Lesser General Public License for more details.                        *
+ *                                                                            *
+ * You should have received a copy of the GNU Lesser General Public License   *
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.      *
+ * -------------------------------------------------------------------------- */
+
+#include "openmm/common/ArrayInterface.h"
+#include "openmm/common/ComputeParameterInfo.h"
+#include <string>
+#include <vector>
+
+namespace OpenMM {
+
+/**
+ * This class provides a generic interface for calculating nonbonded interactions.  Clients only need
+ * to provide the code for evaluating a single interaction and the list of parameters it depends on.
+ * A complete kernel is then synthesized using an appropriate algorithm to evaluate all interactions on
+ * all atoms.  Call addInteraction() to define a nonbonded interaction, and addParameter() to define
+ * per-particle parameters that the interaction depends on.
+ *
+ * During each force or energy evaluation, the following sequence of steps takes place:
+ *
+ * 1. Data structures (e.g. neighbor lists) are calculated to allow nonbonded interactions to be evaluated
+ * quickly.
+ *
+ * 2. calcForcesAndEnergy() is called on each ForceImpl in the System.
+ *
+ * 3. Finally, the default interaction kernel is invoked to calculate all interactions that were added
+ * to it.
+ *
+ * This sequence means that the default interaction kernel may depend on quantities that were calculated
+ * by ForceImpls during calcForcesAndEnergy().
+ */
+
+class OPENMM_EXPORT_COMMON NonbondedUtilities {
+public:
+    virtual ~NonbondedUtilities() {
+    }
+    /**
+     * Add a nonbonded interaction to be evaluated by the default interaction kernel.
+     *
+     * @param usesCutoff     specifies whether a cutoff should be applied to this interaction
+     * @param usesPeriodic   specifies whether periodic boundary conditions should be applied to this interaction
+     * @param usesExclusions specifies whether this interaction uses exclusions.  If this is true, it must have identical exclusions to every other interaction.
+     * @param cutoffDistance the cutoff distance for this interaction (ignored if usesCutoff is false)
+     * @param exclusionList  for each atom, specifies the list of other atoms whose interactions should be excluded
+     * @param kernel         the code to evaluate the interaction
+     * @param forceGroup     the force group in which the interaction should be calculated
+     */
+    virtual void addInteraction(bool usesCutoff, bool usesPeriodic, bool usesExclusions, double cutoffDistance, const std::vector<std::vector<int> >& exclusionList, const std::string& kernel, int forceGroup) = 0;
+    /**
+     * Add a per-atom parameter that the default interaction kernel may depend on.
+     */
+    virtual void addParameter(ComputeParameterInfo parameter) = 0;
+    /**
+     * Add an array (other than a per-atom parameter) that should be passed as an argument to the default interaction kernel.
+     */
+    virtual void addArgument(ComputeParameterInfo parameter) = 0;
+    /**
+     * Register that the interaction kernel will be computing the derivative of the potential energy
+     * with respect to a parameter.
+     * 
+     * @param param   the name of the parameter
+     * @return the variable that will be used to accumulate the derivative.  Any code you pass to addInteraction() should
+     * add its contributions to this variable.
+     */
+    virtual std::string addEnergyParameterDerivative(const std::string& param) = 0;
+    /**
+     * Get the number of force buffers required for nonbonded forces.
+     */
+    virtual int getNumForceBuffers() const = 0;
+    /**
+     * Get whether a cutoff is being used.
+     */
+    virtual bool getUseCutoff() = 0;
+    /**
+     * Get whether periodic boundary conditions are being used.
+     */
+    virtual bool getUsePeriodic() = 0;
+    /**
+     * Get the number of thread blocks used for computing nonbonded forces.
+     */
+    virtual int getNumForceThreadBlocks() = 0;
+    /**
+     * Get the size of each thread block used for computing nonbonded forces.
+     */
+    virtual int getForceThreadBlockSize() = 0;
+    /**
+     * Get the maximum cutoff distance used by any interaction.
+     */
+    virtual double getMaxCutoffDistance() = 0;
+    /**
+     * Given a nonbonded cutoff, get the padded cutoff distance used in computing
+     * the neighbor list.
+     */
+    virtual double padCutoff(double cutoff) = 0;
+    /**
+     * Get the array containing the center of each atom block.
+     */
+    virtual ArrayInterface& getBlockCenters() = 0;
+    /**
+     * Get the array containing the dimensions of each atom block.
+     */
+    virtual ArrayInterface& getBlockBoundingBoxes() = 0;
+    /**
+     * Get the array whose first element contains the number of tiles with interactions.
+     */
+    virtual ArrayInterface& getInteractionCount() = 0;
+    /**
+     * Get the array containing tiles with interactions.
+     */
+    virtual ArrayInterface& getInteractingTiles() = 0;
+    /**
+     * Get the array containing the atoms in each tile with interactions.
+     */
+    virtual ArrayInterface& getInteractingAtoms() = 0;
+    /**
+     * Get the array containing exclusion flags.
+     */
+    virtual ArrayInterface& getExclusions() = 0;
+    /**
+     * Get the array containing tiles with exclusions.
+     */
+    virtual ArrayInterface& getExclusionTiles() = 0;
+    /**
+     * Get the array containing the index into the exclusion array for each tile.
+     */
+    virtual ArrayInterface& getExclusionIndices() = 0;
+    /**
+     * Get the array listing where the exclusion data starts for each row.
+     */
+    virtual ArrayInterface& getExclusionRowIndices() = 0;
+    /**
+     * Get the array containing a flag for whether the neighbor list was rebuilt
+     * on the most recent call to prepareInteractions().
+     */
+    virtual ArrayInterface& getRebuildNeighborList() = 0;
+};
+
+} // namespace OpenMM
+
+#endif /*OPENMM_NONBONDEDUTILITIES_H_*/

platforms/opencl/include/windowsExportOpenCL.h → platforms/common/include/openmm/common/windowsExportCommon.h

-#ifndef OPENMM_WINDOWSEXPORTOPENCL_H_
-#define OPENMM_WINDOWSEXPORTOPENCL_H_
-
-/*
- * Shared libraries are messy in Visual Studio. We have to distinguish three
- * cases:
- *   (1) this header is being used to build the OpenMM shared library
- *       (dllexport)
- *   (2) this header is being used by a *client* of the OpenMM shared
- *       library (dllimport)
- *   (3) we are building the OpenMM static library, or the client is
- *       being compiled with the expectation of linking with the
- *       OpenMM static library (nothing special needed)
- * In the CMake script for building this library, we define one of the symbols
- *     OPENMM_OPENCL_BUILDING_{SHARED|STATIC}_LIBRARY
- * Client code normally has no special symbol defined, in which case we'll
- * assume it wants to use the shared library. However, if the client defines
- * the symbol OPENMM_USE_STATIC_LIBRARIES we'll suppress the dllimport so
- * that the client code can be linked with static libraries. Note that
- * the client symbol is not library dependent, while the library symbols
- * affect only the OpenMM library, meaning that other libraries can
- * be clients of this one. However, we are assuming all-static or all-shared.
- */
-
-#ifdef _MSC_VER
-    // We don't want to hear about how sprintf is "unsafe".
-    #pragma warning(disable:4996)
-    // Keep MS VC++ quiet about lack of dll export of private members.
-    #pragma warning(disable:4251)
-    #if defined(OPENMM_OPENCL_BUILDING_SHARED_LIBRARY)
-        #define OPENMM_EXPORT_OPENCL __declspec(dllexport)
-    #elif defined(OPENMM_OPENCL_BUILDING_STATIC_LIBRARY) || defined(OPENMM_OPENCL_USE_STATIC_LIBRARIES)
-        #define OPENMM_EXPORT_OPENCL
-    #else
-        #define OPENMM_EXPORT_OPENCL __declspec(dllimport)   // i.e., a client of a shared library
-    #endif
-#else
-    #define OPENMM_EXPORT_OPENCL // Linux, Mac
-#endif
-
-#endif // OPENMM_WINDOWSEXPORTOPENCL_H_
+#ifndef OPENMM_WINDOWSEXPORTCOMMON_H_
+#define OPENMM_WINDOWSEXPORTCOMMON_H_
+
+/*
+ * Shared libraries are messy in Visual Studio. We have to distinguish three
+ * cases:
+ *   (1) this header is being used to build the OpenMM shared library
+ *       (dllexport)
+ *   (2) this header is being used by a *client* of the OpenMM shared
+ *       library (dllimport)
+ *   (3) we are building the OpenMM static library, or the client is
+ *       being compiled with the expectation of linking with the
+ *       OpenMM static library (nothing special needed)
+ * In the CMake script for building this library, we define one of the symbols
+ *     OPENMM_COMMON_BUILDING_{SHARED|STATIC}_LIBRARY
+ * Client code normally has no special symbol defined, in which case we'll
+ * assume it wants to use the shared library. However, if the client defines
+ * the symbol OPENMM_USE_STATIC_LIBRARIES we'll suppress the dllimport so
+ * that the client code can be linked with static libraries. Note that
+ * the client symbol is not library dependent, while the library symbols
+ * affect only the OpenMM library, meaning that other libraries can
+ * be clients of this one. However, we are assuming all-static or all-shared.
+ */
+
+#ifdef _MSC_VER
+    // We don't want to hear about how sprintf is "unsafe".
+    #pragma warning(disable:4996)
+    // Keep MS VC++ quiet about lack of dll export of private members.
+    #pragma warning(disable:4251)
+    #if defined(OPENMM_COMMON_BUILDING_SHARED_LIBRARY)
+        #define OPENMM_EXPORT_COMMON __declspec(dllexport)
+    #elif defined(OPENMM_COMMON_BUILDING_STATIC_LIBRARY) || defined(OPENMM_COMMON_USE_STATIC_LIBRARIES)
+        #define OPENMM_EXPORT_COMMON
+    #else
+        #define OPENMM_EXPORT_COMMON __declspec(dllimport)   // i.e., a client of a shared library
+    #endif
+#else
+    #define OPENMM_EXPORT_COMMON // Linux, Mac
+#endif
+
+#endif // OPENMM_WINDOWSEXPORTCOMMON_H_

plugins/drude/platforms/opencl/src/OpenCLDrudeKernelSources.cpp.in → platforms/common/src/CommonKernelSources.cpp.in

@@ -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 Stanford University and the Authors.           *
+ * Portions copyright (c) 2019 Stanford University and the Authors.           *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -24,7 +24,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.      *
  * -------------------------------------------------------------------------- */
 
-#include "OpenCLDrudeKernelSources.h"
+#include "CommonKernelSources.h"
 
 using namespace OpenMM;
 using namespace std;

plugins/drude/platforms/opencl/src/OpenCLDrudeKernelSources.h.in → platforms/common/src/CommonKernelSources.h.in

-#ifndef OPENMM_OPENCLDRUDEKERNELSOURCES_H_
-#define OPENMM_OPENCLDRUDEKERNELSOURCES_H_
+#ifndef OPENMM_COMMONKERNELSOURCES_H_
+#define OPENMM_COMMONKERNELSOURCES_H_
 
 /* -------------------------------------------------------------------------- *
  *                                   OpenMM                                   *
@@ -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) 2010 Stanford University and the Authors.           *
+ * Portions copyright (c) 2019 Stanford University and the Authors.           *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -27,21 +27,22 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.      *
  * -------------------------------------------------------------------------- */
 
+#include "openmm/common/windowsExportCommon.h"
 #include <string>
 
 namespace OpenMM {
 
 /**
- * This class is a central holding place for the source code of OpenCL kernels.
- * The CMake build script inserts declarations into it based on the .cu files in the
+ * This class is a central holding place for the source code of common kernels.
+ * The CMake build script inserts declarations into it based on the .cc files in the
  * kernels subfolder.
  */
 
-class OpenCLDrudeKernelSources {
+class OPENMM_EXPORT_COMMON CommonKernelSources {
 public:
-@CL_FILE_DECLARATIONS@
+@KERNEL_FILE_DECLARATIONS@
 };
 
 } // namespace OpenMM
 
-#endif /*OPENMM_OPENCLDRUDEKERNELSOURCES_H_*/
+#endif /*OPENMM_COMMONKERNELSOURCES_H_*/

platforms/common/src/ComputeArray.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: Peter Eastman                                                     *
+ * Contributors:                                                              *
+ *                                                                            *
+ * This program is free software: you can redistribute it and/or modify       *
+ * it under the terms of the GNU Lesser General Public License as published   *
+ * by the Free Software Foundation, either version 3 of the License, or       *
+ * (at your option) any later version.                                        *
+ *                                                                            *
+ * This program is distributed in the hope that it will be useful,            *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of             *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *
+ * GNU Lesser General Public License for more details.                        *
+ *                                                                            *
+ * You should have received a copy of the GNU Lesser General Public License   *
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.      *
+ * -------------------------------------------------------------------------- */
+
+#include "openmm/common/ComputeArray.h"
+#include "openmm/common/ComputeContext.h"
+
+using namespace OpenMM;
+
+ComputeArray::ComputeArray() : impl(NULL) {
+}
+
+ComputeArray::~ComputeArray() {
+    if (impl != NULL)
+        delete impl;
+}
+
+ArrayInterface& ComputeArray::getArray() {
+    if (impl == NULL)
+        throw OpenMMException("ComputeArray has not been initialized");
+    return *impl;
+}
+
+void ComputeArray::initialize(ComputeContext& context, int size, int elementSize, const std::string& name) {
+    if (impl != NULL)
+        throw OpenMMException("The array "+getName()+" has already been initialized");
+    impl = context.createArray();
+    impl->initialize(context, size, elementSize, name);
+}
+
+void ComputeArray::resize(int size) {
+    if (impl == NULL)
+        throw OpenMMException("ComputeArray has not been initialized");
+    impl->resize(size);
+}
+
+bool ComputeArray::isInitialized() const {
+    return (impl != NULL);
+}
+
+int ComputeArray::getSize() const {
+    if (impl == NULL)
+        throw OpenMMException("ComputeArray has not been initialized");
+    return impl->getSize();
+}
+
+int ComputeArray::getElementSize() const {
+    if (impl == NULL)
+        throw OpenMMException("ComputeArray has not been initialized");
+    return impl->getElementSize();
+}
+
+const std::string& ComputeArray::getName() const {
+    if (impl == NULL)
+        throw OpenMMException("ComputeArray has not been initialized");
+    return impl->getName();
+}
+
+ComputeContext& ComputeArray::getContext() {
+    if (impl == NULL)
+        throw OpenMMException("ComputeArray has not been initialized");
+    return impl->getContext();
+}
+
+void ComputeArray::upload(const void* data, bool blocking) {
+    if (impl == NULL)
+        throw OpenMMException("ComputeArray has not been initialized");
+    impl->upload(data, blocking);
+}
+
+void ComputeArray::download(void* data, bool blocking) const {
+    if (impl == NULL)
+        throw OpenMMException("ComputeArray has not been initialized");
+    impl->download(data, blocking);
+}
+
+void ComputeArray::copyTo(ArrayInterface& dest) const {
+    if (impl == NULL)
+        throw OpenMMException("ComputeArray has not been initialized");
+    impl->copyTo(dest);
+}
\ No newline at end of file

platforms/opencl/src/OpenCLForceInfo.cpp → platforms/common/src/ComputeForceInfo.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) 2009 Stanford University and the Authors.           *
+ * Portions copyright (c) 2012-2019 Stanford University and the Authors.      *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -24,23 +24,23 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.      *
  * -------------------------------------------------------------------------- */
 
-#include "OpenCLForceInfo.h"
+#include "openmm/common/ComputeForceInfo.h"
 
 using namespace OpenMM;
 using namespace std;
 
-bool OpenCLForceInfo::areParticlesIdentical(int particle1, int particle2) {
+bool ComputeForceInfo::areParticlesIdentical(int particle1, int particle2) {
     return true;
 }
 
-int OpenCLForceInfo::getNumParticleGroups() {
+int ComputeForceInfo::getNumParticleGroups() {
     return 0;
 }
 
-void OpenCLForceInfo::getParticlesInGroup(int index, vector<int>& particles) {
+void ComputeForceInfo::getParticlesInGroup(int index, vector<int>& particles) {
     return;
 }
 
-bool OpenCLForceInfo::areGroupsIdentical(int group1, int group2) {
+bool ComputeForceInfo::areGroupsIdentical(int group1, int group2) {
     return true;
 }

platforms/cuda/src/CudaExpressionUtilities.cpp → platforms/common/src/ExpressionUtilities.cpp

@@ -24,7 +24,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.      *
  * -------------------------------------------------------------------------- */
 
-#include "CudaExpressionUtilities.h"
+#include "openmm/common/ExpressionUtilities.h"
 #include "openmm/OpenMMException.h"
 #include "openmm/internal/SplineFitter.h"
 #include "lepton/Operation.h"
@@ -33,10 +33,10 @@ using namespace OpenMM;
 using namespace Lepton;
 using namespace std;
 
-CudaExpressionUtilities::CudaExpressionUtilities(CudaContext& context) : context(context), fp1(1), fp2(2), fp3(3), periodicDistance(6) {
+ExpressionUtilities::ExpressionUtilities(ComputeContext& context) : context(context), fp1(1), fp2(2), fp3(3), periodicDistance(6) {
 }
 
-string CudaExpressionUtilities::createExpressions(const map<string, ParsedExpression>& expressions, const map<string, string>& variables,
+string ExpressionUtilities::createExpressions(const map<string, ParsedExpression>& expressions, const map<string, string>& variables,
         const vector<const TabulatedFunction*>& functions, const vector<pair<string, string> >& functionNames, const string& prefix, const string& tempType) {
     vector<pair<ExpressionTreeNode, string> > variableNodes;
     for (map<string, string>::const_iterator iter = variables.begin(); iter != variables.end(); ++iter)
@@ -44,7 +44,7 @@ string CudaExpressionUtilities::createExpressions(const map<string, ParsedExpres
     return createExpressions(expressions, variableNodes, functions, functionNames, prefix, tempType);
 }
 
-string CudaExpressionUtilities::createExpressions(const map<string, ParsedExpression>& expressions, const vector<pair<ExpressionTreeNode, string> >& variables,
+string ExpressionUtilities::createExpressions(const map<string, ParsedExpression>& expressions, const vector<pair<ExpressionTreeNode, string> >& variables,
         const vector<const TabulatedFunction*>& functions, const vector<pair<string, string> >& functionNames, const string& prefix, const string& tempType) {
     stringstream out;
     vector<ParsedExpression> allExpressions;
@@ -59,7 +59,7 @@ string CudaExpressionUtilities::createExpressions(const map<string, ParsedExpres
     return out.str();
 }
 
-void CudaExpressionUtilities::processExpression(stringstream& out, const ExpressionTreeNode& node, vector<pair<ExpressionTreeNode, string> >& temps,
+void ExpressionUtilities::processExpression(stringstream& out, const ExpressionTreeNode& node, vector<pair<ExpressionTreeNode, string> >& temps,
         const vector<const TabulatedFunction*>& functions, const vector<pair<string, string> >& functionNames, const string& prefix, const vector<vector<double> >& functionParams,
         const vector<ParsedExpression>& allExpressions, const string& tempType) {
     for (int i = 0; i < (int) temps.size(); i++)
@@ -662,7 +662,7 @@ void CudaExpressionUtilities::processExpression(stringstream& out, const Express
         temps.push_back(make_pair(node, name));
 }
 
-string CudaExpressionUtilities::getTempName(const ExpressionTreeNode& node, const vector<pair<ExpressionTreeNode, string> >& temps) {
+string ExpressionUtilities::getTempName(const ExpressionTreeNode& node, const vector<pair<ExpressionTreeNode, string> >& temps) {
     for (int i = 0; i < (int) temps.size(); i++)
         if (temps[i].first == node)
             return temps[i].second;
@@ -671,7 +671,7 @@ string CudaExpressionUtilities::getTempName(const ExpressionTreeNode& node, cons
     throw OpenMMException(out.str());
 }
 
-void CudaExpressionUtilities::findRelatedCustomFunctions(const ExpressionTreeNode& node, const ExpressionTreeNode& searchNode,
+void ExpressionUtilities::findRelatedCustomFunctions(const ExpressionTreeNode& node, const ExpressionTreeNode& searchNode,
             vector<const Lepton::ExpressionTreeNode*>& nodes) {
     if (searchNode.getOperation().getId() == Operation::CUSTOM && node.getOperation().getName() == searchNode.getOperation().getName()) {
         // Make sure the arguments are identical.
@@ -695,7 +695,7 @@ void CudaExpressionUtilities::findRelatedCustomFunctions(const ExpressionTreeNod
             findRelatedCustomFunctions(node, searchNode.getChildren()[i], nodes);
 }
 
-void CudaExpressionUtilities::findRelatedPowers(const ExpressionTreeNode& node, const ExpressionTreeNode& searchNode, map<int, const ExpressionTreeNode*>& powers) {
+void ExpressionUtilities::findRelatedPowers(const ExpressionTreeNode& node, const ExpressionTreeNode& searchNode, map<int, const ExpressionTreeNode*>& powers) {
     if (searchNode.getOperation().getId() == Operation::POWER_CONSTANT && node.getChildren()[0] == searchNode.getChildren()[0]) {
         double realPower = dynamic_cast<const Operation::PowerConstant*>(&searchNode.getOperation())->getValue();
         int power = (int) realPower;
@@ -712,7 +712,7 @@ void CudaExpressionUtilities::findRelatedPowers(const ExpressionTreeNode& node,
             findRelatedPowers(node, searchNode.getChildren()[i], powers);
 }
 
-vector<float> CudaExpressionUtilities::computeFunctionCoefficients(const TabulatedFunction& function, int& width) {
+vector<float> ExpressionUtilities::computeFunctionCoefficients(const TabulatedFunction& function, int& width) {
     if (dynamic_cast<const Continuous1DFunction*>(&function) != NULL) {
         // Compute the spline coefficients.
 
@@ -827,7 +827,7 @@ vector<float> CudaExpressionUtilities::computeFunctionCoefficients(const Tabulat
     throw OpenMMException("computeFunctionCoefficients: Unknown function type");
 }
 
-vector<vector<double> > CudaExpressionUtilities::computeFunctionParameters(const vector<const TabulatedFunction*>& functions) {
+vector<vector<double> > ExpressionUtilities::computeFunctionParameters(const vector<const TabulatedFunction*>& functions) {
     vector<vector<double> > params(functions.size());
     for (int i = 0; i < (int) functions.size(); i++) {
         if (dynamic_cast<const Continuous1DFunction*>(functions[i]) != NULL) {
@@ -903,7 +903,7 @@ vector<vector<double> > CudaExpressionUtilities::computeFunctionParameters(const
     return params;
 }
 
-Lepton::CustomFunction* CudaExpressionUtilities::getFunctionPlaceholder(const TabulatedFunction& function) {
+Lepton::CustomFunction* ExpressionUtilities::getFunctionPlaceholder(const TabulatedFunction& function) {
     if (dynamic_cast<const Continuous1DFunction*>(&function) != NULL)
         return &fp1;
     if (dynamic_cast<const Continuous2DFunction*>(&function) != NULL)
@@ -919,11 +919,11 @@ Lepton::CustomFunction* CudaExpressionUtilities::getFunctionPlaceholder(const Ta
     throw OpenMMException("getFunctionPlaceholder: Unknown function type");
 }
 
-Lepton::CustomFunction* CudaExpressionUtilities::getPeriodicDistancePlaceholder() {
+Lepton::CustomFunction* ExpressionUtilities::getPeriodicDistancePlaceholder() {
     return &periodicDistance;
 }
 
-void CudaExpressionUtilities::callFunction(stringstream& out, string singleFn, string doubleFn, const string& arg, const string& tempType) {
+void ExpressionUtilities::callFunction(stringstream& out, string singleFn, string doubleFn, const string& arg, const string& tempType) {
     bool isDouble = (tempType[0] == 'd');
     bool isVector = (tempType[tempType.size()-1] == '3');
     string fn = (isDouble ? doubleFn : singleFn);
@@ -933,7 +933,7 @@ void CudaExpressionUtilities::callFunction(stringstream& out, string singleFn, s
         out<<fn<<"("<<arg<<")";
 }
 
-void CudaExpressionUtilities::callFunction2(stringstream& out, string singleFn, string doubleFn, const string& arg1, const string& arg2, const string& tempType) {
+void ExpressionUtilities::callFunction2(stringstream& out, string singleFn, string doubleFn, const string& arg1, const string& arg2, const string& tempType) {
     bool isDouble = (tempType[0] == 'd');
     bool isVector = (tempType[tempType.size()-1] == '3');
     string fn = (isDouble ? doubleFn : singleFn);

platforms/cuda/src/kernels/andersenThermostat.cu → platforms/common/src/kernels/andersenThermostat.cc

@@ -2,11 +2,11 @@
  * Apply the Andersen thermostat to adjust particle velocities.
  */
 
-extern "C" __global__ void applyAndersenThermostat(int numAtoms, float collisionFrequency, float kT, mixed4* velm, const mixed4* __restrict__ stepSize, const float4* __restrict__ random,
-        unsigned int randomIndex, const int* __restrict__ atomGroups) {
-    float collisionProbability = 1.0f-expf(-(float) (collisionFrequency*stepSize[0].y));
-    float randomRange = erff(collisionProbability/sqrtf(2.0f));
-    for (int index = blockIdx.x*blockDim.x+threadIdx.x; index < numAtoms; index += blockDim.x*gridDim.x) {
+KERNEL void applyAndersenThermostat(int numAtoms, float collisionFrequency, float kT, GLOBAL mixed4* velm, real stepSize, GLOBAL const float4* RESTRICT random,
+        unsigned int randomIndex, GLOBAL const int* RESTRICT atomGroups) {
+    float collisionProbability = (float) (1-EXP(-collisionFrequency*stepSize));
+    float randomRange = (float) erf(collisionProbability/SQRT(2.0f));
+    for (int index = GLOBAL_ID; index < numAtoms; index += GLOBAL_SIZE) {
         mixed4 velocity = velm[index];
         float4 selectRand = random[randomIndex+atomGroups[index]];
         float4 velRand = random[randomIndex+index];

platforms/common/src/kernels/angleForce.cc

+real3 v0 = make_real3(pos2.x-pos1.x, pos2.y-pos1.y, pos2.z-pos1.z);
+real3 v1 = make_real3(pos2.x-pos3.x, pos2.y-pos3.y, pos2.z-pos3.z);
+#if APPLY_PERIODIC
+APPLY_PERIODIC_TO_DELTA(v0)
+APPLY_PERIODIC_TO_DELTA(v1)
+#endif
+real3 cp = cross(v0, v1);
+real rp = cp.x*cp.x + cp.y*cp.y + cp.z*cp.z;
+rp = max(SQRT(rp), (real) 1.0e-06f);
+real r21 = v0.x*v0.x + v0.y*v0.y + v0.z*v0.z;
+real r23 = v1.x*v1.x + v1.y*v1.y + v1.z*v1.z;
+real dot = v0.x*v1.x + v0.y*v1.y + v0.z*v1.z;
+real cosine = min(max(dot*RSQRT(r21*r23), (real) -1), (real) 1);
+real theta = ACOS(cosine);
+COMPUTE_FORCE
+real3 force1 = cross(v0, cp)*(dEdAngle/(r21*rp));
+real3 force3 = cross(cp, v1)*(dEdAngle/(r23*rp));
+real3 force2 = -force1-force3;