Merge pull request #1553 from peastman/gayberne

Implemented Gay-Berne ellipsoids

docs-source/usersguide/references.bib

@@ -80,6 +80,17 @@
    type = {Journal Article}
 }
 
+@article{Everaers2003
+   author = {Everaers, R. and Ejtehadi, M. R.},
+   title = {Interaction potentials for soft and hard ellipsoids},
+   journal = {Physical Review E},
+   volume = {67},
+   issue = {4},
+   pages = {041710},
+   year = {2003},
+   type = {Journal Article}
+}
+
 @article{Hall1984
    author = {Hall, Randall W. and Berne, B. J.},
    title = {Nonergodicity in path integral molecular dynamics},

docs-source/usersguide/theory.rst

@@ -182,7 +182,7 @@ an energy term of the form
 
 
 .. math::
-   E=4\epsilon\left({\left(\frac{\sigma}{r}\right)}^{\text{12}}-{\left(\frac{\sigma}{r}\right)}^{6}\right)
+   E=4\epsilon\left({\left(\frac{\sigma}{r}\right)}^{12}-{\left(\frac{\sigma}{r}\right)}^{6}\right)
 
 
 where *r* is the distance between the two particles, :math:`\sigma` is the distance
@@ -201,7 +201,7 @@ at the cutoff distance.  When :math:`r_\mathit{switch} < r < r_\mathit{cutoff}`\
 
 where :math:`x = (r-r_\mathit{switch})/(r_\mathit{cutoff}-r_\mathit{switch})`. This function decreases smoothly from 1 at
 :math:`r = r_\mathit{switch}` to 0 at :math:`r = r_\mathit{cutoff}`, and has continuous first and
-second derivatives at both ends
+second derivatives at both ends.
 
 When an exception has been added for a pair of particles, :math:`\sigma` and :math:`\epsilon`
 are the parameters specified by the exception.  Otherwise they are determined
@@ -497,6 +497,84 @@ its atomic radius, and :math:`r_\mathit{solvent}` is the solvent radius, which i
 to be 0.14 nm.  The default value for the energy scale :math:`E_{SA}` is 2.25936 kJ/mol/nm\ :sup:`2`\ .
 
 
+GayBerneForce
+*************
+
+This is similar to the Lennard-Jones interaction described in section :ref:`lennard-jones-interaction`,
+but instead of being based on the distance between two point particles, it is based
+on the distance of closest approach between two ellipsoids.\ :cite:`Everaers2003`
+Let :math:`\mathbf{A}_1` and :math:`\mathbf{A}_2` be rotation matrices that transform
+from the lab frame to the body frames of two interacting ellipsoids.  These rotations
+are determined from the positions of other particles, as described in the API documentation.
+Let :math:`\mathbf{r}_{12}` be the vector pointing from particle 1 to particle 2, and
+:math:`\hat{\mathbf{r}}_{12}=\mathbf{r}_{12}/|\mathbf{r}_{12}|`.  Let :math:`\mathbf{S}_1`
+and :math:`\mathbf{S}_2` be diagonal matrices containing the three radii of each particle:
+
+.. math::
+   \mathbf{S}_i=\begin{bmatrix}
+   a_i & 0 & 0 \\
+   0 & b_i & 0 \\
+   0 & 0 & c_i
+   \end{bmatrix}
+
+The energy is computed as a product of three terms:
+
+.. math::
+   E=U_r(\mathbf{A}_1, \mathbf{A}_2, \mathbf{r}_{12}) \cdot \eta_{12}(\mathbf{A}_1, \mathbf{A}_2) \cdot \chi_{12}(\mathbf{A}_1, \mathbf{A}_2, \hat{\mathbf{r}}_{12}) 
+
+The first term describes the distance dependence, and is very similar in form to
+the Lennard-Jones interaction:
+
+.. math::
+   U_r=4\epsilon\left({\left(\frac{\sigma}{h_{12}+\sigma}\right)}^{12}-{\left(\frac{\sigma}{h_{12}+\sigma}\right)}^{6}\right)
+
+where :math:`h_{12}` is an approximation to the distance of closest approach between
+the two ellipsoids:
+
+.. math::
+   h_{12}=|\mathbf{r}_{12}|-\sigma_{12}(\mathbf{A}_1, \mathbf{A}_2, \hat{\mathbf{r}}_{12})
+
+.. math::
+   \sigma_{12}(\mathbf{A}_1, \mathbf{A}_2, \hat{\mathbf{r}}_{12})=\left[ \frac{1}{2} \hat{\mathbf{r}}_{12}^T \mathbf{G}_{12}^{-1} \hat{\mathbf{r}}_{12} \right]^{-1/2}
+
+.. math::
+   \mathbf{G}_{12}=\mathbf{A}_1^T \mathbf{S}_1^2 \mathbf{A}_1 + \mathbf{A}_2^T \mathbf{S}_2^2 \mathbf{A}_2
+
+The second term adjusts the energy based on the relative orientations of the two ellipsoids:
+
+.. math::
+   \eta_{12}(\mathbf{A}_1, \mathbf{A}_2)=\left[ \frac{2 s_1 s_2}{\text{det}(\mathbf{G}_{12})} \right]^{1/2}
+
+.. math::
+   s_i=(a_i b_i + c_i^2)\sqrt{a_i b_i}
+
+The third term applies the user-defined scale factors :math:`e_a`, :math:`e_b`,
+and :math:`e_c` that adjust the strength of the interaction along each axis:
+
+.. math::
+   \chi_{12}(\mathbf{A}_1, \mathbf{A}_2, \hat{\mathbf{r}}_{12})=(2 \hat{\mathbf{r}}_{12}^T \mathbf{B}_{12}^{-1} \hat{\mathbf{r}}_{12})^2
+
+.. math::
+   \mathbf{B}_{12}=\mathbf{A}_1^T \mathbf{E}_1 \mathbf{A}_1 + \mathbf{A}_2^T \mathbf{E}_2 \mathbf{A}_2
+
+.. math::
+   \mathbf{E}_i=\begin{bmatrix}
+   e_{ai}^{-1/2} & 0 & 0 \\
+   0 & e_{bi}^{-1/2} & 0 \\
+   0 & 0 & e_{ci}^{-1/2}
+   \end{bmatrix}
+
+When using a cutoff, you can optionally use a switching function to make the energy go smoothly to 0
+at the cutoff distance.  When :math:`r_\mathit{switch} < r < r_\mathit{cutoff}`\ , the energy is multiplied by
+
+.. math::
+   S=1-{6x}^{5}+15{x}^{4}-10{x}^{3}
+
+where :math:`x = (r-r_\mathit{switch})/(r_\mathit{cutoff}-r_\mathit{switch})`. This function decreases smoothly from 1 at
+:math:`r = r_\mathit{switch}` to 0 at :math:`r = r_\mathit{cutoff}`, and has continuous first and
+second derivatives at both ends.
+
+
 AndersenThermostat
 ******************
 

olla/include/openmm/kernels.h

@@ -47,6 +47,7 @@
 #include "openmm/CustomNonbondedForce.h"
 #include "openmm/CustomManyParticleForce.h"
 #include "openmm/CustomTorsionForce.h"
+#include "openmm/GayBerneForce.h"
 #include "openmm/GBSAOBCForce.h"
 #include "openmm/HarmonicAngleForce.h"
 #include "openmm/HarmonicBondForce.h"
@@ -897,6 +898,41 @@ public:
     virtual void copyParametersToContext(ContextImpl& context, const CustomManyParticleForce& force) = 0;
 };
 
