Merge pull request #1553 from peastman/gayberne

Implemented Gay-Berne ellipsoids

platforms/cuda/tests/TestCudaGayBerneForce.cpp

+/* -------------------------------------------------------------------------- *
+ *                                   OpenMM                                   *
+ * -------------------------------------------------------------------------- *
+ * This is part of the OpenMM molecular simulation toolkit originating from   *
+ * Simbios, the NIH National Center for Physics-Based Simulation of           *
+ * Biological Structures at Stanford, funded under the NIH Roadmap for        *
+ * Medical Research, grant U54 GM072970. See https://simtk.org.               *
+ *                                                                            *
+ * Portions copyright (c) 2016 Stanford University and the Authors.           *
+ * Authors: Peter Eastman                                                     *
+ * Contributors:                                                              *
+ *                                                                            *
+ * Permission is hereby granted, free of charge, to any person obtaining a    *
+ * copy of this software and associated documentation files (the "Software"), *
+ * to deal in the Software without restriction, including without limitation  *
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,   *
+ * and/or sell copies of the Software, and to permit persons to whom the      *
+ * Software is furnished to do so, subject to the following conditions:       *
+ *                                                                            *
+ * The above copyright notice and this permission notice shall be included in *
+ * all copies or substantial portions of the Software.                        *
+ *                                                                            *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *
+ * THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,    *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR      *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE  *
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
+ * -------------------------------------------------------------------------- */
+
+#include "CudaTests.h"
+#include "TestGayBerneForce.h"
+
+void runPlatformTests() {
+}

platforms/opencl/include/OpenCLKernels.h

@@ -1084,6 +1084,72 @@ private:
     cl::Kernel forceKernel, blockBoundsKernel, neighborsKernel, startIndicesKernel, copyPairsKernel;
 };
 
