Mods for clean Windows compile

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

@@ -200,6 +200,7 @@ public:
            buffer << "TorsionInfo::copyTorsionParameter: input torsionParameter index(=" << index << ") is not in range [0," << maxTorsions << ")!";
            throw OpenMMException( buffer.str() );
         }
+        return 0;
     }
 };
 

plugins/amoeba/openmmapi/include/openmm/internal/AmoebaTorsionTorsionForceImpl.h

@@ -61,7 +61,8 @@ public:
     }
     std::vector<std::string> getKernelNames();
 
-    static void reorderGrid( const TorsionTorsionGrid& grid, TorsionTorsionGrid& reorderedGrid );
+    OPENMM_EXPORT static void reorderGrid( const TorsionTorsionGrid& grid, TorsionTorsionGrid& reorderedGrid );
+
 private:
     AmoebaTorsionTorsionForce& owner;
     Kernel kernel;

plugins/amoeba/openmmapi/src/AmoebaMultipoleForceImpl.cpp

@@ -54,7 +54,7 @@ void AmoebaMultipoleForceImpl::initialize(ContextImpl& context) {
 
     for( int ii = 0; ii < system.getNumParticles(); ii++ ){
 
-        int index, axisType, multipoleAtomZ, multipoleAtomX, multipoleAtomY;
+        int axisType, multipoleAtomZ, multipoleAtomX, multipoleAtomY;
         double charge, thole, dampingFactor, polarity ;
         std::vector<double> molecularDipole;
         std::vector<double> molecularQuadrupole;

plugins/amoeba/openmmapi/src/AmoebaTorsionTorsionForce.cpp

@@ -73,7 +73,7 @@ const TorsionTorsionGrid& AmoebaTorsionTorsionForce::getTorsionTorsionGrid(int i
 }
 
 void AmoebaTorsionTorsionForce::setTorsionTorsionGrid(int index, const TorsionTorsionGrid& grid ) {
-   if( index >= torsionTorsionGrids.size() ){
+   if( index >= static_cast<int>(torsionTorsionGrids.size()) ){
       torsionTorsionGrids.resize( index + 1);
    }
    torsionTorsionGrids[index] = grid;

plugins/amoeba/openmmapi/src/AmoebaVdwForce.cpp

@@ -85,7 +85,7 @@ void AmoebaVdwForce::setParticleExclusions( int particleIndex, const std::vector
    if( exclusions.size() < parameters.size() ){
        exclusions.resize( parameters.size() );
    }
-   if(  exclusions.size() < particleIndex ){
+   if(  static_cast<int>(exclusions.size()) < particleIndex ){
        exclusions.resize( particleIndex + 10 );
    }
    for( unsigned int ii = 0; ii < inputExclusions.size(); ii++ ){
@@ -95,7 +95,7 @@ void AmoebaVdwForce::setParticleExclusions( int particleIndex, const std::vector
 
 void AmoebaVdwForce::getParticleExclusions( int particleIndex, std::vector< int >& outputExclusions ) const {
 
-   if( particleIndex < exclusions.size() ){
+   if( particleIndex < static_cast<int>(exclusions.size()) ){
        outputExclusions.resize( exclusions[particleIndex].size() );
        for( unsigned int ii = 0; ii < exclusions[particleIndex].size(); ii++ ){
            outputExclusions[ii] = exclusions[particleIndex][ii];

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

@@ -1037,7 +1037,7 @@ void CudaCalcAmoebaMultipoleForceKernel::initialize(const System& system, const
         data.cudaPlatformData.nonbondedMethod = PARTICLE_MESH_EWALD;
         amoebaGpuContext amoebaGpu            = data.getAmoebaGpu();
         gpuContext gpu                        = amoebaGpu->gpuContext;
-        gpu->sim.nonbondedCutoffSqr           = force.getCutoffDistance()*force.getCutoffDistance();
+        gpu->sim.nonbondedCutoffSqr           = static_cast<float>(force.getCutoffDistance()*force.getCutoffDistance());
         gpu->sim.nonbondedMethod              = PARTICLE_MESH_EWALD;
     }
     data.getAmoebaGpu()->gpuContext->forces.push_back(new ForceInfo(force));

plugins/amoeba/platforms/reference/src/SimTKReference/AmoebaReferenceHarmonicAngleForce.cpp

@@ -195,7 +195,7 @@ RealOpenMM AmoebaReferenceHarmonicAngleForce::calculateForceAndEnergy( int numAn
                                                                        RealOpenMM angleSextic,
                                                                        vector<RealVec>& forceData) const {
     RealOpenMM energy      = 0.0; 
-    for (unsigned int ii = 0; ii < numAngles; ii++) {
+    for (unsigned int ii = 0; ii < static_cast<unsigned int>(numAngles); ii++) {
         int particle1Index      = particle1[ii];
         int particle2Index      = particle2[ii];
         int particle3Index      = particle3[ii];

plugins/amoeba/platforms/reference/src/SimTKReference/AmoebaReferenceHarmonicInPlaneAngleForce.cpp

@@ -258,7 +258,7 @@ RealOpenMM AmoebaReferenceHarmonicInPlaneAngleForce::calculateForceAndEnergy( in
                                                                        RealOpenMM angleSextic,
                                                                        vector<RealVec>& forceData) const {
     RealOpenMM energy      = 0.0; 
-    for (unsigned int ii = 0; ii < numAngles; ii++) {
+    for (unsigned int ii = 0; ii < static_cast<unsigned int>(numAngles); ii++) {
         int particle1Index      = particle1[ii];
         int particle2Index      = particle2[ii];
         int particle3Index      = particle3[ii];

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

@@ -1594,6 +1594,7 @@ void AmoebaReferenceMultipoleForce::mapTorqueToForce( const MultipoleParticleDat
     RealOpenMM vector[LastVectorIndex][3];
     RealOpenMM angles[LastVectorIndex][2];
 
+    static const RealOpenMM zero        = 0.0;
     static const RealOpenMM one         = 1.0;
     static const RealOpenMM two         = 2.0;
  
@@ -1629,22 +1630,22 @@ void AmoebaReferenceMultipoleForce::mapTorqueToForce( const MultipoleParticleDat
     norms[VW]                     = AmoebaReferenceForce::normalizeVector3( vector[VW] );
 
     angles[UV][0]                 = AmoebaReferenceForce::getDotProduct3( vector[U], vector[V] );
-    angles[UV][1]                 = sqrtf( 1.0f - angles[UV][0]*angles[UV][0]);
+    angles[UV][1]                 = SQRT( one - angles[UV][0]*angles[UV][0]);
     
     angles[UW][0]                 = AmoebaReferenceForce::getDotProduct3( vector[U], vector[W] );
-    angles[UW][1]                 = sqrtf( 1.0f - angles[UW][0]*angles[UW][0]);
+    angles[UW][1]                 = SQRT( one - angles[UW][0]*angles[UW][0]);
 
     angles[VW][0]                 = AmoebaReferenceForce::getDotProduct3( vector[V], vector[W] );
-    angles[VW][1]                 = sqrtf( 1.0f - angles[VW][0]*angles[VW][0]);
+    angles[VW][1]                 = SQRT( one - angles[VW][0]*angles[VW][0]);
 
-    float dphi[3];
+    RealOpenMM dphi[3];
     dphi[U]                       = AmoebaReferenceForce::getDotProduct3( vector[U], torque );
     dphi[V]                       = AmoebaReferenceForce::getDotProduct3( vector[V], torque );
     dphi[W]                       = AmoebaReferenceForce::getDotProduct3( vector[W], torque );
 
-    dphi[U]                      *= -1.0f;
-    dphi[V]                      *= -1.0f;
-    dphi[W]                      *= -1.0f;
+    dphi[U]                      *= -one;
+    dphi[V]                      *= -one;
+    dphi[W]                      *= -one;
 
     // branch based on axis type
  
@@ -1653,20 +1654,21 @@ void AmoebaReferenceMultipoleForce::mapTorqueToForce( const MultipoleParticleDat
 
     if( axisType == AmoebaMultipoleForce::ZThenX || axisType == AmoebaMultipoleForce::Bisector ){
  
-        float factor1;
-        float factor2;
-        float factor3;
-        float factor4;
+        RealOpenMM factor1;
+        RealOpenMM factor2;
+        RealOpenMM factor3;
+        RealOpenMM factor4;
+        RealOpenMM half = 0.5;
     
         factor1                 =  dphi[V]/(norms[U]*angles[UV][1]);
         factor2                 =  dphi[W]/(norms[U]);
         factor3                 = -dphi[U]/(norms[V]*angles[UV][1]);
     
         if( axisType == AmoebaMultipoleForce::Bisector ){ 
-            factor2    *= 0.5f;
-            factor4     = 0.5f*dphi[W]/(norms[V]);
+            factor2    *= half;
+            factor4     = half*dphi[W]/(norms[V]);
         } else {
-            factor4     = 0.0f;
+            factor4     = zero;
         }
  
         for( int ii = 0; ii < 3; ii++ ){
@@ -1701,16 +1703,16 @@ void AmoebaReferenceMultipoleForce::mapTorqueToForce( const MultipoleParticleDat
         norms[WS]                 = AmoebaReferenceForce::normalizeVector3( vector[WS] );
 
         angles[UR][0]             = AmoebaReferenceForce::getDotProduct3( vector[U], vector[R] );
-        angles[UR][1]             = sqrtf( 1.0f - angles[UR][0]*angles[UR][0]);
+        angles[UR][1]             = SQRT( one - angles[UR][0]*angles[UR][0]);
 
         angles[US][0]             = AmoebaReferenceForce::getDotProduct3( vector[U], vector[S] );
-        angles[US][1]             = sqrtf( 1.0f - angles[US][0]*angles[US][0]);
+        angles[US][1]             = SQRT( one - angles[US][0]*angles[US][0]);
 
         angles[VS][0]             = AmoebaReferenceForce::getDotProduct3( vector[V], vector[S] );
-        angles[VS][1]             = sqrtf( 1.0f - angles[VS][0]*angles[VS][0]);
+        angles[VS][1]             = SQRT( one - angles[VS][0]*angles[VS][0]);
 
         angles[WS][0]             = AmoebaReferenceForce::getDotProduct3( vector[W], vector[S] );
-        angles[WS][1]             = sqrtf( 1.0f - angles[WS][0]*angles[WS][0]);
+        angles[WS][1]             = SQRT( one - angles[WS][0]*angles[WS][0]);
  
         RealOpenMM t1[3];
         RealOpenMM t2[3];
@@ -1726,13 +1728,13 @@ void AmoebaReferenceMultipoleForce::mapTorqueToForce( const MultipoleParticleDat
               notUsed             = AmoebaReferenceForce::normalizeVector3( t2 );
 
         RealOpenMM ut1cos         = AmoebaReferenceForce::getDotProduct3( vector[U], t1 );
-        RealOpenMM ut1sin         = sqrtf( 1.0f - ut1cos*ut1cos);
+        RealOpenMM ut1sin         = SQRT( one - ut1cos*ut1cos);
 
         RealOpenMM ut2cos         = AmoebaReferenceForce::getDotProduct3( vector[U], t2 );
-        RealOpenMM ut2sin         = sqrtf( 1.0f - ut2cos*ut2cos);
+        RealOpenMM ut2sin         = SQRT( one - ut2cos*ut2cos);
 
-        RealOpenMM dphiR          = -1.0f*AmoebaReferenceForce::getDotProduct3( vector[R], torque );
-        RealOpenMM dphiS          = -1.0f*AmoebaReferenceForce::getDotProduct3( vector[S], torque );
+        RealOpenMM dphiR          = -one*AmoebaReferenceForce::getDotProduct3( vector[R], torque );
+        RealOpenMM dphiS          = -one*AmoebaReferenceForce::getDotProduct3( vector[S], torque );
 
         RealOpenMM factor1        = dphiR/(norms[U]*angles[UR][1]);
         RealOpenMM factor2        = dphiS/(norms[U]);

plugins/freeEnergy/platforms/reference/src/gbsa/CpuGBVISoftcore.cpp

@@ -793,7 +793,7 @@ void CpuGBVISoftcore::printGbvi( const std::vector<OpenMM::RealVec>& atomCoordin
                     gbviParameters->getBornRadiusScalingSoftcoreMethod(), GBVISoftcoreParameters::QuinticSpline );
     (void) fprintf( log, "    preFactor      %15.7e)\n", preFactor );
  
-    for( int atomI = 0; atomI < numberOfAtoms; atomI++ ){
+    for( unsigned int atomI = 0; atomI < numberOfAtoms; atomI++ ){
         (void) fprintf( log, "%6d r=%15.7e rSc=%15.7e swd=%15.7e lmda=%4.2f tau*gam=%15.7e q=%15.7e", atomI,
                         atomicRadii[atomI],    
                         scaledRadii[atomI],