Merge branch 'genpt' of https://github.com/andysim/openmm into

extrapolated

plugins/amoeba/openmmapi/include/openmm/AmoebaMultipoleForce.h

@@ -79,7 +79,13 @@ public:
         /**
          * Direct polarization
          */
-        Direct = 1
+        Direct = 1,
+
+        /**
+         * Optimized perturbation theory
+         */
+        OPT = 2
+
     };
 
     enum MultipoleAxisTypes { ZThenX = 0, Bisector = 1, ZBisect = 2, ThreeFold = 3, ZOnly = 4, NoAxisType = 5, LastAxisTypeIndex = 6 };
@@ -298,6 +304,21 @@ public:
      */
     void setMutualInducedTargetEpsilon(double inputMutualInducedTargetEpsilon);
 
+    /**
+     * Set the coefficients for the mu_0, mu_1, mu_2, ..., mu_n terms in the perturbation
+     * theory algorithm for induced dipoles.
+     *
+     * @param optCoefficients a vector whose mth entry specifies the coefficient for mu_m
+     *
+     */
+    void setOPTCoefficients(const std::vector<double> &OPTFullCoefficientsIn);
+
+    /**
+     * Get the coefficients for the mu_0, mu_1, mu_2, ..., mu_n terms in the perturbation
+     * theory algorithm for induced dipoles.
+     */
+    const std::vector<double>& getOPTCoefficients() const;
+
     /**
      * Get the error tolerance for Ewald summation.  This corresponds to the fractional error in the forces
      * which is acceptable.  This value is used to select the grid dimensions and separation (alpha)
@@ -384,6 +405,8 @@ private:
     int pmeBSplineOrder;
     std::vector<int> pmeGridDimension;
     int mutualInducedMaxIterations;
+    std::vector<double>  OPTFullCoefficients;
+
     double mutualInducedTargetEpsilon;
     double scalingDistanceCutoff;
     double electricConstant;

plugins/amoeba/openmmapi/src/AmoebaMultipoleForce.cpp

@@ -61,6 +61,19 @@ void AmoebaMultipoleForce::setPolarizationType(AmoebaMultipoleForce::Polarizatio
     polarizationType = type;
 }
 
+void AmoebaMultipoleForce::setOPTCoefficients(const std::vector<double> &OPTFullCoefficientsIn)
+{
+    size_t maxPTOrder = OPTFullCoefficientsIn.size();
+    OPTFullCoefficients.resize(maxPTOrder);
+    std::copy(OPTFullCoefficientsIn.begin(), OPTFullCoefficientsIn.end(), OPTFullCoefficients.begin());
+}
+
+const std::vector<double> & AmoebaMultipoleForce::getOPTCoefficients() const
+{
+    return OPTFullCoefficients;
+}
+
+
 double AmoebaMultipoleForce::getCutoffDistance() const {
     return cutoffDistance;
 }

plugins/amoeba/platforms/reference/src/AmoebaReferenceKernels.cpp

@@ -565,6 +565,8 @@ void ReferenceCalcAmoebaMultipoleForceKernel::initialize(const System& system, c
     if (polarizationType == AmoebaMultipoleForce::Mutual) {
         mutualInducedMaxIterations = force.getMutualInducedMaxIterations();
         mutualInducedTargetEpsilon = force.getMutualInducedTargetEpsilon();
+    } else if (polarizationType == AmoebaMultipoleForce::OPT) {
+        OPTFullCoefficients = force.getOPTCoefficients();
     }
 
     // PME
@@ -667,6 +669,9 @@ AmoebaReferenceMultipoleForce* ReferenceCalcAmoebaMultipoleForceKernel::setupAmo
         amoebaReferenceMultipoleForce->setMaximumMutualInducedDipoleIterations(mutualInducedMaxIterations);
     } else if (polarizationType == AmoebaMultipoleForce::Direct) {
         amoebaReferenceMultipoleForce->setPolarizationType(AmoebaReferenceMultipoleForce::Direct);
+    } else if (polarizationType == AmoebaMultipoleForce::OPT) {
+        amoebaReferenceMultipoleForce->setPolarizationType(AmoebaReferenceMultipoleForce::OPT);
+        amoebaReferenceMultipoleForce->setOPTCoefficients(OPTFullCoefficients);
     } else {
         throw OpenMMException("Polarization type not recognzied.");
     }

plugins/amoeba/platforms/reference/src/AmoebaReferenceKernels.h

@@ -432,6 +432,7 @@ private:
 
     int mutualInducedMaxIterations;
     RealOpenMM mutualInducedTargetEpsilon;
+    std::vector<double> OPTFullCoefficients;
 
     bool usePme;
     RealOpenMM alphaEwald;

plugins/amoeba/platforms/reference/src/SimTKReference/AmoebaReferenceMultipoleForce.h

@@ -348,7 +348,12 @@ public:
         /**
          * Direct polarization
          */