+/**
+ * This kernel is invoked by GayBerneForce to calculate the forces acting on the system and the energy of the system.
+ */
+class CalcGayBerneForceKernel : public KernelImpl {
+public:
+    static std::string Name() {
+        return "CalcGayBerneForce";
+    }
+    CalcGayBerneForceKernel(std::string name, const Platform& platform) : KernelImpl(name, platform) {
+    }
+    /**
+     * Initialize the kernel.
+     *
+     * @param system     the System this kernel will be applied to
+     * @param force      the GayBerneForce this kernel will be used for
+     */
+    virtual void initialize(const System& system, const GayBerneForce& force) = 0;
+    /**
+     * 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
+     */
+    virtual double execute(ContextImpl& context, bool includeForces, bool includeEnergy) = 0;
+    /**
+     * Copy changed parameters over to a context.
+     *
+     * @param context    the context to copy parameters to
+     * @param force      the GayBerneForce to copy the parameters from
+     */
+    virtual void copyParametersToContext(ContextImpl& context, const GayBerneForce& force) = 0;
+};
+
 /**
  * This kernel is invoked by VerletIntegrator to take one time step.
  */

openmmapi/include/OpenMM.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) 2009-2015 Stanford University and the Authors.      *
+ * Portions copyright (c) 2009-2016 Stanford University and the Authors.      *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -49,6 +49,7 @@
 #include "openmm/CustomManyParticleForce.h"
 #include "openmm/CustomNonbondedForce.h"
 #include "openmm/Force.h"
+#include "openmm/GayBerneForce.h"
 #include "openmm/GBSAOBCForce.h"
 #include "openmm/HarmonicAngleForce.h"
 #include "openmm/HarmonicBondForce.h"

openmmapi/include/openmm/GayBerneForce.h

