Elimininated obsolete SimTKOpenMMCommon files

platforms/reference/src/SimTKReference/ReferenceLJCoulomb14.cpp

@@ -25,7 +25,6 @@
 #include <string.h>
 #include <sstream>
 
-#include "SimTKOpenMMCommon.h"
 #include "SimTKOpenMMUtilities.h"
 #include "ReferenceLJCoulomb14.h"
 #include "ReferenceForce.h"

platforms/reference/src/SimTKReference/ReferenceLJCoulombIxn.cpp

@@ -27,7 +27,6 @@
 #include <complex>
 #include <algorithm>
 
-#include "SimTKOpenMMCommon.h"
 #include "SimTKOpenMMUtilities.h"
 #include "ReferenceLJCoulombIxn.h"
 #include "ReferenceForce.h"

platforms/reference/src/SimTKReference/ReferenceLincsAlgorithm.cpp

@@ -24,7 +24,6 @@
 #include <string.h>
 #include <sstream>
 
-#include "SimTKOpenMMCommon.h"
 #include "SimTKOpenMMUtilities.h"
 #include "ReferenceLincsAlgorithm.h"
 #include "ReferenceDynamics.h"
@@ -213,12 +212,9 @@ void ReferenceLincsAlgorithm::updateAtomPositions(int numberOfAtoms, vector<Real
    @param atomCoordinatesP atom coordinates prime
    @param inverseMasses    1/mass
 
-   @return SimTKOpenMMCommon::DefaultReturn if converge; else
-    return SimTKOpenMMCommon::ErrorReturn
-
    --------------------------------------------------------------------------------------- */
 
-int ReferenceLincsAlgorithm::apply(int numberOfAtoms, vector<RealVec>& atomCoordinates,
+void ReferenceLincsAlgorithm::apply(int numberOfAtoms, vector<RealVec>& atomCoordinates,
                                          vector<RealVec>& atomCoordinatesP,
                                          vector<RealOpenMM>& inverseMasses) {
 
@@ -233,7 +229,7 @@ int ReferenceLincsAlgorithm::apply(int numberOfAtoms, vector<RealVec>& atomCoord
    // ---------------------------------------------------------------------------------------
 
    if (_numberOfConstraints == 0)
-       return SimTKOpenMMCommon::DefaultReturn;
+       return;
 
    if (!_hasInitialized)
        initialize(numberOfAtoms, inverseMasses);
@@ -287,9 +283,6 @@ int ReferenceLincsAlgorithm::apply(int numberOfAtoms, vector<RealVec>& atomCoord
    }
    solveMatrix();
    updateAtomPositions(numberOfAtoms, atomCoordinatesP, inverseMasses);
-
-   return SimTKOpenMMCommon::DefaultReturn;
-
 }
 
 /**---------------------------------------------------------------------------------------
@@ -301,12 +294,9 @@ int ReferenceLincsAlgorithm::apply(int numberOfAtoms, vector<RealVec>& atomCoord
    @param velocities       atom velocities
    @param inverseMasses    1/mass
 
-   @return SimTKOpenMMCommon::DefaultReturn if converge; else
-    return SimTKOpenMMCommon::ErrorReturn
-
    --------------------------------------------------------------------------------------- */
 
-int ReferenceLincsAlgorithm::applyToVelocities(int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates,
+void ReferenceLincsAlgorithm::applyToVelocities(int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates,
                std::vector<OpenMM::RealVec>& velocities, std::vector<RealOpenMM>& inverseMasses) {
     throw OpenMM::OpenMMException("applyToVelocities is not implemented");
 }

platforms/reference/src/SimTKReference/ReferencePairIxn.cpp

@@ -25,7 +25,6 @@
 #include <string.h>
 #include <sstream>
 
-#include "SimTKOpenMMCommon.h"
 #include "SimTKOpenMMUtilities.h"
 #include "ReferenceForce.h"
 #include "ReferencePairIxn.h"

platforms/reference/src/SimTKReference/ReferenceProperDihedralBond.cpp

@@ -25,7 +25,6 @@
 #include <string.h>
 #include <sstream>
 
-#include "SimTKOpenMMCommon.h"
 #include "SimTKOpenMMUtilities.h"
 #include "ReferenceProperDihedralBond.h"
 #include "ReferenceForce.h"

platforms/reference/src/SimTKReference/ReferenceRbDihedralBond.cpp

@@ -25,7 +25,6 @@
 #include <string.h>
 #include <sstream>
 
-#include "SimTKOpenMMCommon.h"
 #include "SimTKOpenMMUtilities.h"
 #include "ReferenceRbDihedralBond.h"
 #include "ReferenceForce.h"

platforms/reference/src/SimTKReference/ReferenceStochasticDynamics.cpp

@@ -25,7 +25,6 @@
 #include <cstring>
 #include <sstream>
 
-#include "SimTKOpenMMCommon.h"
 #include "SimTKOpenMMUtilities.h"
 #include "ReferenceStochasticDynamics.h"
 #include "ReferenceVirtualSites.h"

platforms/reference/src/SimTKReference/ReferenceVariableStochasticDynamics.cpp

@@ -26,7 +26,6 @@
 #include <sstream>
 #include <algorithm>
 
-#include "SimTKOpenMMCommon.h"
 #include "SimTKOpenMMUtilities.h"
 #include "ReferenceVariableStochasticDynamics.h"
 #include "ReferenceVirtualSites.h"

platforms/reference/src/SimTKReference/ReferenceVariableVerletDynamics.cpp

@@ -26,7 +26,6 @@
 #include <sstream>
 #include <algorithm>
 
-#include "SimTKOpenMMCommon.h"
 #include "SimTKOpenMMUtilities.h"
 #include "ReferenceVariableVerletDynamics.h"
 #include "ReferenceVirtualSites.h"

platforms/reference/src/SimTKReference/ReferenceVerletDynamics.cpp

@@ -25,7 +25,6 @@
 #include <cstring>
 #include <sstream>
 
-#include "SimTKOpenMMCommon.h"
 #include "SimTKOpenMMUtilities.h"
 #include "ReferenceVerletDynamics.h"
 #include "ReferenceVirtualSites.h"

platforms/reference/src/SimTKUtilities/SimTKOpenMMCommon.cpp

-
-/* Portions copyright (c) 2006 Stanford University and Simbios.
- * Contributors: Pande Group
- *
- * 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 "SimTKOpenMMCommon.h"
-
-using namespace OpenMM;
-
-// static settings
-
-// initialization of static data members
-
-const std::string SimTKOpenMMCommon::NotSet                  = std::string("NotSet");
-const std::string SimTKOpenMMCommon::Comment                 = std::string("#");
-const std::string SimTKOpenMMCommon::Tab                     = std::string("\t"); 
-
-const int SimTKOpenMMCommon::DefaultReturn                   = 0;
-const int SimTKOpenMMCommon::ErrorReturn                     = -1;
-const RealOpenMM SimTKOpenMMCommon::BigCutoffValue           = 1.0e+05;
-

platforms/reference/src/gbsa/CpuGBVI.cpp

@@ -26,7 +26,6 @@
 #include <sstream>
 #include <stdio.h>
 
-#include "SimTKOpenMMCommon.h"
 #include "ReferenceForce.h"
 #include "CpuGBVI.h"
 
@@ -86,7 +85,7 @@ void CpuGBVI::setGBVIParameters(GBVIParameters* gbviParameters) {
 
     --------------------------------------------------------------------------------------- */
 
-RealOpenMMVector& CpuGBVI::getSwitchDeriviative() {
+vector<RealOpenMM>& CpuGBVI::getSwitchDeriviative() {
     return _switchDeriviative;
 }
 
@@ -203,7 +202,7 @@ void CpuGBVI::computeBornRadiiUsingQuinticSpline(RealOpenMM atomicRadius3, RealO
 
     --------------------------------------------------------------------------------------- */
 
-void CpuGBVI::computeBornRadii(const vector<RealVec>& atomCoordinates, RealOpenMMVector& bornRadii) {
+void CpuGBVI::computeBornRadii(const vector<RealVec>& atomCoordinates, vector<RealOpenMM>& bornRadii) {
 
     // ---------------------------------------------------------------------------------------
 
@@ -218,10 +217,10 @@ void CpuGBVI::computeBornRadii(const vector<RealVec>& atomCoordinates, RealOpenM
 
     GBVIParameters* gbviParameters        = getGBVIParameters();
     int numberOfAtoms                     = gbviParameters->getNumberOfAtoms();
-    const RealOpenMMVector& atomicRadii   = gbviParameters->getAtomicRadii();
-    const RealOpenMMVector& scaledRadii   = gbviParameters->getScaledRadii();
+    const vector<RealOpenMM>& atomicRadii   = gbviParameters->getAtomicRadii();
+    const vector<RealOpenMM>& scaledRadii   = gbviParameters->getScaledRadii();
 
-    RealOpenMMVector& switchDeriviatives  = getSwitchDeriviative();
+    vector<RealOpenMM>& switchDeriviatives  = getSwitchDeriviative();
 
     // ---------------------------------------------------------------------------------------
 
@@ -448,7 +447,7 @@ RealOpenMM CpuGBVI::Sgb(RealOpenMM t) {
 
     --------------------------------------------------------------------------------------- */
 
-RealOpenMM CpuGBVI::computeBornEnergy(const vector<RealVec>& atomCoordinates, const RealOpenMMVector& partialCharges) {
+RealOpenMM CpuGBVI::computeBornEnergy(const vector<RealVec>& atomCoordinates, const vector<RealOpenMM>& partialCharges) {
 
     // ---------------------------------------------------------------------------------------
 
@@ -466,12 +465,12 @@ RealOpenMM CpuGBVI::computeBornEnergy(const vector<RealVec>& atomCoordinates, co
     const GBVIParameters* gbviParameters       = getGBVIParameters();
     const RealOpenMM preFactor                 = gbviParameters->getElectricConstant();
     const int numberOfAtoms                    = gbviParameters->getNumberOfAtoms();
-    const RealOpenMMVector& atomicRadii        = gbviParameters->getAtomicRadii();
-    const RealOpenMMVector& gammaParameters    = gbviParameters->getGammaParameters();
+    const vector<RealOpenMM>& atomicRadii        = gbviParameters->getAtomicRadii();
+    const vector<RealOpenMM>& gammaParameters    = gbviParameters->getGammaParameters();
 
     // compute Born radii
 
-    RealOpenMMVector bornRadii(numberOfAtoms);
+    vector<RealOpenMM> bornRadii(numberOfAtoms);
     computeBornRadii(atomCoordinates, bornRadii);
 
     // ---------------------------------------------------------------------------------------
@@ -532,7 +531,7 @@ RealOpenMM CpuGBVI::computeBornEnergy(const vector<RealVec>& atomCoordinates, co
     --------------------------------------------------------------------------------------- */
 
 
-void CpuGBVI::computeBornForces(std::vector<RealVec>& atomCoordinates, const RealOpenMMVector& partialCharges,
+void CpuGBVI::computeBornForces(std::vector<RealVec>& atomCoordinates, const vector<RealOpenMM>& partialCharges,
                                  std::vector<OpenMM::RealVec>& inputForces) {
 
     // ---------------------------------------------------------------------------------------
@@ -551,8 +550,8 @@ void CpuGBVI::computeBornForces(std::vector<RealVec>& atomCoordinates, const Rea
 
     const GBVIParameters* gbviParameters       = getGBVIParameters();
     const int numberOfAtoms                    = gbviParameters->getNumberOfAtoms();
-    const RealOpenMMVector& atomicRadii        = gbviParameters->getAtomicRadii();
-    const RealOpenMMVector& gammaParameters    = gbviParameters->getGammaParameters();
+    const vector<RealOpenMM>& atomicRadii        = gbviParameters->getAtomicRadii();
+    const vector<RealOpenMM>& gammaParameters    = gbviParameters->getGammaParameters();
 
     // ---------------------------------------------------------------------------------------
 
@@ -564,7 +563,7 @@ void CpuGBVI::computeBornForces(std::vector<RealVec>& atomCoordinates, const Rea
 
     // compute Born radii
 
-    RealOpenMMVector bornRadii(numberOfAtoms);
+    vector<RealOpenMM> bornRadii(numberOfAtoms);
     computeBornRadii(atomCoordinates, bornRadii);
 
     // set energy/forces to zero
@@ -576,7 +575,7 @@ void CpuGBVI::computeBornForces(std::vector<RealVec>& atomCoordinates, const Rea
         forces[ii][2] = zero;
     }
 
-    RealOpenMMVector bornForces(numberOfAtoms, 0.0);
+    vector<RealOpenMM> bornForces(numberOfAtoms, 0.0);
 
     // ---------------------------------------------------------------------------------------
 
@@ -645,8 +644,8 @@ void CpuGBVI::computeBornForces(std::vector<RealVec>& atomCoordinates, const Rea
     // dGpol/dBornRadius) = bornForces[]
     // dBornRadius/dr     = (1/3)*(bR**4)*(dV/dr)
 
-    const RealOpenMMVector& scaledRadii           = gbviParameters->getScaledRadii();
-    const RealOpenMMVector& switchDeriviative     = getSwitchDeriviative();
+    const vector<RealOpenMM>& scaledRadii           = gbviParameters->getScaledRadii();
+    const vector<RealOpenMM>& switchDeriviative     = getSwitchDeriviative();
     for (int atomI = 0; atomI < numberOfAtoms; atomI++) {
  
         RealOpenMM R        = atomicRadii[atomI];
@@ -748,9 +747,9 @@ void CpuGBVI::computeBornForces(std::vector<RealVec>& atomCoordinates, const Rea
 
     --------------------------------------------------------------------------------------- */
 
-void CpuGBVI::printGbvi(const std::vector<OpenMM::RealVec>& atomCoordinates, const RealOpenMMVector& partialCharges,
-                        const RealOpenMMVector& bornRadii,
-                        const RealOpenMMVector& bornForces,
+void CpuGBVI::printGbvi(const std::vector<OpenMM::RealVec>& atomCoordinates, const vector<RealOpenMM>& partialCharges,
+                        const vector<RealOpenMM>& bornRadii,
+                        const vector<RealOpenMM>& bornForces,
                         const std::vector<OpenMM::RealVec>& forces,
                         const std::string& idString, FILE* log) {
 
@@ -758,8 +757,8 @@ void CpuGBVI::printGbvi(const std::vector<OpenMM::RealVec>& atomCoordinates, con
 
     const GBVIParameters* gbviParameters       = getGBVIParameters();
     const int numberOfAtoms                    = gbviParameters->getNumberOfAtoms();
-    const RealOpenMMVector& atomicRadii        = gbviParameters->getAtomicRadii();
-    const RealOpenMMVector& gammaParameters    = gbviParameters->getGammaParameters();
+    const vector<RealOpenMM>& atomicRadii        = gbviParameters->getAtomicRadii();
+    const vector<RealOpenMM>& gammaParameters    = gbviParameters->getGammaParameters();
 
     // ---------------------------------------------------------------------------------------
 
@@ -769,8 +768,8 @@ void CpuGBVI::printGbvi(const std::vector<OpenMM::RealVec>& atomCoordinates, con
 
     // ---------------------------------------------------------------------------------------
 
-    const RealOpenMMVector& scaledRadii       = gbviParameters->getScaledRadii();
-    const RealOpenMMVector& switchDeriviative = getSwitchDeriviative();
+    const vector<RealOpenMM>& scaledRadii       = gbviParameters->getScaledRadii();
+    const vector<RealOpenMM>& switchDeriviative = getSwitchDeriviative();
     RealOpenMM tau                            = static_cast<RealOpenMM>(gbviParameters->getTau());  
 
     int useComparisonFormat                   = 1;

platforms/reference/src/gbsa/CpuObc.cpp

@@ -28,7 +28,6 @@
 #include <cmath>
 #include <cstdio>
 
-#include "SimTKOpenMMCommon.h"
 #include "ReferenceForce.h"
 #include "CpuObc.h"
 
@@ -144,9 +143,9 @@ void CpuObc::computeBornRadii(const vector<RealVec>& atomCoordinates, vector<Rea
     ObcParameters* obcParameters                = getObcParameters();
 
     int numberOfAtoms                           = obcParameters->getNumberOfAtoms();
-    const RealOpenMMVector& atomicRadii         = obcParameters->getAtomicRadii();
-    const RealOpenMMVector& scaledRadiusFactor  = obcParameters->getScaledRadiusFactors();
-    RealOpenMMVector& obcChain                  = getObcChain();
+    const vector<RealOpenMM>& atomicRadii         = obcParameters->getAtomicRadii();
+    const vector<RealOpenMM>& scaledRadiusFactor  = obcParameters->getScaledRadiusFactors();
+    vector<RealOpenMM>& obcChain                  = getObcChain();
 
     RealOpenMM dielectricOffset                 = obcParameters->getDielectricOffset();
     RealOpenMM alphaObc                         = obcParameters->getAlphaObc();
@@ -237,9 +236,9 @@ void CpuObc::computeBornRadii(const vector<RealVec>& atomCoordinates, vector<Rea
     --------------------------------------------------------------------------------------- */
 
 void CpuObc::computeAceNonPolarForce(const ObcParameters* obcParameters,
-                                      const RealOpenMMVector& bornRadii, 
+                                      const vector<RealOpenMM>& bornRadii,
                                       RealOpenMM* energy,
-                                      RealOpenMMVector& forces) const {
+                                      vector<RealOpenMM>& forces) const {
 
     // ---------------------------------------------------------------------------------------
 
@@ -254,7 +253,7 @@ void CpuObc::computeAceNonPolarForce(const ObcParameters* obcParameters,
     const RealOpenMM probeRadius          = obcParameters->getProbeRadius();
     const RealOpenMM surfaceAreaFactor    = obcParameters->getPi4Asolv();
 
-    const RealOpenMMVector& atomicRadii   = obcParameters->getAtomicRadii();
+    const vector<RealOpenMM>& atomicRadii   = obcParameters->getAtomicRadii();
     int numberOfAtoms                     = obcParameters->getNumberOfAtoms();
 
     // the original ACE equation is based on Eq.2 of
@@ -295,7 +294,7 @@ void CpuObc::computeAceNonPolarForce(const ObcParameters* obcParameters,
     --------------------------------------------------------------------------------------- */
 
 RealOpenMM CpuObc::computeBornEnergyForces(const vector<RealVec>& atomCoordinates,
-                                           const RealOpenMMVector& partialCharges, vector<RealVec>& inputForces) {
+                                           const vector<RealOpenMM>& partialCharges, vector<RealVec>& inputForces) {
 
     // ---------------------------------------------------------------------------------------
 
@@ -325,13 +324,13 @@ RealOpenMM CpuObc::computeBornEnergyForces(const vector<RealVec>& atomCoordinate
 
     // compute Born radii
 
-    RealOpenMMVector bornRadii(numberOfAtoms);
+    vector<RealOpenMM> bornRadii(numberOfAtoms);
     computeBornRadii(atomCoordinates, bornRadii);
 
     // set energy/forces to zero
 
     RealOpenMM obcEnergy                 = zero;
-    RealOpenMMVector bornForces(numberOfAtoms, 0.0);
+    vector<RealOpenMM> bornForces(numberOfAtoms, 0.0);
 
     // ---------------------------------------------------------------------------------------
 
@@ -410,13 +409,13 @@ RealOpenMM CpuObc::computeBornEnergyForces(const vector<RealVec>& atomCoordinate
 
     // second main loop
 
-    const RealOpenMMVector& obcChain            = getObcChain();
-    const RealOpenMMVector& atomicRadii         = _obcParameters->getAtomicRadii();
+    const vector<RealOpenMM>& obcChain            = getObcChain();
+    const vector<RealOpenMM>& atomicRadii         = _obcParameters->getAtomicRadii();
 
     const RealOpenMM alphaObc                   = _obcParameters->getAlphaObc();
     const RealOpenMM betaObc                    = _obcParameters->getBetaObc();
     const RealOpenMM gammaObc                   = _obcParameters->getGammaObc();
-    const RealOpenMMVector& scaledRadiusFactor  = _obcParameters->getScaledRadiusFactors();
+    const vector<RealOpenMM>& scaledRadiusFactor  = _obcParameters->getScaledRadiusFactors();
 
     // compute factor that depends only on the outer loop index
 
@@ -515,9 +514,9 @@ RealOpenMM CpuObc::computeBornEnergyForces(const vector<RealVec>& atomCoordinate
     --------------------------------------------------------------------------------------- */
 
 void CpuObc::printObc(const std::vector<OpenMM::RealVec>& atomCoordinates,
-                      const RealOpenMMVector& partialCharges,
-                      const RealOpenMMVector& bornRadii,
-                      const RealOpenMMVector& bornForces,
+                      const vector<RealOpenMM>& partialCharges,
+                      const vector<RealOpenMM>& bornRadii,
+                      const vector<RealOpenMM>& bornForces,
                       const std::vector<OpenMM::RealVec>& forces,
                       const std::string& idString, FILE* log) {
 
@@ -525,10 +524,10 @@ void CpuObc::printObc(const std::vector<OpenMM::RealVec>& atomCoordinates,
 
     const ObcParameters* obcParameters          = getObcParameters();
     const int numberOfAtoms                     = obcParameters->getNumberOfAtoms();
-    const RealOpenMMVector& atomicRadii         = obcParameters->getAtomicRadii();
+    const vector<RealOpenMM>& atomicRadii         = obcParameters->getAtomicRadii();
     const RealOpenMM preFactor                  = 2.0*obcParameters->getElectricConstant();
-    const RealOpenMMVector& obcChain            = getObcChain();
-    const RealOpenMMVector& scaledRadiusFactor  = obcParameters->getScaledRadiusFactors();
+    const vector<RealOpenMM>& obcChain            = getObcChain();
+    const vector<RealOpenMM>& scaledRadiusFactor  = obcParameters->getScaledRadiusFactors();
 
     const RealOpenMM alphaObc                   = obcParameters->getAlphaObc();
     const RealOpenMM betaObc                    = obcParameters->getBetaObc();

platforms/reference/src/gbsa/GBVIParameters.cpp

@@ -28,7 +28,6 @@
 
 #include "openmm/OpenMMException.h"
 #include "GBVIParameters.h"
-#include "SimTKOpenMMCommon.h"
 
 using std::vector;
 using namespace OpenMM;
@@ -146,7 +145,7 @@ void GBVIParameters::setSoluteDielectric(RealOpenMM soluteDielectric) {
 
     --------------------------------------------------------------------------------------- */
 
-const RealOpenMMVector& GBVIParameters::getAtomicRadii() const {
+const vector<RealOpenMM>& GBVIParameters::getAtomicRadii() const {
     return _atomicRadii;
 }
 
@@ -158,7 +157,7 @@ const RealOpenMMVector& GBVIParameters::getAtomicRadii() const {
 
     --------------------------------------------------------------------------------------- */
 
-void GBVIParameters::setAtomicRadii(const RealOpenMMVector& atomicRadii) {
+void GBVIParameters::setAtomicRadii(const vector<RealOpenMM>& atomicRadii) {
 
     if (atomicRadii.size() == _atomicRadii.size()) {
         for (unsigned int ii = 0; ii < atomicRadii.size(); ii++) {
@@ -170,7 +169,7 @@ void GBVIParameters::setAtomicRadii(const RealOpenMMVector& atomicRadii) {
         msg << atomicRadii.size();
         msg << " current size=" << _atomicRadii.size();
         throw OpenMM::OpenMMException(msg.str());
-    }   
+    }
 
 }
 
@@ -181,7 +180,7 @@ void GBVIParameters::setAtomicRadii(const RealOpenMMVector& atomicRadii) {
 
     --------------------------------------------------------------------------------------- */
 
-const RealOpenMMVector& GBVIParameters::getScaledRadii() const {
+const vector<RealOpenMM>& GBVIParameters::getScaledRadii() const {
     return _scaledRadii;
 }
 
@@ -193,7 +192,7 @@ const RealOpenMMVector& GBVIParameters::getScaledRadii() const {
 
     --------------------------------------------------------------------------------------- */
 
-void GBVIParameters::setScaledRadii(const RealOpenMMVector& scaledRadii) {
+void GBVIParameters::setScaledRadii(const vector<RealOpenMM>& scaledRadii) {
 
     if (scaledRadii.size() == _scaledRadii.size()) {
         for (unsigned int ii = 0; ii < scaledRadii.size(); ii++) {
@@ -218,7 +217,7 @@ void GBVIParameters::setScaledRadii(const RealOpenMMVector& scaledRadii) {
 
     --------------------------------------------------------------------------------------- */
 
-const RealOpenMMVector& GBVIParameters::getGammaParameters() const {
+const vector<RealOpenMM>& GBVIParameters::getGammaParameters() const {
     return _gammaParameters;
 }
 
@@ -230,7 +229,7 @@ const RealOpenMMVector& GBVIParameters::getGammaParameters() const {
 
     --------------------------------------------------------------------------------------- */
 
-void GBVIParameters::setGammaParameters(const RealOpenMMVector& gammas) {
+void GBVIParameters::setGammaParameters(const vector<RealOpenMM>& gammas) {
 
     if (gammas.size() == _gammaParameters.size()) {
         for (unsigned int ii = 0; ii < gammas.size(); ii++) {

platforms/reference/src/gbsa/ObcParameters.cpp

@@ -28,7 +28,6 @@
 
 #include "openmm/OpenMMException.h"
 #include "ObcParameters.h"
-#include "SimTKOpenMMCommon.h"
 
 using std::vector;
 using namespace OpenMM;
@@ -271,7 +270,7 @@ void ObcParameters::setPi4Asolv(RealOpenMM pi4Asolv) {
 
     --------------------------------------------------------------------------------------- */
 
-const RealOpenMMVector& ObcParameters::getAtomicRadii() const {
+const vector<RealOpenMM>& ObcParameters::getAtomicRadii() const {
     return _atomicRadii;
 }
 
@@ -283,7 +282,7 @@ const RealOpenMMVector& ObcParameters::getAtomicRadii() const {
 
     --------------------------------------------------------------------------------------- */
 
-void ObcParameters::setAtomicRadii(const RealOpenMMVector& atomicRadii) {
+void ObcParameters::setAtomicRadii(const vector<RealOpenMM>& atomicRadii) {
 
     if (atomicRadii.size() == _atomicRadii.size()) {
         for (unsigned int ii = 0; ii < atomicRadii.size(); ii++) {
@@ -307,7 +306,7 @@ void ObcParameters::setAtomicRadii(const RealOpenMMVector& atomicRadii) {
 
     --------------------------------------------------------------------------------------- */
 
-const RealOpenMMVector& ObcParameters::getScaledRadiusFactors() const {
+const vector<RealOpenMM>& ObcParameters::getScaledRadiusFactors() const {
     return _scaledRadiusFactors;
 }
 
@@ -319,7 +318,7 @@ const RealOpenMMVector& ObcParameters::getScaledRadiusFactors() const {
 
     --------------------------------------------------------------------------------------- */
 
-void ObcParameters::setScaledRadiusFactors(const RealOpenMMVector& scaledRadiusFactors) {
+void ObcParameters::setScaledRadiusFactors(const vector<RealOpenMM>& scaledRadiusFactors) {
 
     if (scaledRadiusFactors.size() == _scaledRadiusFactors.size()) {
         for (unsigned int ii = 0; ii < scaledRadiusFactors.size(); ii++) {