Began converting AMOEBA to the new CUDA platform: AmoebaHarmonicBondForce,...

Began converting AMOEBA to the new CUDA platform: AmoebaHarmonicBondForce, AmoebaHarmonicAngleForce, AmoebaHarmonicInPlaneAngleForce, AmoebaPiTorsionForce

plugins/amoeba/platforms/cuda2/CMakeLists.txt

+#---------------------------------------------------
+# OpenMM CUDA Amoeba Implementation
+#
+# Creates OpenMM library, base name=OpenMMAmoebaCUDA.
+# Default libraries are shared & optimized. Variants
+# are created for debug (_d).
+#
+# Windows:
+#   OpenMMAmoebaCUDA[_d].dll
+#   OpenMMAmoebaCUDA[_d].lib
+# Unix:
+#   libOpenMMAmoebaCUDA[_d].so
+#----------------------------------------------------
+
+# The source is organized into subdirectories, but we handle them all from
+# this CMakeLists file rather than letting CMake visit them as SUBDIRS.
+SET(OPENMM_SOURCE_SUBDIRS .)
+
+
+# Collect up information about the version of the OpenMM library we're building
+# and make it available to the code so it can be built into the binaries.
+
+SET(OPENMMAMOEBACUDA_LIBRARY_NAME OpenMMAmoebaCUDA)
+
+SET(SHARED_TARGET ${OPENMMAMOEBACUDA_LIBRARY_NAME})
+
+
+# Ensure that debug libraries have "_d" appended to their names.
+# CMake gets this right on Windows automatically with this definition.
+IF (${CMAKE_GENERATOR} MATCHES "Visual Studio")
+    SET(CMAKE_DEBUG_POSTFIX "_d" CACHE INTERNAL "" FORCE)
+ENDIF (${CMAKE_GENERATOR} MATCHES "Visual Studio")
+
+# But on Unix or Cygwin we have to add the suffix manually
+IF (UNIX AND CMAKE_BUILD_TYPE MATCHES Debug)
+    SET(SHARED_TARGET ${SHARED_TARGET}_d)
+ENDIF (UNIX AND CMAKE_BUILD_TYPE MATCHES Debug)
+
+
+# These are all the places to search for header files which are
+# to be part of the API.
+SET(API_INCLUDE_DIRS) # start empty
+FOREACH(subdir ${OPENMM_SOURCE_SUBDIRS})
+    # append
+    SET(API_INCLUDE_DIRS ${API_INCLUDE_DIRS}
+                         ${CMAKE_CURRENT_SOURCE_DIR}/${subdir}/include
+                         ${CMAKE_CURRENT_SOURCE_DIR}/${subdir}/include/internal)
+ENDFOREACH(subdir)
+
+# We'll need both *relative* path names, starting with their API_INCLUDE_DIRS,
+# and absolute pathnames.
+SET(API_REL_INCLUDE_FILES)   # start these out empty
+SET(API_ABS_INCLUDE_FILES)
+
+FOREACH(dir ${API_INCLUDE_DIRS})
+    FILE(GLOB fullpaths ${dir}/*.h)	# returns full pathnames
+    SET(API_ABS_INCLUDE_FILES ${API_ABS_INCLUDE_FILES} ${fullpaths})
+
+    FOREACH(pathname ${fullpaths})
+        GET_FILENAME_COMPONENT(filename ${pathname} NAME)
+        SET(API_REL_INCLUDE_FILES ${API_REL_INCLUDE_FILES} ${dir}/${filename})
+    ENDFOREACH(pathname)
+ENDFOREACH(dir)
+
+# collect up source files
+SET(SOURCE_FILES) # empty
+SET(SOURCE_INCLUDE_FILES)
+
+FOREACH(subdir ${OPENMM_SOURCE_SUBDIRS})
+    FILE(GLOB_RECURSE src_files  ${CMAKE_CURRENT_SOURCE_DIR}/${subdir}/src/*.cpp ${CMAKE_CURRENT_SOURCE_DIR}/${subdir}/src/*.c)
+    FILE(GLOB incl_files ${CMAKE_CURRENT_SOURCE_DIR}/${subdir}/src/*.h)
+    SET(SOURCE_FILES         ${SOURCE_FILES}         ${src_files})   #append
+    SET(SOURCE_INCLUDE_FILES ${SOURCE_INCLUDE_FILES} ${incl_files})
+    INCLUDE_DIRECTORIES(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/${subdir}/include)
+ENDFOREACH(subdir)
+
+INCLUDE_DIRECTORIES(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/src)
+INCLUDE_DIRECTORIES(BEFORE ${CMAKE_SOURCE_DIR}/platforms/cuda2/include)
+INCLUDE_DIRECTORIES(BEFORE ${CMAKE_SOURCE_DIR}/platforms/cuda2/src)
+INCLUDE_DIRECTORIES(BEFORE ${CMAKE_BINARY_DIR}/platforms/cuda2/src)
+
+# Set variables needed for encoding kernel sources into a C++ class
+
+SET(CUDA_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src)
+SET(CUDA_SOURCE_CLASS CudaAmoebaKernelSources)
+SET(CUDA_KERNELS_CPP ${CMAKE_CURRENT_BINARY_DIR}/src/${CUDA_SOURCE_CLASS}.cpp)
+SET(CUDA_KERNELS_H ${CMAKE_CURRENT_BINARY_DIR}/src/${CUDA_SOURCE_CLASS}.h)
+SET(SOURCE_FILES ${SOURCE_FILES} ${CUDA_KERNELS_CPP} ${CUDA_KERNELS_H})
+INCLUDE_DIRECTORIES(BEFORE ${CMAKE_CURRENT_BINARY_DIR}/src)
+
+# Create the library
+
+INCLUDE_DIRECTORIES(${CUDA_TOOLKIT_INCLUDE})
+
+FILE(GLOB CUDA_KERNELS ${CUDA_SOURCE_DIR}/kernels/*.cu)
+ADD_CUSTOM_COMMAND(OUTPUT ${CUDA_KERNELS_CPP} ${CUDA_KERNELS_H}
+    COMMAND ${CMAKE_COMMAND}
+    ARGS -D CUDA_SOURCE_DIR=${CUDA_SOURCE_DIR} -D CUDA_KERNELS_CPP=${CUDA_KERNELS_CPP} -D CUDA_KERNELS_H=${CUDA_KERNELS_H} -D CUDA_SOURCE_CLASS=${CUDA_SOURCE_CLASS} -P ${CMAKE_SOURCE_DIR}/platforms/cuda2/EncodeCUDAFiles.cmake
+    DEPENDS ${CUDA_KERNELS}
+)
+SET_SOURCE_FILES_PROPERTIES(${CUDA_KERNELS_CPP} ${CUDA_KERNELS_H} PROPERTIES GENERATED TRUE)
+ADD_LIBRARY(${SHARED_TARGET} SHARED ${SOURCE_FILES} ${SOURCE_INCLUDE_FILES} ${API_ABS_INCLUDE_FILES})
+
+IF (UNIX AND CMAKE_BUILD_TYPE MATCHES Debug)
+    SET(MAIN_OPENMM_LIB ${OPENMM_LIBRARY_NAME}_d)
+ELSE (UNIX AND CMAKE_BUILD_TYPE MATCHES Debug)
+    SET(MAIN_OPENMM_LIB ${OPENMM_LIBRARY_NAME})
+ENDIF (UNIX AND CMAKE_BUILD_TYPE MATCHES Debug)
+TARGET_LINK_LIBRARIES(${SHARED_TARGET} ${MAIN_OPENMM_LIB}  ${CUDA_LIBRARIES} ${PTHREADS_LIB})
+TARGET_LINK_LIBRARIES(${SHARED_TARGET} debug ${OPENMM_LIBRARY_NAME}CUDA_d optimized ${OPENMM_LIBRARY_NAME}CUDA)
+TARGET_LINK_LIBRARIES(${SHARED_TARGET} debug ${SHARED_AMOEBA_TARGET} optimized ${SHARED_AMOEBA_TARGET})
+SET_TARGET_PROPERTIES(${SHARED_TARGET} PROPERTIES COMPILE_FLAGS "-DOPENMM_BUILDING_SHARED_LIBRARY")
+
+INSTALL(TARGETS ${SHARED_TARGET} DESTINATION ${CMAKE_INSTALL_PREFIX}/lib/plugins)
+# Ensure that links to the main CUDA library will be resolved.
+IF (APPLE)
+    IF (CMAKE_BUILD_TYPE MATCHES Debug)
+        SET(CUDA_LIBRARY libOpenMMCUDA_d.dylib)
+    ELSE (CMAKE_BUILD_TYPE MATCHES Debug)
+        SET(CUDA_LIBRARY libOpenMMCUDA.dylib)
+    ENDIF (CMAKE_BUILD_TYPE MATCHES Debug)
+    INSTALL(CODE "EXECUTE_PROCESS(COMMAND install_name_tool -change ${CUDA_LIBRARY} @loader_path/${CUDA_LIBRARY} ${CMAKE_INSTALL_PREFIX}/lib/plugins/lib${SHARED_TARGET}.dylib)")
+ENDIF (APPLE)
+SUBDIRS (tests)

plugins/amoeba/platforms/cuda2/include/AmoebaCudaKernelFactory.h

+#ifndef AMOEBA_OPENMM_CUDAKERNELFACTORY_H_
+#define AMOEBA_OPENMM_CUDAKERNELFACTORY_H_
+
+/* -------------------------------------------------------------------------- *
+ *                            OpenMMAmoeba                                    *
+ * -------------------------------------------------------------------------- *
+ * 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) 2008 Stanford University and the Authors.           *
+ * Authors:                                                                   *
+ * 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/KernelFactory.h"
+
+namespace OpenMM {
+
+/**
+ * This KernelFactory creates all kernels for AmoebaCudaPlatform.
+ */
+
+class AmoebaCudaKernelFactory : public KernelFactory {
+public:
+    KernelImpl* createKernelImpl(std::string name, const Platform& platform, ContextImpl& context) const;
+};
+
+} // namespace OpenMM
+
+#endif /*AMOEBA_OPENMM_CUDAKERNELFACTORY_H_*/

plugins/amoeba/platforms/cuda2/src/AmoebaCudaKernelFactory.cpp

