Merge branch 'master' into applecl

openmmapi/src/NonbondedForceImpl.cpp

@@ -6,7 +6,7 @@
  * Biological Structures at Stanford, funded under the NIH Roadmap for        *
  * Medical Research, grant U54 GM072970. See https://simtk.org.               *
  *                                                                            *
- * Portions copyright (c) 2008-2014 Stanford University and the Authors.      *
+ * Portions copyright (c) 2008-2015 Stanford University and the Authors.      *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -98,6 +98,8 @@ void NonbondedForceImpl::initialize(ContextImpl& context) {
         double cutoff = owner.getCutoffDistance();
         if (cutoff > 0.5*boxVectors[0][0] || cutoff > 0.5*boxVectors[1][1] || cutoff > 0.5*boxVectors[2][2])
             throw OpenMMException("NonbondedForce: The cutoff distance cannot be greater than half the periodic box size.");
+        if (owner.getNonbondedMethod() == NonbondedForce::Ewald && (boxVectors[1][0] != 0.0 || boxVectors[2][0] != 0.0 || boxVectors[2][1] != 0))
+            throw OpenMMException("NonbondedForce: Ewald is not supported with non-rectangular boxes.  Use PME instead.");
     }
     kernel.getAs<CalcNonbondedForceKernel>().initialize(context.getSystem(), owner);
 }

openmmapi/src/State.cpp

@@ -76,6 +76,9 @@ const map<string, double>& State::getParameters() const {
         throw OpenMMException("Invoked getParameters() on a State which does not contain parameters.");
     return parameters;
 }