+/**
+ * This kernel is invoked by GayBerneForce to calculate the forces acting on the system.
+ */
+class OpenCLCalcGayBerneForceKernel : public CalcGayBerneForceKernel {
+public:
+    OpenCLCalcGayBerneForceKernel(std::string name, const Platform& platform, OpenCLContext& cl) : CalcGayBerneForceKernel(name, platform), cl(cl),
+            hasInitializedKernels(false), sortedParticles(NULL), axisParticleIndices(NULL), sigParams(NULL), epsParams(NULL), scale(NULL), exceptionParticles(NULL),
+            exceptionParams(NULL), aMatrix(NULL),
+            bMatrix(NULL), gMatrix(NULL), exclusions(NULL), exclusionStartIndex(NULL), blockCenter(NULL), blockBoundingBox(NULL), neighbors(NULL),
+            neighborIndex(NULL), neighborBlockCount(NULL), sortedPos(NULL), torque(NULL) {
+    }
+    ~OpenCLCalcGayBerneForceKernel();
+    /**
+     * Initialize the kernel.
+     *
+     * @param system     the System this kernel will be applied to
+     * @param force      the GayBerneForce this kernel will be used for
+     */
+    void initialize(const System& system, const GayBerneForce& 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
+     * @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 GayBerneForce to copy the parameters from
+     */
+    void copyParametersToContext(ContextImpl& context, const GayBerneForce& force);
+private:
+    class ReorderListener;
+    void sortAtoms();
+    OpenCLContext& cl;
+    bool hasInitializedKernels;
+    int numRealParticles, maxNeighborBlocks;
+    GayBerneForce::NonbondedMethod nonbondedMethod;
+    OpenCLArray* sortedParticles;
+    OpenCLArray* axisParticleIndices;
+    OpenCLArray* sigParams;
+    OpenCLArray* epsParams;
+    OpenCLArray* scale;
+    OpenCLArray* exceptionParticles;
+    OpenCLArray* exceptionParams;
+    OpenCLArray* aMatrix;
+    OpenCLArray* bMatrix;
+    OpenCLArray* gMatrix;
+    OpenCLArray* exclusions;
+    OpenCLArray* exclusionStartIndex;
+    OpenCLArray* blockCenter;
+    OpenCLArray* blockBoundingBox;
+    OpenCLArray* neighbors;
+    OpenCLArray* neighborIndex;
+    OpenCLArray* neighborBlockCount;
+    OpenCLArray* sortedPos;
+    OpenCLArray* torque;
+    std::vector<bool> isRealParticle;
+    std::vector<std::pair<int, int> > exceptionAtoms;
+    std::vector<std::pair<int, int> > excludedPairs;
+    cl::Kernel framesKernel, blockBoundsKernel, neighborsKernel, forceKernel, torqueKernel;
+};
+
 /**
  * This kernel is invoked by VerletIntegrator to take one time step.
  */

platforms/opencl/src/OpenCLKernelFactory.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 Stanford University and the Authors.           *
+ * Portions copyright (c) 2008-2016 Stanford University and the Authors.      *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -108,6 +108,8 @@ KernelImpl* OpenCLKernelFactory::createKernelImpl(std::string name, const Platfo
         return new OpenCLCalcCustomCompoundBondForceKernel(name, platform, cl, context.getSystem());
     if (name == CalcCustomManyParticleForceKernel::Name())
         return new OpenCLCalcCustomManyParticleForceKernel(name, platform, cl, context.getSystem());
+    if (name == CalcGayBerneForceKernel::Name())
+        return new OpenCLCalcGayBerneForceKernel(name, platform, cl);
     if (name == IntegrateVerletStepKernel::Name())
         return new OpenCLIntegrateVerletStepKernel(name, platform, cl);
     if (name == IntegrateLangevinStepKernel::Name())

platforms/opencl/src/OpenCLPlatform.cpp

@@ -83,6 +83,7 @@ OpenCLPlatform::OpenCLPlatform() {
     registerKernelFactory(CalcCustomCentroidBondForceKernel::Name(), factory);
     registerKernelFactory(CalcCustomCompoundBondForceKernel::Name(), factory);
     registerKernelFactory(CalcCustomManyParticleForceKernel::Name(), factory);
+    registerKernelFactory(CalcGayBerneForceKernel::Name(), factory);
     registerKernelFactory(IntegrateVerletStepKernel::Name(), factory);
     registerKernelFactory(IntegrateLangevinStepKernel::Name(), factory);
     registerKernelFactory(IntegrateBrownianStepKernel::Name(), factory);

platforms/opencl/tests/TestOpenCLGayBerneForce.cpp

+/* -------------------------------------------------------------------------- *
+ *                                   OpenMM                                   *
+ * -------------------------------------------------------------------------- *
+ * This is part of the OpenMM molecular simulation toolkit originating from   *
+ * Simbios, the NIH National Center for Physics-Based Simulation of           *
+ * Biological Structures at Stanford, funded under the NIH Roadmap for        *
+ * Medical Research, grant U54 GM072970. See https://simtk.org.               *
+ *                                                                            *
+ * Portions copyright (c) 2016 Stanford University and the Authors.           *
+ * Authors: Peter Eastman                                                     *
+ * Contributors:                                                              *
+ *                                                                            *
+ * Permission is hereby granted, free of charge, to any person obtaining a    *
+ * copy of this software and associated documentation files (the "Software"), *
+ * to deal in the Software without restriction, including without limitation  *
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,   *
+ * and/or sell copies of the Software, and to permit persons to whom the      *
+ * Software is furnished to do so, subject to the following conditions:       *
+ *                                                                            *
+ * The above copyright notice and this permission notice shall be included in *
+ * all copies or substantial portions of the Software.                        *
+ *                                                                            *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *
+ * THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,    *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR      *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE  *
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
+ * -------------------------------------------------------------------------- */
+
+#include "OpenCLTests.h"
+#include "TestGayBerneForce.h"
+
+void runPlatformTests() {
+}

platforms/reference/include/ReferenceGayBerneForce.h

+/* -------------------------------------------------------------------------- *
+ *                                   OpenMM                                   *
+ * -------------------------------------------------------------------------- *
+ * This is part of the OpenMM molecular simulation toolkit originating from   *
+ * Simbios, the NIH National Center for Physics-Based Simulation of           *
+ * Biological Structures at Stanford, funded under the NIH Roadmap for        *
+ * Medical Research, grant U54 GM072970. See https://simtk.org.               *
+ *                                                                            *
+ * Portions copyright (c) 2016 Stanford University and the Authors.           *
+ * Authors: Peter Eastman                                                     *
+ * Contributors:                                                              *
+ *                                                                            *
+ * Permission is hereby granted, free of charge, to any person obtaining a    *
+ * copy of this software and associated documentation files (the "Software"), *
+ * to deal in the Software without restriction, including without limitation  *
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,   *
+ * and/or sell copies of the Software, and to permit persons to whom the      *
+ * Software is furnished to do so, subject to the following conditions:       *
+ *                                                                            *
+ * The above copyright notice and this permission notice shall be included in *
+ * all copies or substantial portions of the Software.                        *
+ *                                                                            *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *
+ * THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,    *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR      *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE  *
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
+ * -------------------------------------------------------------------------- */
+
+#ifndef __ReferenceGayBerneForce_H__
+#define __ReferenceGayBerneForce_H__
+
+#include "openmm/GayBerneForce.h"
+#include "RealVec.h"
+#include <set>
+#include <utility>
+
+namespace OpenMM {
+
+class OPENMM_EXPORT ReferenceGayBerneForce {
+public:
+    struct Matrix;
+    /**
+     * Constructor.
+     */
+    ReferenceGayBerneForce(const GayBerneForce& force);
+
+    /**
+     * Compute the interaction.
+     *
+     * @param positions     the positions of the atoms
+     * @param forces        forces will be added to this vector
+     * @param boxVectors    the periodic box vectors
+     * @return the energy of the interaction
+     */
+    RealOpenMM calculateForce(const std::vector<RealVec>& positions, std::vector<RealVec>& forces, const RealVec* boxVectors);
+
+private:
+    struct ParticleInfo;
+    struct ExceptionInfo;
+    std::vector<ParticleInfo> particles;
+    std::vector<ExceptionInfo> exceptions;
+    std::set<std::pair<int, int> > exclusions;
+    GayBerneForce::NonbondedMethod nonbondedMethod;
+    RealOpenMM cutoffDistance, switchingDistance;
+    bool useSwitchingFunction;
+    std::vector<RealOpenMM> s;
+    std::vector<Matrix> A, B, G;
+
+    void computeEllipsoidFrames(const std::vector<RealVec>& positions);
+    
+    void applyTorques(const std::vector<RealVec>& positions, std::vector<RealVec>& forces, const std::vector<RealVec>& torques);
+
+    RealOpenMM computeOneInteraction(int particle1, int particle2, RealOpenMM sigma, RealOpenMM epsilon, const std::vector<RealVec>& positions,
+            std::vector<RealVec>& forces, std::vector<RealVec>& torques, const RealVec* boxVectors);
+};
+
+struct ReferenceGayBerneForce::ParticleInfo {
+    int xparticle, yparticle;
+    RealOpenMM sigma, epsilon, rx, ry, rz, ex, ey, ez;
+};
+
+struct ReferenceGayBerneForce::ExceptionInfo {
+    int particle1, particle2;
+    RealOpenMM sigma, epsilon;
+};
+
+struct ReferenceGayBerneForce::Matrix {
+    RealOpenMM v[3][3];
+    RealVec operator*(const RealVec& r) {
+        return RealVec(v[0][0]*r[0] + v[0][1]*r[1] + v[0][2]*r[2],
+                       v[1][0]*r[0] + v[1][1]*r[1] + v[1][2]*r[2],
+                       v[2][0]*r[0] + v[2][1]*r[1] + v[2][2]*r[2]);
+    }
+
+    Matrix operator+(const Matrix& m) {
+        Matrix result;
+        for (int i = 0; i < 3; i++)
+            for (int j = 0; j < 3; j++)
+                result.v[i][j] = v[i][j]+m.v[i][j];
+        return result;
+    }
+
+    RealOpenMM determinant() {
+        return (v[0][0]*v[1][1]*v[2][2] + v[0][1]*v[1][2]*v[2][0] + v[0][2]*v[1][0]*v[2][1] -
+                v[0][0]*v[1][2]*v[2][1] - v[0][1]*v[1][0]*v[2][2] - v[0][2]*v[1][1]*v[2][0]);
+    }
+    
+    Matrix inverse() {
+        RealOpenMM invDet = 1/determinant();
+        Matrix result;
+        result.v[0][0] = invDet*(v[1][1]*v[2][2] - v[1][2]*v[2][1]);
+        result.v[1][0] = -invDet*(v[1][0]*v[2][2] - v[1][2]*v[2][0]);
+        result.v[2][0] = invDet*(v[1][0]*v[2][1] - v[1][1]*v[2][0]);
+        result.v[0][1] = -invDet*(v[0][1]*v[2][2] - v[0][2]*v[2][1]);
+        result.v[1][1] = invDet*(v[0][0]*v[2][2] - v[0][2]*v[2][0]);
+        result.v[2][1] = -invDet*(v[0][0]*v[2][1] - v[0][1]*v[2][0]);
+        result.v[0][2] = invDet*(v[0][1]*v[1][2] - v[0][2]*v[1][1]);
+        result.v[1][2] = -invDet*(v[0][0]*v[1][2] - v[0][2]*v[1][0]);
+        result.v[2][2] = invDet*(v[0][0]*v[1][1] - v[0][1]*v[1][0]);
+        return result;
+    }
+};
+
+static RealVec operator*(const RealVec& r, ReferenceGayBerneForce::Matrix& m) {
+    return RealVec(m.v[0][0]*r[0] + m.v[1][0]*r[1] + m.v[2][0]*r[2],
+                   m.v[0][1]*r[0] + m.v[1][1]*r[1] + m.v[2][1]*r[2],
+                   m.v[0][2]*r[0] + m.v[1][2]*r[1] + m.v[2][2]*r[2]);
+}
+
+} // namespace OpenMM
+
+#endif // __ReferenceGayBerneForce_H__

platforms/reference/include/ReferenceKernels.h

@@ -47,6 +47,7 @@ class ReferenceCustomCentroidBondIxn;
 class ReferenceCustomCompoundBondIxn;
 class ReferenceCustomHbondIxn;
 class ReferenceCustomManyParticleIxn;
+class ReferenceGayBerneForce;
 class ReferenceBrownianDynamics;
 class ReferenceStochasticDynamics;
 class ReferenceConstraintAlgorithm;
@@ -962,6 +963,40 @@ private:
     NonbondedMethod nonbondedMethod;
 };
 
+/**
+ * This kernel is invoked by GayBerneForce to calculate the forces acting on the system.
+ */
+class ReferenceCalcGayBerneForceKernel : public CalcGayBerneForceKernel {
+public:
+    ReferenceCalcGayBerneForceKernel(std::string name, const Platform& platform) : CalcGayBerneForceKernel(name, platform), ixn(NULL) {
+    }
+    ~ReferenceCalcGayBerneForceKernel();
+    /**
+     * Initialize the kernel.
+     *
+     * @param system     the System this kernel will be applied to
+     * @param force      the GayBerneForce this kernel will be used for
+     */
+    void initialize(const System& system, const GayBerneForce& 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
+     * @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 GayBerneForce to copy the parameters from
+     */
+    void copyParametersToContext(ContextImpl& context, const GayBerneForce& force);
+private:
+    ReferenceGayBerneForce* ixn;
+};
+
 /**
  * This kernel is invoked by VerletIntegrator to take one time step.
  */

platforms/reference/src/ReferenceKernelFactory.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 Stanford University and the Authors.           *
+ * Portions copyright (c) 2008-2016 Stanford University and the Authors.      *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -56,8 +56,6 @@ KernelImpl* ReferenceKernelFactory::createKernelImpl(std::string name, const Pla
         return new ReferenceCalcCustomBondForceKernel(name, platform);
     if (name == CalcHarmonicAngleForceKernel::Name())
         return new ReferenceCalcHarmonicAngleForceKernel(name, platform);
-    if (name == CalcHarmonicAngleForceKernel::Name())
-        return new ReferenceCalcHarmonicAngleForceKernel(name, platform);
     if (name == CalcCustomAngleForceKernel::Name())
         return new ReferenceCalcCustomAngleForceKernel(name, platform);
     if (name == CalcPeriodicTorsionForceKernel::Name())
@@ -82,6 +80,8 @@ KernelImpl* ReferenceKernelFactory::createKernelImpl(std::string name, const Pla
         return new ReferenceCalcCustomCompoundBondForceKernel(name, platform);
     if (name == CalcCustomManyParticleForceKernel::Name())
         return new ReferenceCalcCustomManyParticleForceKernel(name, platform);
+    if (name == CalcGayBerneForceKernel::Name())
+        return new ReferenceCalcGayBerneForceKernel(name, platform);
     if (name == IntegrateVerletStepKernel::Name())
         return new ReferenceIntegrateVerletStepKernel(name, platform, data);
     if (name == IntegrateLangevinStepKernel::Name())

platforms/reference/src/ReferenceKernels.cpp

@@ -49,6 +49,7 @@
 #include "ReferenceCustomNonbondedIxn.h"
 #include "ReferenceCustomManyParticleIxn.h"
 #include "ReferenceCustomTorsionIxn.h"
+#include "ReferenceGayBerneForce.h"
 #include "ReferenceHarmonicBondIxn.h"
 #include "ReferenceLJCoulomb14.h"
 #include "ReferenceLJCoulombIxn.h"
@@ -1973,6 +1974,25 @@ void ReferenceCalcCustomManyParticleForceKernel::copyParametersToContext(Context
     }
 }
 
+ReferenceCalcGayBerneForceKernel::~ReferenceCalcGayBerneForceKernel() {
+    if (ixn != NULL)
+        delete ixn;
+}
+
+void ReferenceCalcGayBerneForceKernel::initialize(const System& system, const GayBerneForce& force) {
+    ixn = new ReferenceGayBerneForce(force);
+}
+
+double ReferenceCalcGayBerneForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
+    return ixn->calculateForce(extractPositions(context), extractForces(context), extractBoxVectors(context));
+}
+
+void ReferenceCalcGayBerneForceKernel::copyParametersToContext(ContextImpl& context, const GayBerneForce& force) {
+    delete ixn;
+    ixn = NULL;
+    ixn = new ReferenceGayBerneForce(force);
+}
+
 ReferenceIntegrateVerletStepKernel::~ReferenceIntegrateVerletStepKernel() {
     if (dynamics)
         delete dynamics;

platforms/reference/src/ReferencePlatform.cpp

@@ -65,6 +65,7 @@ ReferencePlatform::ReferencePlatform() {
     registerKernelFactory(CalcCustomCentroidBondForceKernel::Name(), factory);
     registerKernelFactory(CalcCustomCompoundBondForceKernel::Name(), factory);
     registerKernelFactory(CalcCustomManyParticleForceKernel::Name(), factory);
+    registerKernelFactory(CalcGayBerneForceKernel::Name(), factory);
     registerKernelFactory(IntegrateVerletStepKernel::Name(), factory);
     registerKernelFactory(IntegrateLangevinStepKernel::Name(), factory);
     registerKernelFactory(IntegrateBrownianStepKernel::Name(), factory);

platforms/reference/src/SimTKReference/ReferenceGayBerneForce.cpp

+/* -------------------------------------------------------------------------- *
+ *                                   OpenMM                                   *
+ * -------------------------------------------------------------------------- *
+ * This is part of the OpenMM molecular simulation toolkit originating from   *
+ * Simbios, the NIH National Center for Physics-Based Simulation of           *
+ * Biological Structures at Stanford, funded under the NIH Roadmap for        *
+ * Medical Research, grant U54 GM072970. See https://simtk.org.               *
+ *                                                                            *
+ * Portions copyright (c) 2016 Stanford University and the Authors.           *
+ * Authors: Peter Eastman                                                     *
+ * Contributors:                                                              *
+ *                                                                            *
+ * Permission is hereby granted, free of charge, to any person obtaining a    *
+ * copy of this software and associated documentation files (the "Software"), *
+ * to deal in the Software without restriction, including without limitation  *
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,   *
+ * and/or sell copies of the Software, and to permit persons to whom the      *
+ * Software is furnished to do so, subject to the following conditions:       *
+ *                                                                            *
+ * The above copyright notice and this permission notice shall be included in *
+ * all copies or substantial portions of the Software.                        *
+ *                                                                            *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *
+ * THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,    *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR      *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE  *
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
+ * -------------------------------------------------------------------------- */
+
+#ifdef _MSC_VER
+    // Prevent Windows from defining macros that interfere with other code.
+    #define NOMINMAX
+#endif
+#include "ReferenceGayBerneForce.h"
+#include "ReferenceForce.h"
+#include "openmm/OpenMMException.h"
+#include <algorithm>
+#include <cmath>
+
+using namespace OpenMM;
+using namespace std;
+
+ReferenceGayBerneForce::ReferenceGayBerneForce(const GayBerneForce& force) {
+    // Record the force parameters.
+
+    int numParticles = force.getNumParticles();
+    particles.resize(numParticles);
+    for (int i = 0; i < numParticles; i++) {
+        ParticleInfo& p = particles[i];
+        double sx, sy, sz;
+        force.getParticleParameters(i, p.sigma, p.epsilon, p.xparticle, p.yparticle, sx, sy, sz, p.ex, p.ey, p.ez);
+        p.rx = 0.5*sx;
+        p.ry = 0.5*sy;
+        p.rz = 0.5*sz;
+    }
+    int numExceptions = force.getNumExceptions();
+    exceptions.resize(numExceptions);
+    for (int i = 0; i < numExceptions; i++) {
+        ExceptionInfo& e = exceptions[i];
+        force.getExceptionParameters(i, e.particle1, e.particle2, e.sigma, e.epsilon);
+        exclusions.insert(make_pair(min(e.particle1, e.particle2), max(e.particle1, e.particle2)));
+    }
+    nonbondedMethod = force.getNonbondedMethod();
+    cutoffDistance = force.getCutoffDistance();
+    switchingDistance = force.getSwitchingDistance();
+    useSwitchingFunction = force.getUseSwitchingFunction();
+
+    // Allocate workspace for calculations.
+
+    s.resize(numParticles);
+    A.resize(numParticles);
+    B.resize(numParticles);
+    G.resize(numParticles);
+
+    // We can precompute the shape factors.
+
+    for (int i = 0; i < numParticles; i++) {
+        ParticleInfo& p = particles[i];
+        s[i] = (p.rx*p.ry + p.rz*p.rz)*SQRT(p.rx*p.ry);
+    }
+}
+
+RealOpenMM ReferenceGayBerneForce::calculateForce(const vector<RealVec>& positions, vector<RealVec>& forces, const RealVec* boxVectors) {
+    if (nonbondedMethod == GayBerneForce::CutoffPeriodic) {
+        double minAllowedSize = 1.999999*cutoffDistance;
+        if (boxVectors[0][0] < minAllowedSize || boxVectors[1][1] < minAllowedSize || boxVectors[2][2] < minAllowedSize)
+            throw OpenMMException("The periodic box size has decreased to less than twice the nonbonded cutoff.");
+    }
+
+    // First find the orientations of the particles and compute the matrices we'll be needing.
+
+    computeEllipsoidFrames(positions);
+
+    // Compute standard interactions.
+
+    RealOpenMM energy = 0;
+    int numParticles = particles.size();
+    vector<RealVec> torques(numParticles, Vec3());
+    for (int i = 1; i < numParticles; i++) {
+        if (particles[i].epsilon == 0.0)
+            continue;
+        for (int j = 0; j < i; j++) {
+            if (particles[j].epsilon == 0.0)
+                continue;
+            if (exclusions.find(make_pair(j, i)) != exclusions.end())
+                continue; // This interaction will be handled by an exception.
+            RealOpenMM sigma = 0.5*(particles[i].sigma+particles[j].sigma);
+            RealOpenMM epsilon = SQRT(particles[i].epsilon*particles[j].epsilon);
+            energy += computeOneInteraction(i, j, sigma, epsilon, positions, forces, torques, boxVectors);
+        }
+    }
+
+    // Compute exceptions.
+
+    int numExceptions = exceptions.size();
+    for (int i = 0; i < numExceptions; i++) {
+        ExceptionInfo& e = exceptions[i];
+        energy += computeOneInteraction(e.particle1, e.particle2, e.sigma, e.epsilon, positions, forces, torques, boxVectors);
+    }
+    
+    // Apply torques.
+    
+    applyTorques(positions, forces, torques);
+    return energy;
+}
+
+void ReferenceGayBerneForce::computeEllipsoidFrames(const vector<RealVec>& positions) {
+    int numParticles = particles.size();
+    for (int particle = 0; particle < numParticles; particle++) {
+        ParticleInfo& p = particles[particle];
+
+        // Compute the local coordinate system of the ellipsoid;
+
+        RealVec xdir, ydir, zdir;
+        if (p.xparticle == -1) {
+            xdir = RealVec(1, 0, 0);
+            ydir = RealVec(0, 1, 0);
+        }
+        else {
+            xdir = positions[particle]-positions[p.xparticle];
+            xdir /= SQRT(xdir.dot(xdir));
+            if (p.yparticle == -1) {
+                if (xdir[1] > -0.5 && xdir[1] < 0.5)
+                    ydir = RealVec(0, 1, 0);
+                else
+                    ydir = RealVec(1, 0, 0);
+            }
+            else
+                ydir = positions[particle]-positions[p.yparticle];
+            ydir -= xdir*(xdir.dot(ydir));
+            ydir /= SQRT(ydir.dot(ydir));
+        }
+        zdir = xdir.cross(ydir);
+
+        // Compute matrices we will need later.
+
+        RealOpenMM (&a)[3][3] = A[particle].v;
+        RealOpenMM (&b)[3][3] = B[particle].v;
+        RealOpenMM (&g)[3][3] = G[particle].v;
+        a[0][0] = xdir[0];
+        a[0][1] = xdir[1];
+        a[0][2] = xdir[2];
+        a[1][0] = ydir[0];
+        a[1][1] = ydir[1];
+        a[1][2] = ydir[2];
+        a[2][0] = zdir[0];
+        a[2][1] = zdir[1];
+        a[2][2] = zdir[2];
+        RealVec r2(p.rx*p.rx, p.ry*p.ry, p.rz*p.rz);
+        RealVec e2(1/sqrt(p.ex), 1/sqrt(p.ey), 1/sqrt(p.ez));
+        for (int i = 0; i < 3; i++)
+            for (int j = 0; j < 3; j++) {
+                b[i][j] = 0;
+                g[i][j] = 0;
+                for (int k = 0; k < 3; k++) {
+                    b[i][j] += a[k][i]*e2[k]*a[k][j];
+                    g[i][j] += a[k][i]*r2[k]*a[k][j];
+                }
+            }
+    }
+}
+
+void ReferenceGayBerneForce::applyTorques(const vector<RealVec>& positions, vector<RealVec>& forces, const vector<RealVec>& torques) {
+    int numParticles = particles.size();
+    for (int particle = 0; particle < numParticles; particle++) {
+        ParticleInfo& p = particles[particle];
+        RealVec pos = positions[particle];
+        if (p.xparticle != -1) {
+            // Apply a force to the x particle.
+            
+            RealVec dx = positions[p.xparticle]-pos;
+            double dx2 = dx.dot(dx);
+            RealVec f = torques[particle].cross(dx)/dx2;
+            forces[p.xparticle] += f;
+            forces[particle] -= f;
+            if (p.yparticle != -1) {
+                // Apply a force to the y particle.  This is based on the component of the torque
+                // that was not already applied to the x particle.
+                
+                RealVec dy = positions[p.yparticle]-pos;
+                double dy2 = dy.dot(dy);
+                RealVec torque = dx*(torques[particle].dot(dx)/dx2);
+                f = torque.cross(dy)/dy2;
+                forces[p.yparticle] += f;
+                forces[particle] -= f;
+            }
+        }
+    }
+}
+
+RealOpenMM ReferenceGayBerneForce::computeOneInteraction(int particle1, int particle2, RealOpenMM sigma, RealOpenMM epsilon, const vector<RealVec>& positions,
+        vector<RealVec>& forces, vector<RealVec>& torques, const RealVec* boxVectors) {
+    // Compute the displacement and check against the cutoff.
+
+    RealOpenMM deltaR[ReferenceForce::LastDeltaRIndex];
+    if (nonbondedMethod == GayBerneForce::CutoffPeriodic)
+        ReferenceForce::getDeltaRPeriodic(positions[particle2], positions[particle1], boxVectors, deltaR);
+    else
+        ReferenceForce::getDeltaR(positions[particle2], positions[particle1], deltaR);
+    RealOpenMM r = deltaR[ReferenceForce::RIndex];
+    if (nonbondedMethod != GayBerneForce::NoCutoff && r >= cutoffDistance)
+        return 0;
+
+    // Compute vectors and matrices we'll be needing.
+
+    RealOpenMM rInv = 1/r;
+    RealVec dr(deltaR[ReferenceForce::XIndex], deltaR[ReferenceForce::YIndex], deltaR[ReferenceForce::ZIndex]);
+    RealVec drUnit = dr*rInv;
+    Matrix B12 = B[particle1]+B[particle2];
+    Matrix G12 = G[particle1]+G[particle2];
+    Matrix B12inv = B12.inverse();
+    Matrix G12inv = G12.inverse();
+    RealOpenMM detG12 = G12.determinant();
+    
+    // Compute the switching function.
+
+    RealOpenMM switchValue = 1, switchDeriv = 0;
+    if (useSwitchingFunction && r > switchingDistance) {
+        RealOpenMM t = (r-switchingDistance)/(cutoffDistance-switchingDistance);
+        switchValue = 1+t*t*t*(-10+t*(15-t*6));
+        switchDeriv = t*t*(-30+t*(60-t*30))/(cutoffDistance-switchingDistance);
+    }
+
+    // Estimate the distance between the ellipsoids and compute the first terms needed for the energy.
+
+    RealOpenMM sigma12 = 1/SQRT(0.5*drUnit.dot(G12inv*drUnit));
+    RealOpenMM h12 = r - sigma12;
+    RealOpenMM rho = sigma/(h12+sigma);
+    RealOpenMM rho2 = rho*rho;
+    RealOpenMM rho6 = rho2*rho2*rho2;
+    RealOpenMM u = 4*epsilon*(rho6*rho6-rho6);
+    RealOpenMM eta = SQRT(2*s[particle1]*s[particle2]/detG12);
+    RealOpenMM chi = 2*drUnit.dot(B12inv*drUnit);
+    chi *= chi;
+    RealOpenMM energy = u*eta*chi;
+    
+    // Compute the terms needed for the force.
+
+    RealVec kappa = G12inv*dr;
+    RealVec iota = B12inv*dr;
+    RealOpenMM rInv2 = rInv*rInv;
+    RealOpenMM dUSLJdr = 24*epsilon*(2*rho6-1)*rho6*rho/sigma;
+    RealOpenMM temp = 0.5*sigma12*sigma12*sigma12*rInv2;
+    RealVec dudr = (drUnit + (kappa-drUnit*kappa.dot(drUnit))*temp)*dUSLJdr;
+    RealVec dchidr = (iota-drUnit*iota.dot(drUnit))*(-8*rInv2*SQRT(chi));
+    RealVec force = (dchidr*u + dudr*chi)*(eta*switchValue) - drUnit*(energy*switchDeriv);
+    forces[particle1] += force;
+    forces[particle2] -= force;
+
+    // Compute the terms needed for the torque.
+
+    for (int j = 0; j < 2; j++) {
+        int particle = (j == 0 ? particle1 : particle2);
+        RealVec dudq = (kappa*G[particle]).cross(kappa*(temp*dUSLJdr));
+        RealVec dchidq = (iota*B[particle]).cross(iota)*(-4*rInv2);
+        RealOpenMM (&g12)[3][3] = G12.v;
+        RealOpenMM (&a)[3][3] = A[particle].v;
+        ParticleInfo& p = particles[particle];
+        RealVec scale = RealVec(p.rx*p.rx, p.ry*p.ry, p.rz*p.rz)*(-0.5*eta/detG12);
+        Matrix D;
+        RealOpenMM (&d)[3][3] = D.v;
+        d[0][0] = scale[0]*(2*a[0][0]*(g12[1][1]*g12[2][2] - g12[1][2]*g12[2][1]) +
+                              a[0][2]*(g12[1][2]*g12[0][1] + g12[1][0]*g12[2][1] - g12[1][1]*(g12[0][2] + g12[2][0])) +
+                              a[0][1]*(g12[0][2]*g12[2][1] + g12[2][0]*g12[1][2] - g12[2][2]*(g12[0][1] + g12[1][0])));
+        d[0][1] = scale[0]*(  a[0][0]*(g12[0][2]*g12[2][1] + g12[2][0]*g12[1][2] - g12[2][2]*(g12[0][1] + g12[1][0])) +
+                            2*a[0][1]*(g12[0][0]*g12[2][2] - g12[2][0]*g12[0][2]) +
+                              a[0][2]*(g12[1][0]*g12[0][2] + g12[2][0]*g12[0][1] - g12[0][0]*(g12[1][2] + g12[2][1])));
+        d[0][2] = scale[0]*(  a[0][0]*(g12[0][1]*g12[1][2] + g12[1][0]*g12[2][1] - g12[1][1]*(g12[0][2] + g12[2][0])) +
+                              a[0][1]*(g12[1][0]*g12[0][2] + g12[2][0]*g12[0][1] - g12[0][0]*(g12[1][2] + g12[2][1])) +
+                            2*a[0][2]*(g12[1][1]*g12[0][0] - g12[1][0]*g12[0][1]));
+        d[1][0] = scale[1]*(2*a[1][0]*(g12[1][1]*g12[2][2] - g12[1][2]*g12[2][1]) +
+                              a[1][1]*(g12[0][2]*g12[2][1] + g12[2][0]*g12[1][2] - g12[2][2]*(g12[0][1] + g12[1][0])) +
+                              a[1][2]*(g12[1][2]*g12[0][1] + g12[1][0]*g12[2][1] - g12[1][1]*(g12[0][2] + g12[2][0])));
+        d[1][1] = scale[1]*(  a[1][0]*(g12[0][2]*g12[2][1] + g12[2][0]*g12[1][2] - g12[2][2]*(g12[0][1] + g12[1][0])) +
+                            2*a[1][1]*(g12[2][2]*g12[0][0] - g12[2][0]*g12[0][2]) +
+                              a[1][2]*(g12[1][0]*g12[0][2] + g12[0][1]*g12[2][0] - g12[0][0]*(g12[1][2] + g12[2][1])));
+        d[1][2] = scale[1]*(  a[1][0]*(g12[0][1]*g12[1][2] + g12[1][0]*g12[2][1] - g12[1][1]*(g12[0][2] + g12[2][0])) +
+                              a[1][1]*(g12[1][0]*g12[0][2] + g12[0][1]*g12[2][0] - g12[0][0]*(g12[1][2] + g12[2][1])) +
+                            2*a[1][2]*(g12[1][1]*g12[0][0] - g12[1][0]*g12[0][1]));
+        d[2][0] = scale[2]*(2*a[2][0]*(g12[1][1]*g12[2][2] - g12[2][1]*g12[1][2]) +
+                              a[2][1]*(g12[0][2]*g12[2][1] + g12[1][2]*g12[2][0] - g12[2][2]*(g12[0][1] + g12[1][0])) +
+                              a[2][2]*(g12[0][1]*g12[1][2] + g12[2][1]*g12[1][0] - g12[1][1]*(g12[0][2] + g12[2][0])));
+        d[2][1] = scale[2]*(  a[2][0]*(g12[0][2]*g12[2][1] + g12[1][2]*g12[2][0] - g12[2][2]*(g12[0][1] + g12[1][0])) +
+                            2*a[2][1]*(g12[0][0]*g12[2][2] - g12[0][2]*g12[2][0]) +
+                              a[2][2]*(g12[1][0]*g12[0][2] + g12[0][1]*g12[2][0] - g12[0][0]*(g12[1][2] + g12[2][1])));
+        d[2][2] = scale[2]*(  a[2][0]*(g12[0][1]*g12[1][2] + g12[2][1]*g12[1][0] - g12[1][1]*(g12[0][2] + g12[2][0])) +
+                              a[2][1]*(g12[1][0]*g12[0][2] + g12[2][0]*g12[0][1] - g12[0][0]*(g12[1][2] + g12[2][1])) +
+                            2*a[2][2]*(g12[1][1]*g12[0][0] - g12[1][0]*g12[0][1]));
+        RealVec detadq;
+        for (int i = 0; i < 3; i++)
+            detadq += RealVec(a[i][0], a[i][1], a[i][2]).cross(RealVec(d[i][0], d[i][1], d[i][2]));
+        RealVec torque = (dchidq*(u*eta) + detadq*(u*chi) + dudq*(eta*chi))*switchValue;
+        torques[particle] -= torque;
+    }
+    return switchValue*energy;
+}

platforms/reference/tests/TestReferenceGayBerneForce.cpp

+/* -------------------------------------------------------------------------- *
+ *                                   OpenMM                                   *
+ * -------------------------------------------------------------------------- *
+ * This is part of the OpenMM molecular simulation toolkit originating from   *
+ * Simbios, the NIH National Center for Physics-Based Simulation of           *
+ * Biological Structures at Stanford, funded under the NIH Roadmap for        *
+ * Medical Research, grant U54 GM072970. See https://simtk.org.               *
+ *                                                                            *
+ * Portions copyright (c) 2016 Stanford University and the Authors.           *
+ * Authors: Peter Eastman                                                     *
+ * Contributors:                                                              *
+ *                                                                            *
+ * Permission is hereby granted, free of charge, to any person obtaining a    *
+ * copy of this software and associated documentation files (the "Software"), *
+ * to deal in the Software without restriction, including without limitation  *
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,   *
+ * and/or sell copies of the Software, and to permit persons to whom the      *
+ * Software is furnished to do so, subject to the following conditions:       *
+ *                                                                            *
+ * The above copyright notice and this permission notice shall be included in *
+ * all copies or substantial portions of the Software.                        *
+ *                                                                            *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *
+ * THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,    *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR      *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE  *
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
+ * -------------------------------------------------------------------------- */
+
+#include "ReferenceTests.h"
+#include "TestGayBerneForce.h"
+
+void runPlatformTests() {
+}

serialization/include/openmm/serialization/GayBerneForceProxy.h

+#ifndef OPENMM_GAYBERNEFORCE_PROXY_H_
+#define OPENMM_GAYBERNEFORCE_PROXY_H_
+
+/* -------------------------------------------------------------------------- *
+ *                                   OpenMM                                   *
+ * -------------------------------------------------------------------------- *
+ * This is part of the OpenMM molecular simulation toolkit originating from   *
+ * Simbios, the NIH National Center for Physics-Based Simulation of           *
+ * Biological Structures at Stanford, funded under the NIH Roadmap for        *
+ * Medical Research, grant U54 GM072970. See https://simtk.org.               *
+ *                                                                            *
+ * Portions copyright (c) 2016 Stanford University and the Authors.           *
+ * Authors: Peter Eastman                                                     *
+ * Contributors:                                                              *
+ *                                                                            *
+ * Permission is hereby granted, free of charge, to any person obtaining a    *
+ * copy of this software and associated documentation files (the "Software"), *
+ * to deal in the Software without restriction, including without limitation  *
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,   *
+ * and/or sell copies of the Software, and to permit persons to whom the      *
+ * Software is furnished to do so, subject to the following conditions:       *
+ *                                                                            *
+ * The above copyright notice and this permission notice shall be included in *
+ * all copies or substantial portions of the Software.                        *
+ *                                                                            *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *
+ * THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,    *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR      *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE  *
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
+ * -------------------------------------------------------------------------- */
+
+#include "openmm/internal/windowsExport.h"
+#include "openmm/serialization/SerializationProxy.h"
+
+namespace OpenMM {
+
+/**
+ * This is a proxy for serializing GayBerneForce objects.
+ */
+
+class OPENMM_EXPORT GayBerneForceProxy : public SerializationProxy {
+public:
+    GayBerneForceProxy();
+    void serialize(const void* object, SerializationNode& node) const;
+    void* deserialize(const SerializationNode& node) const;
+};
+
+} // namespace OpenMM
+
+#endif /*OPENMM_GAYBERNEFORCE_PROXY_H_*/

serialization/src/GayBerneForceProxy.cpp

+/* -------------------------------------------------------------------------- *
+ *                                   OpenMM                                   *
+ * -------------------------------------------------------------------------- *
+ * This is part of the OpenMM molecular simulation toolkit originating from   *
+ * Simbios, the NIH National Center for Physics-Based Simulation of           *
+ * Biological Structures at Stanford, funded under the NIH Roadmap for        *
+ * Medical Research, grant U54 GM072970. See https://simtk.org.               *
+ *                                                                            *
+ * Portions copyright (c) 2010-2016 Stanford University and the Authors.      *
+ * Authors: Peter Eastman                                                     *
+ * Contributors:                                                              *
+ *                                                                            *
+ * Permission is hereby granted, free of charge, to any person obtaining a    *
+ * copy of this software and associated documentation files (the "Software"), *
+ * to deal in the Software without restriction, including without limitation  *
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,   *
+ * and/or sell copies of the Software, and to permit persons to whom the      *
+ * Software is furnished to do so, subject to the following conditions:       *
+ *                                                                            *
+ * The above copyright notice and this permission notice shall be included in *
+ * all copies or substantial portions of the Software.                        *
+ *                                                                            *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *
+ * THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,    *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR      *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE  *
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
+ * -------------------------------------------------------------------------- */
+
+#include "openmm/serialization/GayBerneForceProxy.h"
+#include "openmm/serialization/SerializationNode.h"
+#include "openmm/Force.h"
+#include "openmm/GayBerneForce.h"
+#include <sstream>
+
+using namespace OpenMM;
+using namespace std;
+
+GayBerneForceProxy::GayBerneForceProxy() : SerializationProxy("GayBerneForce") {
+}
+
+void GayBerneForceProxy::serialize(const void* object, SerializationNode& node) const {
+    node.setIntProperty("version", 1);
+    const GayBerneForce& force = *reinterpret_cast<const GayBerneForce*>(object);
+    node.setIntProperty("forceGroup", force.getForceGroup());
+    node.setIntProperty("method", (int) force.getNonbondedMethod());
+    node.setDoubleProperty("cutoff", force.getCutoffDistance());
+    node.setBoolProperty("useSwitchingFunction", force.getUseSwitchingFunction());
+    node.setDoubleProperty("switchingDistance", force.getSwitchingDistance());
+    SerializationNode& particles = node.createChildNode("Particles");
+    for (int i = 0; i < force.getNumParticles(); i++) {
+        double sigma, epsilon, sx, sy, sz, ex, ey, ez;
+        int xparticle, yparticle;
+        force.getParticleParameters(i, sigma, epsilon, xparticle, yparticle, sx, sy, sz, ex, ey, ez);
+        particles.createChildNode("Particle").setDoubleProperty("sig", sigma).setDoubleProperty("eps", epsilon).setDoubleProperty("sx", sx)
+                .setDoubleProperty("sy", sy).setDoubleProperty("sz", sz).setDoubleProperty("ex", ex).setDoubleProperty("ey", ey).setDoubleProperty("ez", ez)
+                .setIntProperty("xparticle", xparticle).setIntProperty("yparticle", yparticle);
+    }
+    SerializationNode& exceptions = node.createChildNode("Exceptions");
+    for (int i = 0; i < force.getNumExceptions(); i++) {
+        int particle1, particle2;
+        double sigma, epsilon;
+        force.getExceptionParameters(i, particle1, particle2, sigma, epsilon);
+        exceptions.createChildNode("Exception").setIntProperty("p1", particle1).setIntProperty("p2", particle2).setDoubleProperty("sig", sigma).setDoubleProperty("eps", epsilon);
+    }
+}
+
+void* GayBerneForceProxy::deserialize(const SerializationNode& node) const {
+    if (node.getIntProperty("version") != 1)
+        throw OpenMMException("Unsupported version number");
+    GayBerneForce* force = new GayBerneForce();
+    try {
+        force->setForceGroup(node.getIntProperty("forceGroup", 0));
+        force->setNonbondedMethod((GayBerneForce::NonbondedMethod) node.getIntProperty("method"));
+        force->setCutoffDistance(node.getDoubleProperty("cutoff"));
+        force->setUseSwitchingFunction(node.getBoolProperty("useSwitchingFunction", false));
+        force->setSwitchingDistance(node.getDoubleProperty("switchingDistance", -1.0));
+        const SerializationNode& particles = node.getChildNode("Particles");
+        for (int i = 0; i < (int) particles.getChildren().size(); i++) {
+            const SerializationNode& particle = particles.getChildren()[i];
+            force->addParticle(particle.getDoubleProperty("sig"), particle.getDoubleProperty("eps"), particle.getIntProperty("xparticle"),
+                    particle.getIntProperty("yparticle"), particle.getDoubleProperty("sx"), particle.getDoubleProperty("sy"), particle.getDoubleProperty("sz"),
+                    particle.getDoubleProperty("ex"), particle.getDoubleProperty("ey"), particle.getDoubleProperty("ez"));
+        }
+        const SerializationNode& exceptions = node.getChildNode("Exceptions");
+        for (int i = 0; i < (int) exceptions.getChildren().size(); i++) {
+            const SerializationNode& exception = exceptions.getChildren()[i];
+            force->addException(exception.getIntProperty("p1"), exception.getIntProperty("p2"), exception.getDoubleProperty("sig"), exception.getDoubleProperty("eps"));
+        }
+    }
+    catch (...) {
+        delete force;
+        throw;
+    }
+    return force;
+}

serialization/src/SerializationProxyRegistration.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) 2010-2015 Stanford University and the Authors.      *
+ * Portions copyright (c) 2010-2016 Stanford University and the Authors.      *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -45,6 +45,7 @@
 #include "openmm/CustomManyParticleForce.h"
 #include "openmm/CustomNonbondedForce.h"
 #include "openmm/CustomTorsionForce.h"
+#include "openmm/GayBerneForce.h"
 #include "openmm/GBSAOBCForce.h"
 #include "openmm/HarmonicAngleForce.h"
 #include "openmm/HarmonicBondForce.h"
@@ -78,6 +79,7 @@
 #include "openmm/serialization/CustomManyParticleForceProxy.h"
 #include "openmm/serialization/CustomNonbondedForceProxy.h"
 #include "openmm/serialization/CustomTorsionForceProxy.h"
+#include "openmm/serialization/GayBerneForceProxy.h"
 #include "openmm/serialization/GBSAOBCForceProxy.h"
 #include "openmm/serialization/HarmonicAngleForceProxy.h"
 #include "openmm/serialization/HarmonicBondForceProxy.h"
@@ -132,6 +134,7 @@ extern "C" void registerSerializationProxies() {
     SerializationProxy::registerProxy(typeid(Discrete1DFunction), new Discrete1DFunctionProxy());
     SerializationProxy::registerProxy(typeid(Discrete2DFunction), new Discrete2DFunctionProxy());
     SerializationProxy::registerProxy(typeid(Discrete3DFunction), new Discrete3DFunctionProxy());
+    SerializationProxy::registerProxy(typeid(GayBerneForce), new GayBerneForceProxy());
     SerializationProxy::registerProxy(typeid(GBSAOBCForce), new GBSAOBCForceProxy());
     SerializationProxy::registerProxy(typeid(HarmonicAngleForce), new HarmonicAngleForceProxy());
     SerializationProxy::registerProxy(typeid(HarmonicBondForce), new HarmonicBondForceProxy());

serialization/tests/TestSerializeGayBerneForce.cpp

+/* -------------------------------------------------------------------------- *
+ *                                   OpenMM                                   *
+ * -------------------------------------------------------------------------- *
+ * This is part of the OpenMM molecular simulation toolkit originating from   *
+ * Simbios, the NIH National Center for Physics-Based Simulation of           *
+ * Biological Structures at Stanford, funded under the NIH Roadmap for        *
+ * Medical Research, grant U54 GM072970. See https://simtk.org.               *
+ *                                                                            *
+ * Portions copyright (c) 2010-2016 Stanford University and the Authors.      *
+ * Authors: Peter Eastman                                                     *
+ * Contributors:                                                              *
+ *                                                                            *
+ * Permission is hereby granted, free of charge, to any person obtaining a    *
+ * copy of this software and associated documentation files (the "Software"), *
+ * to deal in the Software without restriction, including without limitation  *
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,   *
+ * and/or sell copies of the Software, and to permit persons to whom the      *
+ * Software is furnished to do so, subject to the following conditions:       *
+ *                                                                            *
+ * The above copyright notice and this permission notice shall be included in *
+ * all copies or substantial portions of the Software.                        *
+ *                                                                            *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *
+ * THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,    *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR      *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE  *
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
+ * -------------------------------------------------------------------------- */
+
+#include "openmm/internal/AssertionUtilities.h"
+#include "openmm/GayBerneForce.h"
+#include "openmm/serialization/XmlSerializer.h"
+#include <iostream>
+#include <sstream>
+
+using namespace OpenMM;
+using namespace std;
+
+void testSerialization() {
+    // Create a Force.
+
+    GayBerneForce force;
+    force.setForceGroup(3);
+    force.setNonbondedMethod(GayBerneForce::CutoffPeriodic);
+    force.setSwitchingDistance(1.5);
+    force.setUseSwitchingFunction(true);
+    force.setCutoffDistance(2.0);
+    force.addParticle(0.1, 0.01, -1, -1, 0.5, 0.5, 0.5, 1.0, 1.0, 1.0);
+    force.addParticle(0.2, 0.02, -1, -1, 0.7, 0.7, 0.7, 1.2, 1.2, 1.2);
+    force.addParticle(0.3, 0.03, 1, 0, 0.8, 0.9, 1.0, 0.5, 0.6, 0.7);
+    force.addException(0, 1, 0.5, 0.1);
+    force.addException(1, 2, 0.4, 0.2);
+
+    // Serialize and then deserialize it.
+
+    stringstream buffer;
+    XmlSerializer::serialize<GayBerneForce>(&force, "Force", buffer);
+    GayBerneForce* copy = XmlSerializer::deserialize<GayBerneForce>(buffer);
+
+    // Compare the two forces to see if they are identical.
+
+    GayBerneForce& force2 = *copy;
+    ASSERT_EQUAL(force.getForceGroup(), force2.getForceGroup());
+    ASSERT_EQUAL(force.getNonbondedMethod(), force2.getNonbondedMethod());
+    ASSERT_EQUAL(force.getSwitchingDistance(), force2.getSwitchingDistance());
+    ASSERT_EQUAL(force.getUseSwitchingFunction(), force2.getUseSwitchingFunction());
+    ASSERT_EQUAL(force.getCutoffDistance(), force2.getCutoffDistance());
+    ASSERT_EQUAL(force.getNumParticles(), force2.getNumParticles());
+    for (int i = 0; i < force.getNumParticles(); i++) {
+        double sigma1, epsilon1, sx1, sy1, sz1, ex1, ey1, ez1;
+        double sigma2, epsilon2, sx2, sy2, sz2, ex2, ey2, ez2;
+        int xparticle1, yparticle1, xparticle2, yparticle2;
+        force.getParticleParameters(i, sigma1, epsilon1, xparticle1, yparticle1, sx1, sy1, sz1, ex1, ey1, ez1);
+        force2.getParticleParameters(i, sigma2, epsilon2, xparticle2, yparticle2, sx2, sy2, sz2, ex2, ey2, ez2);
+        ASSERT_EQUAL(sigma1, sigma2);
+        ASSERT_EQUAL(epsilon1, epsilon2);
+        ASSERT_EQUAL(xparticle1, xparticle1);
+        ASSERT_EQUAL(xparticle2, xparticle2);
+        ASSERT_EQUAL(sx1, sx2);
+        ASSERT_EQUAL(sy1, sy2);
+        ASSERT_EQUAL(sz1, sz2);
+        ASSERT_EQUAL(ex1, ex2);
+        ASSERT_EQUAL(ey1, ey2);
+        ASSERT_EQUAL(ez1, ez2);
+    }
+    ASSERT_EQUAL(force.getNumExceptions(), force2.getNumExceptions());
+    for (int i = 0; i < force.getNumExceptions(); i++) {
+        int a1, a2, b1, b2;
+        double sigma1, epsilon1;
+        double sigma2, epsilon2;
+        force.getExceptionParameters(i, a1, b1, sigma1, epsilon1);
+        force2.getExceptionParameters(i, a2, b2, sigma2, epsilon2);
+        ASSERT_EQUAL(a1, a2);
+        ASSERT_EQUAL(b1, b2);
+        ASSERT_EQUAL(sigma1, sigma2);
+        ASSERT_EQUAL(epsilon1, epsilon2);
+    }
+}
+
+int main() {
+    try {
+        testSerialization();
+    }
+    catch(const exception& e) {
+        cout << "exception: " << e.what() << endl;
+        return 1;
+    }
+    cout << "Done" << endl;
+    return 0;
+}