+#ifndef OPENMM_GAYBERNEFORCE_H_
+#define OPENMM_GAYBERNEFORCE_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 "Context.h"
+#include "Force.h"
+#include <map>
+#include <utility>
+#include <vector>
+#include "internal/windowsExport.h"
+
+namespace OpenMM {
+
+/**
+ * This class implements the Gay-Berne anisotropic potential.  This is similar to a Lennard-Jones potential,
+ * but it represents the particles as ellipsoids rather than point particles.  In addition to the standard
+ * sigma and epsilon parameters, each particle has three widths sx, sy, and sz that give the diameter of the
+ * ellipsoid along each axis.  It also has three scale factors ex, ey, and ez that scale the strength
+ * of the interaction along each axis.  You can think of this force as a Lennard-Jones interaction computed
+ * based on the distance between the nearest points on two ellipsoids.  The scale factors act as multipliers
+ * for epsilon along each axis, so the strength of the interaction along the ellipsoid's x axis is multiplied by
+ * ex, and likewise for the other axes.  If two particles each have all their widths set to sigma and all their
+ * scale factors set to 1, the interaction simplifies to a standard Lennard-Jones force between point particles.
+ *
+ * The orientation of a particle's ellipsoid is determined based on the positions of two other particles.
+ * The vector to the first particle sets the direction of the x axis.  The vector to the second particle
+ * (after subtracting out any x component) sets the direction of the y axis.  If the ellipsoid is axially
+ * symmetric (sy=sz and ey=ez), you can omit the second particle and define only an x axis direction.
+ * If the ellipsoid is a sphere (all three widths and all three scale factors are equal), both particles
+ * can be omitted.
+ *
+ * To determine the values of sigma and epsilon for an interaction, this class uses Lorentz-Berthelot
+ * combining rules: it takes the arithmetic mean of the sigmas and the geometric mean of the epsilons for
+ * the two interacting particles.  You also can specify "exceptions", particular pairs of particles for
+ * which different values should be used.
+ *
+ * To use this class, create a GayBerneForce object, then call addParticle() once for each particle in the
+ * System to define its parameters.  The number of particles for which you define parameters must be exactly
+ * equal to the number of particles in the System, or else an exception will be thrown when you try to
+ * create a Context.  After a particle has been added, you can modify its force field parameters by calling
+ * setParticleParameters().  This will have no effect on Contexts that already exist unless you call
+ * updateParametersInContext().
+ *
+ * When using a cutoff, by default interactions are sharply truncated at the cutoff distance.  Optionally
+ * you can instead use a switching function to make the interaction smoothly go to zero over a finite
+ * distance range.  To enable this, call setUseSwitchingFunction().  You must also call setSwitchingDistance()
+ * to specify the distance at which the interaction should begin to decrease.  The switching distance must be
+ * less than the cutoff distance.
+ */
+
+class OPENMM_EXPORT GayBerneForce : public Force {
+public:
+    /**
+     * This is an enumeration of the different methods that may be used for handling long range nonbonded forces.
+     */
+    enum NonbondedMethod {
+        /**
+         * No cutoff is applied to nonbonded interactions.  The full set of N^2 interactions is computed exactly.
+         * This necessarily means that periodic boundary conditions cannot be used.  This is the default.
+         */
+        NoCutoff = 0,
+        /**
+         * Interactions beyond the cutoff distance are ignored.
+         */
+        CutoffNonPeriodic = 1,
+        /**
+         * Periodic boundary conditions are used, so that each particle interacts only with the nearest periodic copy of
+         * each other particle.  Interactions beyond the cutoff distance are ignored.
+         */
+        CutoffPeriodic = 2
+    };
+    /**
+     * Create a GayBerneForce.
+     */
+    GayBerneForce();
+    /**
+     * Get the number of particles for which force field parameters have been defined.
+     */
+    int getNumParticles() const {
+        return particles.size();
+    }
+    /**
+     * Get the number of special interactions that should be calculated differently from other interactions.
+     */
+    int getNumExceptions() const {
+        return exceptions.size();
+    }
+    /**
+     * Get the method used for handling long range interactions.
+     */
+    NonbondedMethod getNonbondedMethod() const;
+    /**
+     * Set the method used for handling long range interactions.
+     */
+    void setNonbondedMethod(NonbondedMethod method);
+    /**
+     * Get the cutoff distance (in nm) being used for interactions.  If the NonbondedMethod in use
+     * is NoCutoff, this value will have no effect.
+     *
+     * @return the cutoff distance, measured in nm
+     */
+    double getCutoffDistance() const;
+    /**
+     * Set the cutoff distance (in nm) being used for interactions.  If the NonbondedMethod in use
+     * is NoCutoff, this value will have no effect.
+     *
+     * @param distance    the cutoff distance, measured in nm
+     */
+    void setCutoffDistance(double distance);
+    /**
+     * Get whether a switching function is applied to the interaction.  If the nonbonded method is set
+     * to NoCutoff, this option is ignored.
+     */
+    bool getUseSwitchingFunction() const;
+    /**
+     * Set whether a switching function is applied to the interaction.  If the nonbonded method is set
+     * to NoCutoff, this option is ignored.
+     */
+    void setUseSwitchingFunction(bool use);
+    /**
+     * Get the distance at which the switching function begins to reduce the interaction.  This must be
+     * less than the cutoff distance.
+     */
+    double getSwitchingDistance() const;
+    /**
+     * Set the distance at which the switching function begins to reduce the interaction.  This must be
+     * less than the cutoff distance.
+     */
+    void setSwitchingDistance(double distance);
+    /**
+     * Add the parameters for a particle.  This should be called once for each particle in the System.
+     * When it is called for the i'th time, it specifies the parameters for the i'th particle.
+     *
+     * @param sigma     the sigma parameter (corresponding to the van der Waals radius of the particle), measured in nm
+     * @param epsilon   the epsilon parameter (corresponding to the well depth of the van der Waals interaction), measured in kJ/mol
+     * @param xparticle the index of the particle whose position defines the ellipsoid's x axis, or -1 if the ellipsoid is a sphere
+     * @param yparticle the index of the particle whose position defines the ellipsoid's y axis, or -1 if the ellipsoid is axially symmetric
+     * @param sx        the diameter of the ellipsoid along its x axis
+     * @param sy        the diameter of the ellipsoid along its y axis
+     * @param sz        the diameter of the ellipsoid along its z axis
+     * @param ex        the factor by which epsilon is scaled along the ellipsoid's x axis
+     * @param ey        the factor by which epsilon is scaled along the ellipsoid's y axis
+     * @param ez        the factor by which epsilon is scaled along the ellipsoid's z axis
+     * @return the index of the particle that was added
+     */
+    int addParticle(double sigma, double epsilon, int xparticle, int yparticle, double sx, double sy, double sz, double ex, double ey, double ez);
+    /**
+     * Get the parameters for a particle.
+     *
+     * @param index          the index of the particle for which to get parameters
+     * @param[out] sigma     the sigma parameter (corresponding to the van der Waals radius of the particle), measured in nm
+     * @param[out] epsilon   the epsilon parameter (corresponding to the well depth of the van der Waals interaction), measured in kJ/mol
+     * @param[out] xparticle the index of the particle whose position defines the ellipsoid's x axis, or -1 if the ellipsoid is a sphere
+     * @param[out] yparticle the index of the particle whose position defines the ellipsoid's y axis, or -1 if the ellipsoid is axially symmetric
+     * @param[out] sx        the diameter of the ellipsoid along its x axis
+     * @param[out] sy        the diameter of the ellipsoid along its y axis
+     * @param[out] sz        the diameter of the ellipsoid along its z axis
+     * @param[out] ex        the factor by which epsilon is scaled along the ellipsoid's x axis
+     * @param[out] ey        the factor by which epsilon is scaled along the ellipsoid's y axis
+     * @param[out] ez        the factor by which epsilon is scaled along the ellipsoid's z axis
+     */
+    void getParticleParameters(int index, double& sigma, double& epsilon, int& xparticle, int& yparticle, double& sx, double& sy, double& sz, double& ex, double& ey, double& ez) const;
+    /**
+     * Set the parameters for a particle.
+     *
+     * @param index     the index of the particle for which to set parameters
+     * @param sigma     the sigma parameter (corresponding to the van der Waals radius of the particle), measured in nm
+     * @param epsilon   the epsilon parameter (corresponding to the well depth of the van der Waals interaction), measured in kJ/mol
+     * @param xparticle the index of the particle whose position defines the ellipsoid's x axis, or -1 if the ellipsoid is a sphere
+     * @param yparticle the index of the particle whose position defines the ellipsoid's y axis, or -1 if the ellipsoid is axially symmetric
+     * @param sx        the diameter of the ellipsoid along its x axis
+     * @param sy        the diameter of the ellipsoid along its y axis
+     * @param sz        the diameter of the ellipsoid along its z axis
+     * @param ex        the factor by which epsilon is scaled along the ellipsoid's x axis
+     * @param ey        the factor by which epsilon is scaled along the ellipsoid's y axis
+     * @param ez        the factor by which epsilon is scaled along the ellipsoid's z axis
+     */
+    void setParticleParameters(int index, double sigma, double epsilon, int xparticle, int yparticle, double sx, double sy, double sz, double ex, double ey, double ez);
+    /**
+     * Add an interaction to the list of exceptions that should be calculated differently from other interactions.  If
+     * epsilon is equal to 0, this will cause the interaction to be completely omitted from force and energy calculations.
+     *
+     * @param particle1  the index of the first particle involved in the interaction
+     * @param particle2  the index of the second particle involved in the interaction
+     * @param sigma      the sigma parameter (corresponding to the van der Waals radius of the particle), measured in nm
+     * @param epsilon    the epsilon parameter (corresponding to the well depth of the van der Waals interaction), measured in kJ/mol
+     * @param replace    determines the behavior if there is already an exception for the same two particles.  If true, the existing one is replaced.  If false,
+     *                   an exception is thrown.
+     * @return the index of the exception that was added
+     */
+    int addException(int particle1, int particle2, double sigma, double epsilon, bool replace = false);
+    /**
+     * Get the force field parameters for an interaction that should be calculated differently from others.
+     *
+     * @param index           the index of the interaction for which to get parameters
+     * @param[out] particle1  the index of the first particle involved in the interaction
+     * @param[out] particle2  the index of the second particle involved in the interaction
+     * @param[out] sigma      the sigma parameter (corresponding to the van der Waals radius of the particle), measured in nm
+     * @param[out] epsilon    the epsilon parameter (corresponding to the well depth of the van der Waals interaction), measured in kJ/mol
+     */
+    void getExceptionParameters(int index, int& particle1, int& particle2, double& sigma, double& epsilon) const;
+    /**
+     * Set the force field parameters for an interaction that should be calculated differently from others.  If
+     * epsilon is equal to 0, this will cause the interaction to be completely omitted from force and energy calculations.
+     *
+     * @param index      the index of the interaction for which to get parameters
+     * @param particle1  the index of the first particle involved in the interaction
+     * @param particle2  the index of the second particle involved in the interaction
+     * @param sigma      the sigma parameter (corresponding to the van der Waals radius of the particle), measured in nm
+     * @param epsilon    the epsilon parameter (corresponding to the well depth of the van der Waals interaction), measured in kJ/mol
+     */
+    void setExceptionParameters(int index, int particle1, int particle2, double sigma, double epsilon);
+    /**
+     * Update the particle and exception parameters in a Context to match those stored in this Force object.  This method
+     * provides an efficient method to update certain parameters in an existing Context without needing to reinitialize it.
+     * Simply call setParticleParameters() and setExceptionParameters() to modify this object's parameters, then call
+     * updateParametersInContext() to copy them over to the Context.
+     *
+     * This method has several limitations.  The only information it updates is the parameters of particles and exceptions.
+     * All other aspects of the Force (the nonbonded method, the cutoff distance, etc.) are unaffected and can only be
+     * changed by reinitializing the Context.  Furthermore, only the sigma and epsilon values of an exception can be
+     * changed; the pair of particles involved in the exception cannot change.  Likewise, the xparticle and yparticle
+     * defining the orientation of an ellipse cannot be changed.  Finally, this method cannot be used to add new
+     * particles or exceptions, only to change the parameters of existing ones.
+     */
+    void updateParametersInContext(Context& context);
+    /**
+     * Returns whether or not this force makes use of periodic boundary
+     * conditions.
+     *
+     * @returns true if force uses PBC and false otherwise
+     */
+    bool usesPeriodicBoundaryConditions() const {
+        return nonbondedMethod == GayBerneForce::CutoffPeriodic;
+    }
+protected:
+    ForceImpl* createImpl() const;
+private:
+    class ParticleInfo;
+    class ExceptionInfo;
+    NonbondedMethod nonbondedMethod;
+    double cutoffDistance, switchingDistance;
+    bool useSwitchingFunction;
+    std::vector<ParticleInfo> particles;
+    std::vector<ExceptionInfo> exceptions;
+    std::map<std::pair<int, int>, int> exceptionMap;
+};
+
+/**
+ * This is an internal class used to record information about a particle.
+ * @private
+ */
+class GayBerneForce::ParticleInfo {
+public:
+    int xparticle, yparticle;
+    double sigma, epsilon, sx, sy, sz, ex, ey, ez;
+    ParticleInfo() {
+        xparticle = yparticle = -1;
+        sigma = epsilon = sx = sy = sz = ex = ey = ez = 0.0;
+    }
+    ParticleInfo(double sigma, double epsilon, int xparticle, int yparticle, double sx, double sy, double sz, double ex, double ey, double ez) :
+        sigma(sigma), epsilon(epsilon), xparticle(xparticle), yparticle(yparticle), sx(sx), sy(sy), sz(sz), ex(ex), ey(ey), ez(ez) {
+    }
+};
+
+/**
+ * This is an internal class used to record information about an exception.
+ * @private
+ */
+class GayBerneForce::ExceptionInfo {
+public:
+    int particle1, particle2;
+    double sigma, epsilon;
+    ExceptionInfo() {
+        particle1 = particle2 = -1;
+        sigma = epsilon = 0.0;
+    }
+    ExceptionInfo(int particle1, int particle2, double sigma, double epsilon) :
+        particle1(particle1), particle2(particle2), sigma(sigma), epsilon(epsilon) {
+    }
+};
+
+} // namespace OpenMM
+
+#endif /*OPENMM_GAYBERNEFORCE_H_*/