+/* -------------------------------------------------------------------------- *
+ *                              OpenMMAmoeba                                  *
+ * -------------------------------------------------------------------------- *
+ * 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) 2008-2012 Stanford University and the Authors.      *
+ * Authors: Mark Friedrichs, 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 "AmoebaCudaKernelFactory.h"
+#include "AmoebaCudaKernels.h"
+#include "CudaPlatform.h"
+#include "openmm/internal/ContextImpl.h"
+#include "openmm/OpenMMException.h"
+#include "openmm/internal/windowsExport.h"
+
+using namespace OpenMM;
+
+extern "C" void registerPlatforms() {
+}
+
+extern "C" OPENMM_EXPORT void registerKernelFactories() {
+    try {
+        Platform& platform = Platform::getPlatformByName("CUDA");
+        AmoebaCudaKernelFactory* factory = new AmoebaCudaKernelFactory();
+        platform.registerKernelFactory(CalcAmoebaHarmonicBondForceKernel::Name(), factory);
+        platform.registerKernelFactory(CalcAmoebaUreyBradleyForceKernel::Name(), factory);
+        platform.registerKernelFactory(CalcAmoebaHarmonicAngleForceKernel::Name(), factory);
+        platform.registerKernelFactory(CalcAmoebaHarmonicInPlaneAngleForceKernel::Name(), factory);
+        platform.registerKernelFactory(CalcAmoebaTorsionForceKernel::Name(), factory);
+        platform.registerKernelFactory(CalcAmoebaPiTorsionForceKernel::Name(), factory);
+        platform.registerKernelFactory(CalcAmoebaStretchBendForceKernel::Name(), factory);
+        platform.registerKernelFactory(CalcAmoebaOutOfPlaneBendForceKernel::Name(), factory);
+        platform.registerKernelFactory(CalcAmoebaTorsionTorsionForceKernel::Name(), factory);
+        platform.registerKernelFactory(CalcAmoebaMultipoleForceKernel::Name(), factory);
+        platform.registerKernelFactory(CalcAmoebaGeneralizedKirkwoodForceKernel::Name(), factory);
+        platform.registerKernelFactory(CalcAmoebaVdwForceKernel::Name(), factory);
+        platform.registerKernelFactory(CalcAmoebaWcaDispersionForceKernel::Name(), factory);
+    }
+    catch (...) {
+        // Ignore.  The CUDA platform isn't available.
+    }
+}
+
+extern "C" OPENMM_EXPORT void registerAmoebaCudaKernelFactories() {
+    try {
+        Platform::getPlatformByName("CUDA");
+    }
+    catch (...) {
+        Platform::registerPlatform(new CudaPlatform());
+    }
+    registerKernelFactories();
+}
+
+KernelImpl* AmoebaCudaKernelFactory::createKernelImpl(std::string name, const Platform& platform, ContextImpl& context) const {
+    CudaPlatform::PlatformData& data = *static_cast<CudaPlatform::PlatformData*>(context.getPlatformData());
+    CudaContext& cu = *data.contexts[0];
+
+    if (name == CalcAmoebaHarmonicBondForceKernel::Name())
+        return new CudaCalcAmoebaHarmonicBondForceKernel(name, platform, cu, context.getSystem());
+
+    if (name == CalcAmoebaHarmonicAngleForceKernel::Name())
+        return new CudaCalcAmoebaHarmonicAngleForceKernel(name, platform, cu, context.getSystem());
+
+    if (name == CalcAmoebaHarmonicInPlaneAngleForceKernel::Name())
+        return new CudaCalcAmoebaHarmonicInPlaneAngleForceKernel(name, platform, cu, context.getSystem());
+
+//    if (name == CalcAmoebaTorsionForceKernel::Name())
+//        return new CudaCalcAmoebaTorsionForceKernel(name, platform, cu, context.getSystem());
+
+    if (name == CalcAmoebaPiTorsionForceKernel::Name())
+        return new CudaCalcAmoebaPiTorsionForceKernel(name, platform, cu, context.getSystem());
+
+//    if (name == CalcAmoebaStretchBendForceKernel::Name())
+//        return new CudaCalcAmoebaStretchBendForceKernel(name, platform, cu, context.getSystem());
+//
+//    if (name == CalcAmoebaOutOfPlaneBendForceKernel::Name())
+//        return new CudaCalcAmoebaOutOfPlaneBendForceKernel(name, platform, cu, context.getSystem());
+//
+//    if (name == CalcAmoebaTorsionTorsionForceKernel::Name())
+//        return new CudaCalcAmoebaTorsionTorsionForceKernel(name, platform, cu, context.getSystem());
+//
+//    if (name == CalcAmoebaMultipoleForceKernel::Name())
+//        return new CudaCalcAmoebaMultipoleForceKernel(name, platform, cu, context.getSystem());
+//
+//    if (name == CalcAmoebaGeneralizedKirkwoodForceKernel::Name())
+//        return new CudaCalcAmoebaGeneralizedKirkwoodForceKernel(name, platform, cu, context.getSystem());
+//
+//    if (name == CalcAmoebaVdwForceKernel::Name())
+//        return new CudaCalcAmoebaVdwForceKernel(name, platform, cu, context.getSystem());
+//
+//    if (name == CalcAmoebaWcaDispersionForceKernel::Name())
+//        return new CudaCalcAmoebaWcaDispersionForceKernel(name, platform, cu, context.getSystem());
+//
+//    if (name == CalcAmoebaUreyBradleyForceKernel::Name())
+//        return new CudaCalcAmoebaUreyBradleyForceKernel(name, platform, cu, context.getSystem());
+
+    throw OpenMMException((std::string("Tried to create kernel with illegal kernel name '")+name+"'").c_str());
+}

plugins/amoeba/platforms/cuda2/src/AmoebaCudaKernels.cpp

+/* -------------------------------------------------------------------------- *
+ *                               OpenMMAmoeba                                 *
+ * -------------------------------------------------------------------------- *
+ * 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) 2008-2012 Stanford University and the Authors.      *
+ * Authors: Peter Eastman, Mark Friedrichs                                    *
+ * 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 "AmoebaCudaKernels.h"
+#include "CudaAmoebaKernelSources.h"
+#include "openmm/internal/ContextImpl.h"
+#include "openmm/internal/AmoebaMultipoleForceImpl.h"
+#include "openmm/internal/AmoebaWcaDispersionForceImpl.h"
+#include "openmm/internal/AmoebaTorsionTorsionForceImpl.h"
+#include "openmm/internal/NonbondedForceImpl.h"
+#include "CudaBondedUtilities.h"
+#include "CudaForceInfo.h"
+#include "CudaKernelSources.h"
+
+#include <cmath>
+#ifdef _MSC_VER
+#include <windows.h>
+#endif
+
+using namespace OpenMM;
+using namespace std;
+
+/* -------------------------------------------------------------------------- *
+ *                           AmoebaHarmonicBond                               *
+ * -------------------------------------------------------------------------- */
+
+class CudaCalcAmoebaHarmonicBondForceKernel::ForceInfo : public CudaForceInfo {
+public:
+    ForceInfo(const AmoebaHarmonicBondForce& force) : force(force) {
+    }
+    int getNumParticleGroups() {
+        return force.getNumBonds();
+    }
+    void getParticlesInGroup(int index, std::vector<int>& particles) {
+        int particle1, particle2;
+        double length, k;
+        force.getBondParameters(index, particle1, particle2, length, k);
+        particles.resize(2);
+        particles[0] = particle1;
+        particles[1] = particle2;
+    }
+    bool areGroupsIdentical(int group1, int group2) {
+        int particle1, particle2;
+        double length1, length2, k1, k2;
+        force.getBondParameters(group1, particle1, particle2, length1, k1);
+        force.getBondParameters(group2, particle1, particle2, length2, k2);
+        return (length1 == length2 && k1 == k2);
+    }
+private:
+    const AmoebaHarmonicBondForce& force;
+};
+
+CudaCalcAmoebaHarmonicBondForceKernel::CudaCalcAmoebaHarmonicBondForceKernel(std::string name, const Platform& platform, CudaContext& cu, System& system) : 
+                CalcAmoebaHarmonicBondForceKernel(name, platform), cu(cu), system(system) {
+}
+
+CudaCalcAmoebaHarmonicBondForceKernel::~CudaCalcAmoebaHarmonicBondForceKernel() {
+    cu.setAsCurrent();
+    if (params != NULL)
+        delete params;
+}
+
+void CudaCalcAmoebaHarmonicBondForceKernel::initialize(const System& system, const AmoebaHarmonicBondForce& force) {
+    cu.setAsCurrent();
+    int numContexts = cu.getPlatformData().contexts.size();
+    int startIndex = cu.getContextIndex()*force.getNumBonds()/numContexts;
+    int endIndex = (cu.getContextIndex()+1)*force.getNumBonds()/numContexts;
+    numBonds = endIndex-startIndex;
+    if (numBonds == 0)
+        return;
+    vector<vector<int> > atoms(numBonds, vector<int>(2));
+    params = CudaArray::create<float2>(cu, numBonds, "bondParams");
+    vector<float2> paramVector(numBonds);
+    for (int i = 0; i < numBonds; i++) {
+        double length, k;
+        force.getBondParameters(startIndex+i, atoms[i][0], atoms[i][1], length, k);
+        paramVector[i] = make_float2((float) length, (float) k);
+    }
+    params->upload(paramVector);
+    map<string, string> replacements;
+    replacements["COMPUTE_FORCE"] = CudaAmoebaKernelSources::amoebaBondForce;
+    replacements["PARAMS"] = cu.getBondedUtilities().addArgument(params->getDevicePointer(), "float2");
+    replacements["CUBIC_K"] = cu.doubleToString(force.getAmoebaGlobalHarmonicBondCubic());
+    replacements["QUARTIC_K"] = cu.doubleToString(force.getAmoebaGlobalHarmonicBondQuartic());
+    cu.getBondedUtilities().addInteraction(atoms, cu.replaceStrings(CudaKernelSources::bondForce, replacements), force.getForceGroup());
+    cu.addForce(new ForceInfo(force));
+}
+
+double CudaCalcAmoebaHarmonicBondForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
+    return 0.0;
+}
+//
+///* -------------------------------------------------------------------------- *
+// *                           AmoebaUreyBradley                               *
+// * -------------------------------------------------------------------------- */
+//
+//class CudaCalcAmoebaUreyBradleyForceKernel::ForceInfo : public CudaForceInfo {
+//public:
+//    ForceInfo(const AmoebaUreyBradleyForce& force) : force(force) {
+//    }
+//    int getNumParticleGroups() {
+//        return force.getNumInteractions();
+//    }
+//    void getParticlesInGroup(int index, std::vector<int>& particles) {
+//        int particle1, particle2;
+//        double length, k;
+//        force.getUreyBradleyParameters(index, particle1, particle2, length, k);
+//        particles.resize(2);
+//        particles[0] = particle1;
+//        particles[1] = particle2;
+//    }
+//    bool areGroupsIdentical(int group1, int group2) {
+//        int particle1, particle2;
+//        double length1, length2, k1, k2;
+//        force.getUreyBradleyParameters(group1, particle1, particle2, length1, k1);
+//        force.getUreyBradleyParameters(group2, particle1, particle2, length2, k2);
+//        return (length1 == length2 && k1 == k2);
+//    }
+//private:
+//    const AmoebaUreyBradleyForce& force;
+//};
+//
+//CudaCalcAmoebaUreyBradleyForceKernel::CudaCalcAmoebaUreyBradleyForceKernel(std::string name, const Platform& platform, CudaContext& cu, System& system) : 
+//                CalcAmoebaUreyBradleyForceKernel(name, platform), cu(cu), system(system) {
+//    data.incrementKernelCount();
+//}
+//
+//CudaCalcAmoebaUreyBradleyForceKernel::~CudaCalcAmoebaUreyBradleyForceKernel() {
+//    data.decrementKernelCount();
+//}
+//
+//void CudaCalcAmoebaUreyBradleyForceKernel::initialize(const System& system, const AmoebaUreyBradleyForce& force) {
+//
+//    data.setAmoebaLocalForcesKernel( this );
+//
+//    numInteractions = force.getNumInteractions();
+//    std::vector<int>   particle1(numInteractions);
+//    std::vector<int>   particle2(numInteractions);
+//    std::vector<float> length(numInteractions);
+//    std::vector<float> quadratic(numInteractions);
+//
+//    for (int i = 0; i < numInteractions; i++) {
+//
+//        int particle1Index, particle2Index;
+//        double lengthValue, kValue;
+//        force.getUreyBradleyParameters(i, particle1Index, particle2Index, lengthValue, kValue );
+//
+//        particle1[i]     = particle1Index; 
+//        particle2[i]     = particle2Index; 
+//        length[i]        = static_cast<float>( lengthValue );
+//        quadratic[i]     = static_cast<float>( kValue );
+//    } 
+//    gpuSetAmoebaUreyBradleyParameters( data.getAmoebaGpu(), particle1, particle2, length, quadratic, 
+//                                       static_cast<float>(force.getAmoebaGlobalUreyBradleyCubic()),
+//                                       static_cast<float>(force.getAmoebaGlobalUreyBradleyQuartic()) );
+//    data.getAmoebaGpu()->gpuContext->forces.push_back(new ForceInfo(force));
+//}
+//
+//double CudaCalcAmoebaUreyBradleyForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
+//    if( data.getAmoebaLocalForcesKernel() == this ){
+//        computeAmoebaLocalForces( data );
+//    }
+//    return 0.0;
+//}
+
+/* -------------------------------------------------------------------------- *
+ *                           AmoebaHarmonicAngle                              *
+ * -------------------------------------------------------------------------- */
+
+class CudaCalcAmoebaHarmonicAngleForceKernel::ForceInfo : public CudaForceInfo {
+public:
+    ForceInfo(const AmoebaHarmonicAngleForce& force) : force(force) {
+    }
+    int getNumParticleGroups() {
+        return force.getNumAngles();
+    }
+    void getParticlesInGroup(int index, std::vector<int>& particles) {
+        int particle1, particle2, particle3;
+        double angle, k;
+        force.getAngleParameters(index, particle1, particle2, particle3, angle, k);
+        particles.resize(3);
+        particles[0] = particle1;
+        particles[1] = particle2;
+        particles[2] = particle3;
+    }
+    bool areGroupsIdentical(int group1, int group2) {
+        int particle1, particle2, particle3;
+        double angle1, angle2, k1, k2;
+        force.getAngleParameters(group1, particle1, particle2, particle3, angle1, k1);
+        force.getAngleParameters(group2, particle1, particle2, particle3, angle2, k2);
+        return (angle1 == angle2 && k1 == k2);
+    }
+private:
+    const AmoebaHarmonicAngleForce& force;
+};
+
+CudaCalcAmoebaHarmonicAngleForceKernel::CudaCalcAmoebaHarmonicAngleForceKernel(std::string name, const Platform& platform, CudaContext& cu, System& system) :
+            CalcAmoebaHarmonicAngleForceKernel(name, platform), cu(cu), system(system) {
+}
+
+CudaCalcAmoebaHarmonicAngleForceKernel::~CudaCalcAmoebaHarmonicAngleForceKernel() {
+    cu.setAsCurrent();
+    if (params != NULL)
+        delete params;
+}
+
+void CudaCalcAmoebaHarmonicAngleForceKernel::initialize(const System& system, const AmoebaHarmonicAngleForce& force) {
+    cu.setAsCurrent();
+    int numContexts = cu.getPlatformData().contexts.size();
+    int startIndex = cu.getContextIndex()*force.getNumAngles()/numContexts;
+    int endIndex = (cu.getContextIndex()+1)*force.getNumAngles()/numContexts;
+    numAngles = endIndex-startIndex;
+    if (numAngles == 0)
+        return;
+    vector<vector<int> > atoms(numAngles, vector<int>(3));
+    params = CudaArray::create<float2>(cu, numAngles, "angleParams");
+    vector<float2> paramVector(numAngles);
+    for (int i = 0; i < numAngles; i++) {
+        double angle, k;
+        force.getAngleParameters(startIndex+i, atoms[i][0], atoms[i][1], atoms[i][2], angle, k);
+        paramVector[i] = make_float2((float) angle, (float) k);
+
+    }
+    params->upload(paramVector);
+    map<string, string> replacements;
+    replacements["COMPUTE_FORCE"] = CudaAmoebaKernelSources::amoebaAngleForce;
+    replacements["PARAMS"] = cu.getBondedUtilities().addArgument(params->getDevicePointer(), "float2");
+    replacements["CUBIC_K"] = cu.doubleToString(force.getAmoebaGlobalHarmonicAngleCubic());
+    replacements["QUARTIC_K"] = cu.doubleToString(force.getAmoebaGlobalHarmonicAngleQuartic());
+    replacements["PENTIC_K"] = cu.doubleToString(force.getAmoebaGlobalHarmonicAnglePentic());
+    replacements["SEXTIC_K"] = cu.doubleToString(force.getAmoebaGlobalHarmonicAngleSextic());
+    replacements["RAD_TO_DEG"] = cu.doubleToString(180/M_PI);
+    cu.getBondedUtilities().addInteraction(atoms, cu.replaceStrings(CudaKernelSources::angleForce, replacements), force.getForceGroup());
+    cu.addForce(new ForceInfo(force));
+}
+
+double CudaCalcAmoebaHarmonicAngleForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
+    return 0.0;
+}
+
+/* -------------------------------------------------------------------------- *
+ *                           AmoebaHarmonicInPlaneAngle                       *
+ * -------------------------------------------------------------------------- */
+
+class CudaCalcAmoebaHarmonicInPlaneAngleForceKernel::ForceInfo : public CudaForceInfo {
+public:
+    ForceInfo(const AmoebaHarmonicInPlaneAngleForce& force) : force(force) {
+    }
+    int getNumParticleGroups() {
+        return force.getNumAngles();
+    }
+    void getParticlesInGroup(int index, std::vector<int>& particles) {
+        int particle1, particle2, particle3, particle4;
+        double angle, k;
+        force.getAngleParameters(index, particle1, particle2, particle3, particle4, angle, k);
+        particles.resize(4);
+        particles[0] = particle1;
+        particles[1] = particle2;
+        particles[2] = particle3;
+        particles[3] = particle4;
+    }
+    bool areGroupsIdentical(int group1, int group2) {
+        int particle1, particle2, particle3, particle4;
+        double angle1, angle2, k1, k2;
+        force.getAngleParameters(group1, particle1, particle2, particle3, particle4, angle1, k1);
+        force.getAngleParameters(group2, particle1, particle2, particle3, particle4, angle2, k2);
+        return (angle1 == angle2 && k1 == k2);
+    }
+private:
+    const AmoebaHarmonicInPlaneAngleForce& force;
+};
+
+CudaCalcAmoebaHarmonicInPlaneAngleForceKernel::CudaCalcAmoebaHarmonicInPlaneAngleForceKernel(std::string name, const Platform& platform, CudaContext& cu, System& system) : 
+          CalcAmoebaHarmonicInPlaneAngleForceKernel(name, platform), cu(cu), system(system) {
+}
+
+CudaCalcAmoebaHarmonicInPlaneAngleForceKernel::~CudaCalcAmoebaHarmonicInPlaneAngleForceKernel() {
+    cu.setAsCurrent();
+    if (params != NULL)
+        delete params;
+}
+
+void CudaCalcAmoebaHarmonicInPlaneAngleForceKernel::initialize(const System& system, const AmoebaHarmonicInPlaneAngleForce& force) {
+    cu.setAsCurrent();
+    int numContexts = cu.getPlatformData().contexts.size();
+    int startIndex = cu.getContextIndex()*force.getNumAngles()/numContexts;
+    int endIndex = (cu.getContextIndex()+1)*force.getNumAngles()/numContexts;
+    numAngles = endIndex-startIndex;
+    if (numAngles == 0)
+        return;
+    vector<vector<int> > atoms(numAngles, vector<int>(4));
+    params = CudaArray::create<float2>(cu, numAngles, "angleParams");
+    vector<float2> paramVector(numAngles);
+    for (int i = 0; i < numAngles; i++) {
+        double angle, k;
+        force.getAngleParameters(startIndex+i, atoms[i][0], atoms[i][1], atoms[i][2], atoms[i][3], angle, k);
+        paramVector[i] = make_float2((float) angle, (float) k);
+
+    }
+    params->upload(paramVector);
+    map<string, string> replacements;
+    replacements["PARAMS"] = cu.getBondedUtilities().addArgument(params->getDevicePointer(), "float2");
+    replacements["CUBIC_K"] = cu.doubleToString(force.getAmoebaGlobalHarmonicInPlaneAngleCubic());
+    replacements["QUARTIC_K"] = cu.doubleToString(force.getAmoebaGlobalHarmonicInPlaneAngleQuartic());
+    replacements["PENTIC_K"] = cu.doubleToString(force.getAmoebaGlobalHarmonicInPlaneAnglePentic());
+    replacements["SEXTIC_K"] = cu.doubleToString(force.getAmoebaGlobalHarmonicInPlaneAngleSextic());
+    replacements["RAD_TO_DEG"] = cu.doubleToString(180/M_PI);
+    cu.getBondedUtilities().addInteraction(atoms, cu.replaceStrings(CudaAmoebaKernelSources::amoebaInPlaneForce, replacements), force.getForceGroup());
+    cu.addForce(new ForceInfo(force));
+}
+
+double CudaCalcAmoebaHarmonicInPlaneAngleForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
+    return 0.0;
+}
+
+///* -------------------------------------------------------------------------- *
+// *                               AmoebaTorsion                                *
+// * -------------------------------------------------------------------------- */
+//
+//class CudaCalcAmoebaTorsionForceKernel::ForceInfo : public CudaForceInfo {
+//public:
+//    ForceInfo(const AmoebaTorsionForce& force) : force(force) {
+//    }
+//    int getNumParticleGroups() {
+//        return force.getNumTorsions();
+//    }
+//    void getParticlesInGroup(int index, std::vector<int>& particles) {
+//        int particle1, particle2, particle3, particle4;
+//        vector<double> torsion1, torsion2, torsion3;
+//        force.getTorsionParameters(index, particle1, particle2, particle3, particle4, torsion1, torsion2, torsion3);
+//        particles.resize(4);
+//        particles[0] = particle1;
+//        particles[1] = particle2;
+//        particles[2] = particle3;
+//        particles[3] = particle4;
+//    }
+//    bool areGroupsIdentical(int group1, int group2) {
+//        int particle1, particle2, particle3, particle4;
+//        vector<double> torsion11, torsion21, torsion31;
+//        vector<double> torsion12, torsion22, torsion32;
+//        force.getTorsionParameters(group1, particle1, particle2, particle3, particle4, torsion11, torsion21, torsion31);
+//        force.getTorsionParameters(group2, particle1, particle2, particle3, particle4, torsion12, torsion22, torsion32);
+//        for (int i = 0; i < (int) torsion11.size(); ++i)
+//            if (torsion11[i] != torsion12[i])
+//                return false;
+//        for (int i = 0; i < (int) torsion21.size(); ++i)
+//            if (torsion21[i] != torsion22[i])
+//                return false;
+//        for (int i = 0; i < (int) torsion31.size(); ++i)
+//            if (torsion31[i] != torsion32[i])
+//                return false;
+//        return true;
+//    }
+//private:
+//    const AmoebaTorsionForce& force;
+//};
+//
+//CudaCalcAmoebaTorsionForceKernel::CudaCalcAmoebaTorsionForceKernel(std::string name, const Platform& platform, CudaContext& cu, System& system) :
+//             CalcAmoebaTorsionForceKernel(name, platform), cu(cu), system(system) {
+//    data.incrementKernelCount();
+//}
+//
+//CudaCalcAmoebaTorsionForceKernel::~CudaCalcAmoebaTorsionForceKernel() {
+//    data.decrementKernelCount();
+//}
+//
+//void CudaCalcAmoebaTorsionForceKernel::initialize(const System& system, const AmoebaTorsionForce& force) {
+//
+//    data.setAmoebaLocalForcesKernel( this );
+//    numTorsions                     = force.getNumTorsions();
+//    std::vector<int> particle1(numTorsions);
+//    std::vector<int> particle2(numTorsions);
+//    std::vector<int> particle3(numTorsions);
+//    std::vector<int> particle4(numTorsions);
+//
+//    std::vector< std::vector<float> > torsionParameters1(numTorsions);
+//    std::vector< std::vector<float> > torsionParameters2(numTorsions);
+//    std::vector< std::vector<float> > torsionParameters3(numTorsions);
+//
+//    for (int i = 0; i < numTorsions; i++) {
+//
+//        std::vector<double> torsionParameter1;
+//        std::vector<double> torsionParameter2;
+//        std::vector<double> torsionParameter3;
+//
+//        std::vector<float> torsionParameters1F(3);
+//        std::vector<float> torsionParameters2F(3);
+//        std::vector<float> torsionParameters3F(3);
+//
+//        force.getTorsionParameters(i, particle1[i], particle2[i], particle3[i], particle4[i], torsionParameter1, torsionParameter2, torsionParameter3 );
+//        for ( unsigned int jj = 0; jj < torsionParameter1.size(); jj++) {
+//            torsionParameters1F[jj] = static_cast<float>(torsionParameter1[jj]);
+//            torsionParameters2F[jj] = static_cast<float>(torsionParameter2[jj]);
+//            torsionParameters3F[jj] = static_cast<float>(torsionParameter3[jj]);
+//        }
+//        torsionParameters1[i] = torsionParameters1F;
+//        torsionParameters2[i] = torsionParameters2F;
+//        torsionParameters3[i] = torsionParameters3F;
+//    }
+//    gpuSetAmoebaTorsionParameters(data.getAmoebaGpu(), particle1, particle2, particle3, particle4, torsionParameters1, torsionParameters2, torsionParameters3 );
+//    data.getAmoebaGpu()->gpuContext->forces.push_back(new ForceInfo(force));
+//}
+//
+//double CudaCalcAmoebaTorsionForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
+//    if( data.getAmoebaLocalForcesKernel() == this ){
+//        computeAmoebaLocalForces( data );
+//    }
+//    return 0.0;
+//}
+
+/* -------------------------------------------------------------------------- *
+  *                              AmoebaPiTorsion                              *
+ * -------------------------------------------------------------------------- */
+
+class CudaCalcAmoebaPiTorsionForceKernel::ForceInfo : public CudaForceInfo {
+public:
+    ForceInfo(const AmoebaPiTorsionForce& force) : force(force) {
+    }
+    int getNumParticleGroups() {
+        return force.getNumPiTorsions();
+    }
+    void getParticlesInGroup(int index, std::vector<int>& particles) {
+        int particle1, particle2, particle3, particle4, particle5, particle6;
+        double k;
+        force.getPiTorsionParameters(index, particle1, particle2, particle3, particle4, particle5, particle6, k);
+        particles.resize(6);
+        particles[0] = particle1;
+        particles[1] = particle2;
+        particles[2] = particle3;
+        particles[3] = particle4;
+        particles[4] = particle5;
+        particles[5] = particle6;
+    }
+    bool areGroupsIdentical(int group1, int group2) {
+        int particle1, particle2, particle3, particle4, particle5, particle6;
+        double k1, k2;
+        force.getPiTorsionParameters(group1, particle1, particle2, particle3, particle4, particle5, particle6, k1);
+        force.getPiTorsionParameters(group2, particle1, particle2, particle3, particle4, particle5, particle6, k2);
+        return (k1 == k2);
+    }
+private:
+    const AmoebaPiTorsionForce& force;
+};
+
+CudaCalcAmoebaPiTorsionForceKernel::CudaCalcAmoebaPiTorsionForceKernel(std::string name, const Platform& platform, CudaContext& cu, System& system) :
+         CalcAmoebaPiTorsionForceKernel(name, platform), cu(cu), system(system) {
+}
+
+CudaCalcAmoebaPiTorsionForceKernel::~CudaCalcAmoebaPiTorsionForceKernel() {
+    cu.setAsCurrent();
+    if (params != NULL)
+        delete params;
+}
+
+void CudaCalcAmoebaPiTorsionForceKernel::initialize(const System& system, const AmoebaPiTorsionForce& force) {
+    cu.setAsCurrent();
+    int numContexts = cu.getPlatformData().contexts.size();
+    int startIndex = cu.getContextIndex()*force.getNumPiTorsions()/numContexts;
+    int endIndex = (cu.getContextIndex()+1)*force.getNumPiTorsions()/numContexts;
+    numPiTorsions = endIndex-startIndex;
+    if (numPiTorsions == 0)
+        return;
+    vector<vector<int> > atoms(numPiTorsions, vector<int>(6));
+    params = CudaArray::create<float>(cu, numPiTorsions, "piTorsionParams");
+    vector<float> paramVector(numPiTorsions);
+    for (int i = 0; i < numPiTorsions; i++) {
+        double k;
+        force.getPiTorsionParameters(startIndex+i, atoms[i][0], atoms[i][1], atoms[i][2], atoms[i][3], atoms[i][4], atoms[i][5], k);
+        paramVector[i] = (float) k;
+
+    }
+    params->upload(paramVector);
+    map<string, string> replacements;
+    replacements["PARAMS"] = cu.getBondedUtilities().addArgument(params->getDevicePointer(), "float");
+    cu.getBondedUtilities().addInteraction(atoms, cu.replaceStrings(CudaAmoebaKernelSources::amoebaPiTorsionForce, replacements), force.getForceGroup());
+    cu.addForce(new ForceInfo(force));
+}
+
+double CudaCalcAmoebaPiTorsionForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
+    return 0.0;
+}
+
+///* -------------------------------------------------------------------------- *
+// *                           AmoebaStretchBend                                *
+// * -------------------------------------------------------------------------- */
+//
+//class CudaCalcAmoebaStretchBendForceKernel::ForceInfo : public CudaForceInfo {
+//public:
+//    ForceInfo(const AmoebaStretchBendForce& force) : force(force) {
+//    }
+//    int getNumParticleGroups() {
+//        return force.getNumStretchBends();
+//    }
+//    void getParticlesInGroup(int index, std::vector<int>& particles) {
+//        int particle1, particle2, particle3;
+//        double lengthAB, lengthCB, angle, k;
+//        force.getStretchBendParameters(index, particle1, particle2, particle3, lengthAB, lengthCB, angle, k);
+//        particles.resize(3);
+//        particles[0] = particle1;
+//        particles[1] = particle2;
+//        particles[2] = particle3;
+//    }
+//    bool areGroupsIdentical(int group1, int group2) {
+//        int particle1, particle2, particle3;
+//        double lengthAB1, lengthAB2, lengthCB1, lengthCB2, angle1, angle2, k1, k2;
+//        force.getStretchBendParameters(group1, particle1, particle2, particle3, lengthAB1, lengthCB1, angle1, k1);
+//        force.getStretchBendParameters(group2, particle1, particle2, particle3, lengthAB2, lengthCB2, angle2, k2);
+//        return (lengthAB1 == lengthAB2 && lengthCB1 == lengthCB2 && angle1 == angle2 && k1 == k2);
+//    }
+//private:
+//    const AmoebaStretchBendForce& force;
+//};
+//
+//CudaCalcAmoebaStretchBendForceKernel::CudaCalcAmoebaStretchBendForceKernel(std::string name, const Platform& platform, CudaContext& cu, System& system) :
+//                   CalcAmoebaStretchBendForceKernel(name, platform), cu(cu), system(system) {
+//    data.incrementKernelCount();
+//}
+//
+//CudaCalcAmoebaStretchBendForceKernel::~CudaCalcAmoebaStretchBendForceKernel() {
+//    data.decrementKernelCount();
+//}
+//
+//void CudaCalcAmoebaStretchBendForceKernel::initialize(const System& system, const AmoebaStretchBendForce& force) {
+//
+//    data.setAmoebaLocalForcesKernel( this );
+//    numStretchBends                     = force.getNumStretchBends();
+//
+//    std::vector<int>   particle1(numStretchBends);
+//    std::vector<int>   particle2(numStretchBends);
+//    std::vector<int>   particle3(numStretchBends);
+//    std::vector<float> lengthABParameters(numStretchBends);
+//    std::vector<float> lengthCBParameters(numStretchBends);
+//    std::vector<float> angleParameters(numStretchBends);
+//    std::vector<float> kParameters(numStretchBends);
+//
+//    for (int i = 0; i < numStretchBends; i++) {
+//
+//        double lengthAB, lengthCB, angle, k;
+//
+//        force.getStretchBendParameters(i, particle1[i], particle2[i], particle3[i], lengthAB, lengthCB, angle, k);
+//        lengthABParameters[i] = static_cast<float>(lengthAB);
+//        lengthCBParameters[i] = static_cast<float>(lengthCB);
+//        angleParameters[i]    = static_cast<float>(angle);
+//        kParameters[i]        = static_cast<float>(k);
+//    }
+//    gpuSetAmoebaStretchBendParameters(data.getAmoebaGpu(), particle1, particle2, particle3, lengthABParameters, lengthCBParameters, angleParameters, kParameters);
+//    data.getAmoebaGpu()->gpuContext->forces.push_back(new ForceInfo(force));
+//}
+//
+//double CudaCalcAmoebaStretchBendForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
+//    if( data.getAmoebaLocalForcesKernel() == this ){
+//        computeAmoebaLocalForces( data );
+//    }
+//    return 0.0;
+//}
+//
+///* -------------------------------------------------------------------------- *
+// *                           AmoebaOutOfPlaneBend                             *
+// * -------------------------------------------------------------------------- */
+//
+//class CudaCalcAmoebaOutOfPlaneBendForceKernel::ForceInfo : public CudaForceInfo {
+//public:
+//    ForceInfo(const AmoebaOutOfPlaneBendForce& force) : force(force) {
+//    }
+//    int getNumParticleGroups() {
+//        return force.getNumOutOfPlaneBends();
+//    }
+//    void getParticlesInGroup(int index, std::vector<int>& particles) {
+//        int particle1, particle2, particle3, particle4;
+//        double k;
+//        force.getOutOfPlaneBendParameters(index, particle1, particle2, particle3, particle4, k);
+//        particles.resize(4);
+//        particles[0] = particle1;
+//        particles[1] = particle2;
+//        particles[2] = particle3;
+//        particles[3] = particle4;
+//    }
+//    bool areGroupsIdentical(int group1, int group2) {
+//        int particle1, particle2, particle3, particle4;
+//        double k1, k2;
+//        force.getOutOfPlaneBendParameters(group1, particle1, particle2, particle3, particle4, k1);
+//        force.getOutOfPlaneBendParameters(group2, particle1, particle2, particle3, particle4, k2);
+//        return (k1 == k2);
+//    }
+//private:
+//    const AmoebaOutOfPlaneBendForce& force;
+//};
+//
+//CudaCalcAmoebaOutOfPlaneBendForceKernel::CudaCalcAmoebaOutOfPlaneBendForceKernel(std::string name, const Platform& platform, CudaContext& cu, System& system) :
+//          CalcAmoebaOutOfPlaneBendForceKernel(name, platform), cu(cu), system(system) {
+//    data.incrementKernelCount();
+//}
+//
+//CudaCalcAmoebaOutOfPlaneBendForceKernel::~CudaCalcAmoebaOutOfPlaneBendForceKernel() {
+//    data.decrementKernelCount();
+//}
+//
+//void CudaCalcAmoebaOutOfPlaneBendForceKernel::initialize(const System& system, const AmoebaOutOfPlaneBendForce& force) {
+//
+//    data.setAmoebaLocalForcesKernel( this );
+//    numOutOfPlaneBends                     = force.getNumOutOfPlaneBends();
+//
+//    std::vector<int>   particle1(numOutOfPlaneBends);
+//    std::vector<int>   particle2(numOutOfPlaneBends);
+//    std::vector<int>   particle3(numOutOfPlaneBends);
+//    std::vector<int>   particle4(numOutOfPlaneBends);
+//    std::vector<float> kParameters(numOutOfPlaneBends);
+//
+//    for (int i = 0; i < numOutOfPlaneBends; i++) {
+//
+//        double k;
+//
+//        force.getOutOfPlaneBendParameters(i, particle1[i], particle2[i], particle3[i], particle4[i], k);
+//        kParameters[i] = static_cast<float>(k);
+//    }
+//    gpuSetAmoebaOutOfPlaneBendParameters(data.getAmoebaGpu(), particle1, particle2, particle3, particle4, kParameters,
+//                                         static_cast<float>( force.getAmoebaGlobalOutOfPlaneBendCubic()),
+//                                         static_cast<float>( force.getAmoebaGlobalOutOfPlaneBendQuartic()),
+//                                         static_cast<float>( force.getAmoebaGlobalOutOfPlaneBendPentic()),
+//                                         static_cast<float>( force.getAmoebaGlobalOutOfPlaneBendSextic() ) );
+//    data.getAmoebaGpu()->gpuContext->forces.push_back(new ForceInfo(force));
+//}
+//
+//double CudaCalcAmoebaOutOfPlaneBendForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
+//    if( data.getAmoebaLocalForcesKernel() == this ){
+//        computeAmoebaLocalForces( data );
+//    }
+//    return 0.0;
+//}
+//
+///* -------------------------------------------------------------------------- *
+// *                           AmoebaTorsionTorsion                             *
+// * -------------------------------------------------------------------------- */
+//
+//class CudaCalcAmoebaTorsionTorsionForceKernel::ForceInfo : public CudaForceInfo {
+//public:
+//    ForceInfo(const AmoebaTorsionTorsionForce& force) : force(force) {
+//    }
+//    int getNumParticleGroups() {
+//        return force.getNumTorsionTorsions();
+//    }
+//    void getParticlesInGroup(int index, std::vector<int>& particles) {
+//        int particle1, particle2, particle3, particle4, particle5, chiralCheckAtomIndex, gridIndex;
+//        force.getTorsionTorsionParameters(index, particle1, particle2, particle3, particle4, particle5, chiralCheckAtomIndex, gridIndex);
+//        particles.resize(5);
+//        particles[0] = particle1;
+//        particles[1] = particle2;
+//        particles[2] = particle3;
+//        particles[3] = particle4;
+//        particles[4] = particle5;
+//    }
+//    bool areGroupsIdentical(int group1, int group2) {
+//        int particle1, particle2, particle3, particle4, particle5;
+//        int chiral1, chiral2, grid1, grid2;
+//        force.getTorsionTorsionParameters(group1, particle1, particle2, particle3, particle4, particle5, chiral1, grid1);
+//        force.getTorsionTorsionParameters(group2, particle1, particle2, particle3, particle4, particle5, chiral2, grid2);
+//        return (grid1 == grid2);
+//    }
+//private:
+//    const AmoebaTorsionTorsionForce& force;
+//};
+//
+//CudaCalcAmoebaTorsionTorsionForceKernel::CudaCalcAmoebaTorsionTorsionForceKernel(std::string name, const Platform& platform, CudaContext& cu, System& system) :
+//                CalcAmoebaTorsionTorsionForceKernel(name, platform), cu(cu), system(system) {
+//    data.incrementKernelCount();
+//}
+//
+//CudaCalcAmoebaTorsionTorsionForceKernel::~CudaCalcAmoebaTorsionTorsionForceKernel() {
+//    data.decrementKernelCount();
+//}
+//
+//void CudaCalcAmoebaTorsionTorsionForceKernel::initialize(const System& system, const AmoebaTorsionTorsionForce& force) {
+//
+//    data.setAmoebaLocalForcesKernel( this );
+//    numTorsionTorsions = force.getNumTorsionTorsions();
+//
+//    // torsion-torsion parameters
+//
+//    std::vector<int>   particle1(numTorsionTorsions);
+//    std::vector<int>   particle2(numTorsionTorsions);
+//    std::vector<int>   particle3(numTorsionTorsions);
+//    std::vector<int>   particle4(numTorsionTorsions);
+//    std::vector<int>   particle5(numTorsionTorsions);
+//    std::vector<int>   chiralCheckAtomIndex(numTorsionTorsions);
+//    std::vector<int>   gridIndices(numTorsionTorsions);
+//
+//    for (int i = 0; i < numTorsionTorsions; i++) {
+//        force.getTorsionTorsionParameters(i, particle1[i], particle2[i], particle3[i],
+//                                             particle4[i], particle5[i],
+//                                             chiralCheckAtomIndex[i], gridIndices[i]);
+//    }
+//    gpuSetAmoebaTorsionTorsionParameters(data.getAmoebaGpu(), particle1, particle2, particle3, particle4, particle5, chiralCheckAtomIndex, gridIndices );
+//
+//    // torsion-torsion grids
+//
+//    numTorsionTorsionGrids = force.getNumTorsionTorsionGrids();
+//    std::vector<TorsionTorsionGridFloat> floatGrids;
+//
+//    floatGrids.resize(numTorsionTorsionGrids);
+//    for (int gridIndex = 0; gridIndex < numTorsionTorsionGrids; gridIndex++) {
+//
+//        const TorsionTorsionGrid& grid = force.getTorsionTorsionGrid( gridIndex );
+//        floatGrids[gridIndex].resize( grid.size() );
+//
+//        // check if grid needs to be reordered: x-angle should be 'slow' index
+//
+//        TorsionTorsionGrid reorderedGrid;
+//        int reorder = 0;
+//        if( grid[0][0][0] != grid[0][1][0] ){
+//            AmoebaTorsionTorsionForceImpl::reorderGrid( grid, reorderedGrid );
+//            reorder = 1;
+//            if( data.getLog() ){
+//                (void) fprintf( data.getLog(), "CudaCalcAmoebaTorsionTorsionForceKernel Reordered torsion-torsion grid %4d [%u %u] %12.3f %12.3f   [%u %u] %12.3f %12.3f.\n",
+//                                gridIndex, static_cast<unsigned int>(grid.size()), static_cast<unsigned int>(grid[0].size()), grid[0][0][0], grid[0][1][0],
+//                                static_cast<unsigned int>(reorderedGrid.size() ),  static_cast<unsigned int>(reorderedGrid[0].size() ), reorderedGrid[0][0][0], reorderedGrid[0][1][0] );
+//            }
+//        }
+//        for (unsigned int ii = 0; ii < grid.size(); ii++) {
+//
+//            floatGrids[gridIndex][ii].resize( grid[ii].size() );
+//            for (unsigned int jj = 0; jj < grid[ii].size(); jj++) {
+//
+//                floatGrids[gridIndex][ii][jj].resize( grid[ii][jj].size() );
+//                if( reorder ){
+//
+//                    for( unsigned int kk = 0; kk < grid[ii][jj].size(); kk++) {
+//                        floatGrids[gridIndex][ii][jj][kk] = static_cast<float>(reorderedGrid[ii][jj][kk]);
+//                    }
+//
+//                } else {
+//                    for( unsigned int kk = 0; kk < grid[ii][jj].size(); kk++) {
+//                        floatGrids[gridIndex][ii][jj][kk] = static_cast<float>(grid[ii][jj][kk]);
+//                    }
+//                }
+//            }
+//        }
+//    }
+//    gpuSetAmoebaTorsionTorsionGrids(data.getAmoebaGpu(), floatGrids );
+//    data.getAmoebaGpu()->gpuContext->forces.push_back(new ForceInfo(force));
+//}
+//
+//double CudaCalcAmoebaTorsionTorsionForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
+//    if( data.getAmoebaLocalForcesKernel() == this ){
+//        computeAmoebaLocalForces( data );
+//    }
+//    return 0.0;
+//}
+//
+///* -------------------------------------------------------------------------- *
+// *                             AmoebaMultipole                                *
+// * -------------------------------------------------------------------------- */
+//
+//static void computeAmoebaMultipoleForce( CudaContext& cu ) {
+//
+//    amoebaGpuContext gpu = data.getAmoebaGpu();
+//    data.incrementMultipoleForceCount();
+//
+//    if( 0 && data.getLog() ){
+//        (void) fprintf( data.getLog(), "In computeAmoebaMultipoleForce hasAmoebaGeneralizedKirkwood=%d\n", data.getHasAmoebaGeneralizedKirkwood() );
+//        (void) fflush( data.getLog());
+//    }
+//
+//    data.initializeGpu();
+//
+//    // calculate Born radii using either the Grycuk or OBC algorithm if GK is active
+//
+//    if( data.getHasAmoebaGeneralizedKirkwood() ){
+//        kClearBornSum( gpu->gpuContext );
+//        if( data.getUseGrycuk() ){
+//            kCalculateAmoebaGrycukBornRadii( gpu );
+//            kReduceGrycukGbsaBornSum( gpu );
+//        } else {
+//            kCalculateObcGbsaBornSum(gpu->gpuContext);
+//            kReduceObcGbsaBornSum(gpu->gpuContext);
+//       }
+//    }   
+//
+//    // multipoles
+//
+//    kCalculateAmoebaMultipoleForces(gpu, data.getHasAmoebaGeneralizedKirkwood() );
+//
+//    // GK
+//
+//    if( data.getHasAmoebaGeneralizedKirkwood() ){
+//        kCalculateAmoebaKirkwood(gpu);
+//    }
+//
+//    if( 0 && data.getLog() ){
+//        (void) fprintf( data.getLog(), "completed computeAmoebaMultipoleForce\n" );
+//        (void) fflush( data.getLog());
+//    }
+//}
+//
+//static void computeAmoebaMultipolePotential( CudaContext& cu, const std::vector< Vec3 >& inputGrid,
+//                                             std::vector< double >& outputElectrostaticPotential) {
+//
+//    amoebaGpuContext gpu = data.getAmoebaGpu();
+//
+//    // load grid to board and allocate board memory for potential buffers
+//    // calculate potential
+//    // load potential into return vector
+//    // deallocate board memory
+//
+//    gpuSetupElectrostaticPotentialCalculation( gpu, inputGrid );
+//    data.setGpuInitialized( false );
+//    data.initializeGpu();
+// 
+//    kCalculateAmoebaMultipolePotential( gpu );
+//    gpuLoadElectrostaticPotential( gpu, inputGrid.size(), outputElectrostaticPotential );
+//    gpuCleanupElectrostaticPotentialCalculation( gpu );
+//
+//    if( 0 && data.getLog() ){
+//        (void) fprintf( data.getLog(), "completed computeAmoebaMultipolePotential\n" );
+//        (void) fflush( data.getLog());
+//    }
+//}
+//
+//static void computeAmoebaSystemMultipoleMoments( CudaContext& cu, const Vec3& origin,
+//                                                 std::vector< double >& outputMultipoleMonents) {
+//
+//    amoebaGpuContext gpu = data.getAmoebaGpu();
+//
+//    data.setGpuInitialized( false );
+//    data.initializeGpu();
+//    kCalculateAmoebaSystemMultipoleMoments( gpu, origin, outputMultipoleMonents );
+//
+//}
+//
+//class CudaCalcAmoebaMultipoleForceKernel::ForceInfo : public CudaForceInfo {
+//public:
+//    ForceInfo(const AmoebaMultipoleForce& force) : force(force) {
+//    }
+//    bool areParticlesIdentical(int particle1, int particle2) {
+//        double charge1, charge2, thole1, thole2, damping1, damping2, polarity1, polarity2;
+//        int axis1, axis2, multipole11, multipole12, multipole21, multipole22, multipole31, multipole32;
+//        vector<double> dipole1, dipole2, quadrupole1, quadrupole2;
+//        force.getMultipoleParameters(particle1, charge1, dipole1, quadrupole1, axis1, multipole11, multipole21, multipole31, thole1, damping1, polarity1);
+//        force.getMultipoleParameters(particle2, charge2, dipole2, quadrupole2, axis2, multipole12, multipole22, multipole32, thole2, damping2, polarity2);
+//        if (charge1 != charge2 || thole1 != thole2 || damping1 != damping2 || polarity1 != polarity2 || axis1 != axis2){
+//            return false;
+//        }
+//        for (int i = 0; i < (int) dipole1.size(); ++i){
+//            if (dipole1[i] != dipole2[i]){
+//                return false;
+//            }
+//        }
+//        for (int i = 0; i < (int) quadrupole1.size(); ++i){
+//            if (quadrupole1[i] != quadrupole2[i]){
+//                return false;
+//            }
+//        }
+//        return true;
+//    }
+//private:
+//    const AmoebaMultipoleForce& force;
+//};
+//
+//CudaCalcAmoebaMultipoleForceKernel::CudaCalcAmoebaMultipoleForceKernel(std::string name, const Platform& platform, CudaContext& cu, System& system) : 
+//         CalcAmoebaMultipoleForceKernel(name, platform), cu(cu), system(system) {
+//    data.incrementKernelCount();
+//}
+//
+//CudaCalcAmoebaMultipoleForceKernel::~CudaCalcAmoebaMultipoleForceKernel() {
+//    data.decrementKernelCount();
+//}
+//
+//void CudaCalcAmoebaMultipoleForceKernel::initialize(const System& system, const AmoebaMultipoleForce& force) {
+//
+//    numMultipoles   = force.getNumMultipoles();
+//
+//    data.setHasAmoebaMultipole( true );
+//
+//    std::vector<float> charges(numMultipoles);
+//    std::vector<float> dipoles(3*numMultipoles);
+//    std::vector<float> quadrupoles(9*numMultipoles);
+//    std::vector<float> tholes(numMultipoles);
+//    std::vector<float> dampingFactors(numMultipoles);
+//    std::vector<float> polarity(numMultipoles);
+//    std::vector<int>   axisTypes(numMultipoles);
+//    std::vector<int>   multipoleAtomZs(numMultipoles);
+//    std::vector<int>   multipoleAtomXs(numMultipoles);
+//    std::vector<int>   multipoleAtomYs(numMultipoles);
+//    std::vector< std::vector< std::vector<int> > > multipoleAtomCovalentInfo(numMultipoles);
+//    std::vector<int> minCovalentIndices(numMultipoles);
+//    std::vector<int> minCovalentPolarizationIndices(numMultipoles);
+//
+//    //float scalingDistanceCutoff = static_cast<float>(force.getScalingDistanceCutoff());
+//    float scalingDistanceCutoff = 50.0f;
+//
+//    std::vector<AmoebaMultipoleForce::CovalentType> covalentList;
+//    covalentList.push_back( AmoebaMultipoleForce::Covalent12 );
+//    covalentList.push_back( AmoebaMultipoleForce::Covalent13 );
+//    covalentList.push_back( AmoebaMultipoleForce::Covalent14 );
+//    covalentList.push_back( AmoebaMultipoleForce::Covalent15 );
+//
+//    std::vector<AmoebaMultipoleForce::CovalentType> polarizationCovalentList;
+//    polarizationCovalentList.push_back( AmoebaMultipoleForce::PolarizationCovalent11 );
+//    polarizationCovalentList.push_back( AmoebaMultipoleForce::PolarizationCovalent12 );
+//    polarizationCovalentList.push_back( AmoebaMultipoleForce::PolarizationCovalent13 );
+//    polarizationCovalentList.push_back( AmoebaMultipoleForce::PolarizationCovalent14 );
+//
+//    std::vector<int> covalentDegree;
+//    AmoebaMultipoleForceImpl::getCovalentDegree( force, covalentDegree );
+//    int dipoleIndex      = 0;
+//    int quadrupoleIndex  = 0;
+//    int maxCovalentRange = 0;
+//    double totalCharge   = 0.0;
+//    for (int i = 0; i < numMultipoles; i++) {
+//
+//        // multipoles
+//
+//        int axisType, multipoleAtomZ, multipoleAtomX, multipoleAtomY;
+//        double charge, tholeD, dampingFactorD, polarityD;
+//        std::vector<double> dipolesD;
+//        std::vector<double> quadrupolesD;
+//        force.getMultipoleParameters(i, charge, dipolesD, quadrupolesD, axisType, multipoleAtomZ, multipoleAtomX, multipoleAtomY,
+//                                     tholeD, dampingFactorD, polarityD );
+//
+//        totalCharge                       += charge;
+//        axisTypes[i]                       = axisType;
+//        multipoleAtomZs[i]                 = multipoleAtomZ;
+//        multipoleAtomXs[i]                 = multipoleAtomX;
+//        multipoleAtomYs[i]                 = multipoleAtomY;
+//
+//        charges[i]                         = static_cast<float>(charge);
+//        tholes[i]                          = static_cast<float>(tholeD);
+//        dampingFactors[i]                  = static_cast<float>(dampingFactorD);
+//        polarity[i]                        = static_cast<float>(polarityD);
+//
+//        dipoles[dipoleIndex++]             = static_cast<float>(dipolesD[0]);
+//        dipoles[dipoleIndex++]             = static_cast<float>(dipolesD[1]);
+//        dipoles[dipoleIndex++]             = static_cast<float>(dipolesD[2]);
+//        
+//        quadrupoles[quadrupoleIndex++]     = static_cast<float>(quadrupolesD[0]);
+//        quadrupoles[quadrupoleIndex++]     = static_cast<float>(quadrupolesD[1]);
+//        quadrupoles[quadrupoleIndex++]     = static_cast<float>(quadrupolesD[2]);
+//        quadrupoles[quadrupoleIndex++]     = static_cast<float>(quadrupolesD[3]);
+//        quadrupoles[quadrupoleIndex++]     = static_cast<float>(quadrupolesD[4]);
+//        quadrupoles[quadrupoleIndex++]     = static_cast<float>(quadrupolesD[5]);
+//        quadrupoles[quadrupoleIndex++]     = static_cast<float>(quadrupolesD[6]);
+//        quadrupoles[quadrupoleIndex++]     = static_cast<float>(quadrupolesD[7]);
+//        quadrupoles[quadrupoleIndex++]     = static_cast<float>(quadrupolesD[8]);
+//
+//        // covalent info
+//
+//        std::vector< std::vector<int> > covalentLists;
+//        force.getCovalentMaps(i, covalentLists );
+//        multipoleAtomCovalentInfo[i] = covalentLists;
+//
+//        int minCovalentIndex, maxCovalentIndex;
+//        AmoebaMultipoleForceImpl::getCovalentRange( force, i, covalentList, &minCovalentIndex, &maxCovalentIndex );
+//        minCovalentIndices[i] = minCovalentIndex;
+//        if( maxCovalentRange < (maxCovalentIndex - minCovalentIndex) ){
+//            maxCovalentRange = maxCovalentIndex - minCovalentIndex;
+//        }
+//
+//        AmoebaMultipoleForceImpl::getCovalentRange( force, i, polarizationCovalentList, &minCovalentIndex, &maxCovalentIndex );
+//        minCovalentPolarizationIndices[i] = minCovalentIndex;
+//        if( maxCovalentRange < (maxCovalentIndex - minCovalentIndex) ){
+//            maxCovalentRange = maxCovalentIndex - minCovalentIndex;
+//        }
+//    }
+//
+//    int polarizationType = static_cast<int>(force.getPolarizationType());
+//    int nonbondedMethod = static_cast<int>(force.getNonbondedMethod());
+//    if( nonbondedMethod != 0 && nonbondedMethod != 1 ){
+//         throw OpenMMException("AmoebaMultipoleForce nonbonded method not recognized.\n");
+//    }
+//
+//    if( polarizationType != 0 && polarizationType != 1 ){
+//         throw OpenMMException("AmoebaMultipoleForce polarization type not recognized.\n");
+//    }
+//
+//    gpuSetAmoebaMultipoleParameters(data.getAmoebaGpu(), charges, dipoles, quadrupoles, axisTypes, multipoleAtomZs, multipoleAtomXs, multipoleAtomYs,
+//                                    tholes, scalingDistanceCutoff, dampingFactors, polarity,
+//                                    multipoleAtomCovalentInfo, covalentDegree, minCovalentIndices, minCovalentPolarizationIndices, (maxCovalentRange+2),
+//                                    0, force.getMutualInducedMaxIterations(),
+//                                    static_cast<float>( force.getMutualInducedTargetEpsilon()),
+//                                    nonbondedMethod, polarizationType,
+//                                    static_cast<float>( force.getCutoffDistance()),
+//                                    static_cast<float>( force.getAEwald()) );
+//    if (nonbondedMethod == AmoebaMultipoleForce::PME) {
+//        double alpha = force.getAEwald();
+//        int xsize, ysize, zsize;
+//        NonbondedForce nb;
+//        nb.setEwaldErrorTolerance(force.getEwaldErrorTolerance());
+//        nb.setCutoffDistance(force.getCutoffDistance());
+//        std::vector<int> pmeGridDimension;
+//        force.getPmeGridDimensions( pmeGridDimension );
+//        int pmeParametersSetBasedOnEwaldErrorTolerance;
+//        if( pmeGridDimension[0] == 0 || alpha == 0.0 ){
+//            NonbondedForceImpl::calcPMEParameters(system, nb, alpha, xsize, ysize, zsize);
+//            pmeParametersSetBasedOnEwaldErrorTolerance = 1;
+//        } else {
+//            alpha = force.getAEwald();
+//            xsize = pmeGridDimension[0];
+//            ysize = pmeGridDimension[1];
+//            zsize = pmeGridDimension[2];
+//            pmeParametersSetBasedOnEwaldErrorTolerance = 0;
+//        }
+//
+//        gpuSetAmoebaPMEParameters(data.getAmoebaGpu(), (float) alpha, xsize, ysize, zsize);
+//
+//        if( data.getLog() ){
+//            (void) fprintf( data.getLog(), "AmoebaMultipoleForce: PME parameters tol=%12.3e cutoff=%12.3f alpha=%12.3f [%d %d %d]\n",
+//                            force.getEwaldErrorTolerance(), force.getCutoffDistance(),  alpha, xsize, ysize, zsize );
+//            if( pmeParametersSetBasedOnEwaldErrorTolerance  ){
+//                 (void) fprintf( data.getLog(), "Parameters based on error tolerance and OpenMM algorithm.\n" );
+//            } else {
+//                 double alphaT;
+//                 int xsizeT, ysizeT, zsizeT;
+//                 NonbondedForceImpl::calcPMEParameters(system, nb, alphaT, xsizeT, ysizeT, zsizeT);
+//                 double impliedTolerance  = alpha*force.getCutoffDistance();
+//                        impliedTolerance  = 0.5*exp( -(impliedTolerance*impliedTolerance) );
+//                 (void) fprintf( data.getLog(), "Using input parameters implied tolerance=%12.3e;", impliedTolerance );
+//                 (void) fprintf( data.getLog(), "OpenMM param: aEwald=%12.3f [%6d %6d %6d]\n", alphaT, xsizeT, ysizeT, zsizeT);
+//            }
+//            (void) fprintf( data.getLog(), "\n" );
+//            (void) fflush( data.getLog() );
+//        }
+//
+//        data.setApplyMultipoleCutoff( 1 );
+//
+//        data.cudaPlatformData.nonbondedMethod = PARTICLE_MESH_EWALD;
+//        amoebaGpuContext amoebaGpu            = data.getAmoebaGpu();
+//        gpuContext gpu                        = amoebaGpu->gpuContext;
+//        gpu->sim.nonbondedCutoffSqr           = static_cast<float>(force.getCutoffDistance()*force.getCutoffDistance());
+//        gpu->sim.nonbondedMethod              = PARTICLE_MESH_EWALD;
+//    }
+//    data.getAmoebaGpu()->gpuContext->forces.push_back(new ForceInfo(force));
+//}
+//
+//double CudaCalcAmoebaMultipoleForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
+//    computeAmoebaMultipoleForce( data );
+//    return 0.0;
+//}
+//
+//void CudaCalcAmoebaMultipoleForceKernel::getElectrostaticPotential(ContextImpl& context,  const std::vector< Vec3 >& inputGrid,
+//                                                                   std::vector< double >& outputElectrostaticPotential) {
+//    computeAmoebaMultipolePotential( data, inputGrid, outputElectrostaticPotential );
+//    return;
+//}
+//
+//void CudaCalcAmoebaMultipoleForceKernel::getSystemMultipoleMoments(ContextImpl& context,  const Vec3& origin,
+//                                                                   std::vector< double >& outputMultipoleMonents) {
+//    computeAmoebaSystemMultipoleMoments( data, origin, outputMultipoleMonents);
+//    return;
+//}
+//
+///* -------------------------------------------------------------------------- *
+// *                       AmoebaGeneralizedKirkwood                            *
+// * -------------------------------------------------------------------------- */
+//
+//class CudaCalcAmoebaGeneralizedKirkwoodForceKernel::ForceInfo : public CudaForceInfo {
+//public:
+//    ForceInfo(const AmoebaGeneralizedKirkwoodForce& force) : force(force) {
+//    }
+//    bool areParticlesIdentical(int particle1, int particle2) {
+//        double charge1, charge2, radius1, radius2, scale1, scale2;
+//        force.getParticleParameters(particle1, charge1, radius1, scale1);
+//        force.getParticleParameters(particle2, charge2, radius2, scale2);
+//        return (charge1 == charge2 && radius1 == radius2 && scale1 == scale2);
+//    }
+//private:
+//    const AmoebaGeneralizedKirkwoodForce& force;
+//};
+//
+//CudaCalcAmoebaGeneralizedKirkwoodForceKernel::CudaCalcAmoebaGeneralizedKirkwoodForceKernel(std::string name, const Platform& platform, CudaContext& cu, System& system) : 
+//           CalcAmoebaGeneralizedKirkwoodForceKernel(name, platform), cu(cu), system(system) {
+//    data.incrementKernelCount();
+//}
+//
+//CudaCalcAmoebaGeneralizedKirkwoodForceKernel::~CudaCalcAmoebaGeneralizedKirkwoodForceKernel() {
+//    data.decrementKernelCount();
+//}
+//
+//void CudaCalcAmoebaGeneralizedKirkwoodForceKernel::initialize(const System& system, const AmoebaGeneralizedKirkwoodForce& force) {
+//
+//    data.setHasAmoebaGeneralizedKirkwood( true );
+//
+//    int numParticles = system.getNumParticles();
+//
+//    std::vector<float> radius(numParticles);
+//    std::vector<float> scale(numParticles);
+//    std::vector<float> charge(numParticles);
+//
+//    for( int ii = 0; ii < numParticles; ii++ ){
+//        double particleCharge, particleRadius, scalingFactor;
+//        force.getParticleParameters(ii, particleCharge, particleRadius, scalingFactor);
+//        radius[ii]  = static_cast<float>( particleRadius );
+//        scale[ii]   = static_cast<float>( scalingFactor );
+//        charge[ii]  = static_cast<float>( particleCharge );
+//    }   
+//    if( data.getUseGrycuk() ){
+//
+//        gpuSetAmoebaGrycukParameters( data.getAmoebaGpu(), static_cast<float>(force.getSoluteDielectric() ), 
+//                                      static_cast<float>( force.getSolventDielectric() ), 
+//                                      radius, scale, charge,
+//                                      force.getIncludeCavityTerm(),
+//                                      static_cast<float>( force.getProbeRadius() ), 
+//                                      static_cast<float>( force.getSurfaceAreaFactor() ) ); 
+//        
+//    } else {
+//
+//        gpuSetAmoebaObcParameters( data.getAmoebaGpu(), static_cast<float>(force.getSoluteDielectric() ), 
+//                                   static_cast<float>( force.getSolventDielectric() ), 
+//                                   radius, scale, charge,
+//                                   force.getIncludeCavityTerm(),
+//                                   static_cast<float>( force.getProbeRadius() ), 
+//                                   static_cast<float>( force.getSurfaceAreaFactor() ) ); 
+//
+//    }
+//    data.getAmoebaGpu()->gpuContext->forces.push_back(new ForceInfo(force));
+//}
+//
+//double CudaCalcAmoebaGeneralizedKirkwoodForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
+//    // handled in computeAmoebaMultipoleForce()
+//    return 0.0;
+//}
+//
+//static void computeAmoebaVdwForce( CudaContext& cu ) {
+//
+//    amoebaGpuContext gpu = data.getAmoebaGpu();
+//    data.initializeGpu();
+//
+//    // Vdw14_7F
+//    kCalculateAmoebaVdw14_7Forces(gpu, data.getUseVdwNeighborList());
+//}
+//
+///* -------------------------------------------------------------------------- *
+// *                           AmoebaVdw                                        *
+// * -------------------------------------------------------------------------- */
+//
+//class CudaCalcAmoebaVdwForceKernel::ForceInfo : public CudaForceInfo {
+//public:
+//    ForceInfo(const AmoebaVdwForce& force) : force(force) {
+//    }
+//    bool areParticlesIdentical(int particle1, int particle2) {
+//        int iv1, iv2, class1, class2;
+//        double sigma1, sigma2, epsilon1, epsilon2, reduction1, reduction2;
+//        force.getParticleParameters(particle1, iv1, class1, sigma1, epsilon1, reduction1);
+//        force.getParticleParameters(particle2, iv2, class2, sigma2, epsilon2, reduction2);
+//        return (class1 == class2 && sigma1 == sigma2 && epsilon1 == epsilon2 && reduction1 == reduction2);
+//    }
+//private:
+//    const AmoebaVdwForce& force;
+//};
+//
+//CudaCalcAmoebaVdwForceKernel::CudaCalcAmoebaVdwForceKernel(std::string name, const Platform& platform, CudaContext& cu, System& system) :
+//       CalcAmoebaVdwForceKernel(name, platform), cu(cu), system(system) {
+//    data.incrementKernelCount();
+//}
+//
+//CudaCalcAmoebaVdwForceKernel::~CudaCalcAmoebaVdwForceKernel() {
+//    data.decrementKernelCount();
+//}
+//
+//void CudaCalcAmoebaVdwForceKernel::initialize(const System& system, const AmoebaVdwForce& force) {
+//
+//    // per-particle parameters
+//
+//    int numParticles = system.getNumParticles();
+//
+//    std::vector<int> indexIVs(numParticles);
+//    std::vector<int> indexClasses(numParticles);
+//    std::vector< std::vector<int> > allExclusions(numParticles);
+//    std::vector<float> sigmas(numParticles);
+//    std::vector<float> epsilons(numParticles);
+//    std::vector<float> reductions(numParticles);
+//    for( int ii = 0; ii < numParticles; ii++ ){
+//
+//        int indexIV, indexClass;
+//        double sigma, epsilon, reduction;
+//        std::vector<int> exclusions;
+//
+//        force.getParticleParameters( ii, indexIV, indexClass, sigma, epsilon, reduction );
+//        force.getParticleExclusions( ii, exclusions );
+//        for( unsigned int jj = 0; jj < exclusions.size(); jj++ ){
+//           allExclusions[ii].push_back( exclusions[jj] );
+//        }
+//
+//        indexIVs[ii]      = indexIV;
+//        indexClasses[ii]  = indexClass;
+//        sigmas[ii]        = static_cast<float>( sigma );
+//        epsilons[ii]      = static_cast<float>( epsilon );
+//        reductions[ii]    = static_cast<float>( reduction );
+//    }   
+//
+//    gpuSetAmoebaVdwParameters( data.getAmoebaGpu(), indexIVs, indexClasses, sigmas, epsilons, reductions,
+//                               force.getSigmaCombiningRule(), force.getEpsilonCombiningRule(),
+//                               allExclusions, force.getPBC(), static_cast<float>(force.getCutoff()) );
+//    data.getAmoebaGpu()->gpuContext->forces.push_back(new ForceInfo(force));
+//    if( data.getLog() ){
+//        (void) fprintf( data.getLog(), "CudaCalcAmoebaVdwForceKernel PBC=%d getUseNeighborList=%d\n",
+//                        force.getPBC(), force.getUseNeighborList() );
+//    }
+//    data.setUseVdwNeighborList( force.getUseNeighborList() );
+//}
+//
+//double CudaCalcAmoebaVdwForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
+//    computeAmoebaVdwForce( data );
+//    return 0.0;
+//}
+//
+///* -------------------------------------------------------------------------- *
+// *                           AmoebaWcaDispersion                              *
+// * -------------------------------------------------------------------------- */
+//
+//static void computeAmoebaWcaDispersionForce( CudaContext& cu ) {
+//
+//    data.initializeGpu();
+//    if( 0 && data.getLog() ){
+//        (void) fprintf( data.getLog(), "Calling computeAmoebaWcaDispersionForce  " ); (void) fflush( data.getLog() );
+//    }
+//
+//    kCalculateAmoebaWcaDispersionForces( data.getAmoebaGpu() );
+//
+//    if( 0 && data.getLog() ){
+//        (void) fprintf( data.getLog(), " -- completed\n" ); (void) fflush( data.getLog() );
+//    }
+//}
+//
+//class CudaCalcAmoebaWcaDispersionForceKernel::ForceInfo : public CudaForceInfo {
+//public:
+//    ForceInfo(const AmoebaWcaDispersionForce& force) : force(force) {
+//    }
+//    bool areParticlesIdentical(int particle1, int particle2) {
+//        double radius1, radius2, epsilon1, epsilon2;
+//        force.getParticleParameters(particle1, radius1, epsilon1);
+//        force.getParticleParameters(particle2, radius2, epsilon2);
+//        return (radius1 == radius2 && epsilon1 == epsilon2);
+//    }
+//private:
+//    const AmoebaWcaDispersionForce& force;
+//};
+//
+//CudaCalcAmoebaWcaDispersionForceKernel::CudaCalcAmoebaWcaDispersionForceKernel(std::string name, const Platform& platform, CudaContext& cu, System& system) : 
+//           CalcAmoebaWcaDispersionForceKernel(name, platform), cu(cu), system(system) {
+//    data.incrementKernelCount();
+//}
+//
+//CudaCalcAmoebaWcaDispersionForceKernel::~CudaCalcAmoebaWcaDispersionForceKernel() {
+//    data.decrementKernelCount();
+//}
+//
+//void CudaCalcAmoebaWcaDispersionForceKernel::initialize(const System& system, const AmoebaWcaDispersionForce& force) {
+//
+//    // per-particle parameters
+//
+//    int numParticles = system.getNumParticles();
+//    std::vector<float> radii(numParticles);
+//    std::vector<float> epsilons(numParticles);
+//    for( int ii = 0; ii < numParticles; ii++ ){
+//
+//        double radius, epsilon;
+//        force.getParticleParameters( ii, radius, epsilon );
+//
+//        radii[ii]         = static_cast<float>( radius );
+//        epsilons[ii]      = static_cast<float>( epsilon );
+//    }   
+//    float totalMaximumDispersionEnergy =  static_cast<float>( AmoebaWcaDispersionForceImpl::getTotalMaximumDispersionEnergy( force ) );
+//    gpuSetAmoebaWcaDispersionParameters( data.getAmoebaGpu(), radii, epsilons, totalMaximumDispersionEnergy,
+//                                          static_cast<float>( force.getEpso( )),
+//                                          static_cast<float>( force.getEpsh( )),
+//                                          static_cast<float>( force.getRmino( )),
+//                                          static_cast<float>( force.getRminh( )),
+//                                          static_cast<float>( force.getAwater( )),
+//                                          static_cast<float>( force.getShctd( )),
+//                                          static_cast<float>( force.getDispoff( ) ) );
+//    data.getAmoebaGpu()->gpuContext->forces.push_back(new ForceInfo(force));
+//}
+//
+//double CudaCalcAmoebaWcaDispersionForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
+//    computeAmoebaWcaDispersionForce( data );
+//    return 0.0;
+//}