-        Direct = 1 
+        Direct = 1,
+
+        /**
+         * Optimized perturbation theory
+         */
+        OPT = 2
     };
 
     /**
@@ -422,6 +427,15 @@ public:
      */
     RealOpenMM getMutualInducedDipoleEpsilon() const;
 
+    /**
+     * Set the coefficients for the µ_0, µ_1, µ_2, µ_n terms in the pertubation
+     * theory algorithm for induced dipoles
+     *
+     * @param optCoefficients a vector whose mth entry specifies the coefficient for µ_m
+     *
+     */
+    void setOPTCoefficients(const std::vector<RealOpenMM> &OPTFullCoefficients);
+
     /**
      * Set the target epsilon for converging mutual induced dipoles.
      *
@@ -628,6 +642,7 @@ protected:
             std::vector<OpenMM::RealVec>* fixedMultipoleField;
             std::vector<OpenMM::RealVec>* inducedDipoles;
             std::vector<OpenMM::RealVec> inducedDipoleField;
+            std::vector<std::vector<RealOpenMM> > inducedDipoleFieldGradient;
     };
 
     unsigned int _numParticles;
@@ -651,10 +666,19 @@ protected:
     std::vector<RealVec> _fixedMultipoleFieldPolar;
     std::vector<RealVec> _inducedDipole;
     std::vector<RealVec> _inducedDipolePolar;
+    std::vector< std::vector<RealVec> > _ptDipoleP;
+    std::vector< std::vector<RealVec> > _ptDipoleD;
+    std::vector<std::vector<RealOpenMM> > _ptDipoleFieldGradientP;
+    std::vector<std::vector<RealOpenMM> > _ptDipoleFieldGradientD;
+
+
 
     int _mutualInducedDipoleConverged;
     int _mutualInducedDipoleIterations;
     int _maximumMutualInducedDipoleIterations;
+    int _maxPTOrder;
+    std::vector<RealOpenMM>  _OPTFullCoefficients;
+    std::vector<RealOpenMM>  _OPTPartCoefficients;
     RealOpenMM  _mutualInducedDipoleEpsilon;
     RealOpenMM  _mutualInducedDipoleTargetEpsilon;
     RealOpenMM  _polarSOR;
@@ -920,6 +944,14 @@ protected:
      */
     virtual void calculateInducedDipoleFields(const std::vector<MultipoleParticleData>& particleData,
                                               std::vector<UpdateInducedDipoleFieldStruct>& updateInducedDipoleFields);
+    /**
+     * Calculated induced dipoles using Optimized Perturbation Theory.
+     *
+     * @param particleData              vector of particle positions and parameters (charge, labFrame dipoles, quadrupoles, ...)
+     * @param updateInducedDipoleFields vector of UpdateInducedDipoleFieldStruct containing input induced dipoles and output fields
+     */
+    void convergeInduceDipolesByOPT(const std::vector<MultipoleParticleData>& particleData,
+                                    std::vector<UpdateInducedDipoleFieldStruct>& calculateInducedDipoleField);
     /**
      * Converge induced dipoles.
      * 

wrappers/python/src/swig_doxygen/swigInputConfig.py

@@ -247,6 +247,7 @@ UNITS = {
 ("AmoebaMultipoleForce",                 "getPmeBSplineOrder")                            :  ( None,()),
 ("AmoebaMultipoleForce",                 "getMutualInducedMaxIterations")                 :  ( None, ()),
 ("AmoebaMultipoleForce",                 "getMutualInducedTargetEpsilon")                 :  ( None, ()),
+("AmoebaMultipoleForce",                 "getOPTCoefficients")                            :  ( None, ()),
 ("AmoebaMultipoleForce",                 "getEwaldErrorTolerance")                        :  ( None, ()),
 ("AmoebaMultipoleForce",                 "getPmeGridDimensions")                          :  ( None,()),