openmmapi/include/openmm/internal/GayBerneForceImpl.h

+#ifndef OPENMM_GAYBERNEFORCEIMPL_H_
+#define OPENMM_GAYBERNEFORCEIMPL_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) 2008-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 "ForceImpl.h"
+#include "openmm/GayBerneForce.h"
+#include "openmm/Kernel.h"
+#include <utility>
+#include <set>
+#include <string>
+
+namespace OpenMM {
+
+class System;
+
+/**
+ * This is the internal implementation of GayBerneForce.
+ */
+
+class OPENMM_EXPORT GayBerneForceImpl : public ForceImpl {
+public:
+    GayBerneForceImpl(const GayBerneForce& owner);
+    ~GayBerneForceImpl();
+    void initialize(ContextImpl& context);
+    const GayBerneForce& getOwner() const {
+        return owner;
+    }
+    void updateContextState(ContextImpl& context) {
+        // This force field doesn't update the state directly.
+    }
+    double calcForcesAndEnergy(ContextImpl& context, bool includeForces, bool includeEnergy, int groups);
+    std::map<std::string, double> getDefaultParameters() {
+        return std::map<std::string, double>(); // This force field doesn't define any parameters.
+    }
+    std::vector<std::string> getKernelNames();
+    void updateParametersInContext(ContextImpl& context);
+private:
+    const GayBerneForce& owner;
+    Kernel kernel;
+};
+
+} // namespace OpenMM
+
+#endif /*OPENMM_GAYBERNEFORCEIMPL_H_*/