plugins/amoeba/platforms/cuda2/src/AmoebaCudaKernels.h

+#ifndef AMOEBA_OPENMM_CUDAKERNELS_H_
+#define AMOEBA_OPENMM_CUDAKERNELS_H_
+
+/* -------------------------------------------------------------------------- *
+ *                              OpenMMAmoeba                                  *
+ * -------------------------------------------------------------------------- *
+ * 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) 2008-2012 Stanford University and the Authors.      *
+ * Authors: Mark Friedrichs, 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/amoebaKernels.h"
+#include "openmm/kernels.h"
+#include "openmm/System.h"
+#include "CudaContext.h"
+#include "CudaArray.h"
+
+namespace OpenMM {
+
+/**
+ * This kernel is invoked by AmoebaHarmonicBondForce to calculate the forces acting on the system and the energy of the system.
+ */
+class CudaCalcAmoebaHarmonicBondForceKernel : public CalcAmoebaHarmonicBondForceKernel {
+public:
+    CudaCalcAmoebaHarmonicBondForceKernel(std::string name, 
+                                          const Platform& platform,
+                                          CudaContext& cu,
+                                          System& system);
+    ~CudaCalcAmoebaHarmonicBondForceKernel();
+    /**
+     * Initialize the kernel.
+     * 
+     * @param system     the System this kernel will be applied to
+     * @param force      the AmoebaHarmonicBondForce this kernel will be used for
+     */
+    void initialize(const System& system, const AmoebaHarmonicBondForce& force);
+    /**
+     * Execute the kernel to calculate the forces and/or energy.
+     *
+     * @param context        the context in which to execute this kernel
+     * @param includeForces  true if forces should be calculated
+     * @param includeEnergy  true if the energy should be calculated
+     * @return the potential energy due to the force
+     */
+    double execute(ContextImpl& context, bool includeForces, bool includeEnergy);
+private:
+    class ForceInfo;
+    int numBonds;
+    CudaContext& cu;
+    System& system;
+    CudaArray* params;
+};
+
+/**
+ * This kernel is invoked by AmoebaUreyBradleyForce to calculate the forces acting on the system and the energy of the system.
+ */
+class CudaCalcAmoebaUreyBradleyForceKernel : public CalcAmoebaUreyBradleyForceKernel {
+public:
+    CudaCalcAmoebaUreyBradleyForceKernel(std::string name, 
+                                         const Platform& platform,
+                                         CudaContext& cu,
+                                         System& system);
+    ~CudaCalcAmoebaUreyBradleyForceKernel();
+    /**
+     * Initialize the kernel.
+     * 
+     * @param system     the System this kernel will be applied to
+     * @param force      the AmoebaUreyBradleyForce this kernel will be used for
+     */
+    void initialize(const System& system, const AmoebaUreyBradleyForce& force);
+    /**
+     * Execute the kernel to calculate the forces and/or energy.
+     *
+     * @param context        the context in which to execute this kernel
+     * @param includeForces  true if forces should be calculated
+     * @param includeEnergy  true if the energy should be calculated
+     * @return the potential energy due to the force
+     */
+    double execute(ContextImpl& context, bool includeForces, bool includeEnergy);
+private:
+    class ForceInfo;
+    int numInteractions;
+    CudaContext& cu;
+    System& system;
+};
+
+/**
+ * This kernel is invoked by AmoebaHarmonicAngleForce to calculate the forces acting on the system and the energy of the system.
+ */
+class CudaCalcAmoebaHarmonicAngleForceKernel : public CalcAmoebaHarmonicAngleForceKernel {
+public:
+    CudaCalcAmoebaHarmonicAngleForceKernel(std::string name, const Platform& platform, CudaContext& cu, System& system);
+    ~CudaCalcAmoebaHarmonicAngleForceKernel();
+    /**
+     * Initialize the kernel.
+     * 
+     * @param system     the System this kernel will be applied to
+     * @param force      the AmoebaHarmonicAngleForce this kernel will be used for
+     */
+    void initialize(const System& system, const AmoebaHarmonicAngleForce& force);
+    /**
+     * Execute the kernel to calculate the forces and/or energy.
+     *
+     * @param context        the context in which to execute this kernel
+     * @param includeForces  true if forces should be calculated
+     * @param includeEnergy  true if the energy should be calculated
+     * @return the potential energy due to the force
+     */
+    double execute(ContextImpl& context, bool includeForces, bool includeEnergy);
+private:
+    class ForceInfo;
+    int numAngles;
+    CudaContext& cu;
+    System& system;
+    CudaArray* params;
+};
+
+/**
+ * This kernel is invoked by AmoebaHarmonicInPlaneAngleForce to calculate the forces acting on the system and the energy of the system.
+ */
+class CudaCalcAmoebaHarmonicInPlaneAngleForceKernel : public CalcAmoebaHarmonicInPlaneAngleForceKernel {
+public:
+    CudaCalcAmoebaHarmonicInPlaneAngleForceKernel(std::string name, const Platform& platform, CudaContext& cu, System& system);
+    ~CudaCalcAmoebaHarmonicInPlaneAngleForceKernel();
+    /**
+     * Initialize the kernel.
+     * 
+     * @param system     the System this kernel will be applied to
+     * @param force      the AmoebaHarmonicInPlaneAngleForce this kernel will be used for
+     */
+    void initialize(const System& system, const AmoebaHarmonicInPlaneAngleForce& force);
+    /**
+     * Execute the kernel to calculate the forces and/or energy.
+     *
+     * @param context        the context in which to execute this kernel
+     * @param includeForces  true if forces should be calculated
+     * @param includeEnergy  true if the energy should be calculated
+     * @return the potential energy due to the force
+     */
+    double execute(ContextImpl& context, bool includeForces, bool includeEnergy);
+private:
+    class ForceInfo;
+    int numAngles;
+    CudaContext& cu;
+    System& system;
+    CudaArray* params;
+};
+
+/**
+ * This kernel is invoked by AmoebaTorsionForce to calculate the forces acting on the system and the energy of the system.
+ */
+class CudaCalcAmoebaTorsionForceKernel : public CalcAmoebaTorsionForceKernel {
+public:
+    CudaCalcAmoebaTorsionForceKernel(std::string name, const Platform& platform, CudaContext& cu, System& system);
+    ~CudaCalcAmoebaTorsionForceKernel();
+    /**
+     * Initialize the kernel.
+     * 
+     * @param system     the System this kernel will be applied to
+     * @param force      the AmoebaTorsionForce this kernel will be used for
+     */
+    void initialize(const System& system, const AmoebaTorsionForce& force);
+    /**
+     * Execute the kernel to calculate the forces and/or energy.
+     *
+     * @param context        the context in which to execute this kernel
+     * @param includeForces  true if forces should be calculated
+     * @param includeEnergy  true if the energy should be calculated
+     * @return the potential energy due to the force
+     */
+    double execute(ContextImpl& context, bool includeForces, bool includeEnergy);
+private:
+    class ForceInfo;
+    int numTorsions;
+    CudaContext& cu;
+    System& system;
+};
+
+/**
+ * This kernel is invoked by AmoebaPiTorsionForce to calculate the forces acting on the system and the energy of the system.
+ */
+class CudaCalcAmoebaPiTorsionForceKernel : public CalcAmoebaPiTorsionForceKernel {
+public:
+    CudaCalcAmoebaPiTorsionForceKernel(std::string name, const Platform& platform, CudaContext& cu, System& system);
+    ~CudaCalcAmoebaPiTorsionForceKernel();
+    /**
+     * Initialize the kernel.
+     * 
+     * @param system     the System this kernel will be applied to
+     * @param force      the AmoebaPiTorsionForce this kernel will be used for
+     */
+    void initialize(const System& system, const AmoebaPiTorsionForce& force);
+    /**
+     * Execute the kernel to calculate the forces and/or energy.
+     *
+     * @param context        the context in which to execute this kernel
+     * @param includeForces  true if forces should be calculated
+     * @param includeEnergy  true if the energy should be calculated
+     * @return the potential energy due to the force
+     */
+    double execute(ContextImpl& context, bool includeForces, bool includeEnergy);
+private:
+    class ForceInfo;
+    int numPiTorsions;
+    CudaContext& cu;
+    System& system;
+    CudaArray* params;
+};
+
+/**
+ * This kernel is invoked by AmoebaStretchBendForce to calculate the forces acting on the system and the energy of the system.
+ */
+class CudaCalcAmoebaStretchBendForceKernel : public CalcAmoebaStretchBendForceKernel {
+public:
+    CudaCalcAmoebaStretchBendForceKernel(std::string name, const Platform& platform, CudaContext& cu, System& system);
+    ~CudaCalcAmoebaStretchBendForceKernel();
+    /**
+     * Initialize the kernel.
+     * 
+     * @param system     the System this kernel will be applied to
+     * @param force      the AmoebaStretchBendForce this kernel will be used for
+     */
+    void initialize(const System& system, const AmoebaStretchBendForce& force);
+    /**
+     * Execute the kernel to calculate the forces and/or energy.
+     *
+     * @param context        the context in which to execute this kernel
+     * @param includeForces  true if forces should be calculated
+     * @param includeEnergy  true if the energy should be calculated
+     * @return the potential energy due to the force
+     */
+    double execute(ContextImpl& context, bool includeForces, bool includeEnergy);
+private:
+    class ForceInfo;
+    int numStretchBends;
+    CudaContext& cu;
+    System& system;
+};
+
+/**
+ * This kernel is invoked by AmoebaOutOfPlaneBendForce to calculate the forces acting on the system and the energy of the system.
+ */
+class CudaCalcAmoebaOutOfPlaneBendForceKernel : public CalcAmoebaOutOfPlaneBendForceKernel {
+public:
+    CudaCalcAmoebaOutOfPlaneBendForceKernel(std::string name, const Platform& platform, CudaContext& cu, System& system);
+    ~CudaCalcAmoebaOutOfPlaneBendForceKernel();
+    /**
+     * Initialize the kernel.
+     * 
+     * @param system     the System this kernel will be applied to
+     * @param force      the AmoebaOutOfPlaneBendForce this kernel will be used for
+     */
+    void initialize(const System& system, const AmoebaOutOfPlaneBendForce& force);
+    /**
+     * Execute the kernel to calculate the forces and/or energy.
+     *
+     * @param context        the context in which to execute this kernel
+     * @param includeForces  true if forces should be calculated
+     * @param includeEnergy  true if the energy should be calculated
+     * @return the potential energy due to the force
+     */
+    double execute(ContextImpl& context, bool includeForces, bool includeEnergy);
+private:
+    class ForceInfo;
+    int numOutOfPlaneBends;
+    CudaContext& cu;
+    System& system;
+};
+
+/**
+ * This kernel is invoked by AmoebaTorsionTorsionForce to calculate the forces acting on the system and the energy of the system.
+ */
+class CudaCalcAmoebaTorsionTorsionForceKernel : public CalcAmoebaTorsionTorsionForceKernel {
+public:
+    CudaCalcAmoebaTorsionTorsionForceKernel(std::string name, const Platform& platform, CudaContext& cu, System& system);
+    ~CudaCalcAmoebaTorsionTorsionForceKernel();
+    /**
+     * Initialize the kernel.
+     * 
+     * @param system     the System this kernel will be applied to
+     * @param force      the AmoebaTorsionTorsionForce this kernel will be used for
+     */
+    void initialize(const System& system, const AmoebaTorsionTorsionForce& force);
+    /**
+     * Execute the kernel to calculate the forces and/or energy.
+     *
+     * @param context        the context in which to execute this kernel
+     * @param includeForces  true if forces should be calculated
+     * @param includeEnergy  true if the energy should be calculated
+     * @return the potential energy due to the force
+     */
+    double execute(ContextImpl& context, bool includeForces, bool includeEnergy);
+private:
+    class ForceInfo;
+    int numTorsionTorsions;
+    int numTorsionTorsionGrids;
+    CudaContext& cu;
+    System& system;
+};
+
+/**
+ * This kernel is invoked by AmoebaMultipoleForce to calculate the forces acting on the system and the energy of the system.
+ */
+class CudaCalcAmoebaMultipoleForceKernel : public CalcAmoebaMultipoleForceKernel {
+public:
+    CudaCalcAmoebaMultipoleForceKernel(std::string name, const Platform& platform, CudaContext& cu, System& system);
+    ~CudaCalcAmoebaMultipoleForceKernel();
+    /**
+     * Initialize the kernel.
+     * 
+     * @param system     the System this kernel will be applied to
+     * @param force      the AmoebaMultipoleForce this kernel will be used for
+     */
+    void initialize(const System& system, const AmoebaMultipoleForce& force);
+    /**
+     * Execute the kernel to calculate the forces and/or energy.
+     *
+     * @param context        the context in which to execute this kernel
+     * @param includeForces  true if forces should be calculated
+     * @param includeEnergy  true if the energy should be calculated
+     * @return the potential energy due to the force
+     */
+    double execute(ContextImpl& context, bool includeForces, bool includeEnergy);
+    /**
+     * Execute the kernel to calculate the electrostatic potential
+     *
+     * @param context        the context in which to execute this kernel
+     * @param inputGrid      input grid coordinates
+     * @param outputElectrostaticPotential output potential 
+     */
+    void getElectrostaticPotential(ContextImpl& context, const std::vector< Vec3 >& inputGrid,
+                                   std::vector< double >& outputElectrostaticPotential );
+
+   /** 
+     * Get the system multipole moments
+     *
+     * @param origin       origin
+     * @param context      context
+     * @param outputMultipoleMonents (charge,
+                                      dipole_x, dipole_y, dipole_z,
+                                      quadrupole_xx, quadrupole_xy, quadrupole_xz,
+                                      quadrupole_yx, quadrupole_yy, quadrupole_yz,
+                                      quadrupole_zx, quadrupole_zy, quadrupole_zz )
+     */
+
+    void getSystemMultipoleMoments( ContextImpl& context, const Vec3& origin, std::vector< double >& outputMultipoleMonents );
+
+
+private:
+    class ForceInfo;
+    int numMultipoles;
+    CudaContext& cu;
+    System& system;
+};
+
+/**
+ * This kernel is invoked by AmoebaMultipoleForce to calculate the forces acting on the system and the energy of the system.
+ */
+class CudaCalcAmoebaGeneralizedKirkwoodForceKernel : public CalcAmoebaGeneralizedKirkwoodForceKernel {
+public:
+    CudaCalcAmoebaGeneralizedKirkwoodForceKernel(std::string name, const Platform& platform, CudaContext& cu, System& system);
+    ~CudaCalcAmoebaGeneralizedKirkwoodForceKernel();
+    /**
+     * Initialize the kernel.
+     * 
+     * @param system     the System this kernel will be applied to
+     * @param force      the AmoebaMultipoleForce this kernel will be used for
+     */
+    void initialize(const System& system, const AmoebaGeneralizedKirkwoodForce& force);
+    /**
+     * Execute the kernel to calculate the forces and/or energy.
+     *
+     * @param context        the context in which to execute this kernel
+     * @param includeForces  true if forces should be calculated
+     * @param includeEnergy  true if the energy should be calculated
+     * @return the potential energy due to the force
+     */
+    double execute(ContextImpl& context, bool includeForces, bool includeEnergy);
+private:
+    class ForceInfo;
+    CudaContext& cu;
+    System& system;
+};
+
+/**
+ * This kernel is invoked to calculate the vdw forces acting on the system and the energy of the system.
+ */
+class CudaCalcAmoebaVdwForceKernel : public CalcAmoebaVdwForceKernel {
+public:
+    CudaCalcAmoebaVdwForceKernel(std::string name, const Platform& platform, CudaContext& cu, System& system);
+    ~CudaCalcAmoebaVdwForceKernel();
+    /**
+     * Initialize the kernel.
+     * 
+     * @param system     the System this kernel will be applied to
+     * @param force      the AmoebaMultipoleForce this kernel will be used for
+     */
+    void initialize(const System& system, const AmoebaVdwForce& force);
+    /**
+     * Execute the kernel to calculate the forces and/or energy.
+     *
+     * @param context        the context in which to execute this kernel
+     * @param includeForces  true if forces should be calculated
+     * @param includeEnergy  true if the energy should be calculated
+     * @return the potential energy due to the force
+     */
+    double execute(ContextImpl& context, bool includeForces, bool includeEnergy);
+private:
+    class ForceInfo;
+    CudaContext& cu;
+    System& system;
+};
+
+/**
+ * This kernel is invoked to calculate the WCA dispersion forces acting on the system and the energy of the system.
+ */
+class CudaCalcAmoebaWcaDispersionForceKernel : public CalcAmoebaWcaDispersionForceKernel {
+public:
+    CudaCalcAmoebaWcaDispersionForceKernel(std::string name, const Platform& platform, CudaContext& cu, System& system);
+    ~CudaCalcAmoebaWcaDispersionForceKernel();
+    /**
+     * Initialize the kernel.
+     * 
+     * @param system     the System this kernel will be applied to
+     * @param force      the AmoebaMultipoleForce this kernel will be used for
+     */
+    void initialize(const System& system, const AmoebaWcaDispersionForce& force);
+    /**
+     * Execute the kernel to calculate the forces and/or energy.
+     *
+     * @param context        the context in which to execute this kernel
+     * @param includeForces  true if forces should be calculated
+     * @param includeEnergy  true if the energy should be calculated
+     * @return the potential energy due to the force
+     */
+    double execute(ContextImpl& context, bool includeForces, bool includeEnergy);
+private:
+    class ForceInfo;
+    CudaContext& cu;
+    System& system;
+};
+
+} // namespace OpenMM
+
+#endif /*AMOEBA_OPENMM_CUDAKERNELS_H*/

