Began creating CPU version of CustomGBForce

platforms/cpu/include/CpuCustomGBForce.h

+
+/* Portions copyright (c) 2009-2014 Stanford University and Simbios.
+ * Contributors: Peter Eastman
+ *
+ * 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.
+ */
+
+#ifndef OPENMM_CPU_CUSTOM_GB_FORCE_H__
+#define OPENMM_CPU_CUSTOM_GB_FORCE_H__
+
+#include "ReferenceNeighborList.h"
+#include "CompiledExpressionSet.h"
+#include "lepton/CompiledExpression.h"
+#include "openmm/CustomGBForce.h"
+#include <map>
+#include <set>
+#include <vector>
+
+class CpuCustomGBForce {
+private:
+    bool cutoff;
+    bool periodic;
+    const OpenMM::NeighborList* neighborList;
+    RealOpenMM periodicBoxSize[3];
+    RealOpenMM cutoffDistance;
+    OpenMM::CompiledExpressionSet expressionSet;
+    std::vector<Lepton::CompiledExpression> valueExpressions;
+    std::vector<std::vector<Lepton::CompiledExpression> > valueDerivExpressions;
+    std::vector<std::vector<Lepton::CompiledExpression> > valueGradientExpressions;
+    std::vector<std::string> valueNames;
+    std::vector<int> valueIndex;
+    std::vector<OpenMM::CustomGBForce::ComputationType> valueTypes;
+    std::vector<Lepton::CompiledExpression> energyExpressions;
+    std::vector<std::vector<Lepton::CompiledExpression> > energyDerivExpressions;
+    std::vector<std::vector<Lepton::CompiledExpression> > energyGradientExpressions;
+    std::vector<std::string> paramNames;
+    std::vector<int> paramIndex;
+    std::vector<OpenMM::CustomGBForce::ComputationType> energyTypes;
+    std::vector<std::string> particleParamNames;
+    std::vector<std::string> particleValueNames;
+    std::vector<int> particleParamIndex;
+    std::vector<int> particleValueIndex;
+    int xindex, yindex, zindex, rindex;
+
+    /**
+     * Calculate a computed value of type SingleParticle
+     * 
+     * @param index            the index of the value to compute
+     * @param numAtoms         number of atoms
+     * @param atomCoordinates  atom coordinates
+     * @param values           the vector to store computed values into
+     * @param globalParameters the values of global parameters
+     * @param atomParameters   atomParameters[atomIndex][paramterIndex]
+     */
+
+    void calculateSingleParticleValue(int index, int numAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, std::vector<std::vector<RealOpenMM> >& values,
+                                      const std::map<std::string, double>& globalParameters, RealOpenMM** atomParameters);
+
+    /**
+     * Calculate a computed value that is based on particle pairs
+     * 
+     * @param index            the index of the value to compute
+     * @param numAtoms         number of atoms
+     * @param atomCoordinates  atom coordinates
+     * @param atomParameters   atomParameters[atomIndex][paramterIndex]
+     * @param values           the vector to store computed values into
+     * @param globalParameters the values of global parameters
+     * @param exclusions       exclusions[i] is the set of excluded indices for atom i
+     * @param useExclusions    specifies whether to use exclusions
+     */
+
+    void calculateParticlePairValue(int index, int numAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, RealOpenMM** atomParameters,
+                                    std::vector<std::vector<RealOpenMM> >& values,
+                                    const std::map<std::string, double>& globalParameters,
+                                    const std::vector<std::set<int> >& exclusions, bool useExclusions);
+
+    /**
+     * Evaluate a single atom pair as part of calculating a computed value
+     * 
+     * @param index            the index of the value to compute
+     * @param atom1            the index of the first atom in the pair
+     * @param atom2            the index of the second atom in the pair
+     * @param atomCoordinates  atom coordinates
+     * @param atomParameters   atomParameters[atomIndex][paramterIndex]
+     * @param globalParameters the values of global parameters
+     * @param values           the vector to store computed values into
+     */
+
+    void calculateOnePairValue(int index, int atom1, int atom2, std::vector<OpenMM::RealVec>& atomCoordinates, RealOpenMM** atomParameters,
+                               const std::map<std::string, double>& globalParameters,
+                               std::vector<std::vector<RealOpenMM> >& values);
+
+    /**
+     * Calculate an energy term of type SingleParticle
+     * 
+     * @param index            the index of the value to compute
+     * @param numAtoms         number of atoms
+     * @param atomCoordinates  atom coordinates
+     * @param values           the vector containing computed values
+     * @param globalParameters the values of global parameters
+     * @param atomParameters   atomParameters[atomIndex][paramterIndex]
+     * @param forces           forces on atoms are added to this
+     * @param totalEnergy      the energy contribution is added to this
+     * @param dEdV             the derivative of energy with respect to computed values is stored in this
+     */
+
+    void calculateSingleParticleEnergyTerm(int index, int numAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, const std::vector<std::vector<RealOpenMM> >& values,
+                                      const std::map<std::string, double>& globalParameters, RealOpenMM** atomParameters, std::vector<OpenMM::RealVec>& forces,
+                                      RealOpenMM* totalEnergy, std::vector<std::vector<RealOpenMM> >& dEdV);
+
+    /**
+     * Calculate an energy term that is based on particle pairs
+     * 
+     * @param index            the index of the term to compute
+     * @param numAtoms         number of atoms
+     * @param atomCoordinates  atom coordinates
+     * @param atomParameters   atomParameters[atomIndex][paramterIndex]
+     * @param values           the vector containing computed values
+     * @param globalParameters the values of global parameters
+     * @param exclusions       exclusions[i] is the set of excluded indices for atom i
+     * @param useExclusions    specifies whether to use exclusions
+     * @param forces           forces on atoms are added to this
+     * @param totalEnergy      the energy contribution is added to this
+     * @param dEdV             the derivative of energy with respect to computed values is stored in this
+     */
+
+    void calculateParticlePairEnergyTerm(int index, int numAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, RealOpenMM** atomParameters,
+                                    const std::vector<std::vector<RealOpenMM> >& values,
+                                    const std::map<std::string, double>& globalParameters,
+                                    const std::vector<std::set<int> >& exclusions, bool useExclusions,
+                                    std::vector<OpenMM::RealVec>& forces, RealOpenMM* totalEnergy, std::vector<std::vector<RealOpenMM> >& dEdV);
+
+    /**
+     * Evaluate a single atom pair as part of calculating an energy term
+     * 
+     * @param index            the index of the term to compute
+     * @param atom1            the index of the first atom in the pair
+     * @param atom2            the index of the second atom in the pair
+     * @param atomCoordinates  atom coordinates
+     * @param atomParameters   atomParameters[atomIndex][paramterIndex]
+     * @param globalParameters the values of global parameters
+     * @param values           the vector containing computed values
+     * @param forces           forces on atoms are added to this
+     * @param totalEnergy      the energy contribution is added to this
+     * @param dEdV             the derivative of energy with respect to computed values is stored in this
+     */
+
+    void calculateOnePairEnergyTerm(int index, int atom1, int atom2, std::vector<OpenMM::RealVec>& atomCoordinates, RealOpenMM** atomParameters,
+                               const std::map<std::string, double>& globalParameters,
+                               const std::vector<std::vector<RealOpenMM> >& values,
+                               std::vector<OpenMM::RealVec>& forces, RealOpenMM* totalEnergy, std::vector<std::vector<RealOpenMM> >& dEdV);
+
+    /**
+     * Apply the chain rule to compute forces on atoms
+     * 
+     * @param numAtoms         number of atoms
+     * @param atomCoordinates  atom coordinates
+     * @param atomParameters   atomParameters[atomIndex][paramterIndex]
+     * @param values           the vector containing computed values
+     * @param globalParameters the values of global parameters
+     * @param exclusions       exclusions[i] is the set of excluded indices for atom i
+     * @param forces           forces on atoms are added to this
+     * @param dEdV             the derivative of energy with respect to computed values is stored in this
+     */
+
+    void calculateChainRuleForces(int numAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, RealOpenMM** atomParameters,
+                                    const std::vector<std::vector<RealOpenMM> >& values,
+                                    const std::map<std::string, double>& globalParameters,
+                                    const std::vector<std::set<int> >& exclusions,
+                                    std::vector<OpenMM::RealVec>& forces, std::vector<std::vector<RealOpenMM> >& dEdV);
+
+    /**
+     * Evaluate a single atom pair as part of applying the chain rule
+     * 
+     * @param atom1            the index of the first atom in the pair
+     * @param atom2            the index of the second atom in the pair
+     * @param atomCoordinates  atom coordinates
+     * @param atomParameters   atomParameters[atomIndex][paramterIndex]
+     * @param globalParameters the values of global parameters
+     * @param values           the vector containing computed values
+     * @param forces           forces on atoms are added to this
+     * @param dEdV             the derivative of energy with respect to computed values is stored in this
+     * @param isExcluded       specifies whether this is an excluded pair
+     */
+
+    void calculateOnePairChainRule(int atom1, int atom2, std::vector<OpenMM::RealVec>& atomCoordinates, RealOpenMM** atomParameters,
+                               const std::map<std::string, double>& globalParameters,
+                               const std::vector<std::vector<RealOpenMM> >& values,
+                               std::vector<OpenMM::RealVec>& forces, std::vector<std::vector<RealOpenMM> >& dEdV,
+                               bool isExcluded);
+
+public:
+
+    /**
+     * Construct a new CpuCustomGBForce.
+     */
+
+     CpuCustomGBForce(const std::vector<Lepton::CompiledExpression>& valueExpressions,
+                          const std::vector<std::vector<Lepton::CompiledExpression> > valueDerivExpressions,
+                          const std::vector<std::vector<Lepton::CompiledExpression> > valueGradientExpressions,
+                          const std::vector<std::string>& valueNames,
+                          const std::vector<OpenMM::CustomGBForce::ComputationType>& valueTypes,
+                          const std::vector<Lepton::CompiledExpression>& energyExpressions,
+                          const std::vector<std::vector<Lepton::CompiledExpression> > energyDerivExpressions,
+                          const std::vector<std::vector<Lepton::CompiledExpression> > energyGradientExpressions,
+                          const std::vector<OpenMM::CustomGBForce::ComputationType>& energyTypes,
+                          const std::vector<std::string>& parameterNames);
+
+     ~CpuCustomGBForce();
+
+    /**
+     * Set the force to use a cutoff.
+     * 
+     * @param distance            the cutoff distance
+     * @param neighbors           the neighbor list to use
+     */
+
+    void setUseCutoff(RealOpenMM distance, const OpenMM::NeighborList& neighbors);
+
+    /**
+     * Set the force to use periodic boundary conditions.  This requires that a cutoff has
+     * already been set, and the smallest side of the periodic box is at least twice the cutoff
+     * distance.
+     * 
+     * @param boxSize             the X, Y, and Z widths of the periodic box
+     */
+
+    void setPeriodic(OpenMM::RealVec& boxSize);
+
+    /**
+     * Calculate custom GB ixn
+     * 
+     * @param numberOfAtoms    number of atoms
+     * @param atomCoordinates  atom coordinates
+     * @param atomParameters   atomParameters[atomIndex][paramterIndex]
+     * @param exclusions       exclusions[i] is the set of excluded indices for atom i
+     * @param globalParameters the values of global parameters
+     * @param forces           force array (forces added)
+     * @param totalEnergy      total energy
+     */
+
+    void calculateIxn(int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, RealOpenMM** atomParameters, const std::vector<std::set<int> >& exclusions,
+                     std::map<std::string, double>& globalParameters, std::vector<OpenMM::RealVec>& forces, RealOpenMM* totalEnergy);
+};
+
+#endif // OPENMM_CPU_CUSTOM_GB_FORCE_H__