openmmapi/src/GayBerneForce.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) 2008-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/Force.h"
+#include "openmm/OpenMMException.h"
+#include "openmm/GayBerneForce.h"
+#include "openmm/internal/AssertionUtilities.h"
+#include "openmm/internal/GayBerneForceImpl.h"
+#include <cmath>
+#include <map>
+#include <sstream>
+#include <utility>
+
+using namespace OpenMM;
+using std::map;
+using std::pair;
+using std::set;
+using std::string;
+using std::stringstream;
+using std::vector;
+
+GayBerneForce::GayBerneForce() : nonbondedMethod(NoCutoff), cutoffDistance(1.0), switchingDistance(-1.0), useSwitchingFunction(false) {
+}
+
+GayBerneForce::NonbondedMethod GayBerneForce::getNonbondedMethod() const {
+    return nonbondedMethod;
+}
+
+void GayBerneForce::setNonbondedMethod(NonbondedMethod method) {
+    nonbondedMethod = method;
+}
+
+double GayBerneForce::getCutoffDistance() const {
+    return cutoffDistance;
+}
+
+void GayBerneForce::setCutoffDistance(double distance) {
+    cutoffDistance = distance;
+}
+
+bool GayBerneForce::getUseSwitchingFunction() const {
+    return useSwitchingFunction;
+}
+
+void GayBerneForce::setUseSwitchingFunction(bool use) {
+    useSwitchingFunction = use;
+}
+
+double GayBerneForce::getSwitchingDistance() const {
+    return switchingDistance;
+}
+
+void GayBerneForce::setSwitchingDistance(double distance) {
+    switchingDistance = distance;
+}
+
+int GayBerneForce::addParticle(double sigma, double epsilon, int xparticle, int yparticle, double sx, double sy, double sz, double ex, double ey, double ez) {
+    if (yparticle == -1 && (sy != sz || ey != ez))
+        throw OpenMMException("GayBerneForce: yparticle is -1 for a particle that is not axially symmetric");
+    if (xparticle == -1 && (sx != sz || ex != ez))
+        throw OpenMMException("GayBerneForce: xparticle is -1 for a particle that is not spherical");
+    if (xparticle == -1 && yparticle != -1)
+        throw OpenMMException("GayBerneForce: xparticle cannot be -1 if yparticle is not also -1");
+    particles.push_back(ParticleInfo(sigma, epsilon, xparticle, yparticle, sx, sy, sz, ex, ey, ez));
+    return particles.size()-1;
+}
+
+void GayBerneForce::getParticleParameters(int index, double& sigma, double& epsilon, int& xparticle, int& yparticle, double& sx, double& sy, double& sz, double& ex, double& ey, double& ez) const {
+    ASSERT_VALID_INDEX(index, particles);
+    sigma = particles[index].sigma;
+    epsilon = particles[index].epsilon;
+    xparticle = particles[index].xparticle;
+    yparticle = particles[index].yparticle;
+    sx = particles[index].sx;
+    sy = particles[index].sy;
+    sz = particles[index].sz;
+    ex = particles[index].ex;
+    ey = particles[index].ey;
+    ez = particles[index].ez;
+}
+
+void GayBerneForce::setParticleParameters(int index, double sigma, double epsilon, int xparticle, int yparticle, double sx, double sy, double sz, double ex, double ey, double ez) {
+    ASSERT_VALID_INDEX(index, particles);
+    if (yparticle == -1 && (sy != sz || ey != ez))
+        throw OpenMMException("GayBerneForce: yparticle is -1 for a particle that is not axially symmetric");
+    if (xparticle == -1 && (sx != sz || ex != ez))
+        throw OpenMMException("GayBerneForce: xparticle is -1 for a particle that is not spherical");
+    if (xparticle == -1 && yparticle != -1)
+        throw OpenMMException("GayBerneForce: xparticle cannot be -1 if yparticle is not also -1");
+    particles[index].sigma = sigma;
+    particles[index].epsilon = epsilon;
+    particles[index].xparticle = xparticle;
+    particles[index].yparticle = yparticle;
+    particles[index].sx = sx;
+    particles[index].sy = sy;
+    particles[index].sz = sz;
+    particles[index].ex = ex;
+    particles[index].ey = ey;
+    particles[index].ez = ez;
+}
+
+int GayBerneForce::addException(int particle1, int particle2, double sigma, double epsilon, bool replace) {
+    map<pair<int, int>, int>::iterator iter = exceptionMap.find(pair<int, int>(particle1, particle2));
+    int newIndex;
+    if (iter == exceptionMap.end())
+        iter = exceptionMap.find(pair<int, int>(particle2, particle1));
+    if (iter != exceptionMap.end()) {
+        if (!replace) {
+            stringstream msg;
+            msg << "GayBerneForce: There is already an exception for particles ";
+            msg << particle1;
+            msg << " and ";
+            msg << particle2;
+            throw OpenMMException(msg.str());
+        }
+        exceptions[iter->second] = ExceptionInfo(particle1, particle2, sigma, epsilon);
+        newIndex = iter->second;
+        exceptionMap.erase(iter->first);
+    }
+    else {
+        exceptions.push_back(ExceptionInfo(particle1, particle2, sigma, epsilon));
+        newIndex = exceptions.size()-1;
+    }
+    exceptionMap[pair<int, int>(particle1, particle2)] = newIndex;
+    return newIndex;
+}
+
+void GayBerneForce::getExceptionParameters(int index, int& particle1, int& particle2, double& sigma, double& epsilon) const {
+    ASSERT_VALID_INDEX(index, exceptions);
+    particle1 = exceptions[index].particle1;
+    particle2 = exceptions[index].particle2;
+    sigma = exceptions[index].sigma;
+    epsilon = exceptions[index].epsilon;
+}
+
+void GayBerneForce::setExceptionParameters(int index, int particle1, int particle2, double sigma, double epsilon) {
+    ASSERT_VALID_INDEX(index, exceptions);
+    exceptions[index].particle1 = particle1;
+    exceptions[index].particle2 = particle2;
+    exceptions[index].sigma = sigma;
+    exceptions[index].epsilon = epsilon;
+}
+
+ForceImpl* GayBerneForce::createImpl() const {
+    return new GayBerneForceImpl(*this);
+}
+
+void GayBerneForce::updateParametersInContext(Context& context) {
+    dynamic_cast<GayBerneForceImpl&>(getImplInContext(context)).updateParametersInContext(getContextImpl(context));
+}