plugins/amoeba/platforms/cuda2/src/CudaAmoebaKernelSources.cpp.in

+/* -------------------------------------------------------------------------- *
+ *                                   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) 2012 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 "CudaAmoebaKernelSources.h"
+
+using namespace OpenMM;
+using namespace std;
+

plugins/amoeba/platforms/cuda2/src/CudaAmoebaKernelSources.h.in

+#ifndef OPENMM_CUDAAMOEBAKERNELSOURCES_H_
+#define OPENMM_CUDAAMOEBAKERNELSOURCES_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) 2010-2012 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/internal/windowsExport.h"
+#include <string>
+
+namespace OpenMM {
+
+/**
+ * This class is a central holding place for the source code of CUDA kernels.
+ * The CMake build script inserts declarations into it based on the .cu files in the
+ * kernels subfolder.
+ */
+
+class OPENMM_EXPORT CudaAmoebaKernelSources {
+public:
+@CUDA_FILE_DECLARATIONS@
+};
+
+} // namespace OpenMM
+
+#endif /*OPENMM_CUDAAMOEBAKERNELSOURCES_H_*/

plugins/amoeba/platforms/cuda2/src/kernels/amoebaAngleForce.cu

+float2 angleParams = PARAMS[index];
+real deltaIdeal = theta*RAD_TO_DEG-angleParams.x;
+real deltaIdeal2 = deltaIdeal*deltaIdeal;
+real deltaIdeal3 = deltaIdeal*deltaIdeal2;
+real deltaIdeal4 = deltaIdeal2*deltaIdeal2;
+energy += angleParams.y*deltaIdeal2*(1.0f + CUBIC_K*deltaIdeal + QUARTIC_K*deltaIdeal2 + PENTIC_K*deltaIdeal3 + SEXTIC_K*deltaIdeal4);
+real dEdAngle = angleParams.y*deltaIdeal*(2.0f + 3.0f*CUBIC_K*deltaIdeal + 4.0f*QUARTIC_K*deltaIdeal2 + 5.0f*PENTIC_K*deltaIdeal3 + 6.0f*SEXTIC_K*deltaIdeal4);
+dEdAngle *= RAD_TO_DEG;
\ No newline at end of file

