Initial RealSpaceEwald code for AmoebaMultipoleForce

Removal SASA code
Versioning introduced in AmoebaTinkerParameterFile
Decomposition of PME forces included in prm files 

plugins/amoeba/openmmapi/include/AmoebaMultipoleForce.h

@@ -50,6 +50,19 @@ namespace OpenMM {
 class OPENMM_EXPORT AmoebaMultipoleForce : public Force {
 public:
  
+    enum AmoebaNonbondedMethod {
+        /** 
+         * 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,
+        /**
+         * Periodic boundary conditions are used, and Particle-Mesh Ewald (PME) summation is used to compute the interaction of each particle
+         * with all periodic copies of every other particle.
+         */
+        PME = 1 
+    };  
+
     enum MultipoleAxisTypes { ZThenX, Bisector };
 
     // Algorithm used to converge mutual induced dipoles:
@@ -74,6 +87,46 @@ public:
         return multipoles.size();
     }
 
+    /**
+     * Get the method used for handling long range nonbonded interactions.
+     */
+    AmoebaNonbondedMethod getNonbondedMethod( void ) const;
+
+    /**
+     * Set the method used for handling long range nonbonded interactions.
+     */
+    void setNonbondedMethod(AmoebaNonbondedMethod method);
+
+    /**
+     * Get the cutoff distance (in nm) being used for nonbonded interactions.  If the NonbondedMethod in use
+     * is NoCutoff, this value will have no effect.
+     *
+     * @return the cutoff distance, measured in nm
+     */
+    double getCutoffDistance( void ) const;
+
+    /**
+     * Set the cutoff distance (in nm) being used for nonbonded 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 the aEwald parameter
+     *
+     * @return the Ewald parameter
+     */
+    double getAEwald() const;
+
+    /**
+     * Set the aEwald parameter
+     *
+     * @param Ewald parameter
+     */
+    void setAEwald(double aewald);
+
     /**
      * Add multipole-related info for a particle 
      *
@@ -224,6 +277,9 @@ protected:
     ForceImpl* createImpl();
 private:
 
+    AmoebaNonbondedMethod nonbondedMethod;
+    double cutoffDistance;
+    double aewald;
     MutualInducedIterationMethod mutualInducedIterationMethod;
     int mutualInducedMaxIterations;
     double mutualInducedTargetEpsilon;

plugins/amoeba/openmmapi/src/AmoebaMultipoleForce.cpp

@@ -36,15 +36,32 @@
 
 using namespace OpenMM;
 
-AmoebaMultipoleForce::AmoebaMultipoleForce() {
+AmoebaMultipoleForce::AmoebaMultipoleForce() : nonbondedMethod(NoCutoff), cutoffDistance(1.0), aewald(0.0), mutualInducedIterationMethod(SOR), mutualInducedMaxIterations(60),
+                                               mutualInducedTargetEpsilon(1.0e-05), scalingDistanceCutoff(100.0), electricConstant(138.9354558456) {
+}
+
+AmoebaMultipoleForce::AmoebaNonbondedMethod AmoebaMultipoleForce::getNonbondedMethod( void ) const {
+    return nonbondedMethod;
+}
+
+void AmoebaMultipoleForce::setNonbondedMethod( AmoebaMultipoleForce::AmoebaNonbondedMethod method) {
+    nonbondedMethod = method;
+}
 
-    mutualInducedIterationMethod  = SOR;
-    mutualInducedMaxIterations    = 60;
-    mutualInducedTargetEpsilon    = 1.0e-06;
-    scalingDistanceCutoff         = 100.0;
+double AmoebaMultipoleForce::getCutoffDistance( void ) const {
+    return cutoffDistance;
+}
+
+void AmoebaMultipoleForce::setCutoffDistance(double distance) {
+    cutoffDistance = distance;
+}
+
+double AmoebaMultipoleForce::getAEwald() const {
+    return aewald;
+}
 
-                                    // ONE_4PI_EPS0
-    electricConstant              = 138.9354558456;
+void AmoebaMultipoleForce::setAEwald(double inputAewald ) {
+    aewald = inputAewald;
 }
 
 AmoebaMultipoleForce::MutualInducedIterationMethod AmoebaMultipoleForce::getMutualInducedIterationMethod( void ) const {

plugins/amoeba/platforms/cuda/src/AmoebaCudaData.h

@@ -30,7 +30,6 @@
 #include "CudaPlatform.h"
 #include "kernels/amoebaGpuTypes.h"
 #include "kernels/cudaKernels.h"
-#include "kernels/amoebaCudaKernels.h"
 #include "openmm/KernelImpl.h"
 
 namespace OpenMM {

plugins/amoeba/platforms/cuda/src/AmoebaCudaKernels.cpp

@@ -575,12 +575,20 @@ void CudaCalcAmoebaMultipoleForceKernel::initialize(const System& system, const
          throw OpenMMException("Iterative method for mutual induced dipoles not recognized.\n");
     }
 
+    int nonbondedMethod = static_cast<int>(force.getNonbondedMethod());
+    if( nonbondedMethod != 0 && nonbondedMethod != 1 ){
+         throw OpenMMException("AmoebaMultipoleForce nonbonded method not recognized.\n");
+    }
+
     gpuSetAmoebaMultipoleParameters(data.getAmoebaGpu(), charges, dipoles, quadrupoles, axisTypes, multipoleAtomId1s, multipoleAtomId2s,
                                     tholes, scalingDistanceCutoff, dampingFactors, polarity,
                                     multipoleAtomCovalentInfo, covalentDegree, minCovalentIndices, minCovalentPolarizationIndices, (maxCovalentRange+2),
                                     static_cast<int>(force.getMutualInducedIterationMethod()),
                                     force.getMutualInducedMaxIterations(),
                                     static_cast<float>( force.getMutualInducedTargetEpsilon()),
+                                    nonbondedMethod,
+                                    static_cast<float>( force.getCutoffDistance()),
+                                    static_cast<float>( force.getAEwald()),
                                     static_cast<float>( force.getElectricConstant()) );
 
 }

plugins/amoeba/platforms/cuda/src/kernels/AmoebaGpu.cpp

@@ -29,6 +29,7 @@
  * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
  * -------------------------------------------------------------------------- */
 
+#include "openmm/OpenMMException.h"
 #include "cudaKernels.h"
 #include "amoebaCudaKernels.h"
 
@@ -332,7 +333,11 @@ void gpuPrintCudaAmoebaGmxSimulation(amoebaGpuContext amoebaGpu, FILE* log )
     (void) fprintf( log, "     pD_ScaleIndices                    %p\n",      amoebaGpu->amoebaSim.pD_ScaleIndices );
     (void) fprintf( log, "     pP_ScaleIndices                    %p\n",      amoebaGpu->amoebaSim.pP_ScaleIndices );
     (void) fprintf( log, "     pM_ScaleIndices                    %p\n",      amoebaGpu->amoebaSim.pM_ScaleIndices );
+    (void) fprintf( log, "     sqrtPi                             %15.7e\n",  amoebaGpu->amoebaSim.sqrtPi );
+    (void) fprintf( log, "     cutoffDistance2                    %15.7e\n",  amoebaGpu->amoebaSim.cutoffDistance2 );
+    (void) fprintf( log, "     aewald                             %15.7e\n",  amoebaGpu->amoebaSim.aewald );
     (void) fprintf( log, "     electric                           %15.7e\n",  amoebaGpu->amoebaSim.electric );
+    (void) fprintf( log, "     box                                %15.7e %15.7e %15.7e\n", gpu->sim.periodicBoxSizeX, gpu->sim.periodicBoxSizeY, gpu->sim.periodicBoxSizeZ);
     (void) fprintf( log, "     gkc                                %15.7e\n",  amoebaGpu->amoebaSim.gkc );
     (void) fprintf( log, "     dielec                             %15.7e\n",  amoebaGpu->amoebaSim.dielec );
     (void) fprintf( log, "     dwater                             %15.7e\n",  amoebaGpu->amoebaSim.dwater );
@@ -1429,7 +1434,8 @@ void gpuSetAmoebaMultipoleParameters(amoebaGpuContext amoebaGpu, const std::vect
                                      const std::vector<float>& tholes, float scalingDistanceCutoff,const std::vector<float>& dampingFactors, const std::vector<float>& polarity,
                                      const std::vector< std::vector< std::vector<int> > >& multipoleParticleCovalentInfo, const std::vector<int>& covalentDegree,
                                      const std::vector<int>& minCovalentIndices,  const std::vector<int>& minCovalentPolarizationIndices, int maxCovalentRange, 
-                                     int mutualInducedIterativeMethod, int mutualInducedMaxIterations, float mutualInducedTargetEpsilon, float electricConstant ){
+                                     int mutualInducedIterativeMethod, int mutualInducedMaxIterations, float mutualInducedTargetEpsilon,
+                                     int nonbondedMethod, float cutoffDistance, float aewald, float electricConstant ){
 
 // ---------------------------------------------------------------------------------------
 
@@ -1514,6 +1520,16 @@ void gpuSetAmoebaMultipoleParameters(amoebaGpuContext amoebaGpu, const std::vect
         amoebaGpu->psMultipoleParticlesIdsAndAxisType->_pSysStream[0][ii].z   = ii;
     }
 
+    if( nonbondedMethod == 0 ){
+        amoebaGpu->multipoleNonbondedMethod = AMOEBA_NO_CUTOFF;
+    } else if( nonbondedMethod == 1 ){
+        amoebaGpu->multipoleNonbondedMethod = AMOEBA_PARTICLE_MESH_EWALD;
+    } else {
+        throw OpenMM::OpenMMException("multipoleNonbondedMethod not recognzied.\n" );
+    }
+    amoebaGpu->amoebaSim.cutoffDistance2    = cutoffDistance*cutoffDistance;
+    amoebaGpu->amoebaSim.sqrtPi             = sqrt( 3.1415926535897932384626433832795 );
+    amoebaGpu->amoebaSim.aewald             = aewald;
     amoebaGpu->amoebaSim.electric           = electricConstant;
     if( amoebaGpu->amoebaSim.dielec < 1.0e-05 ){
         amoebaGpu->amoebaSim.dielec      = 1.0f;
@@ -2432,73 +2448,6 @@ void gpuSetAmoebaWcaDispersionParameters( amoebaGpuContext amoebaGpu,
 
 }
 
-extern "C"
-void gpuSetAmoebaSASAParameters( amoebaGpuContext amoebaGpu, float probeRadius, 
-                                 const std::vector<float>& radii, const std::vector<float>& weights )
-{
-   // ---------------------------------------------------------------------------------------
-
-    static const char* methodName = "gpuSetAmoebaSASAParameters";
-    static const int maxarc       = 500;
-
-   // ---------------------------------------------------------------------------------------
-
-
-    gpuContext gpu                         = amoebaGpu->gpuContext;
-    amoebaGpu->paddedNumberOfAtoms         = amoebaGpu->gpuContext->sim.paddedNumberOfAtoms;
-    unsigned int particles                 = radii.size();
-    if( particles < 1 ){
-        (void) fprintf( stderr, "%s no particles\n", methodName );
-        return;
-    } 
-(void) fprintf( stderr, "%s radius converted Ang !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n", methodName );
-float scaleRadius = 10.0f;
-
-    amoebaGpu->amoebaSim.probeRadius       = probeRadius;
-    amoebaGpu->amoebaSim.maxarc            = maxarc;
-    amoebaGpu->psSASA_Radii                = new CUDAStream<float>(amoebaGpu->paddedNumberOfAtoms,   1, "SASARadii");
-    amoebaGpu->psSASA_Weights              = new CUDAStream<float>(amoebaGpu->paddedNumberOfAtoms,   1, "SASAWeights");
-    for (unsigned int ii = 0; ii < particles; ii++) 
-    {    
-        amoebaGpu->psSASA_Radii->_pSysStream[0][ii]     = scaleRadius*( radii[ii] + probeRadius );
-        amoebaGpu->psSASA_Weights->_pSysStream[0][ii]   = weights[ii];
-    }    
-
-    // Dummy out extra particles data
-    for (unsigned int ii = particles; ii < amoebaGpu->paddedNumberOfAtoms; ii++) 
-    {    
-        amoebaGpu->psSASA_Radii->_pSysStream[0][ii]     = 1.0f;
-        amoebaGpu->psSASA_Weights->_pSysStream[0][ii]   = 0.0f;
-    }    
-    for (unsigned int ii = 0; ii < 4; ii++) 
-    {
-        amoebaGpu->psIntWorkArray[ii] = new CUDAStream<int>(amoebaGpu->amoebaSim.maxarc*amoebaGpu->paddedNumberOfAtoms,   1, "SASAIntWorkArray");
-    }
-    amoebaGpu->psFloatWorkArray = new CUDAStream<float>(amoebaGpu->amoebaSim.maxarc*amoebaGpu->paddedNumberOfAtoms,   1, "SASAFloatWorkArray");
-    amoebaGpu->psIoListCount    = new CUDAStream<int>(amoebaGpu->paddedNumberOfAtoms,   1, "SASAIoCount");
-    amoebaGpu->psDoneAtom       = new CUDAStream<int>(amoebaGpu->paddedNumberOfAtoms,   1, "SASADoneAtom");
-
-    amoebaGpu->psSASA_Radii->Upload();
-    amoebaGpu->psSASA_Weights->Upload();
-
-#ifdef AMOEBA_DEBUG
-    if( amoebaGpu->log ){
-        unsigned int maxPrint = 32;
-        (void) fprintf( amoebaGpu->log, "%s probeRadius=%12.3f\n", methodName, probeRadius );
-        for (unsigned int ii = 0; ii < gpu->natoms; ii++) 
-        {    
-            (void) fprintf( amoebaGpu->log, "%5u %15.7e %15.7e\n", ii, radii[ii], weights[ii] );
-            if( ii == maxPrint && ii < (amoebaGpu->paddedNumberOfAtoms - maxPrint) )
-            {
-                ii = (amoebaGpu->paddedNumberOfAtoms - maxPrint);
-            }
-        } 
-        (void) fflush( amoebaGpu->log );
-    }    
-#endif
-
-}
-
 extern "C"
 void amoebaGpuShutDown(amoebaGpuContext gpu)
 {
@@ -2584,16 +2533,6 @@ void amoebaGpuShutDown(amoebaGpuContext gpu)
 
     delete gpu->psWcaDispersionRadiusEpsilon;
 
-    delete gpu->psSASA_Radii;
-    delete gpu->psSASA_Weights;
-    //delete gpu->psSASA_WeightIntWorkArray[0];
-    //delete gpu->psSASA_WeightIntWorkArray[1];
-    //delete gpu->psSASA_WeightIntWorkArray[2];
-    //delete gpu->psSASA_WeightIntWorkArray[3];
-    delete gpu->psDoneAtom;
-    delete gpu->psIoListCount;
-    delete gpu->psFloatWorkArray;
-
     delete gpu->psWorkArray_3_1; 
     delete gpu->psWorkArray_3_2; 
     delete gpu->psWorkArray_3_3; 
@@ -2648,7 +2587,6 @@ void amoebaGpuSetConstants(amoebaGpuContext amoebaGpu)
 
     gpuSetAmoebaBondOffsets( amoebaGpu );
     SetCalculateAmoebaLocalForcesSim( amoebaGpu );
-    //SetCalculateAmoebaCudaSASAForcesSim( amoebaGpu );
     SetForcesSim( amoebaGpu->gpuContext );
     SetCalculateAmoebaMultipoleForcesSim( amoebaGpu );
     SetCalculateAmoebaCudaFixedEFieldSim( amoebaGpu );
@@ -2656,12 +2594,12 @@ void amoebaGpuSetConstants(amoebaGpuContext amoebaGpu)
     SetCalculateAmoebaCudaWcaDispersionSim( amoebaGpu );
     SetCalculateAmoebaCudaMutualInducedFieldSim( amoebaGpu );
     SetCalculateAmoebaElectrostaticSim( amoebaGpu );
+    SetCalculateAmoebaRealSpaceEwaldSim( amoebaGpu );
     SetCalculateAmoebaCudaMapTorquesSim( amoebaGpu );
     SetCalculateAmoebaKirkwoodSim( amoebaGpu );
     SetCalculateAmoebaKirkwoodEDiffSim( amoebaGpu );
     SetCalculateAmoebaCudaFixedEAndGKFieldsSim( amoebaGpu );
     SetCalculateAmoebaCudaMutualInducedAndGkFieldsSim( amoebaGpu );
-    //SetCalculateAmoebaObcGbsaForces2Sim( amoebaGpu );
     SetCalculateObcGbsaForces2Sim(  amoebaGpu->gpuContext  );
 }
 

plugins/amoeba/platforms/cuda/src/kernels/amoebaCudaKernels.h

@@ -97,6 +97,10 @@ extern void SetCalculateAmoebaElectrostaticSim( amoebaGpuContext amoebaGpu );
 extern void GetCalculateAmoebaElectrostaticSim( amoebaGpuContext amoebaGpu );
 extern void cudaComputeAmoebaElectrostatic( amoebaGpuContext amoebaGpu );
 
+extern void SetCalculateAmoebaRealSpaceEwaldSim( amoebaGpuContext amoebaGpu );
+extern void GetCalculateAmoebaRealSpaceEwaldSim( amoebaGpuContext amoebaGpu );
+extern void cudaComputeAmoebaRealSpaceEwald( amoebaGpuContext amoebaGpu );
+
 extern void SetCalculateAmoebaCudaMapTorquesSim(amoebaGpuContext gpu);
 extern void GetCalculateAmoebaCudaMapTorquesSim(amoebaGpuContext gpu);
 extern void cudaComputeAmoebaMapTorques( amoebaGpuContext gpu, CUDAStream<float>* psTorque, CUDAStream<float>* psForce);
@@ -144,7 +148,7 @@ extern void kClearFields_1( amoebaGpuContext amoebaGpu );
 extern void kClearFields_3( amoebaGpuContext amoebaGpu, unsigned int numberToClear );
 extern unsigned int getThreadsPerBlock( amoebaGpuContext amoebaGpu, unsigned int sharedMemoryPerThread );
 
-extern int isNanOrInfinity( double number );
+//extern int isNanOrInfinity( double number );
 extern void trackMutualInducedIterations( amoebaGpuContext amoebaGpu, int iteration);
 
 #endif //__AMOEBA_GPU_TYPES_H__

plugins/amoeba/platforms/cuda/src/kernels/amoebaCudaTypes.h

@@ -41,6 +41,12 @@
 #include <builtin_types.h>
 #include <vector_functions.h>
 
+enum CudaAmoebaNonbondedMethod
+{
+    AMOEBA_NO_CUTOFF,
+    AMOEBA_PARTICLE_MESH_EWALD
+};
+
 struct cudaAmoebaGmxSimulation {
     // Constants
 
@@ -118,6 +124,9 @@ struct cudaAmoebaGmxSimulation {
 
     unsigned int numberOfAtoms;                     // number of atoms
     unsigned int paddedNumberOfAtoms;               // padded number of atoms
+    float cutoffDistance2;                          // cutoff distance squared for PME
+    float sqrtPi;                                   // sqrt(PI)
+    float aewald;                                   // aewald parameter
     float scalingDistanceCutoff;                    // scaling cutoff
     float2*         pDampingFactorAndThole;         // Thole & damping factors
 
@@ -168,89 +177,6 @@ struct cudaAmoebaGmxSimulation {
     float fd;        // electric * 2.0f * (1.0f-dwater)/(1.0f+2.0f*dwater);
     float fq;        // electric * 3.0f * (1.0f-dwater)/(2.0f+3.0f*dwater);
 
-    // SASA probe radius
-    float probeRadius; 
-    int maxarc; 
-
-//    texture<float4,2,cudaReadModeElementType> texTorTorGrid;
-
-#if 0
-    unsigned int    dihedrals;                      // Number of dihedrals
-    int4*           pDihedralID1;                   // Dihedral IDs
-    int4*           pDihedralID2;                   // Dihedral output buffer IDs
-    float4*         pDihedralParameter;             // Dihedral parameters
-    unsigned int    rb_dihedrals;                   // Number of Ryckaert Bellemans dihedrals
-    int4*           pRbDihedralID1;                 // Ryckaert Bellemans Dihedral IDs
-    int4*           pRbDihedralID2;                 // Ryckaert Bellemans Dihedral output buffer IDs
-    float4*         pRbDihedralParameter1;          // Ryckaert Bellemans Dihedral parameters
-    float2*         pRbDihedralParameter2;          // Ryckaert Bellemans Dihedral parameters
-    unsigned int    LJ14s;                          // Number of Lennard Jones 1-4 interactions
-    int4*           pLJ14ID;                        // Lennard Jones 1-4 atom and output buffer IDs
-    float4*         pLJ14Parameter;                 // Lennard Jones 1-4 parameters
-    float           inverseTotalMass;               // Used in linear momentum removal
-    unsigned int    ShakeConstraints;               // Total number of Shake constraints
-    unsigned int    settleConstraints;              // Total number of Settle constraints
-    unsigned int    ccmaConstraints;                // Total number of CCMA constraints.
-    unsigned int    rigidClusters;                  // Total number of rigid clusters
-    unsigned int    maxRigidClusterSize;            // The size of the largest rigid cluster
-    unsigned int    clusterShakeBlockSize;          // The number of threads to process each rigid cluster
-    unsigned int    NonShakeConstraints;            // Total number of NonShake atoms
-    unsigned int    maxShakeIterations;             // Maximum shake iterations
-    unsigned int    degreesOfFreedom;               // Number of degrees of freedom in system
-    float           shakeTolerance;                 // Shake tolerance
-    float           InvMassJ;                       // Shake inverse mass for hydrogens
-    int*            pNonShakeID;                    // Not Shaking atoms
-    int4*           pShakeID;                       // Shake atoms and phase
-    float4*         pShakeParameter;                // Shake parameters
-    int4*           pSettleID;                      // Settle atoms
-    float2*         pSettleParameter;               // Settle parameters
-    unsigned int*   pExclusion;                     // Nonbond exclusion data
-    unsigned int*   pExclusionIndex;                // Index of exclusion data for each work unit
-    unsigned int    dihedral_offset;                // Offset to end of dihedrals
-    unsigned int    rb_dihedral_offset;             // Offset to end of Ryckaert Bellemans dihedrals
-    unsigned int    LJ14_offset;                    // Offset to end of Lennard Jones 1-4 parameters
-    int*            pAtomIndex;                     // The original index of each atom
-    float4*         pGridBoundingBox;               // The size of each grid cell
-    float4*         pGridCenter;                    // The center of each grid cell
-    int2*           pCcmaAtoms;                     // The atoms connected by each CCMA constraint
-    float4*         pCcmaDistance;                  // The displacement vector (x, y, z) and constraint distance (w) for each CCMA constraint
-    float*          pCcmaDelta1;                    // Workspace for CCMA
-    float*          pCcmaDelta2;                    // Workspace for CCMA
-    int*            pCcmaAtomConstraints;           // The indices of constraints involving each atom
-    int*            pCcmaNumAtomConstraints;        // The number of constraints involving each atom
-    short*          pSyncCounter;                   // Used for global thread synchronization
-    unsigned int*   pRequiredIterations;            // Used by CCMA to communicate whether iteration has converged
-    float*          pCcmaReducedMass;               // The reduced mass for each CCMA constraint
-    unsigned int*   pConstraintMatrixColumn;        // The column of each element in the constraint matrix.
-    float*          pConstraintMatrixValue;         // The value of each element in the constraint matrix.
-
-    // Mutable stuff
-    float4*         pPosq;                          // Pointer to atom positions and charges
-    float4*         pPosqP;                         // Pointer to mid-integration atom positions
-    float4*         pOldPosq;                       // Pointer to old atom positions
-    float4*         pVelm4;                         // Pointer to atom velocity and inverse mass
-    float4*         pvVector4;                      // Pointer to atom v Vector
-    float4*         pxVector4;                      // Pointer to atom x Vector
-    float*          pBornForce;                     // Pointer to Born force data
-    float*	    pBornSum;                       // Pointer to Born Radii calculation output buffers
-    float*	    pBornRadii;                     // Pointer to Born Radii
-    float*          pObcChain;                      // Pointer to OBC chain data
-    float4*         pLinearMomentum;                // Pointer to linear momentum
-    
-    // Random numbers
-    float4*         pRandom4a;                      // Pointer to first set of 4 random numbers
-    float4*         pRandom4b;                      // Pointer to second set of 4 random numbers
-    float2*         pRandom2a;                      // Pointer to first set of 2 random numbers
-    float2*         pRandom2b;                      // Pointer to second set of 2 random numbers
-    uint4*          pRandomSeed;                    // Pointer to random seeds
-    int*            pRandomPosition;                // Pointer to random number positions
-    unsigned int    randoms;                        // Number of randoms
-    unsigned int    totalRandoms;                   // Number of randoms plus overflow.
-    unsigned int    totalRandomsTimesTwo;           // Used for generating randoms
-    unsigned int    randomIterations;               // Number of iterations before regenerating randoms
-    unsigned int    randomFrames;                   // Number of frames of random numbers
-#endif
-
 };
 
 #endif

plugins/amoeba/platforms/cuda/src/kernels/amoebaGpuTypes.h

@@ -152,6 +152,10 @@ struct _amoebaGpuContext {
     CUDAStream<float>*  psE_Field;
     CUDAStream<float>*  psE_FieldPolar;
 
+    int multipoleNonbondedMethod;
+    double cutoffDistance;
+    double aewald;
+
     // mutual induced field
 
     int mutualInducedIterativeMethod;
@@ -215,17 +219,6 @@ struct _amoebaGpuContext {
     // Wca dispersion fields
 
     CUDAStream<float2>*  psWcaDispersionRadiusEpsilon;
-
-    // SASA fields
-
-    CUDAStream<float>*  psSASA_Radii;
-    CUDAStream<float>*  psSASA_Weights; 
-    CUDAStream<int>*    psIntWorkArray[4]; 
-    CUDAStream<int>*    psDoneAtom; 
-    CUDAStream<int>*    psIoListCount; 
-    CUDAStream<float>*  psFloatWorkArray; 
-    float  sasaArea; 
-
 };
 
 typedef struct _amoebaGpuContext *amoebaGpuContext;
@@ -303,7 +296,8 @@ void gpuSetAmoebaMultipoleParameters(amoebaGpuContext amoebaGpu, const std::vect
                                      const std::vector<float>& tholes, float scalingDistanceCutoff,const std::vector<float>& dampingFactors, const std::vector<float>& polarity,
                                      const std::vector< std::vector< std::vector<int> > >& multipoleAtomCovalentInfo, const std::vector<int>& covalentDegree,
                                      const std::vector<int>& minCovalentIndices,  const std::vector<int>& minCovalentPolarizationIndices, int maxCovalentRange,
-                                     int mutualInducedIterationMethod, int mutualInducedMaxIterations, float mutualInducedTargetEpsilon, float electricConstant );
+                                     int mutualInducedIterationMethod, int mutualInducedMaxIterations, float mutualInducedTargetEpsilon,
+                                     int nonbondedMethod, float cutoffDistance, float aewald, float electricConstant );
 
 
 extern "C"
@@ -332,9 +326,6 @@ void gpuSetAmoebaWcaDispersionParameters( amoebaGpuContext amoebaGpu,
                                 const float epso, const float epsh, const float rmino, const float rminh,
                                 const float awater, const float shctd, const float dispoff );
  
-extern "C"
-void gpuSetAmoebaSASAParameters( amoebaGpuContext amoebaGpu , float probeRadius, const std::vector<float>& radii, const std::vector<float>& weights );
-
 extern "C"
 void amoebaGpuSetConstants(amoebaGpuContext gpu);
 

plugins/amoeba/platforms/cuda/src/kernels/kCalculateAmoebaRotateFrame.cu

@@ -382,7 +382,11 @@ void kCalculateAmoebaMultipoleForces(amoebaGpuContext amoebaGpu, bool hasAmoebaG
 
     // calculate electrostatic forces
 
+    if( amoebaGpu->multipoleNonbondedMethod == AMOEBA_NO_CUTOFF ){
         cudaComputeAmoebaElectrostatic( amoebaGpu );
+    } else {
+        cudaComputeAmoebaRealSpaceEwald( amoebaGpu );
+    }
 
     // map torques to forces
 

plugins/amoeba/platforms/cuda/tests/AmoebaTinkerParameterFile.cpp

@@ -40,6 +40,7 @@
 #include <sys/time.h>
 #endif
 
+extern int isNanOrInfinity( double number );
 
 using namespace std;
 
@@ -1937,6 +1938,7 @@ static void readAmoebaMultipoleCovalent( FILE* filePtr, AmoebaMultipoleForce* mu
     Read Amoeba multipole parameters
 
     @param filePtr              file pointer to parameter file
+    @param version              version id for file
     @param forceMap             map of forces to be included
     @param tokens               array of strings from first line of parameter file for this block of parameters
     @param system               System reference
@@ -1949,7 +1951,7 @@ static void readAmoebaMultipoleCovalent( FILE* filePtr, AmoebaMultipoleForce* mu
 
     --------------------------------------------------------------------------------------- */
 
-static int readAmoebaMultipoleParameters( FILE* filePtr, MapStringInt& forceMap, const StringVector& tokens,
+static int readAmoebaMultipoleParameters( FILE* filePtr, int version, MapStringInt& forceMap, const StringVector& tokens,
                                            System& system, int useOpenMMUnits, MapStringVectorOfVectors& supplementary,
                                            MapStringString& inputArgumentMap, int* lineCount, FILE* log ){
 
@@ -1984,8 +1986,27 @@ static int readAmoebaMultipoleParameters( FILE* filePtr, MapStringInt& forceMap,
     // load in parameters
  
     int numberOfMultipoles            = atoi( tokens[1].c_str() );
+    int usePme                        = 0;
+    double aewald                     = 0.0;
+    double cutoffDistance             = 0.0;
+
+    // usePme, aewald, cutoffDistance added w/ Version 1
+
+    if( version > 0 ){
+        usePme                        = atoi( tokens[2].c_str() );
+        aewald                        = atof( tokens[3].c_str() );
+        cutoffDistance                = atof( tokens[4].c_str() );
+    }
+    if( usePme ){
+        multipoleForce->setNonbondedMethod( AmoebaMultipoleForce::PME );
+    } else {
+        multipoleForce->setNonbondedMethod( AmoebaMultipoleForce::NoCutoff );
+    }
+    multipoleForce->setAEwald( aewald );
+    multipoleForce->setCutoffDistance( cutoffDistance );
     if( log ){
-        (void) fprintf( log, "%s number of MultipoleParameter terms=%d\n", methodName.c_str(), numberOfMultipoles );
+        (void) fprintf( log, "%s number of MultipoleParameter terms=%d usePme=%d aewald=%15.7e cutoffDistance=%12.4f\n",
+                        methodName.c_str(), numberOfMultipoles, usePme, aewald, cutoffDistance );
         (void) fflush( log );
     }
     for( int ii = 0; ii < numberOfMultipoles; ii++ ){
@@ -3380,7 +3401,7 @@ Integrator* readAmoebaParameterFile( const std::string& inputParameterFile, MapS
     }
 
     int lineCount                  = 0;
-    std::string version            = "0.1"; 
+    int version                    = 0; 
     int isNotEof                   = 1;
     Integrator* returnIntegrator   = NULL;
 
@@ -3404,9 +3425,9 @@ Integrator* readAmoebaParameterFile( const std::string& inputParameterFile, MapS
    
             if( field == "Version" ){
                 if( tokens.size() > 1 ){
-                   version = tokens[1];
+                   version = atoi( tokens[1].c_str() );
                    if( log ){
-                       (void) fprintf( log, "Version=<%s> at line=%d\n", version.c_str(), lineCount );
+                       (void) fprintf( log, "Version=%d at line=%d\n", version, lineCount );
                    }
                 }
             } else if( field == "Masses" ){
@@ -3522,13 +3543,28 @@ Integrator* readAmoebaParameterFile( const std::string& inputParameterFile, MapS
             // AmoebaMultipole
   
             } else if( field == "AmoebaMultipoleParameters" ){
-                readAmoebaMultipoleParameters( filePtr, forceMap, tokens, system, useOpenMMUnits, supplementary, inputArgumentMap, &lineCount, log );
-            } else if( field == "AmoebaMultipoleForce" ){
+                readAmoebaMultipoleParameters( filePtr, version, forceMap, tokens, system, useOpenMMUnits, supplementary, inputArgumentMap, &lineCount, log );
+            } else if( field == "AmoebaMultipoleForce" || field == "AmoebaPmeForce" ){
                 readVec3( filePtr, tokens, forces[AMOEBA_MULTIPOLE_FORCE], &lineCount, field, log );
-            } else if( field == "AmoebaMultipoleEnergy" ){
+            } else if( field == "AmoebaMultipoleEnergy" || field == "AmoebaPmeEnergy" ){
                if( tokens.size() > 1 ){
                  potentialEnergy[AMOEBA_MULTIPOLE_FORCE] = atof( tokens[1].c_str() ); 
                }
+            } else if( field == "AmoebaRealPmeForce"                   || 
+                       field == "AmoebaKSpacePmeForce"                 ||
+                       field == "AmoebaSelfPmeForce"                   ){
+                std::vector< std::vector<double> > vectorOfDoubleVectors;
+                readVectorOfDoubleVectors( filePtr, tokens, vectorOfDoubleVectors, &lineCount, field, log );
+                supplementary[field] = vectorOfDoubleVectors;
+            } else if( field == "AmoebaRealPmeEnergy"                  || 
+                       field == "AmoebaKSpacePmeEnergy"                ||
+                       field == "AmoebaSelfPmeEnergy"                  ){
+                double value = atof( tokens[1].c_str() );
+                std::vector< std::vector<double> > vectorOfDoubleVectors;
+                std::vector<double> doubleVectors;
+                doubleVectors.push_back( value );
+                vectorOfDoubleVectors.push_back( doubleVectors ); 
+                supplementary[field] =  vectorOfDoubleVectors;
 
             // Amoeba GK
 
@@ -3677,7 +3713,6 @@ void initializeForceMap( MapStringInt& forceMap, int initialValue ){
      forceMap[AMOEBA_GK_FORCE]                       = initialValue;
      forceMap[AMOEBA_VDW_FORCE]                      = initialValue;
      forceMap[AMOEBA_WCA_DISPERSION_FORCE]           = initialValue;
-     forceMap[AMOEBA_SASA_FORCE]                     = 0;
  
      return;
 
@@ -5830,8 +5865,7 @@ Double "simulationTimeBetweenReportsRatio"       simulationTimeBetweenReportsRat
                    key == AMOEBA_MULTIPOLE_FORCE                  ||
                    key == AMOEBA_GK_FORCE                         ||
                    key == AMOEBA_VDW_FORCE                        ||
-                   key == AMOEBA_WCA_DISPERSION_FORCE             ||
-                   key == AMOEBA_SASA_FORCE                       ){
+                   key == AMOEBA_WCA_DISPERSION_FORCE             ){
             forceMap[key]                              = atoi( value.c_str() );
         } else {
             inputArgumentMap[key]                      = value;

plugins/amoeba/platforms/cuda/tests/AmoebaTinkerParameterFile.h

@@ -77,7 +77,6 @@ static std::string AMOEBA_GK_FORCE                                    = "AmoebaG
 static std::string AMOEBA_GK_CAVITY_FORCE                             = "AmoebaGkAndCavity";
 static std::string AMOEBA_VDW_FORCE                                   = "AmoebaVdw";
 static std::string AMOEBA_WCA_DISPERSION_FORCE                        = "AmoebaWcaDispersion";
-static std::string AMOEBA_SASA_FORCE                                  = "AmoebaSASA";
 static std::string ALL_FORCES                                         = "AllForces";
 
 static std::string AMOEBA_MULTIPOLE_ROTATION_MATRICES                 = "AmoebaMultipoleRotationMatrices";