openmmapi/src/GayBerneForceImpl.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) 2008-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/OpenMMException.h"
+#include "openmm/internal/ContextImpl.h"
+#include "openmm/internal/GayBerneForceImpl.h"
+#include "openmm/kernels.h"
+#include <set>
+#include <sstream>
+
+using namespace OpenMM;
+using namespace std;
+
+GayBerneForceImpl::GayBerneForceImpl(const GayBerneForce& owner) : owner(owner) {
+}
+
+GayBerneForceImpl::~GayBerneForceImpl() {
+}
+
+void GayBerneForceImpl::initialize(ContextImpl& context) {
+    kernel = context.getPlatform().createKernel(CalcGayBerneForceKernel::Name(), context);
+
+    // Check for errors in the specification of exceptions.
+
+    const System& system = context.getSystem();
+    if (owner.getNumParticles() != system.getNumParticles())
+        throw OpenMMException("GayBerneForce must have exactly as many particles as the System it belongs to.");
+    if (owner.getUseSwitchingFunction()) {
+        if (owner.getSwitchingDistance() < 0 || owner.getSwitchingDistance() >= owner.getCutoffDistance())
+            throw OpenMMException("GayBerneForce: Switching distance must satisfy 0 <= r_switch < r_cutoff");
+    }
+    for (int i = 0; i < owner.getNumParticles(); i++) {
+        int xparticle, yparticle;
+        double sigma, epsilon, rx, ry, rz, ex, ey, ez;
+        owner.getParticleParameters(i, sigma, epsilon, xparticle, yparticle, rx, ry, rz, ex, ey, ez);
+        if (xparticle < -1 || xparticle >= owner.getNumParticles()) {
+            stringstream msg;
+            msg << "GayBerneForce: Illegal particle index for xparticle: ";
+            msg << xparticle;
+            throw OpenMMException(msg.str());
+        }
+        if (yparticle < -1 || yparticle >= owner.getNumParticles()) {
+            stringstream msg;
+            msg << "GayBerneForce: Illegal particle index for a yparticle: ";
+            msg << yparticle;
+            throw OpenMMException(msg.str());
+        }
+    }
+    vector<set<int> > exceptions(owner.getNumParticles());
+    for (int i = 0; i < owner.getNumExceptions(); i++) {
+        int particle1, particle2;
+        double sigma, epsilon;
+        owner.getExceptionParameters(i, particle1, particle2, sigma, epsilon);
+        if (particle1 < 0 || particle1 >= owner.getNumParticles()) {
+            stringstream msg;
+            msg << "GayBerneForce: Illegal particle index for an exception: ";
+            msg << particle1;
+            throw OpenMMException(msg.str());
+        }
+        if (particle2 < 0 || particle2 >= owner.getNumParticles()) {
+            stringstream msg;
+            msg << "GayBerneForce: Illegal particle index for an exception: ";
+            msg << particle2;
+            throw OpenMMException(msg.str());
+        }
+        if (exceptions[particle1].count(particle2) > 0 || exceptions[particle2].count(particle1) > 0) {
+            stringstream msg;
+            msg << "GayBerneForce: Multiple exceptions are specified for particles ";
+            msg << particle1;
+            msg << " and ";
+            msg << particle2;
+            throw OpenMMException(msg.str());
+        }
+        exceptions[particle1].insert(particle2);
+        exceptions[particle2].insert(particle1);
+    }
+    if (owner.getNonbondedMethod() == GayBerneForce::CutoffPeriodic) {
+        Vec3 boxVectors[3];
+        system.getDefaultPeriodicBoxVectors(boxVectors[0], boxVectors[1], boxVectors[2]);
+        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("GayBerneForce: The cutoff distance cannot be greater than half the periodic box size.");
+    }
+    kernel.getAs<CalcGayBerneForceKernel>().initialize(context.getSystem(), owner);
+}
+
+double GayBerneForceImpl::calcForcesAndEnergy(ContextImpl& context, bool includeForces, bool includeEnergy, int groups) {
+    if ((groups&(1<<owner.getForceGroup())) != 0)
+        return kernel.getAs<CalcGayBerneForceKernel>().execute(context, includeForces, includeEnergy);
+    return 0.0;
+}
+
+std::vector<std::string> GayBerneForceImpl::getKernelNames() {
+    std::vector<std::string> names;
+    names.push_back(CalcGayBerneForceKernel::Name());
+    return names;
+}
+
+void GayBerneForceImpl::updateParametersInContext(ContextImpl& context) {
+    kernel.getAs<CalcGayBerneForceKernel>().copyParametersToContext(context, owner);
+}

