Code cleanup (#5127)

openmmapi/src/MonteCarloMembraneBarostatImpl.cpp

@@ -143,17 +143,13 @@ void MonteCarloMembraneBarostatImpl::updateContextState(ContextImpl& context, bo
 }
 
 map<string, double> MonteCarloMembraneBarostatImpl::getDefaultParameters() {
-    map<string, double> parameters;
-    parameters[MonteCarloMembraneBarostat::Pressure()] = getOwner().getDefaultPressure();
-    parameters[MonteCarloMembraneBarostat::SurfaceTension()] = getOwner().getDefaultSurfaceTension();
-    parameters[MonteCarloMembraneBarostat::Temperature()] = getOwner().getDefaultTemperature();
-    return parameters;
+    return {{MonteCarloMembraneBarostat::Pressure(), getOwner().getDefaultPressure()},
+            {MonteCarloMembraneBarostat::SurfaceTension(), getOwner().getDefaultSurfaceTension()},
+            {MonteCarloMembraneBarostat::Temperature(), getOwner().getDefaultTemperature()}};
 }
 
 vector<string> MonteCarloMembraneBarostatImpl::getKernelNames() {
-    vector<string> names;
-    names.push_back(ApplyMonteCarloBarostatKernel::Name());
-    return names;
+    return {ApplyMonteCarloBarostatKernel::Name()};
 }
 
 Vec3 MonteCarloMembraneBarostatImpl::computeCurrentPressure(ContextImpl& context) {

openmmapi/src/NonbondedForceImpl.cpp

@@ -153,9 +153,7 @@ map<string, double> NonbondedForceImpl::getDefaultParameters() {
 }
 
 std::vector<std::string> NonbondedForceImpl::getKernelNames() {
-    std::vector<std::string> names;
-    names.push_back(CalcNonbondedForceKernel::Name());
-    return names;
+    return {CalcNonbondedForceKernel::Name()};
 }
 
 class NonbondedForceImpl::ErrorFunction {

openmmapi/src/NoseHooverIntegrator.cpp

@@ -348,9 +348,7 @@ void NoseHooverIntegrator::cleanup() {
 }
 
 vector<string> NoseHooverIntegrator::getKernelNames() {
-    std::vector<std::string> names;
-    names.push_back(IntegrateNoseHooverStepKernel::Name());
-    return names;
+    return {IntegrateNoseHooverStepKernel::Name()};
 }
 
 void NoseHooverIntegrator::step(int steps) {

openmmapi/src/OrientationRestraintForceImpl.cpp

@@ -78,9 +78,7 @@ double OrientationRestraintForceImpl::calcForcesAndEnergy(ContextImpl& context,
 }
 
 vector<string> OrientationRestraintForceImpl::getKernelNames() {
-    vector<string> names;
-    names.push_back(CalcOrientationRestraintForceKernel::Name());
-    return names;
+    return {CalcOrientationRestraintForceKernel::Name()};
 }
 
 void OrientationRestraintForceImpl::updateParametersInContext(ContextImpl& context) {

openmmapi/src/PeriodicTorsionForceImpl.cpp

@@ -71,9 +71,7 @@ double PeriodicTorsionForceImpl::calcForcesAndEnergy(ContextImpl& context, bool
 }
 
 std::vector<std::string> PeriodicTorsionForceImpl::getKernelNames() {
-    std::vector<std::string> names;
-    names.push_back(CalcPeriodicTorsionForceKernel::Name());
-    return names;
+    return {CalcPeriodicTorsionForceKernel::Name()};
 }
 
 void PeriodicTorsionForceImpl::updateParametersInContext(ContextImpl& context, int firstTorsion, int lastTorsion) {

openmmapi/src/QTBIntegrator.cpp

@@ -122,9 +122,7 @@ void QTBIntegrator::cleanup() {
 }
 
 vector<string> QTBIntegrator::getKernelNames() {
-    vector<std::string> names;
-    names.push_back(IntegrateQTBStepKernel::Name());
-    return names;
+    return {IntegrateQTBStepKernel::Name()};
 }
 
 double QTBIntegrator::computeKineticEnergy() {

openmmapi/src/RBTorsionForceImpl.cpp

@@ -69,9 +69,7 @@ double RBTorsionForceImpl::calcForcesAndEnergy(ContextImpl& context, bool includ
 }
 
 std::vector<std::string> RBTorsionForceImpl::getKernelNames() {
-    std::vector<std::string> names;
-    names.push_back(CalcRBTorsionForceKernel::Name());
-    return names;
+    return {CalcRBTorsionForceKernel::Name()};
 }
 
 void RBTorsionForceImpl::updateParametersInContext(ContextImpl& context) {

openmmapi/src/RGForceImpl.cpp

@@ -76,7 +76,5 @@ double RGForceImpl::calcForcesAndEnergy(ContextImpl& context, bool includeForces
 }
 
 vector<string> RGForceImpl::getKernelNames() {
-    vector<string> names;
-    names.push_back(CalcRGForceKernel::Name());
-    return names;
+    return {CalcRGForceKernel::Name()};
 }

openmmapi/src/RMSDForceImpl.cpp

@@ -78,9 +78,7 @@ double RMSDForceImpl::calcForcesAndEnergy(ContextImpl& context, bool includeForc
 }
 
 vector<string> RMSDForceImpl::getKernelNames() {
-    vector<string> names;
-    names.push_back(CalcRMSDForceKernel::Name());
-    return names;
+    return {CalcRMSDForceKernel::Name()};
 }
 
 void RMSDForceImpl::updateParametersInContext(ContextImpl& context) {

openmmapi/src/VariableLangevinIntegrator.cpp

@@ -88,9 +88,7 @@ void VariableLangevinIntegrator::cleanup() {
 }
 
 vector<string> VariableLangevinIntegrator::getKernelNames() {
-    std::vector<std::string> names;
-    names.push_back(IntegrateVariableLangevinStepKernel::Name());
-    return names;
+    return {IntegrateVariableLangevinStepKernel::Name()};
 }
 
 double VariableLangevinIntegrator::computeKineticEnergy() {

openmmapi/src/VariableVerletIntegrator.cpp

@@ -70,9 +70,7 @@ void VariableVerletIntegrator::cleanup() {
 }
 
 vector<string> VariableVerletIntegrator::getKernelNames() {
-    std::vector<std::string> names;
-    names.push_back(IntegrateVariableVerletStepKernel::Name());
-    return names;
+    return {IntegrateVariableVerletStepKernel::Name()};
 }
 
 double VariableVerletIntegrator::computeKineticEnergy() {

openmmapi/src/VerletIntegrator.cpp

@@ -57,9 +57,7 @@ void VerletIntegrator::cleanup() {
 }
 
 vector<string> VerletIntegrator::getKernelNames() {
-    std::vector<std::string> names;
-    names.push_back(IntegrateVerletStepKernel::Name());
-    return names;
+    return {IntegrateVerletStepKernel::Name()};
 }
 
 double VerletIntegrator::computeKineticEnergy() {

platforms/reference/include/ReferenceCCMAAlgorithm.h

@@ -43,10 +43,8 @@ protected:
     std::vector<std::pair<int, int> > _atomIndices;
     std::vector<double> _distance;
 
-    std::vector<OpenMM::Vec3> _r_ij;
-    double* _d_ij2;
-    double* _distanceTolerance;
-    double* _reducedMasses;
+    std::vector<OpenMM::Vec3> r_ij;
+    std::vector<double> d_ij2, _distanceTolerance, reducedMasses;
     bool _hasInitializedMasses;
     std::vector<std::vector<std::pair<int, double> > > _matrix;
 
@@ -71,8 +69,6 @@ public:
      */
     ReferenceCCMAAlgorithm(int numberOfAtoms, int numberOfConstraints, const std::vector<std::pair<int, int> >& atomIndices, const std::vector<double>& distance, std::vector<double>& masses, std::vector<AngleInfo>& angles, double elementCutoff);
 
-    ~ReferenceCCMAAlgorithm();
-
     /**
      * Get the number of constraints.
      */

platforms/reference/include/SimTKOpenMMUtilities.h

@@ -58,92 +58,6 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
 
        SimTKOpenMMUtilities() {};
       ~SimTKOpenMMUtilities() {};
-      
-      /**---------------------------------------------------------------------------------------
-      
-         Allocate 1D double array (Simbios)
-      
-         array[i]
-      
-         @param iSize                i-dimension
-         @param array1D              array (if null on entry allocated)
-         @param initialize           if true, then initialize array
-         @param initialValue         intitial value
-         @param idString             id string
-      
-         @return array
-      
-         --------------------------------------------------------------------------------------- */
-      
-      static double* allocateOneDRealOpenMMArray(int iSize, double* array1D, int initialize,
-                                                      double initialValue,
-                                                      const std::string& idString = std::string("1DArray"));
-      
-      /**---------------------------------------------------------------------------------------
-      
-         Allocate 2D double array (Simbios)
-      
-         array[i][j]
-      
-         @param iSize                i-dimension
-         @param jSize                j-dimension
-         @param array2D              array (if null on entry allocated)
-         @param initialize           if true, then initialize array
-         @param initialValue         intitial value
-         @param idString             id string
-      
-         @return array
-      
-         --------------------------------------------------------------------------------------- */
-      
-      static double** allocateTwoDRealOpenMMArray(int iSize, int jSize,
-                                                       double** array2D, int initialize,
-                                                       double initialValue,
-                                                       const std::string& idString = std::string("2DArray"));
-      
-      /* ---------------------------------------------------------------------------------------
-      
-         Free 2D double array (Simbios)
-      
-         array[i][j]
-      
-         @param array2D              array (if null on entry allocated)
-         @param idString             id string
-      
-         --------------------------------------------------------------------------------------- */
-      
-      static void freeOneDRealOpenMMArray(double* array1D,
-                                          const std::string& idString = std::string("1DArray"));
-      
-      /* ---------------------------------------------------------------------------------------
-      
-         Free 2D double array (Simbios)
-      
-         array[i][j]
-      
-         @param array2D              array (if null on entry allocated)
-         @param idString             id string
-      
-         --------------------------------------------------------------------------------------- */
-      
-      static void freeTwoDRealOpenMMArray(double** array2D,
-                                          const std::string& idString = std::string("2DArray"));
-      
-      /**---------------------------------------------------------------------------------------
-      
-         Initialize 2D double array (Simbios)
-      
-         array[i][j]
-      
-         @param iSize                i-dimension
-         @param jSize                j-dimension
-         @param array2D              array (if null on entry allocated)
-         @param initialValue         intitial value
-      
-         --------------------------------------------------------------------------------------- */
-      
-      static void initialize2DRealOpenMMArray(int iSize, int jSize,
-                                              double** array2D, double initialValue);
 
       /**---------------------------------------------------------------------------------------
       

platforms/reference/src/ReferenceKernels.cpp

@@ -173,11 +173,8 @@ void ReferenceCalcForcesAndEnergyKernel::beginComputation(ContextImpl& context,
     vector<Vec3>& forceData = extractForces(context);
     if (includeForces) {
         int numParticles = context.getSystem().getNumParticles();
-        for (int i = 0; i < numParticles; ++i) {
-            forceData[i][0] = 0.0;
-            forceData[i][1] = 0.0;
-            forceData[i][2] = 0.0;
-        }
+        for (int i = 0; i < numParticles; ++i)
+            forceData[i] = Vec3();
     }
     else
         savedForces = forceData;
@@ -217,39 +214,19 @@ void ReferenceUpdateStateDataKernel::setStepCount(const ContextImpl& context, lo
 }
 
 void ReferenceUpdateStateDataKernel::getPositions(ContextImpl& context, std::vector<Vec3>& positions) {
-    int numParticles = context.getSystem().getNumParticles();
-    vector<Vec3>& posData = extractPositions(context);
-    positions.resize(numParticles);
-    for (int i = 0; i < numParticles; ++i)
-        positions[i] = Vec3(posData[i][0], posData[i][1], posData[i][2]);
+    positions = extractPositions(context);
 }
 
 void ReferenceUpdateStateDataKernel::setPositions(ContextImpl& context, const std::vector<Vec3>& positions) {
-    int numParticles = context.getSystem().getNumParticles();
-    vector<Vec3>& posData = extractPositions(context);
-    for (int i = 0; i < numParticles; ++i) {
-        posData[i][0] = positions[i][0];
-        posData[i][1] = positions[i][1];
-        posData[i][2] = positions[i][2];
-    }
+    extractPositions(context) = positions;
 }
 
 void ReferenceUpdateStateDataKernel::getVelocities(ContextImpl& context, std::vector<Vec3>& velocities) {
-    int numParticles = context.getSystem().getNumParticles();
-    vector<Vec3>& velData = extractVelocities(context);
-    velocities.resize(numParticles);
-    for (int i = 0; i < numParticles; ++i)
-        velocities[i] = Vec3(velData[i][0], velData[i][1], velData[i][2]);
+    velocities = extractVelocities(context);
 }
 
 void ReferenceUpdateStateDataKernel::setVelocities(ContextImpl& context, const std::vector<Vec3>& velocities) {
-    int numParticles = context.getSystem().getNumParticles();
-    vector<Vec3>& velData = extractVelocities(context);
-    for (int i = 0; i < numParticles; ++i) {
-        velData[i][0] = velocities[i][0];
-        velData[i][1] = velocities[i][1];
-        velData[i][2] = velocities[i][2];
-    }
+    extractVelocities(context) = velocities;
 }
 
 void ReferenceUpdateStateDataKernel::computeShiftedVelocities(ContextImpl& context, double timeShift, std::vector<Vec3>& velocities) {
@@ -280,11 +257,7 @@ void ReferenceUpdateStateDataKernel::computeShiftedVelocities(ContextImpl& conte
 }
 
 void ReferenceUpdateStateDataKernel::getForces(ContextImpl& context, std::vector<Vec3>& forces) {
-    int numParticles = context.getSystem().getNumParticles();
-    vector<Vec3>& forceData = extractForces(context);
-    forces.resize(numParticles);
-    for (int i = 0; i < numParticles; ++i)
-        forces[i] = Vec3(forceData[i][0], forceData[i][1], forceData[i][2]);
+    forces = extractForces(context);
 }
 
 void ReferenceUpdateStateDataKernel::getEnergyParameterDerivatives(ContextImpl& context, map<string, double>& derivs) {

platforms/reference/src/SimTKReference/ReferenceCCMAAlgorithm.cpp

@@ -57,10 +57,10 @@ ReferenceCCMAAlgorithm::ReferenceCCMAAlgorithm(int numberOfAtoms,
     // work arrays
 
     if (_numberOfConstraints > 0) {
-        _r_ij.resize(numberOfConstraints);
-        _d_ij2 = SimTKOpenMMUtilities::allocateOneDRealOpenMMArray(numberOfConstraints, NULL, 1, 0.0, "dij_2");
-        _distanceTolerance = SimTKOpenMMUtilities::allocateOneDRealOpenMMArray(numberOfConstraints, NULL, 1, 0.0, "distanceTolerance");
-        _reducedMasses = SimTKOpenMMUtilities::allocateOneDRealOpenMMArray(numberOfConstraints, NULL, 1, 0.0, "reducedMasses");
+        r_ij.resize(numberOfConstraints);
+        d_ij2.resize(numberOfConstraints);
+        _distanceTolerance.resize(numberOfConstraints);
+        reducedMasses.resize(numberOfConstraints);
     }
     if (numberOfConstraints > 0)
     {
@@ -201,14 +201,6 @@ ReferenceCCMAAlgorithm::ReferenceCCMAAlgorithm(int numberOfAtoms,
     }
 }
 
-ReferenceCCMAAlgorithm::~ReferenceCCMAAlgorithm() {
-    if (_numberOfConstraints > 0) {
-        SimTKOpenMMUtilities::freeOneDRealOpenMMArray(_d_ij2, "d_ij2");
-        SimTKOpenMMUtilities::freeOneDRealOpenMMArray(_distanceTolerance, "distanceTolerance");
-        SimTKOpenMMUtilities::freeOneDRealOpenMMArray(_reducedMasses, "reducedMasses");
-    }
-}
-
 int ReferenceCCMAAlgorithm::getNumberOfConstraints() const {
     return _numberOfConstraints;
 }
@@ -235,12 +227,6 @@ void ReferenceCCMAAlgorithm::applyToVelocities(std::vector<OpenMM::Vec3>& atomCo
 void ReferenceCCMAAlgorithm::applyConstraints(vector<Vec3>& atomCoordinates,
                                          vector<Vec3>& atomCoordinatesP,
                                          vector<double>& inverseMasses, bool constrainingVelocities, double tolerance) {
-    // temp arrays
-
-    vector<Vec3>& r_ij = _r_ij;
-    double* d_ij2 = _d_ij2;
-    double* reducedMasses = _reducedMasses;
-
     // calculate reduced masses on 1st pass
 
     if (!_hasInitializedMasses) {

platforms/reference/src/SimTKReference/SimTKOpenMMUtilities.cpp

@@ -43,172 +43,6 @@ bool SimTKOpenMMUtilities::nextGaussianIsValid = false;
 double SimTKOpenMMUtilities::nextGaussian = 0;
 OpenMM_SFMT::SFMT SimTKOpenMMUtilities::sfmt;
 
-/* ---------------------------------------------------------------------------------------
-
-   Allocate 1D double array (Simbios)
-
-   array[i]
-
-   @param iSize                i-dimension
-   @param array1D              array (if null on entry allocated)
-   @param initialize           if true, then initialize array
-   @param initialValue         intitial value
-   @param idString             id string
-
-   @return allocated array
-
-   --------------------------------------------------------------------------------------- */
-
-double* SimTKOpenMMUtilities::allocateOneDRealOpenMMArray(int iSize, double* array1D, 
-                                                              int initialize, double initialValue,
-                                                              const std::string& idString) {
-   if (array1D == NULL) {
-
-      array1D = new double[iSize];
-
-   }
-
-   if (initialize) {
-      if (initialValue == 0.0) {
-         memset(array1D, 0, iSize*sizeof(double));
-      } else {
-         for (int ii = 0; ii < iSize; ii++) {
-            array1D[ii] = initialValue;
-         }
-      }
-   }
-
-   return array1D;
-}
-
-/* ---------------------------------------------------------------------------------------
-
-   Allocate 2D double array (Simbios)
-
-   array[i][j]
-
-   @param iSize                i-dimension
-   @param jSize                j-dimension
-   @param array2D              array (if null on entry allocated)
-   @param initialize           if true, then initialize array
-   @param initialValue         intitial value
-   @param idString             id string
-
-   @return allocated array
-
-   --------------------------------------------------------------------------------------- */
-
-double** SimTKOpenMMUtilities::allocateTwoDRealOpenMMArray(int iSize, int jSize, double** array2D, 
-                                                               int initialize, double initialValue,
-                                                               const std::string& idString) {
-   if (array2D == NULL) {
-
-      array2D = new double*[iSize];
-      std::string blockString = idString;
-      blockString.append("Block");
-
-      double* block = new double[jSize*iSize];
-
-      for (int ii = 0; ii < iSize; ii++) {
-         array2D[ii]  = block;
-         block       += jSize;
-      }    
-   }
-
-   if (initialize) {
-      initialize2DRealOpenMMArray(iSize, jSize, array2D, initialValue);
-   }
-
-   return array2D;
-}
-
-/* ---------------------------------------------------------------------------------------
-
-   Free 2D double array (Simbios)
-
-   array[i][j]
-
-   @param array2D              array (if null on entry allocated)
-   @param idString             id string
-
-   --------------------------------------------------------------------------------------- */
-
-void SimTKOpenMMUtilities::freeTwoDRealOpenMMArray(double** array2D, const std::string& idString) {
-   if (array2D != NULL) {
-
-      std::string blockString = idString;
-      blockString.append("Block");
-
-      delete[] array2D[0];
-      delete[] array2D;
-   }
-}
-
-/* ---------------------------------------------------------------------------------------
-
-   Free 1D double array (Simbios)
-
-   array[i]
-
-   @param array1D              array (if null on entry allocated)
-   @param idString             id string
-
-   --------------------------------------------------------------------------------------- */
-
-void SimTKOpenMMUtilities::freeOneDRealOpenMMArray(double* array1D, const std::string& idString) {
-   if (array1D != NULL) {
-      delete[] array1D;
-   }
-}
-
-/* ---------------------------------------------------------------------------------------
-
-   Initialize 2D double array (Simbios)
-
-   array[i][j]
-
-   @param iSize                i-dimension
-   @param jSize                j-dimension
-   @param array2D              array (if null on entry allocated)
-   @param initialValue         intitial value
-
-   --------------------------------------------------------------------------------------- */
-
-void SimTKOpenMMUtilities::initialize2DRealOpenMMArray(int iSize, int jSize,
-                                                       double** array2D,
-                                                       double initialValue) {
-   bool useMemset;
-   bool useMemsetSingleBlock;
-
-   if (initialValue == 0.0f) {
-      useMemset = true;
-      if (jSize > 1 && (array2D[0] + jSize) == array2D[1]) {  
-         useMemsetSingleBlock = true;
-      } else {
-         useMemsetSingleBlock = false;
-      }
-
-   } else {
-      useMemset = false;
-   }
-
-   if (useMemset) {
-      if (useMemsetSingleBlock) {
-         memset(array2D[0], 0, iSize*jSize*sizeof(double));
-      } else {
-         for (int ii = 0; ii < iSize; ii++) {
-            memset(array2D[ii], 0, jSize*sizeof(double));
-         }
-      }
-   } else {
-      for (int ii = 0; ii < iSize; ii++) {
-         for (int jj = 0; jj < jSize; jj++) {
-            array2D[ii][jj] = initialValue;
-         }
-      }
-   }
-}
-
 /* ---------------------------------------------------------------------------------------
 
    Compute cross product of two 3-vectors and place in 3rd vector  -- helper method

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

@@ -53,7 +53,7 @@ public:
     }
     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.
+        return {}; // This force field doesn't define any parameters.
     }
     std::vector<std::string> getKernelNames();
     Kernel& getKernel() {

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

@@ -56,7 +56,7 @@ public:
     }
     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.
+        return {}; // This force field doesn't define any parameters.
     }
     std::vector<std::string> getKernelNames();
 

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

@@ -55,7 +55,7 @@ public:
     }
     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.
+        return {}; // This force field doesn't define any parameters.
     }
     std::vector<std::string> getKernelNames();