platforms/cpu/include/CpuKernels.h

@@ -33,6 +33,7 @@
  * -------------------------------------------------------------------------- */
 
 #include "CpuBondForce.h"
+#include "CpuCustomGBForce.h"
 #include "CpuCustomManyParticleForce.h"
 #include "CpuCustomNonbondedForce.h"
 #include "CpuGBSAOBCForce.h"
@@ -303,6 +304,58 @@ private:
     CpuGBSAOBCForce obc;
 };
 
+/**
+ * This kernel is invoked by CustomGBForce to calculate the forces acting on the system.
+ */
+class CpuCalcCustomGBForceKernel : public CalcCustomGBForceKernel {
+public:
+    CpuCalcCustomGBForceKernel(std::string name, const Platform& platform, CpuPlatform::PlatformData& data) :
+            CalcCustomGBForceKernel(name, platform), data(data) {
+    }
+    ~CpuCalcCustomGBForceKernel();
+    /**
+     * Initialize the kernel.
+     *
+     * @param system     the System this kernel will be applied to
+     * @param force      the CustomGBForce this kernel will be used for
+     */
+    void initialize(const System& system, const CustomGBForce& 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);
+    /**
+     * Copy changed parameters over to a context.
+     *
+     * @param context    the context to copy parameters to
+     * @param force      the CustomGBForce to copy the parameters from
+     */
+    void copyParametersToContext(ContextImpl& context, const CustomGBForce& force);
+private:
+    CpuPlatform::PlatformData& data;
+    int numParticles;
+    bool isPeriodic;
+    RealOpenMM **particleParamArray;
+    RealOpenMM nonbondedCutoff;
+    std::vector<std::set<int> > exclusions;
+    std::vector<std::string> particleParameterNames, globalParameterNames, valueNames;
+    std::vector<Lepton::CompiledExpression> valueExpressions;
+    std::vector<std::vector<Lepton::CompiledExpression> > valueDerivExpressions;
+    std::vector<std::vector<Lepton::CompiledExpression> > valueGradientExpressions;
+    std::vector<OpenMM::CustomGBForce::ComputationType> valueTypes;
+    std::vector<Lepton::CompiledExpression> energyExpressions;
+    std::vector<std::vector<Lepton::CompiledExpression> > energyDerivExpressions;
+    std::vector<std::vector<Lepton::CompiledExpression> > energyGradientExpressions;
+    std::vector<OpenMM::CustomGBForce::ComputationType> energyTypes;
+    NonbondedMethod nonbondedMethod;
+    NeighborList* neighborList;
+};
+
 /**
  * This kernel is invoked by CustomManyParticleForce to calculate the forces acting on the system and the energy of the system.
  */