plugins/amoeba/platforms/cuda2/src/kernels/amoebaBondForce.cu

+float2 bondParams = PARAMS[index];
+real deltaIdeal = r-bondParams.x;
+real deltaIdeal2 = deltaIdeal*deltaIdeal;
+energy += bondParams.y*deltaIdeal2*(1.0f + CUBIC_K*deltaIdeal + QUARTIC_K*deltaIdeal2);
+real dEdR = 2.0f*bondParams.y*deltaIdeal*(1.0f + 1.5f*CUBIC_K*deltaIdeal + 2.0f*QUARTIC_K*deltaIdeal2);

plugins/amoeba/platforms/cuda2/src/kernels/amoebaInPlaneForce.cu

+float2 angleParams = PARAMS[index];
+real xad = pos1.x - pos4.x;
+real yad = pos1.y - pos4.y;
+real zad = pos1.z - pos4.z;
+
+real xbd = pos2.x - pos4.x;
+real ybd = pos2.y - pos4.y;
+real zbd = pos2.z - pos4.z;
+
+real xcd = pos3.x - pos4.x;
+real ycd = pos3.y - pos4.y;
+real zcd = pos3.z - pos4.z;
+
+real xt = yad*zcd - zad*ycd;
+real yt = zad*xcd - xad*zcd;
+real zt = xad*ycd - yad*xcd;
+
+real rt2 = xt*xt + yt*yt + zt*zt;
+
+real delta = -(xt*xbd + yt*ybd + zt*zbd) / rt2;
+
+real xip = pos2.x + xt*delta;
+real yip = pos2.y + yt*delta;
+real zip = pos2.z + zt*delta;
+
+real xap = pos1.x - xip;
+real yap = pos1.y - yip;
+real zap = pos1.z - zip;
+
+real xcp = pos3.x - xip;
+real ycp = pos3.y - yip;
+real zcp = pos3.z - zip;
+
+real rap2 = xap*xap + yap*yap + zap*zap;
+real rcp2 = xcp*xcp + ycp*ycp + zcp*zcp;
+
+real xm = ycp*zap - zcp*yap;
+real ym = zcp*xap - xcp*zap;
+real zm = xcp*yap - ycp*xap;
+
+real rm = max(SQRT(xm*xm + ym*ym + zm*zm), (real) 1e-6f);
+real dot = xap*xcp + yap*ycp + zap*zcp;
+real product = SQRT(rap2*rcp2);
+real cosine = (product > 0 ? (dot/product) : 0);
+cosine = max(min(cosine, (real) 1), (real) -1);
+real angle = ACOS(cosine);
+
+// if product == 0, set force/energy to 0
+
+real deltaIdeal = (product > 0 ? (angle*RAD_TO_DEG - angleParams.x) : 0);
+real deltaIdeal2 = deltaIdeal*deltaIdeal;
+real deltaIdeal3 = deltaIdeal*deltaIdeal2;
+real deltaIdeal4 = deltaIdeal2*deltaIdeal2;
+
+energy += angleParams.y*deltaIdeal2*(1.0f + CUBIC_K*deltaIdeal + QUARTIC_K*deltaIdeal2 + PENTIC_K*deltaIdeal3 + SEXTIC_K*deltaIdeal4);
+real dEdAngle = angleParams.y*deltaIdeal*(2.0f + 3.0f*CUBIC_K*deltaIdeal + 4.0f*QUARTIC_K*deltaIdeal2 + 5.0f*PENTIC_K*deltaIdeal3 + 6.0f*SEXTIC_K*deltaIdeal4);
+dEdAngle *= RAD_TO_DEG;
+
+real terma = -dEdAngle/(rap2*rm);
+real termc = dEdAngle/(rcp2*rm);
+
+real dedxia = terma * (yap*zm-zap*ym);
+real dedyia = terma * (zap*xm-xap*zm);
+real dedzia = terma * (xap*ym-yap*xm);
+
+real dedxic = termc * (ycp*zm-zcp*ym);
+real dedyic = termc * (zcp*xm-xcp*zm);
+real dedzic = termc * (xcp*ym-ycp*xm);
+
+real dedxip = -dedxia - dedxic;
+real dedyip = -dedyia - dedyic;
+real dedzip = -dedzia - dedzic;
+
+real delta2 = 2.0f*delta;
+real ptrt2 = (dedxip*xt + dedyip*yt + dedzip*zt) / rt2;
+
+real term = (zcd*ybd-ycd*zbd) + delta2*(yt*zcd-zt*ycd);
+real dpdxia = delta*(ycd*dedzip-zcd*dedyip) + term*ptrt2;
+
+term = (xcd*zbd-zcd*xbd) + delta2*(zt*xcd-xt*zcd);
+real dpdyia = delta*(zcd*dedxip-xcd*dedzip) + term*ptrt2;
+
+term = (ycd*xbd-xcd*ybd) + delta2*(xt*ycd-yt*xcd);
+real dpdzia = delta*(xcd*dedyip-ycd*dedxip) + term*ptrt2;
+
+term = (yad*zbd-zad*ybd) + delta2*(zt*yad-yt*zad);
+real dpdxic = delta*(zad*dedyip-yad*dedzip) + term*ptrt2;
+
+term = (zad*xbd-xad*zbd) + delta2*(xt*zad-zt*xad);
+real dpdyic = delta*(xad*dedzip-zad*dedxip) + term*ptrt2;
+
+term = (xad*ybd-yad*xbd) + delta2*(yt*xad-xt*yad);
+real dpdzic = delta*(yad*dedxip-xad*dedyip) + term*ptrt2;
+
+dedxia = dedxia + dpdxia;
+dedyia = dedyia + dpdyia;
+dedzia = dedzia + dpdzia;
+
+real dedxib = dedxip;
+real dedyib = dedyip;
+real dedzib = dedzip;
+
+dedxic = dedxic + dpdxic;
+dedyic = dedyic + dpdyic;
+dedzic = dedzic + dpdzic;
+
+real dedxid = -dedxia - dedxib - dedxic;
+real dedyid = -dedyia - dedyib - dedyic;
+real dedzid = -dedzia - dedzib - dedzic;
+
+real3 force1 = make_real3(-dedxia, -dedyia, -dedzia);
+real3 force2 = make_real3(-dedxib, -dedyib, -dedzib);
+real3 force3 = make_real3(-dedxic, -dedyic, -dedzic);
+real3 force4 = make_real3(-dedxid, -dedyid, -dedzid);
\ No newline at end of file

plugins/amoeba/platforms/cuda2/src/kernels/amoebaPiTorsionForce.cu

+// compute the value of the pi-orbital torsion angle
+
+real xad = pos1.x - pos4.x;
+real yad = pos1.y - pos4.y;
+real zad = pos1.z - pos4.z;
+
+real xbd = pos2.x - pos4.x;
+real ybd = pos2.y - pos4.y;
+real zbd = pos2.z - pos4.z;
+
+real xec = pos5.x - pos3.x;
+real yec = pos5.y - pos3.y;
+real zec = pos5.z - pos3.z;
+
+real xgc = pos6.x - pos3.x;
+real ygc = pos6.y - pos3.y;
+real zgc = pos6.z - pos3.z;
+
+real xip = yad*zbd - ybd*zad + pos3.x;
+real yip = zad*xbd - zbd*xad + pos3.y;
+real zip = xad*ybd - xbd*yad + pos3.z;
+
+real xiq = yec*zgc - ygc*zec + pos4.x;
+real yiq = zec*xgc - zgc*xec + pos4.y;
+real ziq = xec*ygc - xgc*yec + pos4.z;
+
+real xcp = pos3.x - xip;
+real ycp = pos3.y - yip;
+real zcp = pos3.z - zip;
+
+real xdc = pos4.x - pos3.x;
+real ydc = pos4.y - pos3.y;
+real zdc = pos4.z - pos3.z;
+
+real xqd = xiq - pos4.x;
+real yqd = yiq - pos4.y;
+real zqd = ziq - pos4.z;
+
+real xt = ycp*zdc - ydc*zcp;
+real yt = zcp*xdc - zdc*xcp;
+real zt = xcp*ydc - xdc*ycp;
+
+real xu = ydc*zqd - yqd*zdc;
+real yu = zdc*xqd - zqd*xdc;
+real zu = xdc*yqd - xqd*ydc;
+
+real xtu = yt*zu - yu*zt;
+real ytu = zt*xu - zu*xt;
+real ztu = xt*yu - xu*yt;
+
+real rt2 = xt*xt + yt*yt + zt*zt;
+real ru2 = xu*xu + yu*yu + zu*zu;
+
+real rtru = sqrtf(rt2 * ru2);
+real rdc = sqrtf(xdc*xdc + ydc*ydc + zdc*zdc);
+
+real cosine = rtru > 0.0f ? (xt*xu + yt*yu + zt*zu) / rtru : 0.0f;
+real sine = (rtru*rdc) > 0.0f ? (xdc*xtu + ydc*ytu + zdc*ztu) / (rdc*rtru) : 0.0f;
+
+// zero energy/force if rtru == 0
+
+float v2 = PARAMS[index];
+v2 = (rtru > 0 ? v2 : 0.0f);
+
+// compute the multiple angle trigonometry and the phase terms
+
+real cosine2 = cosine*cosine - sine*sine;
+real sine2 = 2.0f * cosine * sine;
+real phi2 = 1.0f - cosine2;
+real dphi2 = 2.0f * sine2;
+
+// calculate pi-orbital torsion energy and master chain rule term
+
+energy += v2 * phi2;
+real dedphi = v2 * dphi2;
+
+// chain rule terms for first derivative components
+
+real xdp = pos4.x - xip;
+real ydp = pos4.y - yip;
+real zdp = pos4.z - zip;
+
+real xqc = xiq - pos3.x;
+real yqc = yiq - pos3.y;
+real zqc = ziq - pos3.z;
+
+real dedxt = dedphi * (yt*zdc - ydc*zt) / (rt2*rdc);
+real dedyt = dedphi * (zt*xdc - zdc*xt) / (rt2*rdc);
+real dedzt = dedphi * (xt*ydc - xdc*yt) / (rt2*rdc);
+
+real dedxu = -dedphi * (yu*zdc - ydc*zu) / (ru2*rdc);
+real dedyu = -dedphi * (zu*xdc - zdc*xu) / (ru2*rdc);
+real dedzu = -dedphi * (xu*ydc - xdc*yu) / (ru2*rdc);
+
+// compute first derivative components for pi-orbital angle
+
+real dedxip = zdc*dedyt - ydc*dedzt;
+real dedyip = xdc*dedzt - zdc*dedxt;
+real dedzip = ydc*dedxt - xdc*dedyt;
+
+real dedxic = ydp*dedzt - zdp*dedyt + zqd*dedyu - yqd*dedzu;
+real dedyic = zdp*dedxt - xdp*dedzt + xqd*dedzu - zqd*dedxu;
+real dedzic = xdp*dedyt - ydp*dedxt + yqd*dedxu - xqd*dedyu;
+
+real dedxid = zcp*dedyt - ycp*dedzt + yqc*dedzu - zqc*dedyu;
+real dedyid = xcp*dedzt - zcp*dedxt + zqc*dedxu - xqc*dedzu;
+real dedzid = ycp*dedxt - xcp*dedyt + xqc*dedyu - yqc*dedxu;
+
+real dedxiq = zdc*dedyu - ydc*dedzu;
+real dedyiq = xdc*dedzu - zdc*dedxu;
+real dedziq = ydc*dedxu - xdc*dedyu;
+
+// compute first derivative components for individual atoms
+
+real dedxia = ybd*dedzip - zbd*dedyip;
+real dedyia = zbd*dedxip - xbd*dedzip;
+real dedzia = xbd*dedyip - ybd*dedxip;
+
+real dedxib = zad*dedyip - yad*dedzip;
+real dedyib = xad*dedzip - zad*dedxip;
+real dedzib = yad*dedxip - xad*dedyip;
+
+real dedxie = ygc*dedziq - zgc*dedyiq;
+real dedyie = zgc*dedxiq - xgc*dedziq;
+real dedzie = xgc*dedyiq - ygc*dedxiq;
+
+real dedxig = zec*dedyiq - yec*dedziq;
+real dedyig = xec*dedziq - zec*dedxiq;
+real dedzig = yec*dedxiq - xec*dedyiq;
+
+dedxic = dedxic + dedxip - dedxie - dedxig;
+dedyic = dedyic + dedyip - dedyie - dedyig;
+dedzic = dedzic + dedzip - dedzie - dedzig;
+dedxid = dedxid + dedxiq - dedxia - dedxib;
+dedyid = dedyid + dedyiq - dedyia - dedyib;
+dedzid = dedzid + dedziq - dedzia - dedzib;
+
+real3 force1 = make_real3(-dedxia, -dedyia, -dedzia);
+real3 force2 = make_real3(-dedxib, -dedyib, -dedzib);
+real3 force3 = make_real3(-dedxic, -dedyic, -dedzic);
+real3 force4 = make_real3(-dedxid, -dedyid, -dedzid);
+real3 force5 = make_real3(-dedxie, -dedyie, -dedzie);
+real3 force6 = make_real3(-dedxig, -dedyig, -dedzig);
\ No newline at end of file