platforms/cpu/include/CpuGayBerneForce.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 OPENMM_CPU_GAYBERNEFORCE_H__
+#define OPENMM_CPU_GAYBERNEFORCE_H__
+
+#include "openmm/GayBerneForce.h"
+#include "openmm/internal/ThreadPool.h"
+#include "CpuNeighborList.h"
+#include "CpuPlatform.h"
+#include "RealVec.h"
+#include <set>
+#include <utility>
+
+namespace OpenMM {
+
+class CpuGayBerneForce {
+public:
+    struct Matrix;
+    class ComputeTask;
+
+    /**
+     * Constructor.
+     */
+    CpuGayBerneForce(const GayBerneForce& force);
+
+    /**
+     * Compute the interaction.
+     *
+     * @param positions     the positions of the atoms
+     * @param forces        forces will be added to this vector
+     * @param threadForce   individual threads can add their forces to this vector
+     * @param boxVectors    the periodic box vectors
+     * @param data          the platform data for the current context
+     * @return the energy of the interaction
+     */
+    RealOpenMM calculateForce(const std::vector<RealVec>& positions, std::vector<RealVec>& forces, std::vector<AlignedArray<float> >& threadForce, RealVec* boxVectors, CpuPlatform::PlatformData& data);
+
+    /**
+     * This routine contains the code executed by each thread.
+     */
+    void threadComputeForce(ThreadPool& threads, int threadIndex, CpuNeighborList* neighborList);
+    
+    /**
+     * Get the exclusions being used by the force.
+     */
+    const std::vector<std::set<int> >& getExclusions() const;
+
+private:
+    struct ParticleInfo;
+    struct ExceptionInfo;
+    std::vector<ParticleInfo> particles;
+    std::vector<ExceptionInfo> exceptions;
+    std::set<std::pair<int, int> > exclusions;
+    std::vector<std::set<int> > particleExclusions;
+    GayBerneForce::NonbondedMethod nonbondedMethod;
+    RealOpenMM cutoffDistance, switchingDistance;
+    bool useSwitchingFunction;
+    std::vector<RealOpenMM> s;
+    std::vector<Matrix> A, B, G;
+    std::vector<double> threadEnergy;
+    std::vector<std::vector<RealVec> > threadTorque;
+    // The following variables are used to make information accessible to the individual threads.
+    RealVec const* positions;
+    std::vector<AlignedArray<float> >* threadForce;
+    RealVec* boxVectors;
+    void* atomicCounter;
+
+    void computeEllipsoidFrames(const std::vector<RealVec>& positions);
+    
+    void applyTorques(const std::vector<RealVec>& positions, std::vector<RealVec>& forces);
+
+    RealOpenMM computeOneInteraction(int particle1, int particle2, RealOpenMM sigma, RealOpenMM epsilon, const RealVec* positions,
+            float* forces, std::vector<RealVec>& torques, const RealVec* boxVectors);
+};
+
+struct CpuGayBerneForce::ParticleInfo {
+    int xparticle, yparticle;
+    RealOpenMM sigmaOver2, sqrtEpsilon, rx, ry, rz, ex, ey, ez;
+    bool isPointParticle;
+};
+
+struct CpuGayBerneForce::ExceptionInfo {
+    int particle1, particle2;
+    RealOpenMM sigma, epsilon;
+};
+
+struct CpuGayBerneForce::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, CpuGayBerneForce::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 // OPENMM_CPU_GAYBERNEFORCE_H__

platforms/cpu/include/CpuKernels.h

@@ -36,6 +36,7 @@
 #include "CpuCustomGBForce.h"
 #include "CpuCustomManyParticleForce.h"
 #include "CpuCustomNonbondedForce.h"
+#include "CpuGayBerneForce.h"
 #include "CpuGBSAOBCForce.h"
 #include "CpuLangevinDynamics.h"
 #include "CpuNeighborList.h"
@@ -446,6 +447,42 @@ private:
     NonbondedMethod nonbondedMethod;
 };
 