platforms/cpu/src/CpuKernelFactory.cpp

@@ -53,6 +53,8 @@ KernelImpl* CpuKernelFactory::createKernelImpl(std::string name, const Platform&
         return new CpuCalcCustomManyParticleForceKernel(name, platform, data);
     if (name == CalcGBSAOBCForceKernel::Name())
         return new CpuCalcGBSAOBCForceKernel(name, platform, data);
+    if (name == CalcCustomGBForceKernel::Name())
+        return new CpuCalcCustomGBForceKernel(name, platform, data);
     if (name == IntegrateLangevinStepKernel::Name())
         return new CpuIntegrateLangevinStepKernel(name, platform, data);
     throw OpenMMException((std::string("Tried to create kernel with illegal kernel name '") + name + "'").c_str());

platforms/cpu/src/CpuKernels.cpp

@@ -835,6 +835,162 @@ void CpuCalcGBSAOBCForceKernel::copyParametersToContext(ContextImpl& context, co
     obc.setParticleParameters(particleParams);
 }
 
+CpuCalcCustomGBForceKernel::~CpuCalcCustomGBForceKernel() {
+    if (particleParamArray != NULL) {
+        for (int i = 0; i < numParticles; i++)
+            delete[] particleParamArray[i];
+        delete[] particleParamArray;
+    }
+    if (neighborList != NULL)
+        delete neighborList;
+}
+
+void CpuCalcCustomGBForceKernel::initialize(const System& system, const CustomGBForce& force) {
+    if (force.getNumComputedValues() > 0) {
+        string name, expression;
+        CustomGBForce::ComputationType type;
+        force.getComputedValueParameters(0, name, expression, type);
+        if (type == CustomGBForce::SingleParticle)
+            throw OpenMMException("CpuPlatform requires that the first computed value for a CustomGBForce be of type ParticlePair or ParticlePairNoExclusions.");
+        for (int i = 1; i < force.getNumComputedValues(); i++) {
+            force.getComputedValueParameters(i, name, expression, type);
+            if (type != CustomGBForce::SingleParticle)
+                throw OpenMMException("CpuPlatform requires that a CustomGBForce only have one computed value of type ParticlePair or ParticlePairNoExclusions.");
+        }
+    }
+
+    // Record the exclusions.
+
+    numParticles = force.getNumParticles();
+    exclusions.resize(numParticles);
+    for (int i = 0; i < force.getNumExclusions(); i++) {
+        int particle1, particle2;
+        force.getExclusionParticles(i, particle1, particle2);
+        exclusions[particle1].insert(particle2);
+        exclusions[particle2].insert(particle1);
+    }
+
+    // Build the arrays.
+
+    int numPerParticleParameters = force.getNumPerParticleParameters();
+    particleParamArray = new double*[numParticles];
+    for (int i = 0; i < numParticles; i++)
+        particleParamArray[i] = new double[numPerParticleParameters];
+    for (int i = 0; i < numParticles; ++i) {
+        vector<double> parameters;
+        force.getParticleParameters(i, parameters);
+        for (int j = 0; j < numPerParticleParameters; j++)
+            particleParamArray[i][j] = static_cast<RealOpenMM>(parameters[j]);
+    }
+    for (int i = 0; i < numPerParticleParameters; i++)
+        particleParameterNames.push_back(force.getPerParticleParameterName(i));
+    for (int i = 0; i < force.getNumGlobalParameters(); i++)
+        globalParameterNames.push_back(force.getGlobalParameterName(i));
+    nonbondedMethod = CalcCustomGBForceKernel::NonbondedMethod(force.getNonbondedMethod());
+    nonbondedCutoff = (RealOpenMM) force.getCutoffDistance();
+    if (nonbondedMethod == NoCutoff)
+        neighborList = NULL;
+    else
+        neighborList = new NeighborList();
+
+    // Create custom functions for the tabulated functions.
+
+    map<string, Lepton::CustomFunction*> functions;
+    for (int i = 0; i < force.getNumFunctions(); i++)
+        functions[force.getTabulatedFunctionName(i)] = createReferenceTabulatedFunction(force.getTabulatedFunction(i));
+
+    // Parse the expressions for computed values.
+
+    valueDerivExpressions.resize(force.getNumComputedValues());
+    valueGradientExpressions.resize(force.getNumComputedValues());
+    for (int i = 0; i < force.getNumComputedValues(); i++) {
+        string name, expression;
+        CustomGBForce::ComputationType type;
+        force.getComputedValueParameters(i, name, expression, type);
+        Lepton::ParsedExpression ex = Lepton::Parser::parse(expression, functions).optimize();
+        valueExpressions.push_back(ex.createCompiledExpression());
+        valueTypes.push_back(type);
+        valueNames.push_back(name);
+        if (i == 0)
+            valueDerivExpressions[i].push_back(ex.differentiate("r").createCompiledExpression());
+        else {
+            valueGradientExpressions[i].push_back(ex.differentiate("x").createCompiledExpression());
+            valueGradientExpressions[i].push_back(ex.differentiate("y").createCompiledExpression());
+            valueGradientExpressions[i].push_back(ex.differentiate("z").createCompiledExpression());
+            for (int j = 0; j < i; j++)
+                valueDerivExpressions[i].push_back(ex.differentiate(valueNames[j]).createCompiledExpression());
+        }
+    }
+
+    // Parse the expressions for energy terms.
+
+    energyDerivExpressions.resize(force.getNumEnergyTerms());
+    energyGradientExpressions.resize(force.getNumEnergyTerms());
+    for (int i = 0; i < force.getNumEnergyTerms(); i++) {
+        string expression;
+        CustomGBForce::ComputationType type;
+        force.getEnergyTermParameters(i, expression, type);
+        Lepton::ParsedExpression ex = Lepton::Parser::parse(expression, functions).optimize();
+        energyExpressions.push_back(ex.createCompiledExpression());
+        energyTypes.push_back(type);
+        if (type != CustomGBForce::SingleParticle)
+            energyDerivExpressions[i].push_back(ex.differentiate("r").createCompiledExpression());
+        for (int j = 0; j < force.getNumComputedValues(); j++) {
+            if (type == CustomGBForce::SingleParticle) {
+                energyDerivExpressions[i].push_back(ex.differentiate(valueNames[j]).createCompiledExpression());
+                energyGradientExpressions[i].push_back(ex.differentiate("x").createCompiledExpression());
+                energyGradientExpressions[i].push_back(ex.differentiate("y").createCompiledExpression());
+                energyGradientExpressions[i].push_back(ex.differentiate("z").createCompiledExpression());
+            }
+            else {
+                energyDerivExpressions[i].push_back(ex.differentiate(valueNames[j]+"1").createCompiledExpression());
+                energyDerivExpressions[i].push_back(ex.differentiate(valueNames[j]+"2").createCompiledExpression());
+            }
+        }
+    }
+
+    // Delete the custom functions.
+
+    for (map<string, Lepton::CustomFunction*>::iterator iter = functions.begin(); iter != functions.end(); iter++)
+        delete iter->second;
+}
+
+double CpuCalcCustomGBForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
+    vector<RealVec>& posData = extractPositions(context);
+    vector<RealVec>& forceData = extractForces(context);
+    RealOpenMM energy = 0;
+    CpuCustomGBForce ixn(valueExpressions, valueDerivExpressions, valueGradientExpressions, valueNames, valueTypes, energyExpressions,
+        energyDerivExpressions, energyGradientExpressions, energyTypes, particleParameterNames);
+    bool periodic = (nonbondedMethod == CutoffPeriodic);
+    if (periodic)
+        ixn.setPeriodic(extractBoxSize(context));
+    if (nonbondedMethod != NoCutoff) {
+        computeNeighborListVoxelHash(*neighborList, numParticles, posData, exclusions, extractBoxSize(context), periodic, nonbondedCutoff, 0.0);
+        ixn.setUseCutoff(nonbondedCutoff, *neighborList);
+    }
+    map<string, double> globalParameters;
+    for (int i = 0; i < (int) globalParameterNames.size(); i++)
+        globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
+    ixn.calculateIxn(numParticles, posData, particleParamArray, exclusions, globalParameters, forceData, includeEnergy ? &energy : NULL);
+    return energy;
+}
+
+void CpuCalcCustomGBForceKernel::copyParametersToContext(ContextImpl& context, const CustomGBForce& force) {
+    if (numParticles != force.getNumParticles())
+        throw OpenMMException("updateParametersInContext: The number of particles has changed");
+
+    // Record the values.
+
+    int numParameters = force.getNumPerParticleParameters();
+    vector<double> params;
+    for (int i = 0; i < numParticles; ++i) {
+        vector<double> parameters;
+        force.getParticleParameters(i, parameters);
+        for (int j = 0; j < numParameters; j++)
+            particleParamArray[i][j] = static_cast<RealOpenMM>(parameters[j]);
+    }
+}
+
 CpuCalcCustomManyParticleForceKernel::~CpuCalcCustomManyParticleForceKernel() {
     if (particleParamArray != NULL) {
         for (int i = 0; i < numParticles; i++)

platforms/cpu/src/CpuPlatform.cpp

@@ -67,6 +67,7 @@ CpuPlatform::CpuPlatform() {
     registerKernelFactory(CalcCustomNonbondedForceKernel::Name(), factory);
     registerKernelFactory(CalcCustomManyParticleForceKernel::Name(), factory);
     registerKernelFactory(CalcGBSAOBCForceKernel::Name(), factory);
+    registerKernelFactory(CalcCustomGBForceKernel::Name(), factory);
     registerKernelFactory(IntegrateLangevinStepKernel::Name(), factory);
     platformProperties.push_back(CpuThreads());
     int threads = getNumProcessors();