plugins/amoeba/platforms/cuda2/tests/AmoebaTinkerParameterFile.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 Stanford University and the Authors.           *
+ * Authors: Peter Eastman, Mark Friedrichs                                    *
+ * 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/internal/AssertionUtilities.h"
+
+#include "openmm/CMMotionRemover.h"
+#include "openmm/System.h"
+#include "openmm/Context.h"
+#include "openmm/LangevinIntegrator.h"
+#include "openmm/VariableLangevinIntegrator.h"
+#include "openmm/VerletIntegrator.h"
+#include "openmm/VariableVerletIntegrator.h"
+#include "openmm/BrownianIntegrator.h"
+
+#include "openmm/AmoebaHarmonicBondForce.h"
+#include "openmm/AmoebaHarmonicAngleForce.h"
+#include "openmm/AmoebaHarmonicInPlaneAngleForce.h"
+#include "openmm/AmoebaTorsionForce.h"
+#include "openmm/AmoebaPiTorsionForce.h"
+#include "openmm/AmoebaStretchBendForce.h"
+#include "openmm/AmoebaOutOfPlaneBendForce.h"
+#include "openmm/AmoebaTorsionTorsionForce.h"
+#include "openmm/AmoebaMultipoleForce.h"
+#include "openmm/AmoebaGeneralizedKirkwoodForce.h"
+#include "openmm/AmoebaVdwForce.h"
+#include "openmm/AmoebaWcaDispersionForce.h"
+#include "openmm/AmoebaUreyBradleyForce.h"
+#include "openmm/internal/windowsExport.h"
+#include "openmm/internal/AmoebaWcaDispersionForceImpl.h"
+
+#include <ctime>
+#include <vector>
+#include <algorithm>
+#include <map>
+#include <cfloat>
+#include <cstring>
+#include <cstdlib>
+#include <typeinfo>
+#include <time.h>
+
+extern "C" void registerAmoebaCudaKernelFactories();
+
+// force enums
+
+#define MAX_PRINT 5
+
+static std::string AMOEBA_HARMONIC_BOND_FORCE                         = "AmoebaHarmonicBond";
+static std::string AMOEBA_HARMONIC_ANGLE_FORCE                        = "AmoebaHarmonicAngle"; 
+static std::string AMOEBA_HARMONIC_IN_PLANE_ANGLE_FORCE               = "AmoebaHarmonicInPlaneAngle"; 
+static std::string AMOEBA_TORSION_FORCE                               = "AmoebaTorsion"; 
+static std::string AMOEBA_PI_TORSION_FORCE                            = "AmoebaPiTorsion"; 
+static std::string AMOEBA_STRETCH_BEND_FORCE                          = "AmoebaStretchBend";
+static std::string AMOEBA_OUT_OF_PLANE_BEND_FORCE                     = "AmoebaOutOfPlaneBend";
+static std::string AMOEBA_TORSION_TORSION_FORCE                       = "AmoebaTorsionTorsion";
+static std::string AMOEBA_MULTIPOLE_FORCE                             = "AmoebaMultipole";
+static std::string AMOEBA_GK_FORCE                                    = "AmoebaGk";
+static std::string AMOEBA_GK_CAVITY_FORCE                             = "AmoebaGkAndCavity";
+static std::string AMOEBA_VDW_FORCE                                   = "AmoebaVdw";
+static std::string AMOEBA_WCA_DISPERSION_FORCE                        = "AmoebaWcaDispersion";
+static std::string AMOEBA_UREY_BRADLEY_FORCE                          = "AmoebaUreyBradley";
+static std::string ALL_FORCES                                         = "AllForces";
+
+static std::string AMOEBA_MULTIPOLE_ROTATION_MATRICES                 = "AmoebaMultipoleRotationMatrices";
+static std::string AMOEBA_MULTIPOLE_ROTATED                           = "AmoebaMultipolesRotated";
+static std::string AMOEBA_FIXED_E                                     = "AmoebaFixedE";
+static std::string AMOEBA_FIXED_E_GK                                  = "AmoebaFixedE_GK";
+static std::string AMOEBA_INDUCDED_DIPOLES                            = "AmoebaInducedDipoles";
+static std::string AMOEBA_INDUCDED_DIPOLES_GK                         = "AmoebaInducedDipoles_GK";
+
+static std::string INCLUDE_OBC_CAVITY_TERM                            = "includeObcCavityTerm";
+static std::string MUTUAL_INDUCED_MAX_ITERATIONS                      = "mutualInducedMaxIterations";
+static std::string MUTUAL_INDUCED_TARGET_EPSILON                      = "mutualInducedTargetEpsilon";
+static std::string APPLY_N2                                           = "applyN2";
+static std::string ZERO_HARMONIC_BOND_IXN                             = "zeroHarmonicBondIxn";
+
+#define AmoebaHarmonicBondIndex                            0
+#define AmoebaHarmonicAngleIndex                           1
+#define AmoebaHarmonicInPlaneAngleIndex                    2
+#define AmoebaTorsionIndex                                 3
+#define AmoebaPiTorsionIndex                               4
+#define AmoebaStretchBendIndex                             5
+#define AmoebaOutOfPlaneBendIndex                          6
+#define AmoebaTorsionTorsionIndex                          7
+#define AmoebaMultipoleIndex                               8
+#define AmoebaVdwIndex                                     9
+#define AmoebaWcaDispersionIndex                          10
+#define AmoebaObcIndex                                    11
+#define SumIndex                                          12
+#define UreyBradleyIndex                                  13
+#define AmoebaLastIndex                                   14
+
+#define AngstromToNm 0.1
+#define CalToJoule   4.184
+
+const double DegreesToRadians = 3.14159265/180.0;
+const double RadiansToDegrees = 180/3.14159265;
+
+using namespace OpenMM;
+using namespace std;
+
+// the following are used in parsing parameter file
+
+typedef std::vector<std::string> StringVector;
+typedef StringVector::iterator StringVectorI;
+typedef StringVector::const_iterator StringVectorCI;
+
+typedef std::vector<StringVector> StringVectorVector;
+
+typedef std::vector<std::vector<double> > VectorOfVectors;
+typedef VectorOfVectors::iterator VectorOfVectorsI;
+typedef VectorOfVectors::const_iterator VectorOfVectorsCI;
+
+typedef std::map< std::string, VectorOfVectors > MapStringVectorOfVectors;
+typedef MapStringVectorOfVectors::iterator MapStringVectorOfVectorsI;
+typedef MapStringVectorOfVectors::const_iterator MapStringVectorOfVectorsCI;
+
+typedef std::map< std::string, std::string > MapStringString;
+typedef MapStringString::iterator MapStringStringI;
+typedef MapStringString::const_iterator MapStringStringCI;
+
+typedef std::map< std::string, int > MapStringInt;
+typedef MapStringInt::iterator MapStringIntI;
+typedef MapStringInt::const_iterator MapStringIntCI;
+
+typedef std::map< std::string,  std::vector<Vec3> > MapStringVec3;
+typedef MapStringVec3::iterator MapStringVec3I;
+typedef MapStringVec3::const_iterator MapStringVec3CI;
+
+typedef std::map< std::string, double > MapStringDouble;
+typedef MapStringDouble::iterator MapStringDoubleI;
+typedef MapStringDouble::const_iterator MapStringDoubleCI;
+
+typedef std::map< std::string, Force*> MapStringForce;
+typedef MapStringForce::iterator MapStringForceI;
+typedef MapStringForce::const_iterator MapStringForceCI;
+
+// default return value from methods
+
+static const int DefaultReturnValue               = 0;
+
+
+static const int LengthUnit                       = 0;
+static const int EnergyUnit                       = 1;
+static const int ForceUnit                        = 2;
+static const int LastUnits                        = ForceUnit + 1;
+
+static const int NoUnitsConversion                = 0;
+static const int KcalA_To_kJNm                    = 1;
+
+/**---------------------------------------------------------------------------------------
+ * Initialize units
+ *
+ * @param unitType        has w/ force name as key and int as value
+ * @param units array
+ *
+ *
+    --------------------------------------------------------------------------------------- */
+
+void setUnits( int unitType, double* units );
+
+/**---------------------------------------------------------------------------------------
+
+    Read parameter file
+
+    @param inputParameterFile   input parameter file name
+    @param system               system to which forces based on parameters are to be added
+    @param coordinates          Vec3 array containing coordinates on output
+    @param velocities           Vec3 array containing velocities on output
+    @param inputLog             log file pointer -- may be NULL
+
+    @return number of lines read
+
+    --------------------------------------------------------------------------------------- */
+
+Integrator* readAmoebaParameterFile( const std::string& inputParameterFile, MapStringInt& forceMap, System& system,
+                                     std::vector<Vec3>& coordinates, 
+                                     std::vector<Vec3>& velocities,
+                                     MapStringVec3& forces, MapStringDouble& potentialEnergy,
+                                     MapStringVectorOfVectors& supplementary, FILE* inputLog );
+
+
+/**---------------------------------------------------------------------------------------
+ * Get integrator
+ * 
+ * @param  integratorName       integratorName (VerletIntegrator, BrownianIntegrator, LangevinIntegrator, ...)
+ * @param  timeStep             time step
+ * @param  friction (ps)        friction
+ * @param  temperature          temperature
+ * @param  shakeTolerance       Shake tolerance
+ * @param  errorTolerance       Error tolerance
+ * @param  randomNumberSeed     seed
+ *
+ * @return DefaultReturnValue or ErrorReturnValue
+ *
+    --------------------------------------------------------------------------------------- */
+
+Integrator* getIntegrator( std::string& integratorName, double timeStep,
+                             double friction, double temperature,
+                             double shakeTolerance, double errorTolerance,
+                             int randomNumberSeed, FILE* log );
+
+/**---------------------------------------------------------------------------------------
+ * Initialize forceMap
+ *
+ * @param forceMap        has w/ force name as key and int as value
+ * @param initialValue    initial value
+ *
+ *
+    --------------------------------------------------------------------------------------- */
+
+void initializeForceMap( MapStringInt& forceMap, int initialValue );
+
+void testUsingAmoebaTinkerParameterFile( const std::string& amoebaTinkerParameterFileName, MapStringInt& forceMap,
+                                         double tolerance, FILE* summaryFile, FILE* log );
+
+int OPENMM_EXPORT runTestsUsingAmoebaTinkerParameterFile( MapStringString& argumentMap );
+void OPENMM_EXPORT appendInputArgumentsToArgumentMap( int numberOfArguments, char* argv[], MapStringString& argumentMap );

plugins/amoeba/platforms/cuda2/tests/CMakeLists.txt

+#
+# Testing
+#
+
+ENABLE_TESTING()
+
+INCLUDE_DIRECTORIES(${CUDA_INCLUDE_DIR})
+
+# Automatically create tests using files named "Test*.cpp"
+FILE(GLOB TEST_PROGS "*Test*.cpp")
+FOREACH(TEST_PROG ${TEST_PROGS})
+    GET_FILENAME_COMPONENT(TEST_ROOT ${TEST_PROG} NAME_WE)
+
+    # Link with shared library
+    ADD_EXECUTABLE(${TEST_ROOT} ${TEST_PROG})
+    TARGET_LINK_LIBRARIES(${TEST_ROOT} ${SHARED_AMOEBA_TARGET} ${SHARED_TARGET})
+    ADD_TEST(${TEST_ROOT} ${EXECUTABLE_OUTPUT_PATH}/${TEST_ROOT})
+
+ENDFOREACH(TEST_PROG ${TEST_PROGS})

plugins/amoeba/platforms/cuda2/tests/TestCudaAmoebaHarmonicAngleForce.cpp

+/* -------------------------------------------------------------------------- *
+ *                                   OpenMMAmoeba                             *
+ * -------------------------------------------------------------------------- *
+ * 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) 2008 Stanford University and the Authors.           *
+ * Authors: Mark Friedrichs                                                   *
+ * 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.                                     *
+ * -------------------------------------------------------------------------- */
+
+/**
+ * This tests the CUDA implementation of CudaAmoebaHarmonicAngleForce.
+ */
+
+#include "openmm/internal/AssertionUtilities.h"
+#include "AmoebaTinkerParameterFile.h"
+#include "openmm/Context.h"
+#include "OpenMMAmoeba.h"
+#include "openmm/System.h"
+#include "openmm/LangevinIntegrator.h"
+#include <iostream>
+#include <vector>
+
+using namespace OpenMM;
+
+const double TOL = 1e-5;
+#define PI_M               3.141592653589
+#define RADIAN            57.29577951308
+#define RADIAN_TO_DEGREE  57.29577951308
+#define DEGREE_TO_RADIAN   0.01745329252
+#define RADIAN_INVERSE     0.01745329252
+
+/* ---------------------------------------------------------------------------------------
+
+   Compute cross product of two 3-vectors and place in 3rd vector
+
+   vectorZ = vectorX x vectorY
+
+   @param vectorX             x-vector
+   @param vectorY             y-vector
+   @param vectorZ             z-vector
+
+   @return vector is vectorZ
+
+   --------------------------------------------------------------------------------------- */
+     
+static void crossProductVector3( double* vectorX, double* vectorY, double* vectorZ ){
+
+    vectorZ[0]  = vectorX[1]*vectorY[2] - vectorX[2]*vectorY[1];
+    vectorZ[1]  = vectorX[2]*vectorY[0] - vectorX[0]*vectorY[2];
+    vectorZ[2]  = vectorX[0]*vectorY[1] - vectorX[1]*vectorY[0];
+
+    return;
+}
+
+static void getPrefactorsGivenAngleCosine( double cosine, double idealAngle, double quadraticK, double cubicK,
+                                           double quarticK, double penticK, double sexticK,
+                                           double* dEdR, double* energyTerm, FILE* log ) {
+
+    double angle;
+    if( cosine >= 1.0 ){
+        angle = 0.0f;
+    } else if( cosine <= -1.0 ){
+        angle = RADIAN*PI_M;
+    } else {
+        angle = RADIAN*acos(cosine);
+    }
+
+#ifdef AMOEBA_DEBUG
+    if( log ){
+        (void) fprintf( log, "getPrefactorsGivenAngleCosine: cosine=%10.3e angle=%10.3e ideal=%10.3e\n", cosine, angle, idealAngle ); 
+        (void) fflush( log );
+    }
+#endif
+
+    double deltaIdeal         = angle - idealAngle;
+    double deltaIdeal2        = deltaIdeal*deltaIdeal;
+    double deltaIdeal3        = deltaIdeal*deltaIdeal2;
+    double deltaIdeal4        = deltaIdeal2*deltaIdeal2;
+ 
+    // deltaIdeal = r - r_0
+ 
+    *dEdR        = ( 2.0                        +
+                     3.0*cubicK*  deltaIdeal    +
+                     4.0*quarticK*deltaIdeal2   +
+                     5.0*penticK* deltaIdeal3   +
+                     6.0*sexticK* deltaIdeal4     );
+ 
+    *dEdR       *= RADIAN*quadraticK*deltaIdeal;
+ 
+
+    *energyTerm  = 1.0f + cubicK* deltaIdeal    +
+                          quarticK*deltaIdeal2   +
+                          penticK* deltaIdeal3   +
+                          sexticK* deltaIdeal4;
+    *energyTerm *= quadraticK*deltaIdeal2;
+
+    return;
+}
+
+static void computeAmoebaHarmonicAngleForce(int bondIndex,  std::vector<Vec3>& positions, AmoebaHarmonicAngleForce& amoebaHarmonicAngleForce,
+                                             std::vector<Vec3>& forces, double* energy, FILE* log ) {
+
+    int particle1, particle2, particle3;
+    double idealAngle;
+    double quadraticK;
+    amoebaHarmonicAngleForce.getAngleParameters(bondIndex, particle1, particle2, particle3, idealAngle, quadraticK );
+
+    double cubicK         = amoebaHarmonicAngleForce.getAmoebaGlobalHarmonicAngleCubic();
+    double quarticK       = amoebaHarmonicAngleForce.getAmoebaGlobalHarmonicAngleQuartic();
+    double penticK        = amoebaHarmonicAngleForce.getAmoebaGlobalHarmonicAnglePentic();
+    double sexticK        = amoebaHarmonicAngleForce.getAmoebaGlobalHarmonicAngleSextic();
+
+#ifdef AMOEBA_DEBUG
+    if( log ){
+        (void) fprintf( log, "computeAmoebaHarmonicAngleForce: bond %d [%d %d %d] ang=%10.3f k=%10.3f [%10.3e %10.3e %10.3e %10.3e]\n", 
+                             bondIndex, particle1, particle2, particle3, idealAngle, quadraticK, cubicK, quarticK, penticK, sexticK );
+        (void) fflush( log );
+    }
+#endif
+
+    double deltaR[2][3];
+    double r2_0 = 0.0;
+    double r2_1 = 0.0;
+    for( int ii = 0; ii < 3; ii++ ){
+
+           deltaR[0][ii]    = positions[particle1][ii] - positions[particle2][ii];
+           r2_0            += deltaR[0][ii]*deltaR[0][ii];
+
+           deltaR[1][ii]    = positions[particle3][ii] - positions[particle2][ii];
+           r2_1            += deltaR[1][ii]*deltaR[1][ii];
+
+    }
+
+    double pVector[3];
+    crossProductVector3( deltaR[0], deltaR[1], pVector );
+    double rp      = sqrt( pVector[0]*pVector[0] + pVector[1]*pVector[1] + pVector[2]*pVector[2] );
+    if( rp < 1.0e-06 ){
+       rp = 1.0e-06;
+    }   
+    double dot    = deltaR[0][0]*deltaR[1][0] + deltaR[0][1]*deltaR[1][1] + deltaR[0][2]*deltaR[1][2];
+    double cosine = dot/sqrt(r2_0*r2_1);
+
+#ifdef AMOEBA_DEBUG
+    if( log ){
+        (void) fprintf( log, "dot=%10.3e r2_0=%10.3e r2_1=%10.3e\n", dot, r2_0, r2_1 ); 
+        (void) fflush( log );
+    }
+#endif
+
+    double dEdR;
+    double energyTerm;
+    getPrefactorsGivenAngleCosine( cosine, idealAngle, quadraticK, cubicK,
+                                   quarticK, penticK, sexticK, &dEdR, &energyTerm, log );
+
+    double termA  = -dEdR/(r2_0*rp);
+    double termC  =  dEdR/(r2_1*rp);
+
+    double deltaCrossP[3][3];
+    crossProductVector3( deltaR[0], pVector, deltaCrossP[0] );
+    crossProductVector3( deltaR[1], pVector, deltaCrossP[2] );
+    for( int ii = 0; ii < 3; ii++ ){
+        deltaCrossP[0][ii] *= termA;
+        deltaCrossP[2][ii] *= termC;
+        deltaCrossP[1][ii]  = -1.0*(deltaCrossP[0][ii] + deltaCrossP[2][ii]);
+    }
+
+    forces[particle1][0]       += deltaCrossP[0][0];
+    forces[particle1][1]       += deltaCrossP[0][1];
+    forces[particle1][2]       += deltaCrossP[0][2];
+
+    forces[particle2][0]       += deltaCrossP[1][0];
+    forces[particle2][1]       += deltaCrossP[1][1];
+    forces[particle2][2]       += deltaCrossP[1][2];
+
+    forces[particle3][0]       += deltaCrossP[2][0];
+    forces[particle3][1]       += deltaCrossP[2][1];
+    forces[particle3][2]       += deltaCrossP[2][2];
+
+    *energy                    += energyTerm;
+}
+
+static void computeAmoebaHarmonicAngleForces( Context& context, AmoebaHarmonicAngleForce& amoebaHarmonicAngleForce,
+                                             std::vector<Vec3>& expectedForces, double* expectedEnergy, FILE* log ) {
+
+    // get positions and zero forces
+
+    State state = context.getState(State::Positions);
+    std::vector<Vec3> positions = state.getPositions();
+    expectedForces.resize( positions.size() );
+    
+    for( unsigned int ii = 0; ii < expectedForces.size(); ii++ ){
+        expectedForces[ii][0] = expectedForces[ii][1] = expectedForces[ii][2] = 0.0;
+    }
+
+    // calculates forces/energy
+
+    *expectedEnergy = 0.0;
+    for( int ii = 0; ii < amoebaHarmonicAngleForce.getNumAngles(); ii++ ){
+        computeAmoebaHarmonicAngleForce(ii, positions, amoebaHarmonicAngleForce, expectedForces, expectedEnergy, log );
+    }
+
+#ifdef AMOEBA_DEBUG
+    if( log ){
+        (void) fprintf( log, "computeAmoebaHarmonicAngleForces: expected energy=%14.7e\n", *expectedEnergy );
+        for( unsigned int ii = 0; ii < positions.size(); ii++ ){
+            (void) fprintf( log, "%6u [%14.7e %14.7e %14.7e]\n", ii, expectedForces[ii][0], expectedForces[ii][1], expectedForces[ii][2] );
+        }
+        (void) fflush( log );
+    }
+#endif
+
+    return;
+
+}
+
+void compareWithExpectedForceAndEnergy( Context& context, AmoebaHarmonicAngleForce& amoebaHarmonicAngleForce,
+                                        double tolerance, const std::string& idString, FILE* log) {
+
+    std::vector<Vec3> expectedForces;
+    double expectedEnergy;
+    computeAmoebaHarmonicAngleForces( context, amoebaHarmonicAngleForce, expectedForces, &expectedEnergy, log );
+   
+    State state                      = context.getState(State::Forces | State::Energy);
+    const std::vector<Vec3> forces   = state.getForces();
+
+#ifdef AMOEBA_DEBUG
+    if( log ){
+        (void) fprintf( log, "computeAmoebaHarmonicAngleForces: expected energy=%14.7e %14.7e\n", expectedEnergy, state.getPotentialEnergy() );
+        for( unsigned int ii = 0; ii < forces.size(); ii++ ){
+            (void) fprintf( log, "%6u [%14.7e %14.7e %14.7e]   [%14.7e %14.7e %14.7e]\n", ii,
+                            expectedForces[ii][0], expectedForces[ii][1], expectedForces[ii][2], forces[ii][0], forces[ii][1], forces[ii][2] );
+        }
+        (void) fflush( log );
+    }
+#endif
+
+    for( unsigned int ii = 0; ii < forces.size(); ii++ ){
+        ASSERT_EQUAL_VEC( expectedForces[ii], forces[ii], tolerance );
+    }
+    ASSERT_EQUAL_TOL( expectedEnergy, state.getPotentialEnergy(), tolerance );
+}
+
+void testOneAngle( FILE* log ) {
+
+    System system;
+    int numberOfParticles = 3;
+    for( int ii = 0; ii < numberOfParticles; ii++ ){
+        system.addParticle(1.0);
+    }
+
+    LangevinIntegrator integrator(0.0, 0.1, 0.01);
+
+    AmoebaHarmonicAngleForce* amoebaHarmonicAngleForce = new AmoebaHarmonicAngleForce();
+
+    double angle      = 100.0;
+    double quadraticK = 1.0;
+    double cubicK     = 1.0e-01;
+    double quarticK   = 1.0e-02;
+    double penticK    = 1.0e-03;
+    double sexticK    = 1.0e-04;
+    amoebaHarmonicAngleForce->addAngle(0, 1, 2, angle, quadraticK);
+
+    amoebaHarmonicAngleForce->setAmoebaGlobalHarmonicAngleCubic(cubicK);
+    amoebaHarmonicAngleForce->setAmoebaGlobalHarmonicAngleQuartic(quarticK);
+    amoebaHarmonicAngleForce->setAmoebaGlobalHarmonicAnglePentic(penticK);
+    amoebaHarmonicAngleForce->setAmoebaGlobalHarmonicAngleSextic(sexticK);
+
+    system.addForce(amoebaHarmonicAngleForce);
+    Context context(system, integrator, Platform::getPlatformByName( "CUDA"));
+
+    std::vector<Vec3> positions(numberOfParticles);
+
+    positions[0] = Vec3(0, 1, 0);
+    positions[1] = Vec3(0, 0, 0);
+    positions[2] = Vec3(0, 0, 1);
+
+    context.setPositions(positions);
+    compareWithExpectedForceAndEnergy( context, *amoebaHarmonicAngleForce, TOL, "testOneAngle", log );
+
+}
+
+int main( int numberOfArguments, char* argv[] ) {
+
+    try {
+        std::cout << "TestCudaAmoebaHarmonicAngleForce running test..." << std::endl;
+        registerAmoebaCudaKernelFactories();
+        FILE* log = NULL;
+        testOneAngle( log );
+
+    } catch(const std::exception& e) {
+        std::cout << "exception: " << e.what() << std::endl;
+        std::cout << "FAIL - ERROR.  Test failed." << std::endl;
+        return 1;
+    }
+    std::cout << "Done" << std::endl;
+    return 0;
+}