+int State::getDataTypes() const {
+    return types;
+}
 State::State(double time) : types(0), time(time), ke(0), pe(0) {
 }
 State::State() : types(0), time(0.0), ke(0), pe(0) {

openmmapi/src/System.cpp

@@ -34,6 +34,7 @@
 #include "openmm/System.h"
 #include "openmm/VirtualSite.h"
 #include "openmm/internal/AssertionUtilities.h"
+#include <cmath>
 
 using namespace OpenMM;
 
@@ -60,10 +61,11 @@ void System::setParticleMass(int index, double mass) {
     masses[index] = mass;
 }
 
-
 void System::setVirtualSite(int index, VirtualSite* virtualSite) {
     if (index >= (int) virtualSites.size())
         virtualSites.resize(getNumParticles(), NULL);
+    if (virtualSites[index] != NULL)
+        delete virtualSites[index];
     virtualSites[index] = virtualSite;
 }
 
@@ -92,6 +94,11 @@ void System::setConstraintParameters(int index, int particle1, int particle2, do
     constraints[index].distance = distance;
 }
 
+void System::removeConstraint(int index) {
+    ASSERT_VALID_INDEX(index, constraints);
+    constraints.erase(constraints.begin()+index);
+}
+
 const Force& System::getForce(int index) const {
     ASSERT_VALID_INDEX(index, forces);
     return *forces[index];
@@ -102,6 +109,12 @@ Force& System::getForce(int index) {
     return *forces[index];
 }
 
+void System::removeForce(int index) {
+    ASSERT_VALID_INDEX(index, forces);
+    delete forces[index];
+    forces.erase(forces.begin()+index);
+}
+
 void System::getDefaultPeriodicBoxVectors(Vec3& a, Vec3& b, Vec3& c) const {
     a = periodicBoxVectors[0];
     b = periodicBoxVectors[1];
@@ -111,11 +124,33 @@ void System::getDefaultPeriodicBoxVectors(Vec3& a, Vec3& b, Vec3& c) const {
 void System::setDefaultPeriodicBoxVectors(const Vec3& a, const Vec3& b, const Vec3& c) {
     if (a[1] != 0.0 || a[2] != 0.0)
         throw OpenMMException("First periodic box vector must be parallel to x.");
-    if (b[0] != 0.0 || b[2] != 0.0)
-        throw OpenMMException("Second periodic box vector must be parallel to y.");
-    if (c[0] != 0.0 || c[1] != 0.0)
-        throw OpenMMException("Third periodic box vector must be parallel to z.");
+    if (b[2] != 0.0)
+        throw OpenMMException("Second periodic box vector must be in the x-y plane.");
+    if (a[0] <= 0.0 || b[1] <= 0.0 || c[2] <= 0.0 || a[0] < 2*fabs(b[0]) || a[0] < 2*fabs(c[0]) || b[1] < 2*fabs(c[1]))
+        throw OpenMMException("Periodic box vectors must be in reduced form.");
     periodicBoxVectors[0] = a;
     periodicBoxVectors[1] = b;
     periodicBoxVectors[2] = c;
 }
+
+bool System::usesPeriodicBoundaryConditions() {
+
+    bool uses_pbc = false;
+    bool all_forces_implement = true;
+    for (std::vector<Force*>::const_iterator it = forces.begin();
+            it != forces.end(); it++) {
+        try {
+            if ((*it)->usesPeriodicBoundaryConditions())
+                uses_pbc = true;
+        }
+        catch (OpenMMException &e) {
+            all_forces_implement = false;
+        }
+    }
+
+    if (!all_forces_implement && !uses_pbc) {
+        throw OpenMMException("not all forces implement usesPeriodicBoundaryConditions");
+    }
+
+    return uses_pbc;
+}

openmmapi/src/VariableLangevinIntegrator.cpp

@@ -33,7 +33,6 @@
 #include "openmm/Context.h"
 #include "openmm/OpenMMException.h"
 #include "openmm/internal/ContextImpl.h"
-#include "openmm/internal/OSRngSeed.h"
 #include "openmm/kernels.h"
 #include <limits>
 #include <string>
@@ -48,7 +47,8 @@ VariableLangevinIntegrator::VariableLangevinIntegrator(double temperature, doubl
     setFriction(frictionCoeff);
     setErrorTolerance(errorTol);
     setConstraintTolerance(1e-5);
-    setRandomNumberSeed(osrngseed());
+    setRandomNumberSeed(0);
+    setStepSize(0.0);
 }
 
 void VariableLangevinIntegrator::initialize(ContextImpl& contextRef) {

openmmapi/src/VariableVerletIntegrator.cpp

@@ -43,6 +43,7 @@ using std::vector;
 
 VariableVerletIntegrator::VariableVerletIntegrator(double errorTol) : errorTol(errorTol) {
     setConstraintTolerance(1e-5);
+    setStepSize(0.0);
 }
 
 void VariableVerletIntegrator::initialize(ContextImpl& contextRef) {

platforms/cpu/CMakeLists.txt

@@ -12,7 +12,9 @@
 #   libOpenMMCPU_static.a
 #----------------------------------------------------
 
-SUBDIRS (tests)
+IF(BUILD_TESTING)
+    SUBDIRS(tests)
+ENDIF(BUILD_TESTING)
 
 # The source is organized into subdirectories, but we handle them all from
 # this CMakeLists file rather than letting CMake visit them as SUBDIRS.
@@ -82,4 +84,3 @@ ENDIF(OPENMM_BUILD_SHARED_LIB)
 IF(OPENMM_BUILD_STATIC_LIB)
     SUBDIRS (staticTarget)
 ENDIF(OPENMM_BUILD_STATIC_LIB)
-

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 "CompiledExpressionSet.h"
+#include "CpuNeighborList.h"
+#include "lepton/CompiledExpression.h"
+#include "openmm/CustomGBForce.h"
+#include "openmm/internal/ThreadPool.h"
+#include "openmm/internal/vectorize.h"
+#include <map>
+#include <set>
+#include <vector>
+
+namespace OpenMM {
+
+class CpuCustomGBForce {
+private:
+    class ComputeForceTask;
+    class ThreadData;
+
+    bool cutoff;
+    bool periodic;
+    const CpuNeighborList* neighborList;
+    float periodicBoxSize[3];
+    float cutoffDistance, cutoffDistance2;
+    const std::vector<std::set<int> > exclusions;
+    std::vector<std::string> valueNames;
+    std::vector<CustomGBForce::ComputationType> valueTypes;
+    std::vector<std::string> paramNames;
+    std::vector<CustomGBForce::ComputationType> energyTypes;
+    ThreadPool& threads;
+    std::vector<ThreadData*> threadData;
+    std::vector<double> threadEnergy;
+    // Workspace vectors
+    std::vector<std::vector<float> > values, dEdV;
+    // The following variables are used to make information accessible to the individual threads.
+    int numberOfAtoms;
+    float* posq;
+    RealOpenMM** atomParameters;
+    const std::map<std::string, double>* globalParameters;
+    std::vector<AlignedArray<float> >* threadForce;
+    bool includeForce, includeEnergy;
+    void* atomicCounter;
+    
+    /**
+     * This routine contains the code executed by each thread.
+     */
+    void threadComputeForce(ThreadPool& threads, int threadIndex);
+
+    /**
+     * Calculate a computed value that is based on particle pairs
+     * 
+     * @param index            the index of the value to compute
+     * @param data             workspace for the current thread
+     * @param numAtoms         number of atoms
+     * @param posq             atom coordinates
+     * @param atomParameters   atomParameters[atomIndex][paramterIndex]
+     * @param useExclusions    specifies whether to use exclusions
+     */
+
+    void calculateParticlePairValue(int index, ThreadData& data, int numAtoms, float* posq, RealOpenMM** atomParameters,
+                                    bool useExclusions, const fvec4& boxSize, const fvec4& invBoxSize);
+
+    /**
+     * 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 data             workspace for the current thread
+     * @param posq             atom coordinates
+     * @param atomParameters   atomParameters[atomIndex][paramterIndex]
+     */
+
+    void calculateOnePairValue(int index, int atom1, int atom2, ThreadData& data, float* posq, RealOpenMM** atomParameters,
+                               std::vector<float>& valueArray, const fvec4& boxSize, const fvec4& invBoxSize);
+
+    /**
+     * Calculate an energy term of type SingleParticle
+     * 
+     * @param index            the index of the value to compute
+     * @param data             workspace for the current thread
+     * @param numAtoms         number of atoms
+     * @param posq             atom coordinates
+     * @param atomParameters   atomParameters[atomIndex][paramterIndex]
+     * @param forces           forces on atoms are added to this
+     * @param totalEnergy      the energy contribution is added to this
+     */
+
+    void calculateSingleParticleEnergyTerm(int index, ThreadData& data, int numAtoms, float* posq, RealOpenMM** atomParameters, float* forces, double& totalEnergy);
+
+    /**
+     * Calculate an energy term that is based on particle pairs
+     * 
+     * @param index            the index of the term to compute
+     * @param data             workspace for the current thread
+     * @param numAtoms         number of atoms
+     * @param posq             atom coordinates
+     * @param atomParameters   atomParameters[atomIndex][paramterIndex]
+     * @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
+     */
+
+    void calculateParticlePairEnergyTerm(int index, ThreadData& data, int numAtoms, float* posq, RealOpenMM** atomParameters,
+                                    bool useExclusions, float* forces, double& totalEnergy, const fvec4& boxSize, const fvec4& invBoxSize);
+
+    /**
+     * 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 data             workspace for the current thread
+     * @param posq             atom coordinates
+     * @param atomParameters   atomParameters[atomIndex][paramterIndex]
+     * @param forces           forces on atoms are added to this
+     * @param totalEnergy      the energy contribution is added to this
+     */
+
+    void calculateOnePairEnergyTerm(int index, int atom1, int atom2, ThreadData& data, float* posq, RealOpenMM** atomParameters,
+                               float* forces, double& totalEnergy, const fvec4& boxSize, const fvec4& invBoxSize);
+
+    /**
+     * Apply the chain rule to compute forces on atoms
+     * 
+     * @param data             workspace for the current thread
+     * @param numAtoms         number of atoms
+     * @param posq             atom coordinates
+     * @param atomParameters   atomParameters[atomIndex][paramterIndex]
+     * @param forces           forces on atoms are added to this
+     */
+
+    void calculateChainRuleForces(ThreadData& data, int numAtoms, float* posq, RealOpenMM** atomParameters,
+                                    float* forces, const fvec4& boxSize, const fvec4& invBoxSize);
+
+    /**
+     * 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 data             workspace for the current thread
+     * @param posq             atom coordinates
+     * @param atomParameters   atomParameters[atomIndex][paramterIndex]
+     * @param forces           forces on atoms are added to this
+     * @param isExcluded       specifies whether this is an excluded pair
+     */
+
+    void calculateOnePairChainRule(int atom1, int atom2, ThreadData& data, float* posq, RealOpenMM** atomParameters,
+                               float* forces, bool isExcluded, const fvec4& boxSize, const fvec4& invBoxSize);
+
+    /**
+     * Compute the displacement and squared distance between two points, optionally using
+     * periodic boundary conditions.
+     */
+    void getDeltaR(const fvec4& posI, const fvec4& posJ, fvec4& deltaR, float& r2, bool periodic, const fvec4& boxSize, const fvec4& invBoxSize) const;
+
+public:
+
+    /**
+     * Construct a new CpuCustomGBForce.
+     */
+
+     CpuCustomGBForce(int numAtoms, const std::vector<std::set<int> >& exclusions,
+                        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<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<CustomGBForce::ComputationType>& energyTypes,
+                        const std::vector<std::string>& parameterNames, ThreadPool& threads);
+
+     ~CpuCustomGBForce();
+
+    /**
+     * Set the force to use a cutoff.
+     * 
+     * @param distance            the cutoff distance
+     * @param neighbors           the neighbor list to use
+     */
+
+    void setUseCutoff(float distance, const CpuNeighborList& 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(RealVec& boxSize);
+
+    /**
+     * Calculate custom GB ixn
+     * 
+     * @param numberOfAtoms    number of atoms
+     * @param posq             atom coordinates
+     * @param atomParameters   atomParameters[atomIndex][paramterIndex]
+     * @param globalParameters the values of global parameters
+     * @param forces           force array (forces added)
+     * @param totalEnergy      total energy
+     */
+
+    void calculateIxn(int numberOfAtoms, float* posq, RealOpenMM** atomParameters,
+                     std::map<std::string, double>& globalParameters, std::vector<AlignedArray<float> >& threadForce, bool includeForce, bool includeEnergy, double& totalEnergy);
+};
+
+class CpuCustomGBForce::ThreadData {
+public:
+    ThreadData(int numAtoms, int numThreads, int threadIndex,
+               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<Lepton::CompiledExpression>& energyExpressions,
+               const std::vector<std::vector<Lepton::CompiledExpression> >& energyDerivExpressions,
+               const std::vector<std::vector<Lepton::CompiledExpression> >& energyGradientExpressions,
+               const std::vector<std::string>& parameterNames);
+    CompiledExpressionSet expressionSet;
+    std::vector<Lepton::CompiledExpression> valueExpressions;
+    std::vector<std::vector<Lepton::CompiledExpression> > valueDerivExpressions;
+    std::vector<std::vector<Lepton::CompiledExpression> > valueGradientExpressions;
+    std::vector<int> valueIndex;
+    std::vector<Lepton::CompiledExpression> energyExpressions;
+    std::vector<std::vector<Lepton::CompiledExpression> > energyDerivExpressions;
+    std::vector<std::vector<Lepton::CompiledExpression> > energyGradientExpressions;
+    std::vector<int> paramIndex;
+    std::vector<int> particleParamIndex;
+    std::vector<int> particleValueIndex;
+    int xindex, yindex, zindex, rindex;
+    int firstAtom, lastAtom;
+    // Workspace vectors
+    std::vector<float> value0, dVdR1, dVdR2, dVdX, dVdY, dVdZ;
+    std::vector<std::vector<float> > dEdV;
+};
+
+} // namespace OpenMM
+
+#endif // OPENMM_CPU_CUSTOM_GB_FORCE_H__

platforms/cpu/include/CpuCustomManyParticleForce.h

@@ -51,9 +51,11 @@ private:
     class ComputeForceTask;
     class ThreadData;
     int numParticles, numParticlesPerSet, numPerParticleParameters, numTypes;
-    bool useCutoff, usePeriodic, centralParticleMode;
+    bool useCutoff, usePeriodic, triclinic, centralParticleMode;
     RealOpenMM cutoffDistance;
-    RealOpenMM periodicBoxSize[3];
+    float recipBoxSize[3];
+    RealVec periodicBoxVectors[3];
+    AlignedArray<fvec4> periodicBoxVec4;
     CpuNeighborList* neighborList;
     ThreadPool& threads;
     std::vector<std::set<int> > exclusions;
@@ -138,9 +140,9 @@ public:
      * 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
+     * @param periodicBoxVectors    the vectors defining the periodic box
      */
-    void setPeriodic(OpenMM::RealVec& boxSize);
+    void setPeriodic(RealVec* periodicBoxVectors);
 
     /**
      * Calculate the interaction.

platforms/cpu/include/CpuCustomNonbondedForce.h

@@ -95,11 +95,11 @@ class CpuCustomNonbondedForce {
          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
+         @param periodicBoxVectors    the vectors defining the periodic box
 
          --------------------------------------------------------------------------------------- */
 
-      void setPeriodic(OpenMM::RealVec& boxSize);
+      void setPeriodic(RealVec* periodicBoxVectors);
 
       /**---------------------------------------------------------------------------------------
 
@@ -127,8 +127,11 @@ private:
     bool cutoff;
     bool useSwitch;
     bool periodic;
+    bool triclinic;
     const CpuNeighborList* neighborList;
-    RealOpenMM periodicBoxSize[3];
+    float recipBoxSize[3];
+    RealVec periodicBoxVectors[3];
+    AlignedArray<fvec4> periodicBoxVec4;
     RealOpenMM cutoffDistance, switchingDistance;
     ThreadPool& threads;
     const std::vector<std::set<int> > exclusions;

platforms/cpu/include/CpuGBSAOBCForce.h

@@ -66,6 +66,11 @@ public:
      */
     void setSolventDielectric(float dielectric);
     
+    /**
+     * Set the surface area energy.
+     */
+    void setSurfaceAreaEnergy(float energy);
+    
     /**
      * Get the per-particle parameters (offset radius, scaled radius).
      */
@@ -96,7 +101,7 @@ private:
     bool cutoff;
     bool periodic;
     float periodicBoxSize[3];
-    float cutoffDistance, soluteDielectric, solventDielectric;
+    float cutoffDistance, soluteDielectric, solventDielectric, surfaceAreaFactor;
     std::vector<std::pair<float, float> > particleParams;        
     AlignedArray<float> bornRadii;
     std::vector<AlignedArray<float> > threadBornForces;

platforms/cpu/include/CpuKernels.h

@@ -33,6 +33,7 @@
  * -------------------------------------------------------------------------- */
 
 #include "CpuBondForce.h"
+#include "CpuCustomGBForce.h"
 #include "CpuCustomManyParticleForce.h"
 #include "CpuCustomNonbondedForce.h"
 #include "CpuGBSAOBCForce.h"
@@ -79,11 +80,13 @@ public:
      * @param includeForce  true if forces should be computed
      * @param includeEnergy true if potential energy should be computed
      * @param groups        a set of bit flags for which force groups to include
+     * @param valid         the method may set this to false to indicate the results are invalid and the force/energy
+     *                      calculation should be repeated
      * @return the potential energy of the system.  This value is added to all values returned by ForceImpls'
      * calcForcesAndEnergy() methods.  That is, each force kernel may <i>either</i> return its contribution to the
      * energy directly, <i>or</i> add it to an internal buffer so that it will be included here.
      */
-    double finishComputation(ContextImpl& context, bool includeForce, bool includeEnergy, int groups);
+    double finishComputation(ContextImpl& context, bool includeForce, bool includeEnergy, int groups, bool& valid);
 private:
     CpuPlatform::PlatformData& data;
     Kernel referenceKernel;
@@ -303,6 +306,53 @@ 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;
+    CpuCustomGBForce* ixn;
+    std::vector<std::set<int> > exclusions;
+    std::vector<std::string> particleParameterNames, globalParameterNames, valueNames;
+    std::vector<OpenMM::CustomGBForce::ComputationType> valueTypes;
+    std::vector<OpenMM::CustomGBForce::ComputationType> energyTypes;
+    NonbondedMethod nonbondedMethod;
+    CpuNeighborList* neighborList;
+};
+
 /**
  * This kernel is invoked by CustomManyParticleForce to calculate the forces acting on the system and the energy of the system.
  */

platforms/cpu/include/CpuLangevinDynamics.h

@@ -31,7 +31,7 @@
 #include "openmm/internal/ThreadPool.h"
 #include "sfmt/SFMT.h"
 
-// ---------------------------------------------------------------------------------------
+namespace OpenMM {
 
 class CpuLangevinDynamics : public ReferenceStochasticDynamics {
 public:
@@ -95,6 +95,6 @@ private:
     OpenMM::RealVec* xPrime;
 };
 
-// ---------------------------------------------------------------------------------------
+} // namespace OpenMM
 
 #endif // __CPU_LANGEVIN_DYNAMICS_H__

platforms/cpu/include/CpuNeighborList.h

@@ -9,7 +9,7 @@
  * Biological Structures at Stanford, funded under the NIH Roadmap for        *
  * Medical Research, grant U54 GM072970. See https://simtk.org.               *
  *                                                                            *
- * Portions copyright (c) 2013 Stanford University and the Authors.           *
+ * Portions copyright (c) 2013-2015 Stanford University and the Authors.      *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -33,6 +33,7 @@
  * -------------------------------------------------------------------------- */
 
 #include "AlignedArray.h"
+#include "RealVec.h"
 #include "windowsExportCpu.h"
 #include "openmm/internal/ThreadPool.h"
 #include <set>
@@ -40,14 +41,14 @@
 #include <vector>
 
 namespace OpenMM {
-    
+
 class OPENMM_EXPORT_CPU CpuNeighborList {
 public:
     class ThreadTask;
     class Voxels;
     CpuNeighborList(int blockSize);
     void computeNeighborList(int numAtoms, const AlignedArray<float>& atomLocations, const std::vector<std::set<int> >& exclusions,
-            const float* periodicBoxSize, bool usePeriodic, float maxDistance, ThreadPool& threads);
+            const RealVec* periodicBoxVectors, bool usePeriodic, float maxDistance, ThreadPool& threads);
     int getNumBlocks() const;
     const std::vector<int>& getSortedAtoms() const;
     const std::vector<int>& getBlockNeighbors(int blockIndex) const;
@@ -60,6 +61,7 @@ public:
 private:
     int blockSize;
     std::vector<int> sortedAtoms;
+    std::vector<float> sortedPositions;
     std::vector<std::vector<int> > blockNeighbors;
     std::vector<std::vector<char> > blockExclusions;
     // The following variables are used to make information accessible to the individual threads.
@@ -68,7 +70,7 @@ private:
     Voxels* voxels;
     const std::vector<std::set<int> >* exclusions;
     const float* atomLocations;
-    const float* periodicBoxSize;
+    RealVec periodicBoxVectors[3];
     int numAtoms;
     bool usePeriodic;
     float maxDistance;

platforms/cpu/include/CpuNonbondedForce.h

@@ -83,11 +83,11 @@ class CpuNonbondedForce {
          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
+         @param periodicBoxVectors    the vectors defining the periodic box
       
          --------------------------------------------------------------------------------------- */
       
-      void setPeriodic(float* periodicBoxSize);
+      void setPeriodic(RealVec* periodicBoxVectors);
        
       /**---------------------------------------------------------------------------------------
       
@@ -161,11 +161,14 @@ protected:
         bool cutoff;
         bool useSwitch;
         bool periodic;
+        bool triclinic;
         bool ewald;
         bool pme;
         bool tableIsValid;
         const CpuNeighborList* neighborList;
-        float periodicBoxSize[3];
+        float recipBoxSize[3];
+        RealVec periodicBoxVectors[3];
+        AlignedArray<fvec4> periodicBoxVec4;
         float cutoffDistance, switchingDistance;
         float krf, crf;
         float alphaEwald;

platforms/cpu/include/CpuNonbondedForceVec4.h

 
-/* Portions copyright (c) 2006-2013 Stanford University and Simbios.
+/* Portions copyright (c) 2006-2014 Stanford University and Simbios.
  * Contributors: Pande Group
  *
  * Permission is hereby granted, free of charge, to any person obtaining
@@ -52,6 +52,12 @@ protected:
          --------------------------------------------------------------------------------------- */
           
       void calculateBlockIxn(int blockIndex, float* forces, double* totalEnergy, const fvec4& boxSize, const fvec4& invBoxSize);
+
+      /**
+       * Templatized implementation of calculateBlockIxn.
+       */
+      template <int PERIODIC_TYPE>
+      void calculateBlockIxnImpl(int blockIndex, float* forces, double* totalEnergy, const fvec4& boxSize, const fvec4& invBoxSize, const fvec4& blockCenter);
             
       /**---------------------------------------------------------------------------------------
       
@@ -65,11 +71,18 @@ protected:
           
       void calculateBlockEwaldIxn(int blockIndex, float* forces, double* totalEnergy, const fvec4& boxSize, const fvec4& invBoxSize);
 
+      /**
+       * Templatized implementation of calculateBlockEwaldIxn.
+       */
+      template <int PERIODIC_TYPE>
+      void calculateBlockEwaldIxnImpl(int blockIndex, float* forces, double* totalEnergy, const fvec4& boxSize, const fvec4& invBoxSize, const fvec4& blockCenter);
+
       /**
        * Compute the displacement and squared distance between a collection of points, optionally using
        * periodic boundary conditions.
        */
-      void getDeltaR(const float* posI, const fvec4& x, const fvec4& y, const fvec4& z, fvec4& dx, fvec4& dy, fvec4& dz, fvec4& r2, bool periodic, const fvec4& boxSize, const fvec4& invBoxSize) const;
+      template <int PERIODIC_TYPE>
+      void getDeltaR(const fvec4& posI, const fvec4& x, const fvec4& y, const fvec4& z, fvec4& dx, fvec4& dy, fvec4& dz, fvec4& r2, bool periodic, const fvec4& boxSize, const fvec4& invBoxSize) const;
 
       /**
        * Compute a fast approximation to erfc(x).

platforms/cpu/include/CpuNonbondedForceVec8.h

 
-/* Portions copyright (c) 2006-2013 Stanford University and Simbios.
+/* Portions copyright (c) 2006-2014 Stanford University and Simbios.
  * Contributors: Pande Group
  *
  * Permission is hereby granted, free of charge, to any person obtaining
@@ -51,6 +51,12 @@ protected:
          --------------------------------------------------------------------------------------- */
           
       void calculateBlockIxn(int blockIndex, float* forces, double* totalEnergy, const fvec4& boxSize, const fvec4& invBoxSize);
+      
+      /**
+       * Templatized implementation of calculateBlockIxn.
+       */
+      template <int PERIODIC_TYPE>
+      void calculateBlockIxnImpl(int blockIndex, float* forces, double* totalEnergy, const fvec4& boxSize, const fvec4& invBoxSize, const fvec4& blockCenter);
             
       /**---------------------------------------------------------------------------------------
       
@@ -64,11 +70,18 @@ protected:
           
       void calculateBlockEwaldIxn(int blockIndex, float* forces, double* totalEnergy, const fvec4& boxSize, const fvec4& invBoxSize);
 
+      /**
+       * Templatized implementation of calculateBlockEwaldIxn.
+       */
+      template <int PERIODIC_TYPE>
+      void calculateBlockEwaldIxnImpl(int blockIndex, float* forces, double* totalEnergy, const fvec4& boxSize, const fvec4& invBoxSize, const fvec4& blockCenter);
+
       /**
        * Compute the displacement and squared distance between a collection of points, optionally using
        * periodic boundary conditions.
        */
-      void getDeltaR(const float* posI, const fvec8& x, const fvec8& y, const fvec8& z, fvec8& dx, fvec8& dy, fvec8& dz, fvec8& r2, bool periodic, const fvec4& boxSize, const fvec4& invBoxSize) const;
+      template <int PERIODIC_TYPE>
+      void getDeltaR(const fvec4& posI, const fvec8& x, const fvec8& y, const fvec8& z, fvec8& dx, fvec8& dy, fvec8& dz, fvec8& r2, bool periodic, const fvec4& boxSize, const fvec4& invBoxSize) const;
 
       /**
        * Compute a fast approximation to erfc(x).

platforms/cpu/src/CpuCustomGBForce.cpp

+
+/* 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.
+ */
+
+#include <string.h>
+#include <sstream>
+
+#include "SimTKOpenMMUtilities.h"
+#include "ReferenceForce.h"
+#include "CpuCustomGBForce.h"
+#include "gmx_atomic.h"
+
+using namespace OpenMM;
+using namespace std;
+
+class CpuCustomGBForce::ComputeForceTask : public ThreadPool::Task {
+public:
+    ComputeForceTask(CpuCustomGBForce& owner) : owner(owner) {
+    }
+    void execute(ThreadPool& threads, int threadIndex) {
+        owner.threadComputeForce(threads, threadIndex);
+    }
+    CpuCustomGBForce& owner;
+};
+
+CpuCustomGBForce::ThreadData::ThreadData(int numAtoms, int numThreads, int threadIndex,
+                      const vector<Lepton::CompiledExpression>& valueExpressions,
+                      const vector<vector<Lepton::CompiledExpression> >& valueDerivExpressions,
+                      const vector<vector<Lepton::CompiledExpression> >& valueGradientExpressions,
+                      const vector<string>& valueNames,
+                      const vector<Lepton::CompiledExpression>& energyExpressions,
+                      const vector<vector<Lepton::CompiledExpression> >& energyDerivExpressions,
+                      const vector<vector<Lepton::CompiledExpression> >& energyGradientExpressions,
+                      const vector<string>& parameterNames) :
+            valueExpressions(valueExpressions), valueDerivExpressions(valueDerivExpressions), valueGradientExpressions(valueGradientExpressions),
+            energyExpressions(energyExpressions), energyDerivExpressions(energyDerivExpressions), energyGradientExpressions(energyGradientExpressions) {
+    firstAtom = (threadIndex*(long long) numAtoms)/numThreads;
+    lastAtom = ((threadIndex+1)*(long long) numAtoms)/numThreads;
+    for (int i = 0; i < (int) valueExpressions.size(); i++)
+        expressionSet.registerExpression(this->valueExpressions[i]);
+    for (int i = 0; i < (int) valueDerivExpressions.size(); i++)
+        for (int j = 0; j < (int) valueDerivExpressions[i].size(); j++)
+            expressionSet.registerExpression(this->valueDerivExpressions[i][j]);
+    for (int i = 0; i < (int) valueGradientExpressions.size(); i++)
+        for (int j = 0; j < (int) valueGradientExpressions[i].size(); j++)
+            expressionSet.registerExpression(this->valueGradientExpressions[i][j]);
+    for (int i = 0; i < (int) energyExpressions.size(); i++)
+        expressionSet.registerExpression(this->energyExpressions[i]);
+    for (int i = 0; i < (int) energyDerivExpressions.size(); i++)
+        for (int j = 0; j < (int) energyDerivExpressions[i].size(); j++)
+            expressionSet.registerExpression(this->energyDerivExpressions[i][j]);
+    for (int i = 0; i < (int) energyGradientExpressions.size(); i++)
+        for (int j = 0; j < (int) energyGradientExpressions[i].size(); j++)
+            expressionSet.registerExpression(this->energyGradientExpressions[i][j]);
+    xindex = expressionSet.getVariableIndex("x");
+    yindex = expressionSet.getVariableIndex("y");
+    zindex = expressionSet.getVariableIndex("z");
+    rindex = expressionSet.getVariableIndex("r");
+    for (int i = 0; i < (int) parameterNames.size(); i++) {
+        paramIndex.push_back(expressionSet.getVariableIndex(parameterNames[i]));
+        for (int j = 1; j < 3; j++) {
+            stringstream name;
+            name << parameterNames[i] << j;
+            particleParamIndex.push_back(expressionSet.getVariableIndex(name.str()));
+        }
+    }
+    for (int i = 0; i < (int) valueNames.size(); i++) {
+        valueIndex.push_back(expressionSet.getVariableIndex(valueNames[i]));
+        for (int j = 1; j < 3; j++) {
+            stringstream name;
+            name << valueNames[i] << j;
+            particleValueIndex.push_back(expressionSet.getVariableIndex(name.str()));
+        }
+    }
+    value0.resize(numAtoms);
+    dEdV.resize(valueNames.size());
+    for (int i = 0; i < (int) dEdV.size(); i++)
+        dEdV[i].resize(numAtoms);
+    dVdX.resize(valueDerivExpressions.size());
+    dVdY.resize(valueDerivExpressions.size());
+    dVdZ.resize(valueDerivExpressions.size());
+    dVdR1.resize(valueDerivExpressions.size());
+    dVdR2.resize(valueDerivExpressions.size());
+}
+
+CpuCustomGBForce::CpuCustomGBForce(int numAtoms, const std::vector<std::set<int> >& exclusions,
+                     const vector<Lepton::CompiledExpression>& valueExpressions,
+                     const vector<vector<Lepton::CompiledExpression> >& valueDerivExpressions,
+                     const vector<vector<Lepton::CompiledExpression> >& valueGradientExpressions,
+                     const vector<string>& valueNames,
+                     const vector<CustomGBForce::ComputationType>& valueTypes,
+                     const vector<Lepton::CompiledExpression>& energyExpressions,
+                     const vector<vector<Lepton::CompiledExpression> >& energyDerivExpressions,
+                     const vector<vector<Lepton::CompiledExpression> >& energyGradientExpressions,
+                     const vector<CustomGBForce::ComputationType>& energyTypes,
+                     const vector<string>& parameterNames, ThreadPool& threads) :
+            exclusions(exclusions), cutoff(false), periodic(false), valueNames(valueNames), valueTypes(valueTypes),
+            energyTypes(energyTypes), paramNames(parameterNames), threads(threads) {
+    for (int i = 0; i < threads.getNumThreads(); i++)
+        threadData.push_back(new ThreadData(numAtoms, threads.getNumThreads(), i, valueExpressions, valueDerivExpressions, valueGradientExpressions, valueNames,
+                      energyExpressions, energyDerivExpressions, energyGradientExpressions, parameterNames));
+    values.resize(valueNames.size());
+    dEdV.resize(valueNames.size());
+    for (int i = 0; i < (int) values.size(); i++) {
+        values[i].resize(numAtoms);
+        dEdV[i].resize(numAtoms);
+    }
+}
+
+CpuCustomGBForce::~CpuCustomGBForce() {
+    for (int i = 0; i < (int) threadData.size(); i++)
+        delete threadData[i];
+}
+
+void CpuCustomGBForce::setUseCutoff(float distance, const CpuNeighborList& neighbors) {
+    cutoff = true;
+    cutoffDistance = distance;
+    cutoffDistance2 = distance*distance;
+    neighborList = &neighbors;
+  }
+
+void CpuCustomGBForce::setPeriodic(RealVec& boxSize) {
+    if (cutoff) {
+        assert(boxSize[0] >= 2.0*cutoffDistance);
+        assert(boxSize[1] >= 2.0*cutoffDistance);
+        assert(boxSize[2] >= 2.0*cutoffDistance);
+    }
+    periodic = true;
+    periodicBoxSize[0] = boxSize[0];
+    periodicBoxSize[1] = boxSize[1];
+    periodicBoxSize[2] = boxSize[2];
+  }
+
+void CpuCustomGBForce::calculateIxn(int numberOfAtoms, float* posq, RealOpenMM** atomParameters,
+                                           map<string, double>& globalParameters, vector<AlignedArray<float> >& threadForce,
+                                           bool includeForce, bool includeEnergy, double& totalEnergy) {
+    // Record the parameters for the threads.
+    
+    this->numberOfAtoms = numberOfAtoms;
+    this->posq = posq;
+    this->atomParameters = atomParameters;
+    this->globalParameters = &globalParameters;
+    this->threadForce = &threadForce;
+    this->includeForce = includeForce;
+    this->includeEnergy = includeEnergy;
+    threadEnergy.resize(threads.getNumThreads());
+    gmx_atomic_t counter;
+    this->atomicCounter = &counter;
+
+    // Calculate the first computed value.
+
+    ComputeForceTask task(*this);
+    gmx_atomic_set(&counter, 0);
+    threads.execute(task);
+    threads.waitForThreads();
+    
+    // Calculate the remaining computed values.
+    
+    threads.resumeThreads();
+    threads.waitForThreads();
+
+    // Calculate the energy terms.
+
+    for (int i = 0; i < (int) threadData[0]->energyExpressions.size(); i++) {
+        gmx_atomic_set(&counter, 0);
+        threads.execute(task);
+        threads.waitForThreads();
+    }
+
+    // Sum the energy derivatives.
+
+    threads.resumeThreads();
+    threads.waitForThreads();
+    
+    // Apply the chain rule to evaluate forces.
+
+    gmx_atomic_set(&counter, 0);
+    threads.resumeThreads();
+    threads.waitForThreads();
+
+    // Combine the energies from all the threads.
+    
+    if (includeEnergy) {
+        int numThreads = threads.getNumThreads();
+        for (int i = 0; i < numThreads; i++)
+            totalEnergy += threadEnergy[i];
+    }
+}
+
+void CpuCustomGBForce::threadComputeForce(ThreadPool& threads, int threadIndex) {
+    // Compute this thread's subset of interactions.
+
+    int numThreads = threads.getNumThreads();
+    threadEnergy[threadIndex] = 0;
+    double& energy = threadEnergy[threadIndex];
+    float* forces = &(*threadForce)[threadIndex][0];
+    ThreadData& data = *threadData[threadIndex];
+    fvec4 boxSize(periodicBoxSize[0], periodicBoxSize[1], periodicBoxSize[2], 0);
+    fvec4 invBoxSize((1/periodicBoxSize[0]), (1/periodicBoxSize[1]), (1/periodicBoxSize[2]), 0);
+    for (map<string, double>::const_iterator iter = globalParameters->begin(); iter != globalParameters->end(); ++iter)
+        data.expressionSet.setVariable(data.expressionSet.getVariableIndex(iter->first), iter->second);
+
+    // Calculate the first computed value.
+
+    for (int i = 0; i < (int) data.value0.size(); i++)
+        data.value0[i] = 0.0f;
+    if (valueTypes[0] == CustomGBForce::ParticlePair)
+        calculateParticlePairValue(0, data, numberOfAtoms, posq, atomParameters, true, boxSize, invBoxSize);
+    else
+        calculateParticlePairValue(0, data, numberOfAtoms, posq, atomParameters, false, boxSize, invBoxSize);
+    threads.syncThreads();
+
+    // Sum the first computed value and calculate the remaining ones.
+
+    int numValues = valueTypes.size();
+    for (int atom = data.firstAtom; atom < data.lastAtom; atom++) {
+        float sum = 0.0f;
+        for (int j = 0; j < (int) threadData.size(); j++)
+            sum += threadData[j]->value0[atom];
+        values[0][atom] = sum;
+        data.expressionSet.setVariable(data.xindex, posq[4*atom]);
+        data.expressionSet.setVariable(data.yindex, posq[4*atom+1]);
+        data.expressionSet.setVariable(data.zindex, posq[4*atom+2]);
+        for (int j = 0; j < (int) paramNames.size(); j++)
+            data.expressionSet.setVariable(data.paramIndex[j], atomParameters[atom][j]);
+        for (int i = 1; i < numValues; i++) {
+            data.expressionSet.setVariable(data.valueIndex[i-1], values[i-1][atom]);
+            values[i][atom] = (float) data.valueExpressions[i].evaluate();
+        }
+    }
+    threads.syncThreads();
+
+    // Now calculate the energy and its derivatives.
+
+    for (int i = 0; i < (int) data.dEdV.size(); i++)
+        for (int j = 0; j < (int) data.dEdV[i].size(); j++)
+            data.dEdV[i][j] = 0.0;
+    for (int termIndex = 0; termIndex < (int) data.energyExpressions.size(); termIndex++) {
+        if (energyTypes[termIndex] == CustomGBForce::SingleParticle)
+            calculateSingleParticleEnergyTerm(termIndex, data, numberOfAtoms, posq, atomParameters, forces, energy);
+        else if (energyTypes[termIndex] == CustomGBForce::ParticlePair)
+            calculateParticlePairEnergyTerm(termIndex, data, numberOfAtoms, posq, atomParameters, true, forces, energy, boxSize, invBoxSize);
+        else
+            calculateParticlePairEnergyTerm(termIndex, data, numberOfAtoms, posq, atomParameters, false, forces, energy, boxSize, invBoxSize);
+        threads.syncThreads();
+    }
+
+    // Sum the energy derivatives.
+
+    for (int atom = data.firstAtom; atom < data.lastAtom; atom++) {
+        for (int i = 0; i < (int) dEdV.size(); i++) {
+            float sum = 0.0f;
+            for (int j = 0; j < (int) threadData.size(); j++)
+                sum += threadData[j]->dEdV[i][atom];
+            dEdV[i][atom] = sum;
+        }
+    }
+    threads.syncThreads();
+
+    // Apply the chain rule to evaluate forces.
+
+    calculateChainRuleForces(data, numberOfAtoms, posq, atomParameters, forces, boxSize, invBoxSize);
+}
+
+void CpuCustomGBForce::calculateParticlePairValue(int index, ThreadData& data, int numAtoms, float* posq, RealOpenMM** atomParameters,
+        bool useExclusions, const fvec4& boxSize, const fvec4& invBoxSize) {
+    for (int i = 0; i < numAtoms; i++)
+        values[index][i] = 0.0f;
+    vector<float>& valueArray = (index == 0 ? data.value0 : values[index]);
+    if (cutoff) {
+        // Loop over all pairs in the neighbor list.
+
+        while (true) {
+            int blockIndex = gmx_atomic_fetch_add(reinterpret_cast<gmx_atomic_t*>(atomicCounter), 1);
+            if (blockIndex >= neighborList->getNumBlocks())
+                break;
+            const int* blockAtom = &neighborList->getSortedAtoms()[4*blockIndex];
+            const vector<int>& neighbors = neighborList->getBlockNeighbors(blockIndex);
+            const vector<char>& blockExclusions = neighborList->getBlockExclusions(blockIndex);
+            for (int i = 0; i < (int) neighbors.size(); i++) {
+                int first = neighbors[i];
+                for (int k = 0; k < 4; k++) {
+                    if ((blockExclusions[i] & (1<<k)) == 0) {
+                        int second = blockAtom[k];
+                        if (useExclusions && exclusions[first].find(second) != exclusions[first].end())
+                            continue;
+                        calculateOnePairValue(index, first, second, data, posq, atomParameters, valueArray, boxSize, invBoxSize);
+                        calculateOnePairValue(index, second, first, data, posq, atomParameters, valueArray, boxSize, invBoxSize);
+                    }
+                }
+            }
+        }
+    }
+    else {
+        // Perform an O(N^2) loop over all atom pairs.
+
+        while (true) {
+            int i = gmx_atomic_fetch_add(reinterpret_cast<gmx_atomic_t*>(atomicCounter), 1);
+            if (i >= numAtoms)
+                break;
+            for (int j = i+1; j < numAtoms; j++) {
+                if (useExclusions && exclusions[i].find(j) != exclusions[i].end())
+                    continue;
+                calculateOnePairValue(index, i, j, data, posq, atomParameters, valueArray, boxSize, invBoxSize);
+                calculateOnePairValue(index, j, i, data, posq, atomParameters, valueArray, boxSize, invBoxSize);
+           }
+        }
+    }
+}
+
+void CpuCustomGBForce::calculateOnePairValue(int index, int atom1, int atom2, ThreadData& data, float* posq, RealOpenMM** atomParameters,
+        vector<float>& valueArray, const fvec4& boxSize, const fvec4& invBoxSize) {
+    fvec4 deltaR;
+    fvec4 pos1(posq+4*atom1);
+    fvec4 pos2(posq+4*atom2);
+    float r2;
+    getDeltaR(pos2, pos1, deltaR, r2, periodic, boxSize, invBoxSize);
+    if (cutoff && r2 >= cutoffDistance2)
+        return;
+    float r = sqrtf(r2);
+    for (int i = 0; i < (int) paramNames.size(); i++) {
+        data.expressionSet.setVariable(data.particleParamIndex[i*2], atomParameters[atom1][i]);
+        data.expressionSet.setVariable(data.particleParamIndex[i*2+1], atomParameters[atom2][i]);
+    }
+    data.expressionSet.setVariable(data.rindex, r);
+    for (int i = 0; i < index; i++) {
+        data.expressionSet.setVariable(data.particleValueIndex[i*2], values[i][atom1]);
+        data.expressionSet.setVariable(data.particleValueIndex[i*2+1], values[i][atom2]);
+    }
+    valueArray[atom1] += (float) data.valueExpressions[index].evaluate();
+}
+
+void CpuCustomGBForce::calculateSingleParticleEnergyTerm(int index, ThreadData& data, int numAtoms, float* posq,
+        RealOpenMM** atomParameters, float* forces, double& totalEnergy) {
+    for (int i = data.firstAtom; i < data.lastAtom; i++) {
+        data.expressionSet.setVariable(data.xindex, posq[4*i]);
+        data.expressionSet.setVariable(data.yindex, posq[4*i+1]);
+        data.expressionSet.setVariable(data.zindex, posq[4*i+2]);
+        for (int j = 0; j < (int) paramNames.size(); j++)
+            data.expressionSet.setVariable(data.paramIndex[j], atomParameters[i][j]);
+        for (int j = 0; j < (int) valueNames.size(); j++)
+            data.expressionSet.setVariable(data.valueIndex[j], values[j][i]);
+        if (includeEnergy)
+            totalEnergy += (float) data.energyExpressions[index].evaluate();
+        for (int j = 0; j < (int) valueNames.size(); j++)
+            data.dEdV[j][i] += (float) data.energyDerivExpressions[index][j].evaluate();
+        forces[4*i+0] -= (float) data.energyGradientExpressions[index][0].evaluate();
+        forces[4*i+1] -= (float) data.energyGradientExpressions[index][1].evaluate();
+        forces[4*i+2] -= (float) data.energyGradientExpressions[index][2].evaluate();
+    }
+}
+
+void CpuCustomGBForce::calculateParticlePairEnergyTerm(int index, ThreadData& data, int numAtoms, float* posq, RealOpenMM** atomParameters,
+        bool useExclusions, float* forces, double& totalEnergy, const fvec4& boxSize, const fvec4& invBoxSize) {
+    if (cutoff) {
+        // Loop over all pairs in the neighbor list.
+
+        while (true) {
+            int blockIndex = gmx_atomic_fetch_add(reinterpret_cast<gmx_atomic_t*>(atomicCounter), 1);
+            if (blockIndex >= neighborList->getNumBlocks())
+                break;
+            const int* blockAtom = &neighborList->getSortedAtoms()[4*blockIndex];
+            const vector<int>& neighbors = neighborList->getBlockNeighbors(blockIndex);
+            const vector<char>& blockExclusions = neighborList->getBlockExclusions(blockIndex);
+            for (int i = 0; i < (int) neighbors.size(); i++) {
+                int first = neighbors[i];
+                for (int k = 0; k < 4; k++) {
+                    if ((blockExclusions[i] & (1<<k)) == 0) {
+                        int second = blockAtom[k];
+                        if (useExclusions && exclusions[first].find(second) != exclusions[first].end())
+                            continue;
+                        calculateOnePairEnergyTerm(index, first, second, data, posq, atomParameters, forces, totalEnergy, boxSize, invBoxSize);
+                    }
+                }
+            }
+        }
+    }
+    else {
+        // Perform an O(N^2) loop over all atom pairs.
+
+        while (true) {
+            int i = gmx_atomic_fetch_add(reinterpret_cast<gmx_atomic_t*>(atomicCounter), 1);
+            if (i >= numAtoms)
+                break;
+            for (int j = i+1; j < numAtoms; j++) {
+                if (useExclusions && exclusions[i].find(j) != exclusions[i].end())
+                    continue;
+                calculateOnePairEnergyTerm(index, i, j, data, posq, atomParameters, forces, totalEnergy, boxSize, invBoxSize);
+           }
+        }
+    }
+}
+
+void CpuCustomGBForce::calculateOnePairEnergyTerm(int index, int atom1, int atom2, ThreadData& data, float* posq, RealOpenMM** atomParameters,
+        float* forces, double& totalEnergy, const fvec4& boxSize, const fvec4& invBoxSize) {
+    // Compute the displacement.
+
+    fvec4 deltaR;
+    fvec4 pos1(posq+4*atom1);
+    fvec4 pos2(posq+4*atom2);
+    float r2;
+    getDeltaR(pos2, pos1, deltaR, r2, periodic, boxSize, invBoxSize);
+    if (cutoff && r2 >= cutoffDistance2)
+        return;
+    float r = sqrtf(r2);
+
+    // Record variables for evaluating expressions.
+
+    for (int i = 0; i < (int) paramNames.size(); i++) {
+        data.expressionSet.setVariable(data.particleParamIndex[i*2], atomParameters[atom1][i]);
+        data.expressionSet.setVariable(data.particleParamIndex[i*2+1], atomParameters[atom2][i]);
+    }
+    data.expressionSet.setVariable(data.rindex, r);
+    for (int i = 0; i < (int) valueNames.size(); i++) {
+        data.expressionSet.setVariable(data.particleValueIndex[i*2], values[i][atom1]);
+        data.expressionSet.setVariable(data.particleValueIndex[i*2+1], values[i][atom2]);
+    }
+
+    // Evaluate the energy and its derivatives.
+
+    if (includeEnergy)
+        totalEnergy += (float) data.energyExpressions[index].evaluate();
+    float dEdR = (float) data.energyDerivExpressions[index][0].evaluate();
+    dEdR *= 1/r;
+    fvec4 result = deltaR*dEdR;
+    (fvec4(forces+4*atom1)-result).store(forces+4*atom1);
+    (fvec4(forces+4*atom2)+result).store(forces+4*atom2);
+    for (int i = 0; i < (int) valueNames.size(); i++) {
+        data.dEdV[i][atom1] += (float) data.energyDerivExpressions[index][2*i+1].evaluate();
+        data.dEdV[i][atom2] += (float) data.energyDerivExpressions[index][2*i+2].evaluate();
+    }
+}
+
+void CpuCustomGBForce::calculateChainRuleForces(ThreadData& data, int numAtoms, float* posq, RealOpenMM** atomParameters,
+        float* forces, const fvec4& boxSize, const fvec4& invBoxSize) {
+    if (cutoff) {
+        // Loop over all pairs in the neighbor list.
+
+        while (true) {
+            int blockIndex = gmx_atomic_fetch_add(reinterpret_cast<gmx_atomic_t*>(atomicCounter), 1);
+            if (blockIndex >= neighborList->getNumBlocks())
+                break;
+            const int* blockAtom = &neighborList->getSortedAtoms()[4*blockIndex];
+            const vector<int>& neighbors = neighborList->getBlockNeighbors(blockIndex);
+            const vector<char>& blockExclusions = neighborList->getBlockExclusions(blockIndex);
+            for (int i = 0; i < (int) neighbors.size(); i++) {
+                int first = neighbors[i];
+                for (int k = 0; k < 4; k++) {
+                    if ((blockExclusions[i] & (1<<k)) == 0) {
+                        int second = blockAtom[k];
+                        bool isExcluded = (exclusions[first].find(second) != exclusions[first].end());
+                        calculateOnePairChainRule(first, second, data, posq, atomParameters, forces, isExcluded, boxSize, invBoxSize);
+                        calculateOnePairChainRule(second, first, data, posq, atomParameters, forces, isExcluded, boxSize, invBoxSize);
+                    }
+                }
+            }
+        }
+    }
+    else {
+        // Perform an O(N^2) loop over all atom pairs.
+
+        while (true) {
+            int i = gmx_atomic_fetch_add(reinterpret_cast<gmx_atomic_t*>(atomicCounter), 1);
+            if (i >= numAtoms)
+                break;
+            for (int j = i+1; j < numAtoms; j++) {
+                bool isExcluded = (exclusions[i].find(j) != exclusions[i].end());
+                calculateOnePairChainRule(i, j, data, posq, atomParameters, forces, isExcluded, boxSize, invBoxSize);
+                calculateOnePairChainRule(j, i, data, posq, atomParameters, forces, isExcluded, boxSize, invBoxSize);
+           }
+        }
+    }
+
+    // Compute chain rule terms for computed values that depend explicitly on particle coordinates.
+
+    for (int i = data.firstAtom; i < data.lastAtom; i++) {
+        data.expressionSet.setVariable(data.xindex, posq[4*i]);
+        data.expressionSet.setVariable(data.yindex, posq[4*i+1]);
+        data.expressionSet.setVariable(data.zindex, posq[4*i+2]);
+        for (int j = 0; j < (int) paramNames.size(); j++)
+            data.expressionSet.setVariable(data.paramIndex[j], atomParameters[i][j]);
+        for (int j = 1; j < (int) valueNames.size(); j++) {
+            data.expressionSet.setVariable(data.valueIndex[j-1], values[j-1][i]);
+            data.dVdX[j] = 0.0;
+            data.dVdY[j] = 0.0;
+            data.dVdZ[j] = 0.0;
+            for (int k = 1; k < j; k++) {
+                float dVdV = (float) data.valueDerivExpressions[j][k].evaluate();
+                data.dVdX[j] += dVdV*data.dVdX[k];
+                data.dVdY[j] += dVdV*data.dVdY[k];
+                data.dVdZ[j] += dVdV*data.dVdZ[k];
+            }
+            data.dVdX[j] += (float) data.valueGradientExpressions[j][0].evaluate();
+            data.dVdY[j] += (float) data.valueGradientExpressions[j][1].evaluate();
+            data.dVdZ[j] += (float) data.valueGradientExpressions[j][2].evaluate();
+            forces[4*i+0] -= dEdV[j][i]*data.dVdX[j];
+            forces[4*i+1] -= dEdV[j][i]*data.dVdY[j];
+            forces[4*i+2] -= dEdV[j][i]*data.dVdZ[j];
+        }
+    }
+}
+
+void CpuCustomGBForce::calculateOnePairChainRule(int atom1, int atom2, ThreadData& data, float* posq, RealOpenMM** atomParameters,
+        float* forces, bool isExcluded, const fvec4& boxSize, const fvec4& invBoxSize) {
+    // Compute the displacement.
+
+    fvec4 deltaR;
+    fvec4 pos1(posq+4*atom1);
+    fvec4 pos2(posq+4*atom2);
+    float r2;
+    getDeltaR(pos2, pos1, deltaR, r2, periodic, boxSize, invBoxSize);
+    if (cutoff && r2 >= cutoffDistance2)
+        return;
+    float r = sqrtf(r2);
+
+    // Record variables for evaluating expressions.
+
+    for (int i = 0; i < (int) paramNames.size(); i++) {
+        data.expressionSet.setVariable(data.particleParamIndex[i*2], atomParameters[atom1][i]);
+        data.expressionSet.setVariable(data.particleParamIndex[i*2+1], atomParameters[atom2][i]);
+        data.expressionSet.setVariable(data.paramIndex[i], atomParameters[atom1][i]);
+    }
+    data.expressionSet.setVariable(data.valueIndex[0], values[0][atom1]);
+    data.expressionSet.setVariable(data.xindex, posq[4*atom1]);
+    data.expressionSet.setVariable(data.yindex, posq[4*atom1+1]);
+    data.expressionSet.setVariable(data.zindex, posq[4*atom1+2]);
+    data.expressionSet.setVariable(data.rindex, r);
+    data.expressionSet.setVariable(data.particleValueIndex[0], values[0][atom1]);
+    data.expressionSet.setVariable(data.particleValueIndex[1], values[0][atom2]);
+
+    // Evaluate the derivative of each parameter with respect to position and apply forces.
+
+    float rinv = 1/r;
+    deltaR *= rinv;
+    fvec4 f1(0.0f), f2(0.0f);
+    if (!isExcluded || valueTypes[0] != CustomGBForce::ParticlePair) {
+        data.dVdR1[0] = (float) data.valueDerivExpressions[0][0].evaluate();
+        data.dVdR2[0] = -data.dVdR1[0];
+        f1 -= deltaR*(dEdV[0][atom1]*data.dVdR1[0]);
+        f2 -= deltaR*(dEdV[0][atom1]*data.dVdR2[0]);
+    }
+    for (int i = 1; i < (int) valueNames.size(); i++) {
+        data.expressionSet.setVariable(data.valueIndex[i], values[i][atom1]);
+        data.dVdR1[i] = 0.0;
+        data.dVdR2[i] = 0.0;
+        for (int j = 0; j < i; j++) {
+            float dVdV = (float) data.valueDerivExpressions[i][j].evaluate();
+            data.dVdR1[i] += dVdV*data.dVdR1[j];
+            data.dVdR2[i] += dVdV*data.dVdR2[j];
+        }
+        f1 -= deltaR*(dEdV[i][atom1]*data.dVdR1[i]);
+        f2 -= deltaR*(dEdV[i][atom1]*data.dVdR2[i]);
+    }
+    (fvec4(forces+4*atom1)+f1).store(forces+4*atom1);
+    (fvec4(forces+4*atom2)+f2).store(forces+4*atom2);
+}
+
+void CpuCustomGBForce::getDeltaR(const fvec4& posI, const fvec4& posJ, fvec4& deltaR, float& r2, bool periodic, const fvec4& boxSize, const fvec4& invBoxSize) const {
+    deltaR = posJ-posI;
+    if (periodic) {
+        fvec4 base = round(deltaR*invBoxSize)*boxSize;
+        deltaR = deltaR-base;
+    }
+    r2 = dot3(deltaR, deltaR);
+}

platforms/cpu/src/CpuCustomManyParticleForce.cpp

@@ -26,8 +26,6 @@
 #include <sstream>
 #include <utility>
 
-#include "SimTKOpenMMCommon.h"
-#include "SimTKOpenMMLog.h"
 #include "SimTKOpenMMUtilities.h"
 #include "ReferenceForce.h"
 #include "CpuCustomManyParticleForce.h"
@@ -122,8 +120,7 @@ void CpuCustomManyParticleForce::calculateIxn(AlignedArray<float>& posq, RealOpe
         particleNeighbors.resize(numParticles);
         for (int i = 0; i < numParticles; i++)
             particleNeighbors[i].clear();
-        float boxSizeFloat[] = {(float) periodicBoxSize[0], (float) periodicBoxSize[1], (float) periodicBoxSize[2]};
-        neighborList->computeNeighborList(numParticles, posq, exclusions, boxSizeFloat, usePeriodic, cutoffDistance, threads);
+        neighborList->computeNeighborList(numParticles, posq, exclusions, periodicBoxVectors, usePeriodic, cutoffDistance, threads);
         for (int blockIndex = 0; blockIndex < neighborList->getNumBlocks(); blockIndex++) {
             const vector<int>& neighbors = neighborList->getBlockNeighbors(blockIndex);
             const vector<char>& exclusions = neighborList->getBlockExclusions(blockIndex);
@@ -159,8 +156,8 @@ void CpuCustomManyParticleForce::calculateIxn(AlignedArray<float>& posq, RealOpe
 
 void CpuCustomManyParticleForce::threadComputeForce(ThreadPool& threads, int threadIndex) {
     vector<int> particleIndices(numParticlesPerSet);
-    fvec4 boxSize(periodicBoxSize[0], periodicBoxSize[1], periodicBoxSize[2], 0);
-    fvec4 invBoxSize((1/periodicBoxSize[0]), (1/periodicBoxSize[1]), (1/periodicBoxSize[2]), 0);
+    fvec4 boxSize(periodicBoxVectors[0][0], periodicBoxVectors[1][1], periodicBoxVectors[2][2], 0);
+    fvec4 invBoxSize(recipBoxSize[0], recipBoxSize[1], recipBoxSize[2], 0);
     float* forces = &(*threadForce)[threadIndex][0];
     ThreadData& data = *threadData[threadIndex];
     data.energy = 0;
@@ -201,15 +198,25 @@ void CpuCustomManyParticleForce::setUseCutoff(RealOpenMM distance) {
         neighborList = new CpuNeighborList(4);
 }
 
-void CpuCustomManyParticleForce::setPeriodic(RealVec& boxSize) {
+void CpuCustomManyParticleForce::setPeriodic(RealVec* periodicBoxVectors) {
     assert(useCutoff);
-    assert(boxSize[0] >= 2.0*cutoffDistance);
-    assert(boxSize[1] >= 2.0*cutoffDistance);
-    assert(boxSize[2] >= 2.0*cutoffDistance);
+    assert(periodicBoxVectors[0][0] >= 2.0*cutoffDistance);
+    assert(periodicBoxVectors[1][1] >= 2.0*cutoffDistance);
+    assert(periodicBoxVectors[2][2] >= 2.0*cutoffDistance);
     usePeriodic = true;
-    periodicBoxSize[0] = boxSize[0];
-    periodicBoxSize[1] = boxSize[1];
-    periodicBoxSize[2] = boxSize[2];
+    this->periodicBoxVectors[0] = periodicBoxVectors[0];
+    this->periodicBoxVectors[1] = periodicBoxVectors[1];
+    this->periodicBoxVectors[2] = periodicBoxVectors[2];
+    recipBoxSize[0] = (float) (1.0/periodicBoxVectors[0][0]);
+    recipBoxSize[1] = (float) (1.0/periodicBoxVectors[1][1]);
+    recipBoxSize[2] = (float) (1.0/periodicBoxVectors[2][2]);
+    periodicBoxVec4.resize(3);
+    periodicBoxVec4[0] = fvec4(periodicBoxVectors[0][0], periodicBoxVectors[0][1], periodicBoxVectors[0][2], 0);
+    periodicBoxVec4[1] = fvec4(periodicBoxVectors[1][0], periodicBoxVectors[1][1], periodicBoxVectors[1][2], 0);
+    periodicBoxVec4[2] = fvec4(periodicBoxVectors[2][0], periodicBoxVectors[2][1], periodicBoxVectors[2][2], 0);
+    triclinic = (periodicBoxVectors[0][1] != 0.0 || periodicBoxVectors[0][2] != 0.0 ||
+                 periodicBoxVectors[1][0] != 0.0 || periodicBoxVectors[1][2] != 0.0 ||
+                 periodicBoxVectors[2][0] != 0.0 || periodicBoxVectors[2][1] != 0.0);
 }
 
 void CpuCustomManyParticleForce::loopOverInteractions(vector<int>& availableParticles, vector<int>& particleSet, int loopIndex, int startIndex,
@@ -394,8 +401,15 @@ void CpuCustomManyParticleForce::calculateOneIxn(vector<int>& particleSet, RealO
 void CpuCustomManyParticleForce::computeDelta(const fvec4& posI, const fvec4& posJ, fvec4& deltaR, float& r2, const fvec4& boxSize, const fvec4& invBoxSize) const {
     deltaR = posJ-posI;
     if (usePeriodic) {
-        fvec4 base = round(deltaR*invBoxSize)*boxSize;
-        deltaR = deltaR-base;
+        if (triclinic) {
+            deltaR -= periodicBoxVec4[2]*floorf(deltaR[2]*recipBoxSize[2]+0.5f);
+            deltaR -= periodicBoxVec4[1]*floorf(deltaR[1]*recipBoxSize[1]+0.5f);
+            deltaR -= periodicBoxVec4[0]*floorf(deltaR[0]*recipBoxSize[0]+0.5f);
+        }
+        else {
+            fvec4 base = round(deltaR*invBoxSize)*boxSize;
+            deltaR = deltaR-base;
+        }
     }
     r2 = dot3(deltaR, deltaR);
 }

platforms/cpu/src/CpuCustomNonbondedForce.cpp

@@ -25,8 +25,6 @@
 #include <string.h>
 #include <sstream>
 
-#include "SimTKOpenMMCommon.h"
-#include "SimTKOpenMMLog.h"
 #include "SimTKOpenMMUtilities.h"
 #include "ReferenceForce.h"
 #include "CpuCustomNonbondedForce.h"
@@ -98,15 +96,25 @@ void CpuCustomNonbondedForce::setUseSwitchingFunction(RealOpenMM distance) {
     switchingDistance = distance;
 }
 
-void CpuCustomNonbondedForce::setPeriodic(RealVec& boxSize) {
+void CpuCustomNonbondedForce::setPeriodic(RealVec* periodicBoxVectors) {
     assert(cutoff);
-    assert(boxSize[0] >= 2.0*cutoffDistance);
-    assert(boxSize[1] >= 2.0*cutoffDistance);
-    assert(boxSize[2] >= 2.0*cutoffDistance);
+    assert(periodicBoxVectors[0][0] >= 2.0*cutoffDistance);
+    assert(periodicBoxVectors[1][1] >= 2.0*cutoffDistance);
+    assert(periodicBoxVectors[2][2] >= 2.0*cutoffDistance);
     periodic = true;
-    periodicBoxSize[0] = boxSize[0];
-    periodicBoxSize[1] = boxSize[1];
-    periodicBoxSize[2] = boxSize[2];
+    this->periodicBoxVectors[0] = periodicBoxVectors[0];
+    this->periodicBoxVectors[1] = periodicBoxVectors[1];
+    this->periodicBoxVectors[2] = periodicBoxVectors[2];
+    recipBoxSize[0] = (float) (1.0/periodicBoxVectors[0][0]);
+    recipBoxSize[1] = (float) (1.0/periodicBoxVectors[1][1]);
+    recipBoxSize[2] = (float) (1.0/periodicBoxVectors[2][2]);
+    periodicBoxVec4.resize(3);
+    periodicBoxVec4[0] = fvec4(periodicBoxVectors[0][0], periodicBoxVectors[0][1], periodicBoxVectors[0][2], 0);
+    periodicBoxVec4[1] = fvec4(periodicBoxVectors[1][0], periodicBoxVectors[1][1], periodicBoxVectors[1][2], 0);
+    periodicBoxVec4[2] = fvec4(periodicBoxVectors[2][0], periodicBoxVectors[2][1], periodicBoxVectors[2][2], 0);
+    triclinic = (periodicBoxVectors[0][1] != 0.0 || periodicBoxVectors[0][2] != 0.0 ||
+                 periodicBoxVectors[1][0] != 0.0 || periodicBoxVectors[1][2] != 0.0 ||
+                 periodicBoxVectors[2][0] != 0.0 || periodicBoxVectors[2][1] != 0.0);
 }
 
 
@@ -155,8 +163,8 @@ void CpuCustomNonbondedForce::threadComputeForce(ThreadPool& threads, int thread
         ReferenceForce::setVariable(ReferenceForce::getVariablePointer(data.energyExpression, iter->first), iter->second);
         ReferenceForce::setVariable(ReferenceForce::getVariablePointer(data.forceExpression, iter->first), iter->second);
     }
-    fvec4 boxSize(periodicBoxSize[0], periodicBoxSize[1], periodicBoxSize[2], 0);
-    fvec4 invBoxSize((1/periodicBoxSize[0]), (1/periodicBoxSize[1]), (1/periodicBoxSize[2]), 0);
+    fvec4 boxSize(periodicBoxVectors[0][0], periodicBoxVectors[1][1], periodicBoxVectors[2][2], 0);
+    fvec4 invBoxSize(recipBoxSize[0], recipBoxSize[1], recipBoxSize[2], 0);
     if (groupInteractions.size() > 0) {
         // The user has specified interaction groups, so compute only the requested interactions.
         
@@ -182,9 +190,7 @@ void CpuCustomNonbondedForce::threadComputeForce(ThreadPool& threads, int thread
             int blockIndex = gmx_atomic_fetch_add(reinterpret_cast<gmx_atomic_t*>(atomicCounter), 1);
             if (blockIndex >= neighborList->getNumBlocks())
                 break;
-            int blockAtom[4];
-            for (int i = 0; i < 4; i++)
-                blockAtom[i] = neighborList->getSortedAtoms()[4*blockIndex+i];
+            const int* blockAtom = &neighborList->getSortedAtoms()[4*blockIndex];
             const vector<int>& neighbors = neighborList->getBlockNeighbors(blockIndex);
             const vector<char>& exclusions = neighborList->getBlockExclusions(blockIndex);
             for (int i = 0; i < (int) neighbors.size(); i++) {
@@ -268,8 +274,15 @@ void CpuCustomNonbondedForce::calculateOneIxn(int ii, int jj, ThreadData& data,
 void CpuCustomNonbondedForce::getDeltaR(const fvec4& posI, const fvec4& posJ, fvec4& deltaR, float& r2, const fvec4& boxSize, const fvec4& invBoxSize) const {
     deltaR = posJ-posI;
     if (periodic) {
-        fvec4 base = round(deltaR*invBoxSize)*boxSize;
-        deltaR = deltaR-base;
+        if (triclinic) {
+            deltaR -= periodicBoxVec4[2]*floorf(deltaR[2]*recipBoxSize[2]+0.5f);
+            deltaR -= periodicBoxVec4[1]*floorf(deltaR[1]*recipBoxSize[1]+0.5f);
+            deltaR -= periodicBoxVec4[0]*floorf(deltaR[0]*recipBoxSize[0]+0.5f);
+        }
+        else {
+            fvec4 base = round(deltaR*invBoxSize)*boxSize;
+            deltaR = deltaR-base;
+        }
     }
     r2 = dot3(deltaR, deltaR);
 }

platforms/cpu/src/CpuGBSAOBCForce.cpp

@@ -77,6 +77,10 @@ void CpuGBSAOBCForce::setSolventDielectric(float dielectric) {
     solventDielectric = dielectric;
 }
 
+void CpuGBSAOBCForce::setSurfaceAreaEnergy(float energy) {
+    surfaceAreaFactor = 4*M_PI*energy;
+}
+
 const std::vector<std::pair<float, float> >& CpuGBSAOBCForce::getParticleParameters() const {
     return particleParams;
 }
@@ -211,7 +215,6 @@ void CpuGBSAOBCForce::threadComputeForce(ThreadPool& threads, int threadIndex) {
     // Calculate ACE surface area term.
 
     const float probeRadius = 0.14f;
-    const float surfaceAreaFactor = 28.3919551;
     double energy = 0.0;
     AlignedArray<float>& bornForces = threadBornForces[threadIndex];
     for (int i = 0; i < numParticles; i++)