+/**
+ * This kernel is invoked by GayBerneForce to calculate the forces acting on the system.
+ */
+class CpuCalcGayBerneForceKernel : public CalcGayBerneForceKernel {
+public:
+    CpuCalcGayBerneForceKernel(std::string name, const Platform& platform, CpuPlatform::PlatformData& data) : CalcGayBerneForceKernel(name, platform),
+            data(data), ixn(NULL) {
+    }
+    ~CpuCalcGayBerneForceKernel();
+    /**
+     * 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:
+    CpuPlatform::PlatformData& data;
+    CpuGayBerneForce* ixn;
+};
+
 /**
  * This kernel is invoked by LangevinIntegrator to take one time step.
  */

platforms/cpu/include/CpuPlatform.h

@@ -82,7 +82,7 @@ class CpuPlatform::PlatformData {
 public:
     PlatformData(int numParticles, int numThreads);
     ~PlatformData();
-    void requestNeighborList(double cutoffDistance, double padding, bool useExclusions, std::vector<std::set<int> >& exclusionList);
+    void requestNeighborList(double cutoffDistance, double padding, bool useExclusions, const std::vector<std::set<int> >& exclusionList);
     AlignedArray<float> posq;
     std::vector<AlignedArray<float> > threadForce;
     ThreadPool threads;

platforms/cpu/src/CpuKernelFactory.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) 2013 Stanford University and the Authors.           *
+ * Portions copyright (c) 2013-2016 Stanford University and the Authors.      *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -57,6 +57,8 @@ KernelImpl* CpuKernelFactory::createKernelImpl(std::string name, const Platform&
         return new CpuCalcGBSAOBCForceKernel(name, platform, data);
     if (name == CalcCustomGBForceKernel::Name())
         return new CpuCalcCustomGBForceKernel(name, platform, data);
+    if (name == CalcGayBerneForceKernel::Name())
+        return new CpuCalcGayBerneForceKernel(name, platform, data);
     if (name == IntegrateLangevinStepKernel::Name())
         return new CpuIntegrateLangevinStepKernel(name, platform, data);
     throw OpenMMException((std::string("Tried to create kernel with illegal kernel name '") + name + "'").c_str());

platforms/cpu/src/CpuKernels.cpp

@@ -1236,6 +1236,30 @@ void CpuCalcCustomManyParticleForceKernel::copyParametersToContext(ContextImpl&
     }
 }
 
+CpuCalcGayBerneForceKernel::~CpuCalcGayBerneForceKernel() {
+    if (ixn != NULL)
+        delete ixn;
+}
+
+void CpuCalcGayBerneForceKernel::initialize(const System& system, const GayBerneForce& force) {
+    ixn = new CpuGayBerneForce(force);
+    data.isPeriodic = (force.getNonbondedMethod() == GayBerneForce::CutoffPeriodic);
+    if (force.getNonbondedMethod() != GayBerneForce::NoCutoff) {
+        double cutoff = force.getCutoffDistance();
+        data.requestNeighborList(cutoff, 0.1*cutoff, true, ixn->getExclusions());
+    }
+}
+
+double CpuCalcGayBerneForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
+    return ixn->calculateForce(extractPositions(context), extractForces(context), data.threadForce, extractBoxVectors(context), data);
+}
+
+void CpuCalcGayBerneForceKernel::copyParametersToContext(ContextImpl& context, const GayBerneForce& force) {
+    delete ixn;
+    ixn = NULL;
+    ixn = new CpuGayBerneForce(force);
+}
+
 CpuIntegrateLangevinStepKernel::~CpuIntegrateLangevinStepKernel() {
     if (dynamics)
         delete dynamics;

platforms/cpu/src/CpuPlatform.cpp

@@ -71,6 +71,7 @@ CpuPlatform::CpuPlatform() {
     registerKernelFactory(CalcCustomManyParticleForceKernel::Name(), factory);
     registerKernelFactory(CalcGBSAOBCForceKernel::Name(), factory);
     registerKernelFactory(CalcCustomGBForceKernel::Name(), factory);
+    registerKernelFactory(CalcGayBerneForceKernel::Name(), factory);
     registerKernelFactory(IntegrateLangevinStepKernel::Name(), factory);
     platformProperties.push_back(CpuThreads());
     int threads = getNumProcessors();
@@ -155,7 +156,7 @@ CpuPlatform::PlatformData::~PlatformData() {
 
 bool isVec8Supported();
 
-void CpuPlatform::PlatformData::requestNeighborList(double cutoffDistance, double padding, bool useExclusions, vector<set<int> >& exclusionList) {
+void CpuPlatform::PlatformData::requestNeighborList(double cutoffDistance, double padding, bool useExclusions, const vector<set<int> >& exclusionList) {
     if (neighborList == NULL)
         neighborList = new CpuNeighborList(isVec8Supported() ? 8 : 4);
     if (cutoffDistance > cutoff)

platforms/cpu/tests/TestCpuGayBerneForce.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 "CpuTests.h"
+#include "TestGayBerneForce.h"
+
+void runPlatformTests() {
+}

platforms/cuda/include/CudaKernels.h

@@ -1104,6 +1104,74 @@ private:
     CUevent event;
 };
 
+/**
+ * This kernel is invoked by GayBerneForce to calculate the forces acting on the system.
+ */
+class CudaCalcGayBerneForceKernel : public CalcGayBerneForceKernel {
+public:
+    CudaCalcGayBerneForceKernel(std::string name, const Platform& platform, CudaContext& cu) : CalcGayBerneForceKernel(name, platform), cu(cu),
+            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) {
+    }
+    ~CudaCalcGayBerneForceKernel();
+    /**
+     * 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();
+    CudaContext& cu;
+    bool hasInitializedKernels;
+    int numRealParticles, numExceptions, maxNeighborBlocks;
+    GayBerneForce::NonbondedMethod nonbondedMethod;
+    CudaArray* sortedParticles;
+    CudaArray* axisParticleIndices;
+    CudaArray* sigParams;
+    CudaArray* epsParams;
+    CudaArray* scale;
+    CudaArray* exceptionParticles;
+    CudaArray* exceptionParams;
+    CudaArray* aMatrix;
+    CudaArray* bMatrix;
+    CudaArray* gMatrix;
+    CudaArray* exclusions;
+    CudaArray* exclusionStartIndex;
+    CudaArray* blockCenter;
+    CudaArray* blockBoundingBox;
+    CudaArray* neighbors;
+    CudaArray* neighborIndex;
+    CudaArray* neighborBlockCount;
+    CudaArray* sortedPos;
+    CudaArray* torque;
+    std::vector<bool> isRealParticle;
+    std::vector<std::pair<int, int> > exceptionAtoms;
+    std::vector<std::pair<int, int> > excludedPairs;
+    std::vector<void*> framesArgs, blockBoundsArgs, neighborsArgs, forceArgs, torqueArgs;
+    CUfunction framesKernel, blockBoundsKernel, neighborsKernel, forceKernel, torqueKernel;
+    CUevent event;
+};
+
 /**
  * This kernel is invoked by VerletIntegrator to take one time step.
  */

platforms/cuda/src/CudaKernelFactory.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-2012 Stanford University and the Authors.      *
+ * Portions copyright (c) 2008-2016 Stanford University and the Authors.      *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -110,6 +110,8 @@ KernelImpl* CudaKernelFactory::createKernelImpl(std::string name, const Platform
         return new CudaCalcCustomCompoundBondForceKernel(name, platform, cu, context.getSystem());
     if (name == CalcCustomManyParticleForceKernel::Name())
         return new CudaCalcCustomManyParticleForceKernel(name, platform, cu, context.getSystem());
+    if (name == CalcGayBerneForceKernel::Name())
+        return new CudaCalcGayBerneForceKernel(name, platform, cu);
     if (name == IntegrateVerletStepKernel::Name())
         return new CudaIntegrateVerletStepKernel(name, platform, cu);
     if (name == IntegrateLangevinStepKernel::Name())

platforms/cuda/src/CudaPlatform.cpp

@@ -92,6 +92,7 @@ CudaPlatform::CudaPlatform() {
     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);