plugins/amoeba/platforms/cuda2/tests/TestCudaAmoebaHarmonicBondForce.cpp

+/* -------------------------------------------------------------------------- *
+ *                                   OpenMMAmoeba                             *
+ * -------------------------------------------------------------------------- *
+ * 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) 2008 Stanford University and the Authors.           *
+ * Authors: Mark Friedrichs                                                   *
+ * 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.                                     *
+ * -------------------------------------------------------------------------- */
+
+/**
+ * This tests the Cuda implementation of HarmonicBondForce.
+ */
+
+#include "openmm/internal/AssertionUtilities.h"
+#include "CudaPlatform.h"
+#include "AmoebaTinkerParameterFile.h"
+#include "openmm/Context.h"
+#include "OpenMMAmoeba.h"
+#include "openmm/System.h"
+#include "openmm/LangevinIntegrator.h"
+#include <iostream>
+#include <vector>
+
+using namespace OpenMM;
+
+const double TOL = 1e-5;
+static void computeAmoebaHarmonicBondForce(int bondIndex,  std::vector<Vec3>& positions, AmoebaHarmonicBondForce& amoebaHarmonicBondForce,
+                                           std::vector<Vec3>& forces, double* energy ) {
+
+    int particle1, particle2;
+    double bondLength;
+    double quadraticK;
+    double cubicK    = amoebaHarmonicBondForce.getAmoebaGlobalHarmonicBondCubic();
+    double quarticK  = amoebaHarmonicBondForce.getAmoebaGlobalHarmonicBondQuartic();
+    amoebaHarmonicBondForce.getBondParameters(bondIndex, particle1, particle2,  bondLength,  quadraticK );
+
+    double deltaR[3];
+    double r2 = 0.0;
+    for( int ii = 0; ii < 3; ii++ ){
+           deltaR[ii]    = positions[particle2][ii] - positions[particle1][ii];
+           r2           += deltaR[ii]*deltaR[ii];
+    }
+    double r                   = sqrt( r2 );
+
+    double bondDelta           = (r - bondLength);
+    double bondDelta2          = bondDelta*bondDelta;
+    double dEdR                = 1.0 + 1.5*cubicK*bondDelta + 2.0*quarticK*bondDelta2;
+
+           dEdR               *= (r > 0.0) ? (2.0*quadraticK*bondDelta)/r : 0.0;
+
+   forces[particle1][0]       += dEdR*deltaR[0];
+   forces[particle1][1]       += dEdR*deltaR[1];
+   forces[particle1][2]       += dEdR*deltaR[2];
+
+   forces[particle2][0]       -= dEdR*deltaR[0];
+   forces[particle2][1]       -= dEdR*deltaR[1];
+   forces[particle2][2]       -= dEdR*deltaR[2];
+
+   *energy                    += (1.0f + cubicK*bondDelta + quarticK*bondDelta2)*quadraticK*bondDelta2;
+
+}
+
+static void computeAmoebaHarmonicBondForces( Context& context, AmoebaHarmonicBondForce& amoebaHarmonicBondForce,
+                                             std::vector<Vec3>& expectedForces, double* expectedEnergy, FILE* log ) {
+
+    // get positions and zero forces
+
+    State state = context.getState(State::Positions);
+    std::vector<Vec3> positions = state.getPositions();
+    expectedForces.resize( positions.size() );
+    
+    for( unsigned int ii = 0; ii < expectedForces.size(); ii++ ){
+        expectedForces[ii][0] = expectedForces[ii][1] = expectedForces[ii][2] = 0.0;
+    }
+
+    // calculates forces/energy
+
+    *expectedEnergy = 0.0;
+    for( int ii = 0; ii < amoebaHarmonicBondForce.getNumBonds(); ii++ ){
+        computeAmoebaHarmonicBondForce(ii, positions, amoebaHarmonicBondForce, expectedForces, expectedEnergy );
+    }
+
+#ifdef AMOEBA_DEBUG
+    if( log ){
+        (void) fprintf( log, "computeAmoebaHarmonicBondForces: expected energy=%15.7e\n", *expectedEnergy );
+        for( unsigned int ii = 0; ii < positions.size(); ii++ ){
+            (void) fprintf( log, "%6u [%15.7e %15.7e %15.7e]\n", ii, expectedForces[ii][0], expectedForces[ii][1], expectedForces[ii][2] );
+        }
+        (void) fflush( log );
+    }
+#endif
+    return;
+
+}
+
+void compareWithExpectedForceAndEnergy( Context& context, AmoebaHarmonicBondForce& amoebaHarmonicBondForce, double tolerance, const std::string& idString, FILE* log) {
+
+    std::vector<Vec3> expectedForces;
+    double expectedEnergy;
+    computeAmoebaHarmonicBondForces( context, amoebaHarmonicBondForce, expectedForces, &expectedEnergy, NULL );
+   
+    State state                      = context.getState(State::Forces | State::Energy);
+    const std::vector<Vec3> forces   = state.getForces();
+
+#ifdef AMOEBA_DEBUG
+    if( log ){
+        (void) fprintf( log, "computeAmoebaHarmonicBondForces: expected energy=%15.7e %15.7e\n", expectedEnergy, state.getPotentialEnergy() );
+        for( unsigned int ii = 0; ii < forces.size(); ii++ ){
+            (void) fprintf( log, "%6u [%15.7e %15.7e %15.7e]   [%15.7e %15.7e %15.7e]\n", ii,
+                            expectedForces[ii][0], expectedForces[ii][1], expectedForces[ii][2], forces[ii][0], forces[ii][1], forces[ii][2] );
+        }
+        (void) fflush( log );
+    }
+#endif
+
+    for( unsigned int ii = 0; ii < forces.size(); ii++ ){
+        ASSERT_EQUAL_VEC( expectedForces[ii], forces[ii], tolerance );
+    }
+    ASSERT_EQUAL_TOL( expectedEnergy, state.getPotentialEnergy(), tolerance );
+}
+
+void testOneBond( FILE* log ) {
+
+    System system;
+
+    system.addParticle(1.0);
+    system.addParticle(1.0);
+
+    LangevinIntegrator integrator(0.0, 0.1, 0.01);
+
+    AmoebaHarmonicBondForce* amoebaHarmonicBondForce = new AmoebaHarmonicBondForce();
+
+    double bondLength = 1.5;
+    double quadraticK = 1.0;
+    double cubicK     = 2.0;
+    double quarticicK = 3.0;
+    amoebaHarmonicBondForce->setAmoebaGlobalHarmonicBondCubic( cubicK );
+    amoebaHarmonicBondForce->setAmoebaGlobalHarmonicBondQuartic( quarticicK );
+    amoebaHarmonicBondForce->addBond(0, 1, bondLength, quadraticK);
+
+    system.addForce(amoebaHarmonicBondForce);
+    Context context(system, integrator, Platform::getPlatformByName( "CUDA"));
+    std::vector<Vec3> positions(2);
+
+    positions[0] = Vec3(0, 1, 0);
+    positions[1] = Vec3(0, 0, 0);
+
+    context.setPositions(positions);
+    compareWithExpectedForceAndEnergy( context, *amoebaHarmonicBondForce, TOL, "testOneBond", log );
+}
+
+void testTwoBond( FILE* log ) {
+
+    System system;
+
+    system.addParticle(1.0);
+    system.addParticle(1.0);
+    system.addParticle(1.0);
+
+    LangevinIntegrator integrator(0.0, 0.1, 0.01);
+
+    AmoebaHarmonicBondForce* amoebaHarmonicBondForce = new AmoebaHarmonicBondForce();
+
+    double bondLength = 1.5;
+    double quadraticK = 1.0;
+    double cubicK     = 2.0;
+    double quarticicK = 3.0;
+    amoebaHarmonicBondForce->setAmoebaGlobalHarmonicBondCubic( cubicK );
+    amoebaHarmonicBondForce->setAmoebaGlobalHarmonicBondQuartic( quarticicK );
+    amoebaHarmonicBondForce->addBond(0, 1, bondLength, quadraticK);
+    amoebaHarmonicBondForce->addBond(1, 2, bondLength, quadraticK);
+
+    system.addForce(amoebaHarmonicBondForce);
+    Context context(system, integrator, Platform::getPlatformByName( "CUDA"));
+    //Context context(system, integrator, platform );
+    std::vector<Vec3> positions(3);
+
+    positions[0] = Vec3(0, 1, 0);
+    positions[1] = Vec3(0, 0, 0);
+    positions[2] = Vec3(1, 0, 1);
+
+    context.setPositions(positions);
+    compareWithExpectedForceAndEnergy( context, *amoebaHarmonicBondForce, TOL, "testTwoBond", log );
+}
+
+int main( int numberOfArguments, char* argv[] ) {
+
+    try {
+        std::cout << "TestCudaAmoebaHarmonicBondForce running test..." << std::endl;
+        registerAmoebaCudaKernelFactories();
+        FILE* log = NULL;
+        testTwoBond( log );
+    } catch(const std::exception& e) {
+        std::cout << "exception: " << e.what() << std::endl;
+        std::cout << "FAIL - ERROR.  Test failed." << std::endl;
+        return 1;
+    }
+    std::cout << "Done" << std::endl;
+    return 0;
+}

plugins/amoeba/platforms/cuda2/tests/TestCudaAmoebaHarmonicInPlaneAngleForce.cpp

+/* -------------------------------------------------------------------------- *
+ *                                   OpenMMAmoeba                             *
+ * -------------------------------------------------------------------------- *
+ * 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) 2008 Stanford University and the Authors.           *
+ * Authors: Mark Friedrichs                                                   *
+ * 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.                                     *
+ * -------------------------------------------------------------------------- */
+
+/**
+ * This tests the CUDA implementation of CudaAmoebaHarmonicInPlaneAngleForce.
+ */
+
+#include "openmm/internal/AssertionUtilities.h"
+#include "AmoebaTinkerParameterFile.h"
+#include "openmm/Context.h"
+#include "OpenMMAmoeba.h"
+#include "openmm/System.h"
+#include "openmm/LangevinIntegrator.h"
+#include <iostream>
+#include <vector>
+
+using namespace OpenMM;
+
+const double TOL = 1e-5;
+#define PI_M               3.141592653589
+#define RADIAN            57.29577951308
+
+/* ---------------------------------------------------------------------------------------
+
+   Compute cross product of two 3-vectors and place in 3rd vector
+
+   vectorZ = vectorX x vectorY
+
+   @param vectorX             x-vector
+   @param vectorY             y-vector
+   @param vectorZ             z-vector
+
+   @return vector is vectorZ
+
+   --------------------------------------------------------------------------------------- */
+     
+static void crossProductVector3( double* vectorX, double* vectorY, double* vectorZ ){
+
+    vectorZ[0]  = vectorX[1]*vectorY[2] - vectorX[2]*vectorY[1];
+    vectorZ[1]  = vectorX[2]*vectorY[0] - vectorX[0]*vectorY[2];
+    vectorZ[2]  = vectorX[0]*vectorY[1] - vectorX[1]*vectorY[0];
+
+    return;
+}
+
+static double dotVector3( double* vectorX, double* vectorY ){
+    return vectorX[0]*vectorY[0] + vectorX[1]*vectorY[1] + vectorX[2]*vectorY[2];
+}
+
+static void getPrefactorsGivenInPlaneAngleCosine( double cosine, double idealInPlaneAngle, double quadraticK, double cubicK,
+                                                  double quarticK, double penticK, double sexticK,
+                                                  double* dEdR, double* energyTerm, FILE* log ) {
+
+    double angle;
+    if( cosine >= 1.0 ){
+        angle = 0.0f;
+    } else if( cosine <= -1.0 ){
+        angle = RADIAN*PI_M;
+    } else {
+        angle = RADIAN*acos(cosine);
+    }
+
+#ifdef AMOEBA_DEBUG
+    if( log ){
+        (void) fprintf( log, "getPrefactorsGivenInPlaneAngleCosine: cosine=%10.3e angle=%10.3e ideal=%10.3e\n", cosine, angle, idealInPlaneAngle ); 
+        (void) fflush( log );
+    }
+#endif
+
+    double deltaIdeal         = angle - idealInPlaneAngle;
+    double deltaIdeal2        = deltaIdeal*deltaIdeal;
+    double deltaIdeal3        = deltaIdeal*deltaIdeal2;
+    double deltaIdeal4        = deltaIdeal2*deltaIdeal2;
+ 
+    // deltaIdeal = r - r_0
+ 
+    *dEdR        = ( 2.0                        +
+                     3.0*cubicK*  deltaIdeal    +
+                     4.0*quarticK*deltaIdeal2   +
+                     5.0*penticK* deltaIdeal3   +
+                     6.0*sexticK* deltaIdeal4     );
+ 
+    *dEdR       *= RADIAN*quadraticK*deltaIdeal;
+ 
+
+    *energyTerm  = 1.0f + cubicK* deltaIdeal    +
+                          quarticK*deltaIdeal2   +
+                          penticK* deltaIdeal3   +
+                          sexticK* deltaIdeal4;
+    *energyTerm *= quadraticK*deltaIdeal2;
+
+    return;
+}
+
+static void computeAmoebaHarmonicInPlaneAngleForce(int bondIndex,  std::vector<Vec3>& positions, AmoebaHarmonicInPlaneAngleForce& amoebaHarmonicInPlaneAngleForce,
+                                                   std::vector<Vec3>& forces, double* energy, FILE* log ) {
+
+    int particle1, particle2, particle3, particle4;
+    double idealInPlaneAngle;
+    double quadraticK;
+    amoebaHarmonicInPlaneAngleForce.getAngleParameters(bondIndex, particle1, particle2, particle3, particle4, idealInPlaneAngle, quadraticK );
+
+    double cubicK         = amoebaHarmonicInPlaneAngleForce.getAmoebaGlobalHarmonicInPlaneAngleCubic();
+    double quarticK       = amoebaHarmonicInPlaneAngleForce.getAmoebaGlobalHarmonicInPlaneAngleQuartic();
+    double penticK        = amoebaHarmonicInPlaneAngleForce.getAmoebaGlobalHarmonicInPlaneAnglePentic();
+    double sexticK        = amoebaHarmonicInPlaneAngleForce.getAmoebaGlobalHarmonicInPlaneAngleSextic();
+
+#ifdef AMOEBA_DEBUG
+    if( log ){
+        (void) fprintf( log, "computeAmoebaHarmonicInPlaneAngleForce: bond %d [%d %d %d %d] ang=%10.3f k=%10.3f [%10.3e %10.3e %10.3e %10.3e]\n", 
+                             bondIndex, particle1, particle2, particle3, particle4, idealInPlaneAngle, quadraticK, cubicK, quarticK, penticK, sexticK );
+        (void) fflush( log );
+    }
+#endif
+
+    // T   = AD x CD
+    // P   = B + T*delta
+    // AP  = A - P
+    // CP  = A - P
+    // M   = CP x AP
+
+    enum { AD, BD, CD, T, AP, P, CP, M, APxM, CPxM, ADxBD, BDxCD, TxCD, ADxT, dBxAD, CDxdB, LastDeltaAtomIndex };
+ 
+    // AD   0
+    // BD   1
+    // CD   2 
+    //  T   3
+    // AP   4
+    //  P   5
+    // CP   6
+    // M    7
+    // APxM, CPxM, ADxBD, BDxCD, TxCD, ADxT, dBxAD, CDxdB, LastDeltaAtomIndex
+
+    double deltaR[LastDeltaAtomIndex][3];
+    for( int ii = 0; ii < 3; ii++ ){
+        deltaR[AD][ii] = positions[particle1][ii] - positions[particle4][ii];
+        deltaR[BD][ii] = positions[particle2][ii] - positions[particle4][ii];
+        deltaR[CD][ii] = positions[particle3][ii] - positions[particle4][ii];
+    }
+    crossProductVector3( deltaR[AD], deltaR[CD], deltaR[T] );
+ 
+    double rT2     = dotVector3( deltaR[T], deltaR[T] );
+    double delta   = dotVector3( deltaR[T], deltaR[BD] );
+         delta    *= -1.0/rT2;
+ 
+    for( int ii = 0; ii < 3; ii++ ){
+       deltaR[P][ii]  = positions[particle2][ii] + deltaR[T][ii]*delta;
+       deltaR[AP][ii] = positions[particle1][ii] - deltaR[P][ii];
+       deltaR[CP][ii] = positions[particle3][ii] - deltaR[P][ii];
+    }   
+ 
+    double rAp2 = dotVector3( deltaR[AP],  deltaR[AP] );
+    double rCp2 = dotVector3( deltaR[CP],  deltaR[CP] );
+    if( rAp2 <= 0.0 && rCp2 <= 0.0 ){
+#ifdef AMOEBA_DEBUG
+        if( log ){
+            (void) fprintf( log, "computeAmoebaHarmonicInPlaneAngleForce:  rAp2 or rCp2 <= 0.0\n" );
+            (void) fflush( log );
+        }
+#endif
+
+        return;
+    }
+
+    crossProductVector3( deltaR[CP], deltaR[AP], deltaR[M] );
+ 
+    double rm = dotVector3( deltaR[M], deltaR[M] );
+         rm   = sqrt( rm );
+    if( rm < 0.000001 ){
+       rm = 0.000001;
+    }
+ 
+    double dot     = dotVector3( deltaR[AP], deltaR[CP] );
+    double cosine  = dot/sqrt( rAp2*rCp2 );
+ 
+    double dEdR;
+    double energyTerm;
+    getPrefactorsGivenInPlaneAngleCosine( cosine, idealInPlaneAngle, quadraticK, cubicK,
+                                          quarticK, penticK, sexticK, &dEdR,  &energyTerm, log );
+ 
+    double termA   = -dEdR/(rAp2*rm);
+    double termC   =  dEdR/(rCp2*rm);
+ 
+    crossProductVector3( deltaR[AP], deltaR[M], deltaR[APxM] );
+    crossProductVector3( deltaR[CP], deltaR[M], deltaR[CPxM] );
+ 
+    // forces will be gathered here
+ 
+    enum { dA, dB, dC, dD, LastDIndex };
+    double forceTerm[LastDIndex][3];
+ 
+    for( int ii = 0; ii < 3; ii++ ){
+       forceTerm[dA][ii] = deltaR[APxM][ii]*termA;
+       forceTerm[dC][ii] = deltaR[CPxM][ii]*termC;
+       forceTerm[dB][ii] = -1.0*( forceTerm[dA][ii] + forceTerm[dC][ii] );
+    }
+ 
+    double pTrT2  = dotVector3( forceTerm[dB], deltaR[T] );
+         pTrT2   /= rT2;
+ 
+    crossProductVector3( deltaR[CD], forceTerm[dB], deltaR[CDxdB] );
+    crossProductVector3( forceTerm[dB], deltaR[AD], deltaR[dBxAD] );
+ 
+    if( fabs( pTrT2 ) > 1.0e-08 ){
+       double delta2 = delta*2.0;
+ 
+       crossProductVector3( deltaR[BD], deltaR[CD], deltaR[BDxCD] );
+       crossProductVector3( deltaR[T],  deltaR[CD], deltaR[TxCD]  );
+       crossProductVector3( deltaR[AD], deltaR[BD], deltaR[ADxBD] );
+       crossProductVector3( deltaR[AD], deltaR[T],  deltaR[ADxT]  );
+       for( int ii = 0; ii < 3; ii++ ){
+ 
+          double term           = deltaR[BDxCD][ii] + delta2*deltaR[TxCD][ii];
+          forceTerm[dA][ii]  += delta*deltaR[CDxdB][ii] + term*pTrT2;
+ 
+               term           = deltaR[ADxBD][ii] + delta2*deltaR[ADxT][ii];
+          forceTerm[dC][ii]  += delta*deltaR[dBxAD][ii] + term*pTrT2;
+ 
+          forceTerm[dD][ii]  = -( forceTerm[dA][ii] + forceTerm[dB][ii] + forceTerm[dC][ii] );
+       }
+    } else {
+       for( int ii = 0; ii < 3; ii++ ){
+ 
+          forceTerm[dA][ii] += delta*deltaR[CDxdB][ii];
+          forceTerm[dC][ii] += delta*deltaR[dBxAD][ii];
+ 
+          forceTerm[dD][ii]  = -( forceTerm[dA][ii] + forceTerm[dB][ii] + forceTerm[dC][ii] );
+       }
+    }
+ 
+    // accumulate forces and energy
+ 
+    *energy                    += energyTerm;
+ 
+    forces[particle1][0]       -= forceTerm[0][0];
+    forces[particle1][1]       -= forceTerm[0][1];
+    forces[particle1][2]       -= forceTerm[0][2];
+
+    forces[particle2][0]       -= forceTerm[1][0];
+    forces[particle2][1]       -= forceTerm[1][1];
+    forces[particle2][2]       -= forceTerm[1][2];
+
+    forces[particle3][0]       -= forceTerm[2][0];
+    forces[particle3][1]       -= forceTerm[2][1];
+    forces[particle3][2]       -= forceTerm[2][2];
+
+    forces[particle4][0]       -= forceTerm[3][0];
+    forces[particle4][1]       -= forceTerm[3][1];
+    forces[particle4][2]       -= forceTerm[3][2];
+
+}
+
+static void computeAmoebaHarmonicInPlaneAngleForces( Context& context, AmoebaHarmonicInPlaneAngleForce& amoebaHarmonicInPlaneAngleForce,
+                                                     std::vector<Vec3>& expectedForces, double* expectedEnergy, FILE* log ) {
+
+    // get positions and zero forces
+
+    State state                 = context.getState(State::Positions);
+    std::vector<Vec3> positions = state.getPositions();
+    expectedForces.resize( positions.size() );
+    
+    for( unsigned int ii = 0; ii < expectedForces.size(); ii++ ){
+        expectedForces[ii][0] = expectedForces[ii][1] = expectedForces[ii][2] = 0.0;
+    }
+
+    // calculates forces/energy
+
+    *expectedEnergy = 0.0;
+    for( int ii = 0; ii < amoebaHarmonicInPlaneAngleForce.getNumAngles(); ii++ ){
+        computeAmoebaHarmonicInPlaneAngleForce(ii, positions, amoebaHarmonicInPlaneAngleForce, expectedForces, expectedEnergy, log );
+    }
+
+#ifdef AMOEBA_DEBUG
+    if( log ){
+        (void) fprintf( log, "computeAmoebaHarmonicInPlaneAngleForces: expected energy=%14.7e\n", *expectedEnergy );
+        for( unsigned int ii = 0; ii < positions.size(); ii++ ){
+            (void) fprintf( log, "%6u [%14.7e %14.7e %14.7e]\n", ii, expectedForces[ii][0], expectedForces[ii][1], expectedForces[ii][2] );
+        }
+        (void) fflush( log );
+    }
+#endif
+    return;
+
+}
+
+void compareWithExpectedForceAndEnergy( Context& context, AmoebaHarmonicInPlaneAngleForce& amoebaHarmonicInPlaneAngleForce,
+                                        double tolerance, const std::string& idString, FILE* log) {
+
+    std::vector<Vec3> expectedForces;
+    double expectedEnergy;
+    computeAmoebaHarmonicInPlaneAngleForces( context, amoebaHarmonicInPlaneAngleForce, expectedForces, &expectedEnergy, log );
+   
+    State state                      = context.getState(State::Forces | State::Energy);
+    const std::vector<Vec3> forces   = state.getForces();
+
+#ifdef AMOEBA_DEBUG
+    if( log ){
+        (void) fprintf( log, "computeAmoebaHarmonicInPlaneAngleForces: expected energy=%14.7e %14.7e\n", expectedEnergy, state.getPotentialEnergy() );
+        for( unsigned int ii = 0; ii < forces.size(); ii++ ){
+            (void) fprintf( log, "%6u [%14.7e %14.7e %14.7e]   [%14.7e %14.7e %14.7e]\n", ii,
+                            expectedForces[ii][0], expectedForces[ii][1], expectedForces[ii][2], forces[ii][0], forces[ii][1], forces[ii][2] );
+        }
+        (void) fflush( log );
+    }
+#endif
+
+    for( unsigned int ii = 0; ii < forces.size(); ii++ ){
+        ASSERT_EQUAL_VEC( expectedForces[ii], forces[ii], tolerance );
+    }
+    ASSERT_EQUAL_TOL( expectedEnergy, state.getPotentialEnergy(), tolerance );
+}
+
+void testOneAngle( FILE* log ) {
+
+    System system;
+    int numberOfParticles = 4;
+    for( int ii = 0; ii < numberOfParticles; ii++ ){
+        system.addParticle(1.0);
+    }
+
+    LangevinIntegrator integrator(0.0, 0.1, 0.01);
+
+    AmoebaHarmonicInPlaneAngleForce* amoebaHarmonicInPlaneAngleForce = new AmoebaHarmonicInPlaneAngleForce();
+
+    double angle      = 65.0;
+    double quadraticK = 1.0;
+    double cubicK     = 0.0e-01;
+    double quarticK   = 0.0e-02;
+    double penticK    = 0.0e-03;
+    double sexticK    = 0.0e-04;
+    amoebaHarmonicInPlaneAngleForce->addAngle(0, 1, 2, 3, angle, quadraticK);
+
+    amoebaHarmonicInPlaneAngleForce->setAmoebaGlobalHarmonicInPlaneAngleCubic(cubicK);
+    amoebaHarmonicInPlaneAngleForce->setAmoebaGlobalHarmonicInPlaneAngleQuartic(quarticK);
+    amoebaHarmonicInPlaneAngleForce->setAmoebaGlobalHarmonicInPlaneAnglePentic(penticK);
+    amoebaHarmonicInPlaneAngleForce->setAmoebaGlobalHarmonicInPlaneAngleSextic(sexticK);
+
+    system.addForce(amoebaHarmonicInPlaneAngleForce);
+    Context context(system, integrator, Platform::getPlatformByName( "CUDA"));
+
+    std::vector<Vec3> positions(numberOfParticles);
+
+    positions[0] = Vec3(0, 1, 0);
+    positions[1] = Vec3(0, 0, 0);
+    positions[2] = Vec3(0, 0, 1);
+    positions[3] = Vec3(1, 1, 1);
+
+    context.setPositions(positions);
+    compareWithExpectedForceAndEnergy( context, *amoebaHarmonicInPlaneAngleForce, TOL, "testOneInPlaneAngle", log );
+
+}
+
+int main( int numberOfArguments, char* argv[] ) {
+
+    try {
+        std::cout << "TestCudaAmoebaHarmonicInPlaneAngleForce running test..." << std::endl;
+        registerAmoebaCudaKernelFactories();
+        FILE* log = NULL;
+        testOneAngle( NULL );
+    } catch(const std::exception& e) {
+        std::cout << "exception: " << e.what() << std::endl;
+        std::cout << "FAIL - ERROR.  Test failed." << std::endl;
+        return 1;
+    }
+    std::cout << "Done" << std::endl;
+    return 0;
+}

plugins/amoeba/platforms/cuda2/tests/TestCudaAmoebaPiTorsionForce.cpp

+/* -------------------------------------------------------------------------- *
+ *                                   OpenMMAmoeba                             *
+ * -------------------------------------------------------------------------- *
+ * 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) 2008 Stanford University and the Authors.           *
+ * Authors: Mark Friedrichs                                                   *
+ * 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.                                     *
+ * -------------------------------------------------------------------------- */
+
+/**
+ * This tests the CUDA implementation of CudaAmoebaPiTorsionForce.
+ */
+
+#include "openmm/internal/AssertionUtilities.h"
+#include "AmoebaTinkerParameterFile.h"
+#include "openmm/Context.h"
+#include "OpenMMAmoeba.h"
+#include "openmm/System.h"
+#include "openmm/LangevinIntegrator.h"
+#include <iostream>
+#include <vector>
+
+using namespace OpenMM;
+
+const double TOL = 1e-5;
+#define PI_M               3.141592653589
+#define RADIAN            57.29577951308
+
+/* ---------------------------------------------------------------------------------------
+
+   Compute cross product of two 3-vectors and place in 3rd vector
+
+   vectorZ = vectorX x vectorY
+
+   @param vectorX             x-vector
+   @param vectorY             y-vector
+   @param vectorZ             z-vector
+
+   @return vector is vectorZ
+
+   --------------------------------------------------------------------------------------- */
+     
+static void crossProductVector3( double* vectorX, double* vectorY, double* vectorZ ){
+
+    vectorZ[0]  = vectorX[1]*vectorY[2] - vectorX[2]*vectorY[1];
+    vectorZ[1]  = vectorX[2]*vectorY[0] - vectorX[0]*vectorY[2];
+    vectorZ[2]  = vectorX[0]*vectorY[1] - vectorX[1]*vectorY[0];
+
+    return;
+}
+
+static double dotVector3( double* vectorX, double* vectorY ){
+    return vectorX[0]*vectorY[0] + vectorX[1]*vectorY[1] + vectorX[2]*vectorY[2];
+}
+
+
+static void computeAmoebaPiTorsionForce(int bondIndex,  std::vector<Vec3>& positions, AmoebaPiTorsionForce& amoebaPiTorsionForce,
+                                        std::vector<Vec3>& forces, double* energy, FILE* log ) {
+
+    int particle1, particle2, particle3, particle4, particle5, particle6;
+    double kTorsion;
+
+    amoebaPiTorsionForce.getPiTorsionParameters(bondIndex, particle1, particle2, particle3, particle4,  particle5, particle6, kTorsion);
+
+#ifdef AMOEBA_DEBUG
+    if( log ){
+        (void) fprintf( log, "computeAmoebaPiTorsionForce: bond %d [%d %d %d %d %d %d] k=%10.3e\n", 
+                             bondIndex, particle1, particle2, particle3, particle4, particle5, particle6, kTorsion );
+        (void) fflush( log );
+    }
+#endif
+
+    enum { AD, BD, EC, FC, P, Q, CP, DC, QD, T, U, TU, DP, QC, dT, dU, dP, dQ, dC1, dC2, dD1, dD2, LastDeltaIndex };
+    double deltaR[LastDeltaIndex][3];
+
+    enum { A, B, C, D, E, F, LastAtomIndex };
+    double d[LastAtomIndex][3];
+ 
+    for( int ii = 0; ii < 3; ii++ ){
+         deltaR[AD][ii] = positions[particle1][ii] - positions[particle4][ii];
+         deltaR[BD][ii] = positions[particle2][ii] - positions[particle4][ii];
+         deltaR[EC][ii] = positions[particle5][ii] - positions[particle3][ii];
+         deltaR[FC][ii] = positions[particle6][ii] - positions[particle3][ii];
+    }
+ 
+    crossProductVector3( deltaR[AD], deltaR[BD], deltaR[P] );
+    crossProductVector3( deltaR[EC], deltaR[FC], deltaR[Q] );
+    for( int ii = 0; ii < 3; ii++ ){
+        deltaR[CP][ii]  = -deltaR[P][ii];
+        deltaR[DC][ii]  =  positions[particle4][ii] - positions[particle3][ii];
+        deltaR[QD][ii]  =  deltaR[Q][ii];
+  
+        deltaR[P][ii]  += positions[particle3][ii];
+        deltaR[Q][ii]  += positions[particle4][ii];
+    }
+    crossProductVector3( deltaR[CP], deltaR[DC], deltaR[T]  );
+    crossProductVector3( deltaR[DC], deltaR[QD], deltaR[U]  );
+    crossProductVector3( deltaR[T],  deltaR[U],  deltaR[TU] );
+ 
+    double rT2  = dotVector3( deltaR[T], deltaR[T] );
+    double rU2  = dotVector3( deltaR[U], deltaR[U] );
+    double rTrU = sqrt( rT2*rU2 );
+    if( rTrU <= 0.0 ){
+        return;
+    }
+ 
+    double rDC     = dotVector3( deltaR[DC], deltaR[DC] );
+         rDC       = sqrt( rDC );
+  
+    double cosine  = dotVector3( deltaR[T], deltaR[U] );
+         cosine   /= rTrU;
+ 
+    double sine   = dotVector3( deltaR[DC], deltaR[TU] );
+         sine    /= ( rDC*rTrU );
+ 
+    double cosine2 = cosine*cosine - sine*sine;
+    double sine2   = 2.0*cosine*sine;
+ 
+    double phi2    = 1.0 - cosine2;
+    double dphi2   = 2.0*sine2;
+ 
+    double dedphi = kTorsion*dphi2; 
+ 
+    for( int ii = 0; ii < 3; ii++ ){
+        deltaR[DP][ii] = positions[particle4][ii] -    deltaR[P][ii];
+        deltaR[QC][ii] = deltaR[Q][ii]    - positions[particle3][ii];
+    }
+ 
+    double factorT =  dedphi/( rDC*rT2 );
+    double factorU = -dedphi/( rDC*rU2 );
+ 
+    crossProductVector3( deltaR[T], deltaR[DC], deltaR[dT]  );
+    crossProductVector3( deltaR[U], deltaR[DC], deltaR[dU]  );
+    for( int ii = 0; ii < 3; ii++ ){
+        deltaR[dT][ii] *= factorT;
+        deltaR[dU][ii] *= factorU;
+    }
+ 
+    crossProductVector3( deltaR[dT], deltaR[DC], deltaR[dP]   );
+    crossProductVector3( deltaR[dU], deltaR[DC], deltaR[dQ]   );
+ 
+    crossProductVector3( deltaR[DP], deltaR[dT], deltaR[dC1]  );
+    crossProductVector3( deltaR[dU], deltaR[QD], deltaR[dC2]  );
+ 
+    crossProductVector3( deltaR[dT], deltaR[CP], deltaR[dD1]  );
+    crossProductVector3( deltaR[QC], deltaR[dU], deltaR[dD2]  );
+ 
+    crossProductVector3( deltaR[BD], deltaR[dP], d[A]         );
+    crossProductVector3( deltaR[dP], deltaR[AD], d[B]         );
+ 
+    crossProductVector3( deltaR[FC], deltaR[dQ], d[E]         );
+    crossProductVector3( deltaR[dQ], deltaR[EC], d[F]         );
+ 
+    for( int ii = 0; ii < 3; ii++ ){
+        d[C][ii] = deltaR[dC1][ii] + deltaR[dC2][ii] + deltaR[dP][ii] - d[E][ii] - d[F][ii];
+        d[D][ii] = deltaR[dD1][ii] + deltaR[dD2][ii] + deltaR[dQ][ii] - d[A][ii] - d[B][ii];
+    }
+ 
+    // ---------------------------------------------------------------------------------------
+ 
+    // accumulate forces and energy
+ 
+    forces[particle1][0]       -= d[0][0];
+    forces[particle1][1]       -= d[0][1];
+    forces[particle1][2]       -= d[0][2];
+
+    forces[particle2][0]       -= d[1][0];
+    forces[particle2][1]       -= d[1][1];
+    forces[particle2][2]       -= d[1][2];
+
+    forces[particle3][0]       -= d[2][0];
+    forces[particle3][1]       -= d[2][1];
+    forces[particle3][2]       -= d[2][2];
+
+    forces[particle4][0]       -= d[3][0];
+    forces[particle4][1]       -= d[3][1];
+    forces[particle4][2]       -= d[3][2];
+
+    forces[particle5][0]       -= d[4][0];
+    forces[particle5][1]       -= d[4][1];
+    forces[particle5][2]       -= d[4][2];
+
+    forces[particle6][0]       -= d[5][0];
+    forces[particle6][1]       -= d[5][1];
+    forces[particle6][2]       -= d[5][2];
+
+    *energy                    += kTorsion*phi2;
+ 
+    return;
+}
+ 
+static void computeAmoebaPiTorsionForces( Context& context, AmoebaPiTorsionForce& amoebaPiTorsionForce,
+                                          std::vector<Vec3>& expectedForces, double* expectedEnergy, FILE* log ) {
+
+    // get positions and zero forces
+
+    State state                 = context.getState(State::Positions);
+    std::vector<Vec3> positions = state.getPositions();
+    expectedForces.resize( positions.size() );
+    
+    for( unsigned int ii = 0; ii < expectedForces.size(); ii++ ){
+        expectedForces[ii][0] = expectedForces[ii][1] = expectedForces[ii][2] = 0.0;
+    }
+
+    // calculates forces/energy
+
+    *expectedEnergy = 0.0;
+    for( int ii = 0; ii < amoebaPiTorsionForce.getNumPiTorsions(); ii++ ){
+        computeAmoebaPiTorsionForce(ii, positions, amoebaPiTorsionForce, expectedForces, expectedEnergy, log );
+    }
+
+#ifdef AMOEBA_DEBUG
+    if( log ){
+        (void) fprintf( log, "computeAmoebaPiTorsionForces: expected energy=%14.7e\n", *expectedEnergy );
+        for( unsigned int ii = 0; ii < positions.size(); ii++ ){
+            (void) fprintf( log, "%6u [%14.7e %14.7e %14.7e]\n", ii, expectedForces[ii][0], expectedForces[ii][1], expectedForces[ii][2] );
+        }
+        (void) fflush( log );
+    }
+#endif
+    return;
+
+}
+
+void compareWithExpectedForceAndEnergy( Context& context, AmoebaPiTorsionForce& amoebaPiTorsionForce,
+                                        double tolerance, const std::string& idString, FILE* log) {
+
+    std::vector<Vec3> expectedForces;
+    double expectedEnergy;
+    computeAmoebaPiTorsionForces( context, amoebaPiTorsionForce, expectedForces, &expectedEnergy, log );
+   
+    State state                      = context.getState(State::Forces | State::Energy);
+    const std::vector<Vec3> forces   = state.getForces();
+
+#ifdef AMOEBA_DEBUG
+    if( log ){
+        (void) fprintf( log, "computeAmoebaPiTorsionForces: expected energy=%14.7e %14.7e\n", expectedEnergy, state.getPotentialEnergy() );
+        for( unsigned int ii = 0; ii < forces.size(); ii++ ){
+            (void) fprintf( log, "%6u [%14.7e %14.7e %14.7e]   [%14.7e %14.7e %14.7e]\n", ii,
+                            expectedForces[ii][0], expectedForces[ii][1], expectedForces[ii][2], forces[ii][0], forces[ii][1], forces[ii][2] );
+        }
+        (void) fflush( log );
+    }
+#endif
+
+    for( unsigned int ii = 0; ii < forces.size(); ii++ ){
+        ASSERT_EQUAL_VEC( expectedForces[ii], forces[ii], tolerance );
+    }
+    ASSERT_EQUAL_TOL( expectedEnergy, state.getPotentialEnergy(), tolerance );
+}
+
+void testOnePiTorsion( FILE* log ) {
+
+    System system;
+    int numberOfParticles = 6;
+    for( int ii = 0; ii < numberOfParticles; ii++ ){
+        system.addParticle(1.0);
+    }
+
+    LangevinIntegrator integrator(0.0, 0.1, 0.01);
+
+    AmoebaPiTorsionForce* amoebaPiTorsionForce = new AmoebaPiTorsionForce();
+
+    double kTorsion = 6.85;
+    amoebaPiTorsionForce->addPiTorsion(0, 1, 2, 3, 4, 5, kTorsion );
+
+    system.addForce(amoebaPiTorsionForce);
+    Context context(system, integrator, Platform::getPlatformByName( "CUDA"));
+
+    std::vector<Vec3> positions(numberOfParticles);
+
+    positions[0] = Vec3( 0.262660000E+02,  0.254130000E+02,  0.284200000E+01 );
+    positions[1] = Vec3( 0.278860000E+02,  0.264630000E+02,  0.426300000E+01 );
+    positions[2] = Vec3( 0.269130000E+02,  0.266390000E+02,  0.353100000E+01 );
+
+    positions[3] = Vec3( 0.245568230E+02,  0.250215290E+02,  0.796852800E+01 );
+    positions[4] = Vec3( 0.261000000E+02,  0.292530000E+02,  0.520200000E+01 );
+    positions[5] = Vec3( 0.254124630E+02,  0.234691880E+02,  0.773335400E+01 );
+
+    context.setPositions(positions);
+    compareWithExpectedForceAndEnergy( context, *amoebaPiTorsionForce, TOL, "testOnePiTorsion", log );
+
+}
+
+int main( int numberOfArguments, char* argv[] ) {
+
+    try {
+        std::cout << "TestCudaAmoebaPiTorsionForce running test..." << std::endl;
+        registerAmoebaCudaKernelFactories();
+        FILE* log = NULL;
+        testOnePiTorsion( log );
+    } catch(const std::exception& e) {
+        std::cout << "exception: " << e.what() << std::endl;
+        std::cout << "FAIL - ERROR.  Test failed." << std::endl;
+        return 1;
+    }
+    std::cout << "Done" << std::endl;
+    return 0;
+}