Merge pull request #1747 from peastman/realtype

Eliminated RealOpenMM

platforms/reference/include/ReferencePME.h

@@ -32,13 +32,13 @@
 #ifndef __ReferencePME_H__
 #define __ReferencePME_H__
 
-#include "RealVec.h"
+#include "openmm/Vec3.h"
 #include "openmm/internal/windowsExport.h"
 #include <vector>
 
 namespace OpenMM {
 
-typedef RealOpenMM rvec[3];
+typedef double rvec[3];
 
 
 typedef struct pme *
@@ -59,12 +59,12 @@ pme_t;
  * epsilon_r   Dielectric coefficient, typically 1.0.
  */
 int OPENMM_EXPORT
-pme_init(pme_t *       ppme,
-         RealOpenMM    ewaldcoeff,
+pme_init(pme_t* ppme,
+         double ewaldcoeff,
          int natoms,
          const int ngrid[3],
          int pme_order,
-         RealOpenMM    epsilon_r);
+         double epsilon_r);
 
 /*
  * Evaluate reciprocal space PME energy and forces.
@@ -80,14 +80,14 @@ pme_init(pme_t *       ppme,
  */
 int OPENMM_EXPORT
 pme_exec(pme_t pme,
-         const std::vector<OpenMM::RealVec>& atomCoordinates,
-         std::vector<OpenMM::RealVec>& forces,
-         const std::vector<RealOpenMM>& charges,
-         const OpenMM::RealVec  periodicBoxVectors[3],
-         RealOpenMM *    energy);
+         const std::vector<OpenMM::Vec3>& atomCoordinates,
+         std::vector<OpenMM::Vec3>& forces,
+         const std::vector<double>& charges,
+         const OpenMM::Vec3 periodicBoxVectors[3],
+         double* energy);
 
 
-/*
+/**
  * Evaluate reciprocal space PME dispersion energy and forces.
  *
  * Args:
@@ -101,11 +101,11 @@ pme_exec(pme_t       pme,
  */
 int OPENMM_EXPORT
 pme_exec_dpme(pme_t pme,
-              const std::vector<OpenMM::RealVec>& atomCoordinates,
-              std::vector<OpenMM::RealVec>& forces,
-              const std::vector<RealOpenMM>& c6s,
-              const OpenMM::RealVec  periodicBoxVectors[3],
-              RealOpenMM *    energy);
+              const std::vector<OpenMM::Vec3>& atomCoordinates,
+              std::vector<OpenMM::Vec3>& forces,
+              const std::vector<double>& c6s,
+              const OpenMM::Vec3 periodicBoxVectors[3],
+              double* energy);
 
 
 

platforms/reference/include/ReferencePairIxn.h

@@ -25,7 +25,7 @@
 #ifndef __ReferencePairIxn_H__
 #define __ReferencePairIxn_H__
 
-#include "RealVec.h"
+#include "openmm/Vec3.h"
 #include "openmm/internal/windowsExport.h"
 #include <vector>
 
@@ -68,10 +68,10 @@ class OPENMM_EXPORT ReferencePairIxn {
             
          --------------------------------------------------------------------------------------- */
           
-      virtual void calculatePairIxn(int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates,
-                            RealOpenMM** atomParameters, int** exclusions,
-                            RealOpenMM* fixedParameters, std::vector<OpenMM::RealVec>& forces,
-                            RealOpenMM* energyByAtom, RealOpenMM* totalEnergy) const = 0;
+      virtual void calculatePairIxn(int numberOfAtoms, std::vector<OpenMM::Vec3>& atomCoordinates,
+                            double** atomParameters, int** exclusions,
+                            double* fixedParameters, std::vector<OpenMM::Vec3>& forces,
+                            double* energyByAtom, double* totalEnergy) const = 0;
       
 };
 

platforms/reference/include/ReferenceProperDihedralBond.h

@@ -34,7 +34,7 @@ class OPENMM_EXPORT ReferenceProperDihedralBond : public ReferenceBondIxn {
    private:
 
         bool usePeriodic;
-        RealVec boxVectors[3];
+        Vec3 boxVectors[3];
        
    public:
 
@@ -62,7 +62,7 @@ class OPENMM_EXPORT ReferenceProperDihedralBond : public ReferenceBondIxn {
       
          --------------------------------------------------------------------------------------- */
       
-       void setPeriodic(OpenMM::RealVec* vectors);
+       void setPeriodic(OpenMM::Vec3* vectors);
 
       /**---------------------------------------------------------------------------------------
       
@@ -78,9 +78,9 @@ class OPENMM_EXPORT ReferenceProperDihedralBond : public ReferenceBondIxn {
       
          --------------------------------------------------------------------------------------- */
       
-      void calculateBondIxn(int* atomIndices, std::vector<OpenMM::RealVec>& atomCoordinates,
-                            RealOpenMM* parameters, std::vector<OpenMM::RealVec>& forces,
-                            RealOpenMM* totalEnergy, double* energyParamDerivs);
+      void calculateBondIxn(int* atomIndices, std::vector<OpenMM::Vec3>& atomCoordinates,
+                            double* parameters, std::vector<OpenMM::Vec3>& forces,
+                            double* totalEnergy, double* energyParamDerivs);
 
 };
 

platforms/reference/include/ReferenceRbDihedralBond.h

@@ -34,7 +34,7 @@ class OPENMM_EXPORT ReferenceRbDihedralBond : public ReferenceBondIxn {
    private:
 
         bool usePeriodic;
-        RealVec boxVectors[3];
+        Vec3 boxVectors[3];
        
    public:
 
@@ -62,7 +62,7 @@ class OPENMM_EXPORT ReferenceRbDihedralBond : public ReferenceBondIxn {
       
          --------------------------------------------------------------------------------------- */
       
-       void setPeriodic(OpenMM::RealVec* vectors);
+       void setPeriodic(OpenMM::Vec3* vectors);
 
       /**---------------------------------------------------------------------------------------
       
@@ -76,9 +76,9 @@ class OPENMM_EXPORT ReferenceRbDihedralBond : public ReferenceBondIxn {
             
          --------------------------------------------------------------------------------------- */
       
-      void calculateBondIxn(int* atomIndices, std::vector<OpenMM::RealVec>& atomCoordinates,
-                            RealOpenMM* parameters, std::vector<OpenMM::RealVec>& forces,
-                            RealOpenMM* totalEnergy, double* energyParamDerivs);
+      void calculateBondIxn(int* atomIndices, std::vector<OpenMM::Vec3>& atomCoordinates,
+                            double* parameters, std::vector<OpenMM::Vec3>& forces,
+                            double* totalEnergy, double* energyParamDerivs);
 
 };
 

platforms/reference/include/ReferenceSETTLEAlgorithm.h

@@ -44,7 +44,7 @@ namespace OpenMM {
 class OPENMM_EXPORT ReferenceSETTLEAlgorithm : public ReferenceConstraintAlgorithm {
 public:
     ReferenceSETTLEAlgorithm(const std::vector<int>& atom1, const std::vector<int>& atom2, const std::vector<int>& atom3,
-            const std::vector<RealOpenMM>& distance1, const std::vector<RealOpenMM>& distance2, std::vector<RealOpenMM>& masses);
+            const std::vector<double>& distance1, const std::vector<double>& distance2, std::vector<double>& masses);
 
     /**
      * Get the number of clusters.
@@ -60,7 +60,7 @@ public:
      * @param distance1   the distance between atoms 1 and 2
      * @param distance2   the distance between atoms 2 and 3
      */
-    void getClusterParameters(int index, int& atom1, int& atom2, int& atom3, RealOpenMM& distance1, RealOpenMM& distance2) const;
+    void getClusterParameters(int index, int& atom1, int& atom2, int& atom3, double& distance1, double& distance2) const;
     /**
      * Apply the constraint algorithm.
      * 
@@ -69,7 +69,7 @@ public:
      * @param inverseMasses    1/mass
      * @param tolerance        the constraint tolerance
      */
-    void apply(std::vector<OpenMM::RealVec>& atomCoordinates, std::vector<OpenMM::RealVec>& atomCoordinatesP, std::vector<RealOpenMM>& inverseMasses, RealOpenMM tolerance);
+    void apply(std::vector<OpenMM::Vec3>& atomCoordinates, std::vector<OpenMM::Vec3>& atomCoordinatesP, std::vector<double>& inverseMasses, double tolerance);
 
     /**
      * Apply the constraint algorithm to velocities.
@@ -79,14 +79,14 @@ public:
      * @param inverseMasses    1/mass
      * @param tolerance        the constraint tolerance
      */
-    void applyToVelocities(std::vector<OpenMM::RealVec>& atomCoordinates, std::vector<OpenMM::RealVec>& velocities, std::vector<RealOpenMM>& inverseMasses, RealOpenMM tolerance);
+    void applyToVelocities(std::vector<OpenMM::Vec3>& atomCoordinates, std::vector<OpenMM::Vec3>& velocities, std::vector<double>& inverseMasses, double tolerance);
 private:
     std::vector<int> atom1;
     std::vector<int> atom2;
     std::vector<int> atom3;
-    std::vector<RealOpenMM> distance1;
-    std::vector<RealOpenMM> distance2;
-    std::vector<RealOpenMM> masses;
+    std::vector<double> distance1;
+    std::vector<double> distance2;
+    std::vector<double> masses;
 };
 
 } // namespace OpenMM

platforms/reference/include/ReferenceStochasticDynamics.h

@@ -34,9 +34,9 @@ class OPENMM_EXPORT ReferenceStochasticDynamics : public ReferenceDynamics {
 
    protected:
 
-      std::vector<OpenMM::RealVec> xPrime;
-      std::vector<RealOpenMM> inverseMasses;
-      RealOpenMM friction;
+      std::vector<OpenMM::Vec3> xPrime;
+      std::vector<double> inverseMasses;
+      double friction;
       
    public:
 
@@ -51,7 +51,7 @@ class OPENMM_EXPORT ReferenceStochasticDynamics : public ReferenceDynamics {
       
          --------------------------------------------------------------------------------------- */
 
-       ReferenceStochasticDynamics(int numberOfAtoms, RealOpenMM deltaT, RealOpenMM friction, RealOpenMM temperature);
+       ReferenceStochasticDynamics(int numberOfAtoms, double deltaT, double friction, double temperature);
 
       /**---------------------------------------------------------------------------------------
       
@@ -67,7 +67,7 @@ class OPENMM_EXPORT ReferenceStochasticDynamics : public ReferenceDynamics {
       
          --------------------------------------------------------------------------------------- */
       
-      RealOpenMM getFriction() const;
+      double getFriction() const;
       
       /**---------------------------------------------------------------------------------------
       
@@ -82,8 +82,8 @@ class OPENMM_EXPORT ReferenceStochasticDynamics : public ReferenceDynamics {
       
          --------------------------------------------------------------------------------------- */
      
-      void update(const OpenMM::System& system, std::vector<OpenMM::RealVec>& atomCoordinates,
-                  std::vector<OpenMM::RealVec>& velocities, std::vector<OpenMM::RealVec>& forces, std::vector<RealOpenMM>& masses, RealOpenMM tolerance);
+      void update(const OpenMM::System& system, std::vector<OpenMM::Vec3>& atomCoordinates,
+                  std::vector<OpenMM::Vec3>& velocities, std::vector<OpenMM::Vec3>& forces, std::vector<double>& masses, double tolerance);
      
       /**---------------------------------------------------------------------------------------
       
@@ -98,8 +98,8 @@ class OPENMM_EXPORT ReferenceStochasticDynamics : public ReferenceDynamics {
       
          --------------------------------------------------------------------------------------- */
       
-      virtual void updatePart1(int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, std::vector<OpenMM::RealVec>& velocities,
-                       std::vector<OpenMM::RealVec>& forces, std::vector<RealOpenMM>& inverseMasses, std::vector<OpenMM::RealVec>& xPrime);
+      virtual void updatePart1(int numberOfAtoms, std::vector<OpenMM::Vec3>& atomCoordinates, std::vector<OpenMM::Vec3>& velocities,
+                       std::vector<OpenMM::Vec3>& forces, std::vector<double>& inverseMasses, std::vector<OpenMM::Vec3>& xPrime);
       
       /**---------------------------------------------------------------------------------------
       
@@ -113,8 +113,8 @@ class OPENMM_EXPORT ReferenceStochasticDynamics : public ReferenceDynamics {
       
          --------------------------------------------------------------------------------------- */
       
-      virtual void updatePart2(int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, std::vector<OpenMM::RealVec>& velocities,
-                       std::vector<OpenMM::RealVec>& forces, std::vector<RealOpenMM>& inverseMasses, std::vector<OpenMM::RealVec>& xPrime);
+      virtual void updatePart2(int numberOfAtoms, std::vector<OpenMM::Vec3>& atomCoordinates, std::vector<OpenMM::Vec3>& velocities,
+                       std::vector<OpenMM::Vec3>& forces, std::vector<double>& inverseMasses, std::vector<OpenMM::Vec3>& xPrime);
       
       /**---------------------------------------------------------------------------------------
       
@@ -127,8 +127,8 @@ class OPENMM_EXPORT ReferenceStochasticDynamics : public ReferenceDynamics {
       
          --------------------------------------------------------------------------------------- */
       
-      virtual void updatePart3(int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, std::vector<OpenMM::RealVec>& velocities,
-                       std::vector<RealOpenMM>& inverseMasses, std::vector<OpenMM::RealVec>& xPrime);
+      virtual void updatePart3(int numberOfAtoms, std::vector<OpenMM::Vec3>& atomCoordinates, std::vector<OpenMM::Vec3>& velocities,
+                       std::vector<double>& inverseMasses, std::vector<OpenMM::Vec3>& xPrime);
 };
 
 } // namespace OpenMM

platforms/reference/include/ReferenceVariableStochasticDynamics.h

@@ -33,9 +33,9 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics {
 
    private:
 
-      std::vector<OpenMM::RealVec> xPrime;
-      std::vector<RealOpenMM> inverseMasses;
-      RealOpenMM friction, _accuracy;
+      std::vector<OpenMM::Vec3> xPrime;
+      std::vector<double> inverseMasses;
+      double friction, _accuracy;
 
    public:
 
@@ -50,7 +50,7 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics {
 
          --------------------------------------------------------------------------------------- */
 
-       ReferenceVariableStochasticDynamics(int numberOfAtoms, RealOpenMM friction, RealOpenMM temperature, RealOpenMM accuracy);
+       ReferenceVariableStochasticDynamics(int numberOfAtoms, double friction, double temperature, double accuracy);
 
       /**---------------------------------------------------------------------------------------
 
@@ -66,7 +66,7 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics {
 
          --------------------------------------------------------------------------------------- */
 
-      RealOpenMM getFriction() const;
+      double getFriction() const;
       
       /**---------------------------------------------------------------------------------------
 
@@ -76,7 +76,7 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics {
 
          --------------------------------------------------------------------------------------- */
 
-      RealOpenMM getAccuracy() const;
+      double getAccuracy() const;
 
       /**---------------------------------------------------------------------------------------
 
@@ -84,7 +84,7 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics {
 
          --------------------------------------------------------------------------------------- */
 
-      void setAccuracy(RealOpenMM accuracy);
+      void setAccuracy(double accuracy);
 
       /**---------------------------------------------------------------------------------------
 
@@ -100,8 +100,8 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics {
 
          --------------------------------------------------------------------------------------- */
 
-      void update(const OpenMM::System& system, std::vector<OpenMM::RealVec>& atomCoordinates,
-                  std::vector<OpenMM::RealVec>& velocities, std::vector<OpenMM::RealVec>& forces, std::vector<RealOpenMM>& masses, RealOpenMM maxStepSize, RealOpenMM tolerance);
+      void update(const OpenMM::System& system, std::vector<OpenMM::Vec3>& atomCoordinates,
+                  std::vector<OpenMM::Vec3>& velocities, std::vector<OpenMM::Vec3>& forces, std::vector<double>& masses, double maxStepSize, double tolerance);
 
       /**---------------------------------------------------------------------------------------
 
@@ -118,9 +118,9 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics {
 
          --------------------------------------------------------------------------------------- */
 
-      void updatePart1(int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, std::vector<OpenMM::RealVec>& velocities,
-                       std::vector<OpenMM::RealVec>& forces, std::vector<RealOpenMM>& masses, std::vector<RealOpenMM>& inverseMasses,
-                       std::vector<OpenMM::RealVec>& xPrime, RealOpenMM maxStepSize);
+      void updatePart1(int numberOfAtoms, std::vector<OpenMM::Vec3>& atomCoordinates, std::vector<OpenMM::Vec3>& velocities,
+                       std::vector<OpenMM::Vec3>& forces, std::vector<double>& masses, std::vector<double>& inverseMasses,
+                       std::vector<OpenMM::Vec3>& xPrime, double maxStepSize);
 
       /**---------------------------------------------------------------------------------------
 
@@ -134,9 +134,9 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics {
 
          --------------------------------------------------------------------------------------- */
 
-      void updatePart2(int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, std::vector<OpenMM::RealVec>& velocities,
-                       std::vector<OpenMM::RealVec>& forces, std::vector<RealOpenMM>& inverseMasses,
-                       std::vector<OpenMM::RealVec>& xPrime);
+      void updatePart2(int numberOfAtoms, std::vector<OpenMM::Vec3>& atomCoordinates, std::vector<OpenMM::Vec3>& velocities,
+                       std::vector<OpenMM::Vec3>& forces, std::vector<double>& inverseMasses,
+                       std::vector<OpenMM::Vec3>& xPrime);
       
 };
 

platforms/reference/include/ReferenceVariableVerletDynamics.h

@@ -33,9 +33,9 @@ class ReferenceVariableVerletDynamics : public ReferenceDynamics {
 
    private:
 
-      std::vector<OpenMM::RealVec> xPrime;
-      std::vector<RealOpenMM> inverseMasses;
-      RealOpenMM _accuracy;
+      std::vector<OpenMM::Vec3> xPrime;
+      std::vector<double> inverseMasses;
+      double _accuracy;
 
    public:
 
@@ -48,7 +48,7 @@ class ReferenceVariableVerletDynamics : public ReferenceDynamics {
 
          --------------------------------------------------------------------------------------- */
 
-       ReferenceVariableVerletDynamics(int numberOfAtoms, RealOpenMM accuracy);
+       ReferenceVariableVerletDynamics(int numberOfAtoms, double accuracy);
 
       /**---------------------------------------------------------------------------------------
 
@@ -66,7 +66,7 @@ class ReferenceVariableVerletDynamics : public ReferenceDynamics {
 
          --------------------------------------------------------------------------------------- */
 
-      RealOpenMM getAccuracy() const;
+      double getAccuracy() const;
 
       /**---------------------------------------------------------------------------------------
 
@@ -74,7 +74,7 @@ class ReferenceVariableVerletDynamics : public ReferenceDynamics {
 
          --------------------------------------------------------------------------------------- */
 
-      void setAccuracy(RealOpenMM accuracy);
+      void setAccuracy(double accuracy);
 
       /**---------------------------------------------------------------------------------------
 
@@ -90,8 +90,8 @@ class ReferenceVariableVerletDynamics : public ReferenceDynamics {
 
          --------------------------------------------------------------------------------------- */
 
-      void update(const OpenMM::System& system, std::vector<OpenMM::RealVec>& atomCoordinates,
-                  std::vector<OpenMM::RealVec>& velocities, std::vector<OpenMM::RealVec>& forces, std::vector<RealOpenMM>& masses, RealOpenMM maxStepSize, RealOpenMM tolerance);
+      void update(const OpenMM::System& system, std::vector<OpenMM::Vec3>& atomCoordinates,
+                  std::vector<OpenMM::Vec3>& velocities, std::vector<OpenMM::Vec3>& forces, std::vector<double>& masses, double maxStepSize, double tolerance);
 
 };
 

platforms/reference/include/ReferenceVerletDynamics.h

@@ -33,8 +33,8 @@ class ReferenceVerletDynamics : public ReferenceDynamics {
 
    private:
 
-      std::vector<OpenMM::RealVec> xPrime;
-      std::vector<RealOpenMM> inverseMasses;
+      std::vector<OpenMM::Vec3> xPrime;
+      std::vector<double> inverseMasses;
       
    public:
 
@@ -49,7 +49,7 @@ class ReferenceVerletDynamics : public ReferenceDynamics {
       
          --------------------------------------------------------------------------------------- */
 
-       ReferenceVerletDynamics(int numberOfAtoms, RealOpenMM deltaT);
+       ReferenceVerletDynamics(int numberOfAtoms, double deltaT);
 
       /**---------------------------------------------------------------------------------------
       
@@ -72,8 +72,8 @@ class ReferenceVerletDynamics : public ReferenceDynamics {
       
          --------------------------------------------------------------------------------------- */
      
-      void update(const OpenMM::System& system, std::vector<OpenMM::RealVec>& atomCoordinates,
-                  std::vector<OpenMM::RealVec>& velocities, std::vector<OpenMM::RealVec>& forces, std::vector<RealOpenMM>& masses, RealOpenMM tolerance);
+      void update(const OpenMM::System& system, std::vector<OpenMM::Vec3>& atomCoordinates,
+                  std::vector<OpenMM::Vec3>& velocities, std::vector<OpenMM::Vec3>& forces, std::vector<double>& masses, double tolerance);
       
 };
 

platforms/reference/include/ReferenceVirtualSites.h

@@ -33,7 +33,7 @@
 #define __ReferenceVirtualSites_H__
 
 #include "openmm/System.h"
-#include "RealVec.h"
+#include "openmm/Vec3.h"
 #include <vector>
 
 namespace OpenMM {
@@ -43,11 +43,11 @@ public:
     /**
      * Compute the positions of all virtual sites.
      */
-    static void computePositions(const OpenMM::System& system, std::vector<OpenMM::RealVec>& atomCoordinates);
+    static void computePositions(const OpenMM::System& system, std::vector<OpenMM::Vec3>& atomCoordinates);
     /**
      * Distribute forces from virtual sites to the atoms they are based on.
      */
-    static void distributeForces(const OpenMM::System& system, const std::vector<OpenMM::RealVec>& atomCoordinates, std::vector<OpenMM::RealVec>& forces);
+    static void distributeForces(const OpenMM::System& system, const std::vector<OpenMM::Vec3>& atomCoordinates, std::vector<OpenMM::Vec3>& forces);
 };
 
 } // namespace OpenMM

platforms/reference/include/SimTKOpenMMRealType.h

 
-/* Portions copyright (c) 2006 Stanford University and Simbios.
+/* Portions copyright (c) 2006-2017 Stanford University and Simbios.
  * Contributors: Pande Group
  *
  * Permission is hereby granted, free of charge, to any person obtaining
@@ -28,46 +28,6 @@
 
 #include <cmath>
 
-// Set RealOpenMMType to 2 for double precision, 1 for float
-
-#ifndef RealOpenMMType
-#define RealOpenMMType 2
-#endif 
-
-#if RealOpenMMType == 1 
-
-#define RealOpenMM     float
-#define SQRT           sqrtf
-#define POW            powf
-#define SIN            sinf
-#define COS            cosf
-#define TAN            tanf
-
-// LOG is used in Vishal's gpu code; modifying LOG -> LN 
-#define LN             logf
-
-#define EXP            expf
-#define FABS           fabsf
-#define ACOS           acosf
-#define ASIN           asinf
-#define ATAN           atanf
-#define TANH           tanhf
-
-#define FLOOR          floorf
-
-#define ATOF           atoff
-
-#define PI_M               3.141592653589f
-#define TWO_SIX            1.122462048309372981f
-#define RADIAN            57.29577951308f
-#define RADIAN_TO_DEGREE  57.29577951308f
-#define LOG_TEN            2.302585092994045684f
-#define SQRT_TWO           1.41421356237309504f
-#define DEGREE_TO_RADIAN   0.01745329252f
-#define RADIAN_INVERSE     0.01745329252f
-
-#else
-
 #define RealOpenMM     double
 #define SQRT           sqrt
 #define POW            pow
@@ -98,8 +58,6 @@
 #define DEGREE_TO_RADIAN   0.01745329252
 #define RADIAN_INVERSE     0.01745329252
 
-#endif
-
 #define DOT3(u,v) ((u[0])*(v[0]) + (u[1])*(v[1]) + (u[2])*(v[2]))
 
 #define MATRIXDOT3(u,v) u[0]*v[0] + u[1]*v[1] + u[2]*v[2] + \

platforms/reference/include/SimTKOpenMMUtilities.h

@@ -27,7 +27,7 @@
 
 // class of shared, static utility methods
 
-#include "RealVec.h"
+#include "SimTKOpenMMRealType.h"
 #include "sfmt/SFMT.h"
 #include "openmm/internal/windowsExport.h"
 
@@ -49,7 +49,7 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
        static uint32_t _randomNumberSeed;
        static bool _randomInitialized;
        static bool nextGaussianIsValid;
-       static RealOpenMM nextGaussian;
+       static double nextGaussian;
        static OpenMM_SFMT::SFMT sfmt;
 
    public:
@@ -61,7 +61,7 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
       
       /**---------------------------------------------------------------------------------------
       
-         Allocate 1D RealOpenMM array (Simbios)
+         Allocate 1D double array (Simbios)
       
          array[i]
       
@@ -75,13 +75,13 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
       
          --------------------------------------------------------------------------------------- */
       
-      static RealOpenMM* allocateOneDRealOpenMMArray(int iSize, RealOpenMM* array1D, int initialize,
-                                                      RealOpenMM initialValue,
+      static double* allocateOneDRealOpenMMArray(int iSize, double* array1D, int initialize,
+                                                      double initialValue,
                                                       const std::string& idString = std::string("1DArray"));
       
       /**---------------------------------------------------------------------------------------
       
-         Allocate 2D RealOpenMM array (Simbios)
+         Allocate 2D double array (Simbios)
       
          array[i][j]
       
@@ -96,14 +96,14 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
       
          --------------------------------------------------------------------------------------- */
       
-      static RealOpenMM** allocateTwoDRealOpenMMArray(int iSize, int jSize,
-                                                       RealOpenMM** array2D, int initialize,
-                                                       RealOpenMM initialValue,
+      static double** allocateTwoDRealOpenMMArray(int iSize, int jSize,
+                                                       double** array2D, int initialize,
+                                                       double initialValue,
                                                        const std::string& idString = std::string("2DArray"));
       
       /* ---------------------------------------------------------------------------------------
       
-         Free 2D RealOpenMM array (Simbios)
+         Free 2D double array (Simbios)
       
          array[i][j]
       
@@ -112,12 +112,12 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
       
          --------------------------------------------------------------------------------------- */
       
-      static void freeOneDRealOpenMMArray(RealOpenMM* array1D,
+      static void freeOneDRealOpenMMArray(double* array1D,
                                           const std::string& idString = std::string("1DArray"));
       
       /* ---------------------------------------------------------------------------------------
       
-         Free 2D RealOpenMM array (Simbios)
+         Free 2D double array (Simbios)
       
          array[i][j]
       
@@ -126,12 +126,12 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
       
          --------------------------------------------------------------------------------------- */
       
-      static void freeTwoDRealOpenMMArray(RealOpenMM** array2D,
+      static void freeTwoDRealOpenMMArray(double** array2D,
                                           const std::string& idString = std::string("2DArray"));
       
       /**---------------------------------------------------------------------------------------
       
-         Initialize 2D RealOpenMM array (Simbios)
+         Initialize 2D double array (Simbios)
       
          array[i][j]
       
@@ -143,7 +143,7 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
          --------------------------------------------------------------------------------------- */
       
       static void initialize2DRealOpenMMArray(int iSize, int jSize,
-                                              RealOpenMM** array2D, RealOpenMM initialValue);
+                                              double** array2D, double initialValue);
 
       /**---------------------------------------------------------------------------------------
       
@@ -159,7 +159,7 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
       
          --------------------------------------------------------------------------------------- */
       
-      static void crossProductVector3(RealOpenMM* vectorX, RealOpenMM* vectorY, RealOpenMM* vectorZ);
+      static void crossProductVector3(double* vectorX, double* vectorY, double* vectorZ);
       
       /**---------------------------------------------------------------------------------------
       
@@ -169,7 +169,7 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
       
          --------------------------------------------------------------------------------------- */
       
-      static RealOpenMM getNormallyDistributedRandomNumber();
+      static double getNormallyDistributedRandomNumber();
       
       /**---------------------------------------------------------------------------------------
       
@@ -179,7 +179,7 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
       
          --------------------------------------------------------------------------------------- */
       
-      static RealOpenMM getUniformlyDistributedRandomNumber();
+      static double getUniformlyDistributedRandomNumber();
 
       /**---------------------------------------------------------------------------------------
       

platforms/reference/include/fftpack.h

@@ -20,7 +20,6 @@
 
 #include <stdio.h>
 
-#include "RealVec.h"
 #include "openmm/internal/windowsExport.h"
 
 #ifdef __cplusplus
@@ -33,15 +32,15 @@ extern "C" {
 
 class t_complex {
 public:
-    RealOpenMM re;
-    RealOpenMM im;
+    double re;
+    double im;
     t_complex() : re(0.0), im(0.0) {
     }
-    t_complex(RealOpenMM re, RealOpenMM im) : re(re), im(im) {
+    t_complex(double re, double im) : re(re), im(im) {
     }
     t_complex(const t_complex& c) : re(c.re), im(c.im) {
     }
-    t_complex operator*(RealOpenMM r) {
+    t_complex operator*(double r) {
         return t_complex(re*r, im*r);
     }
     t_complex operator+(const t_complex& c) const {

platforms/reference/src/ReferencePlatform.cpp

@@ -35,7 +35,7 @@
 #include "ReferenceKernels.h"
 #include "openmm/internal/ContextImpl.h"
 #include "SimTKOpenMMRealType.h"
-#include "RealVec.h"
+#include "openmm/Vec3.h"
 #include <map>
 #include <vector>
 
@@ -82,7 +82,7 @@ double ReferencePlatform::getSpeed() const {
 }
 
 bool ReferencePlatform::supportsDoublePrecision() const {
-    return (sizeof(RealOpenMM) >= sizeof(double));
+    return true;
 }
 
 void ReferencePlatform::contextCreated(ContextImpl& context, const map<string, string>& properties) const {
@@ -95,21 +95,21 @@ void ReferencePlatform::contextDestroyed(ContextImpl& context) const {
 }
 
 ReferencePlatform::PlatformData::PlatformData(const System& system) : time(0.0), stepCount(0), numParticles(system.getNumParticles()) {
-    positions = new vector<RealVec>(numParticles);
-    velocities = new vector<RealVec>(numParticles);
-    forces = new vector<RealVec>(numParticles);
-    periodicBoxSize = new RealVec();
-    periodicBoxVectors = new RealVec[3];
+    positions = new vector<Vec3>(numParticles);
+    velocities = new vector<Vec3>(numParticles);
+    forces = new vector<Vec3>(numParticles);
+    periodicBoxSize = new Vec3();
+    periodicBoxVectors = new Vec3[3];
     constraints = new ReferenceConstraints(system);
     energyParameterDerivatives = new map<string, double>();
 }
 
 ReferencePlatform::PlatformData::~PlatformData() {
-    delete (vector<RealVec>*) positions;
-    delete (vector<RealVec>*) velocities;
-    delete (vector<RealVec>*) forces;
-    delete (RealVec*) periodicBoxSize;
-    delete[] (RealVec*) periodicBoxVectors;
+    delete (vector<Vec3>*) positions;
+    delete (vector<Vec3>*) velocities;
+    delete (vector<Vec3>*) forces;
+    delete (Vec3*) periodicBoxSize;
+    delete[] (Vec3*) periodicBoxVectors;
     delete (ReferenceConstraints*) constraints;
     delete (map<string, double>*) energyParameterDerivatives;
 }

platforms/reference/src/SimTKReference/ObcParameters.cpp

@@ -28,6 +28,7 @@
 
 #include "openmm/OpenMMException.h"
 #include "ObcParameters.h"
+#include "SimTKOpenMMRealType.h"
 
 using std::vector;
 using namespace OpenMM;
@@ -121,7 +122,7 @@ void ObcParameters::setObcTypeParameters(ObcParameters::ObcType obcType) {
 
     --------------------------------------------------------------------------------------- */
 
-RealOpenMM ObcParameters::getDielectricOffset() const {
+double ObcParameters::getDielectricOffset() const {
     return _dielectricOffset;
 }
 
@@ -133,7 +134,7 @@ RealOpenMM ObcParameters::getDielectricOffset() const {
 
     --------------------------------------------------------------------------------------- */
 
-RealOpenMM ObcParameters::getAlphaObc() const {
+double ObcParameters::getAlphaObc() const {
     return _alphaObc;
 }
 
@@ -145,7 +146,7 @@ RealOpenMM ObcParameters::getAlphaObc() const {
 
     --------------------------------------------------------------------------------------- */
 
-RealOpenMM ObcParameters::getBetaObc() const {
+double ObcParameters::getBetaObc() const {
     return _betaObc;
 }
 
@@ -157,7 +158,7 @@ RealOpenMM ObcParameters::getBetaObc() const {
 
     --------------------------------------------------------------------------------------- */
 
-RealOpenMM ObcParameters::getGammaObc() const {
+double ObcParameters::getGammaObc() const {
     return _gammaObc;
 }
 
@@ -169,7 +170,7 @@ RealOpenMM ObcParameters::getGammaObc() const {
 
    --------------------------------------------------------------------------------------- */
 
-RealOpenMM ObcParameters::getSolventDielectric() const {
+double ObcParameters::getSolventDielectric() const {
     return _solventDielectric;
 }
 
@@ -181,7 +182,7 @@ RealOpenMM ObcParameters::getSolventDielectric() const {
 
    --------------------------------------------------------------------------------------- */
 
-void ObcParameters::setSolventDielectric(RealOpenMM solventDielectric) {
+void ObcParameters::setSolventDielectric(double solventDielectric) {
     _solventDielectric = solventDielectric;
 }
 /**---------------------------------------------------------------------------------------
@@ -192,7 +193,7 @@ void ObcParameters::setSolventDielectric(RealOpenMM solventDielectric) {
 
    --------------------------------------------------------------------------------------- */
 
-RealOpenMM ObcParameters::getSoluteDielectric() const {
+double ObcParameters::getSoluteDielectric() const {
     return _soluteDielectric;
 }
 
@@ -204,7 +205,7 @@ RealOpenMM ObcParameters::getSoluteDielectric() const {
 
    --------------------------------------------------------------------------------------- */
 
-void ObcParameters::setSoluteDielectric(RealOpenMM soluteDielectric) {
+void ObcParameters::setSoluteDielectric(double soluteDielectric) {
     _soluteDielectric = soluteDielectric;
 }
 
@@ -216,7 +217,7 @@ void ObcParameters::setSoluteDielectric(RealOpenMM soluteDielectric) {
 
    --------------------------------------------------------------------------------------- */
 
-RealOpenMM ObcParameters::getElectricConstant() const {
+double ObcParameters::getElectricConstant() const {
     return _electricConstant;
 }
 
@@ -228,7 +229,7 @@ RealOpenMM ObcParameters::getElectricConstant() const {
 
    --------------------------------------------------------------------------------------- */
 
-RealOpenMM ObcParameters::getProbeRadius() const {
+double ObcParameters::getProbeRadius() const {
     return _probeRadius;
 }
 
@@ -240,25 +241,25 @@ RealOpenMM ObcParameters::getProbeRadius() const {
 
    --------------------------------------------------------------------------------------- */
 
-void ObcParameters::setProbeRadius(RealOpenMM probeRadius) {
+void ObcParameters::setProbeRadius(double probeRadius) {
     _probeRadius = probeRadius;
 }
 
 /**---------------------------------------------------------------------------------------
 
    Get pi*4*Asolv:  used in ACE approximation for nonpolar term  
-         ((RealOpenMM) M_PI)*4.0f*0.0049*1000.0; (Still) 
-         ((RealOpenMM) M_PI)*4.0f*0.0054*1000.0; (OBC) 
+         M_PI*4.0f*0.0049*1000.0; (Still) 
+         M_PI*4.0f*0.0054*1000.0; (OBC) 
 
    @return pi4Asolv
 
    --------------------------------------------------------------------------------------- */
 
-RealOpenMM ObcParameters::getPi4Asolv() const {
+double ObcParameters::getPi4Asolv() const {
     return _pi4Asolv;
 }
 
-void ObcParameters::setPi4Asolv(RealOpenMM pi4Asolv) {
+void ObcParameters::setPi4Asolv(double pi4Asolv) {
     _pi4Asolv = pi4Asolv;
 }
 
@@ -270,7 +271,7 @@ void ObcParameters::setPi4Asolv(RealOpenMM pi4Asolv) {
 
     --------------------------------------------------------------------------------------- */
 
-const vector<RealOpenMM>& ObcParameters::getAtomicRadii() const {
+const vector<double>& ObcParameters::getAtomicRadii() const {
     return _atomicRadii;
 }
 
@@ -282,7 +283,7 @@ const vector<RealOpenMM>& ObcParameters::getAtomicRadii() const {
 
     --------------------------------------------------------------------------------------- */
 
-void ObcParameters::setAtomicRadii(const vector<RealOpenMM>& atomicRadii) {
+void ObcParameters::setAtomicRadii(const vector<double>& atomicRadii) {
 
     if (atomicRadii.size() == _atomicRadii.size()) {
         for (unsigned int ii = 0; ii < atomicRadii.size(); ii++) {
@@ -306,7 +307,7 @@ void ObcParameters::setAtomicRadii(const vector<RealOpenMM>& atomicRadii) {
 
     --------------------------------------------------------------------------------------- */
 
-const vector<RealOpenMM>& ObcParameters::getScaledRadiusFactors() const {
+const vector<double>& ObcParameters::getScaledRadiusFactors() const {
     return _scaledRadiusFactors;
 }
 
@@ -318,7 +319,7 @@ const vector<RealOpenMM>& ObcParameters::getScaledRadiusFactors() const {
 
     --------------------------------------------------------------------------------------- */
 
-void ObcParameters::setScaledRadiusFactors(const vector<RealOpenMM>& scaledRadiusFactors) {
+void ObcParameters::setScaledRadiusFactors(const vector<double>& scaledRadiusFactors) {
 
     if (scaledRadiusFactors.size() == _scaledRadiusFactors.size()) {
         for (unsigned int ii = 0; ii < scaledRadiusFactors.size(); ii++) {
@@ -342,7 +343,7 @@ void ObcParameters::setScaledRadiusFactors(const vector<RealOpenMM>& scaledRadiu
 
       --------------------------------------------------------------------------------------- */
 
-void ObcParameters::setUseCutoff(RealOpenMM distance) {
+void ObcParameters::setUseCutoff(double distance) {
 
      _cutoff         = true;
      _cutoffDistance = distance;
@@ -364,7 +365,7 @@ bool ObcParameters::getUseCutoff() const {
 
       --------------------------------------------------------------------------------------- */
 
-RealOpenMM ObcParameters::getCutoffDistance() const {
+double ObcParameters::getCutoffDistance() const {
      return _cutoffDistance;
 }
 
@@ -378,7 +379,7 @@ RealOpenMM ObcParameters::getCutoffDistance() const {
 
       --------------------------------------------------------------------------------------- */
 
-void ObcParameters::setPeriodic(OpenMM::RealVec* vectors) {
+void ObcParameters::setPeriodic(OpenMM::Vec3* vectors) {
 
     assert(_cutoff);
 
@@ -408,6 +409,6 @@ bool ObcParameters::getPeriodic() {
 
       --------------------------------------------------------------------------------------- */
 
-const OpenMM::RealVec* ObcParameters::getPeriodicBox() {
+const OpenMM::Vec3* ObcParameters::getPeriodicBox() {
      return _periodicBoxVectors;
 }

platforms/reference/src/SimTKReference/ReferenceAndersenThermostat.cpp

@@ -22,6 +22,7 @@
  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
+#include <cmath>
 #include <string.h>
 #include <sstream>
 
@@ -61,10 +62,10 @@ using namespace OpenMM;
                   
          --------------------------------------------------------------------------------------- */
           
-      void ReferenceAndersenThermostat::applyThermostat(const vector<vector<int> >& atomGroups, vector<RealVec>& atomVelocities, vector<RealOpenMM>& atomMasses,
-              RealOpenMM temperature, RealOpenMM collisionFrequency, RealOpenMM stepSize) const {
+      void ReferenceAndersenThermostat::applyThermostat(const vector<vector<int> >& atomGroups, vector<Vec3>& atomVelocities, vector<double>& atomMasses,
+              double temperature, double collisionFrequency, double stepSize) const {
           
-          const RealOpenMM collisionProbability = 1.0f - EXP(-collisionFrequency*stepSize);
+          const double collisionProbability = 1.0f - exp(-collisionFrequency*stepSize);
           for (int i = 0; i < (int) atomGroups.size(); ++i) {
               if (SimTKOpenMMUtilities::getUniformlyDistributedRandomNumber() < collisionProbability) {
                   
@@ -73,7 +74,7 @@ using namespace OpenMM;
                   for (int j = 0; j < (int) atomGroups[i].size(); j++) {
                       int atom = atomGroups[i][j];
                       if (atomMasses[atom] != 0) {
-                          const RealOpenMM velocityScale = static_cast<RealOpenMM>(sqrt(BOLTZ*temperature/atomMasses[atom]));
+                          const double velocityScale = static_cast<double>(sqrt(BOLTZ*temperature/atomMasses[atom]));
                           atomVelocities[atom][0] = velocityScale*SimTKOpenMMUtilities::getNormallyDistributedRandomNumber();
                           atomVelocities[atom][1] = velocityScale*SimTKOpenMMUtilities::getNormallyDistributedRandomNumber();
                           atomVelocities[atom][2] = velocityScale*SimTKOpenMMUtilities::getNormallyDistributedRandomNumber();

platforms/reference/src/SimTKReference/ReferenceAngleBondIxn.cpp

@@ -39,13 +39,6 @@ using namespace OpenMM;
    --------------------------------------------------------------------------------------- */
 
 ReferenceAngleBondIxn::ReferenceAngleBondIxn() : usePeriodic(false) {
-
-   // ---------------------------------------------------------------------------------------
-
-   // static const char* methodName = "\nReferenceAngleBondIxn::ReferenceAngleBondIxn";
-
-   // ---------------------------------------------------------------------------------------
-
 }
 
 /**---------------------------------------------------------------------------------------
@@ -55,16 +48,9 @@ ReferenceAngleBondIxn::ReferenceAngleBondIxn() : usePeriodic(false) {
    --------------------------------------------------------------------------------------- */
 
 ReferenceAngleBondIxn::~ReferenceAngleBondIxn() {
-
-   // ---------------------------------------------------------------------------------------
-
-   // static const char* methodName = "\nReferenceAngleBondIxn::~ReferenceAngleBondIxn";
-
-   // ---------------------------------------------------------------------------------------
-
 }
 
-void ReferenceAngleBondIxn::setPeriodic(OpenMM::RealVec* vectors) {
+void ReferenceAngleBondIxn::setPeriodic(OpenMM::Vec3* vectors) {
     usePeriodic = true;
     boxVectors[0] = vectors[0];
     boxVectors[1] = vectors[1];
@@ -83,32 +69,22 @@ void ReferenceAngleBondIxn::setPeriodic(OpenMM::RealVec* vectors) {
 
    --------------------------------------------------------------------------------------- */
 
-void ReferenceAngleBondIxn::getPrefactorsGivenAngleCosine(RealOpenMM cosine, RealOpenMM* angleParameters,
-                                                          RealOpenMM* dEdR, RealOpenMM* energyTerm) const {
-
-   // ---------------------------------------------------------------------------------------
-
-   // static const std::string methodName = "\nReferenceAngleBondIxn::getPrefactorsGivenAngleCosine";
-
-   static const RealOpenMM zero        = 0.0;
-   static const RealOpenMM one         = 1.0;
-   static const RealOpenMM half        = 0.5;
+void ReferenceAngleBondIxn::getPrefactorsGivenAngleCosine(double cosine, double* angleParameters,
+                                                          double* dEdR, double* energyTerm) const {
 
-   // ---------------------------------------------------------------------------------------
-
-   RealOpenMM angle;
-   if (cosine >= one) {
-      angle = zero;
-   } else if (cosine <= -one) {
+   double angle;
+   if (cosine >= 1.0) {
+      angle = 0.0;
+   } else if (cosine <= -1.0) {
       angle = PI_M;
    } else {
-      angle = ACOS(cosine);
+      angle = acos(cosine);
    }
-   RealOpenMM deltaIdeal         = angle - angleParameters[0];
-   RealOpenMM deltaIdeal2        = deltaIdeal*deltaIdeal;
+   double deltaIdeal         = angle - angleParameters[0];
+   double deltaIdeal2        = deltaIdeal*deltaIdeal;
 
   *dEdR                          = angleParameters[1]*deltaIdeal;
-  *energyTerm                    = half*angleParameters[1]*deltaIdeal2;
+  *energyTerm                    = 0.5*angleParameters[1]*deltaIdeal2;
 
 }
 
@@ -126,24 +102,14 @@ void ReferenceAngleBondIxn::getPrefactorsGivenAngleCosine(RealOpenMM cosine, Rea
    --------------------------------------------------------------------------------------- */
 
 void ReferenceAngleBondIxn::calculateBondIxn(int* atomIndices,
-                                             vector<RealVec>& atomCoordinates,
-                                             RealOpenMM* parameters,
-                                             vector<RealVec>& forces,
-                                             RealOpenMM* totalEnergy, double* energyParamDerivs) {
-
-   // constants -- reduce Visual Studio warnings regarding conversions between float & double
-
-   static const RealOpenMM zero        =  0.0;
-   static const RealOpenMM one         =  1.0;
-   static const RealOpenMM two         =  2.0;
-   static const RealOpenMM three       =  3.0;
-   static const RealOpenMM oneM        = -1.0;
-
-   static const int threeI             = 3;
+                                             vector<Vec3>& atomCoordinates,
+                                             double* parameters,
+                                             vector<Vec3>& forces,
+                                             double* totalEnergy, double* energyParamDerivs) {
 
     static const int LastAtomIndex      = 3;
 
-   RealOpenMM deltaR[2][ReferenceForce::LastDeltaRIndex];
+   double deltaR[2][ReferenceForce::LastDeltaRIndex];
 
    // ---------------------------------------------------------------------------------------
 
@@ -161,37 +127,36 @@ void ReferenceAngleBondIxn::calculateBondIxn(int* atomIndices,
       ReferenceForce::getDeltaR(atomCoordinates[atomCIndex], atomCoordinates[atomBIndex], deltaR[1]);  
    }
 
-   RealOpenMM pVector[threeI];
+   double pVector[3];
    SimTKOpenMMUtilities::crossProductVector3(deltaR[0], deltaR[1], pVector);
-   RealOpenMM rp              = DOT3(pVector, pVector);
-   rp                         = SQRT(rp);
+   double rp = sqrt(DOT3(pVector, pVector));
    if (rp < 1.0e-06) {
-      rp = (RealOpenMM) 1.0e-06;
+      rp = 1.0e-06;
    }   
-   RealOpenMM dot             = DOT3(deltaR[0], deltaR[1]);
-   RealOpenMM cosine          = dot/SQRT((deltaR[0][ReferenceForce::R2Index]*deltaR[1][ReferenceForce::R2Index]));
+   double dot             = DOT3(deltaR[0], deltaR[1]);
+   double cosine          = dot/sqrt((deltaR[0][ReferenceForce::R2Index]*deltaR[1][ReferenceForce::R2Index]));
 
-   RealOpenMM dEdR;
-   RealOpenMM energy;
+   double dEdR;
+   double energy;
    getPrefactorsGivenAngleCosine(cosine, parameters, &dEdR, &energy);
 
-   RealOpenMM termA           =  dEdR/(deltaR[0][ReferenceForce::R2Index]*rp);
-   RealOpenMM termC           = -dEdR/(deltaR[1][ReferenceForce::R2Index]*rp);
+   double termA           =  dEdR/(deltaR[0][ReferenceForce::R2Index]*rp);
+   double termC           = -dEdR/(deltaR[1][ReferenceForce::R2Index]*rp);
 
-   RealOpenMM deltaCrossP[LastAtomIndex][threeI];
+   double deltaCrossP[LastAtomIndex][3];
    SimTKOpenMMUtilities::crossProductVector3(deltaR[0], pVector, deltaCrossP[0]);
    SimTKOpenMMUtilities::crossProductVector3(deltaR[1], pVector, deltaCrossP[2]);
 
-   for (int ii = 0; ii < threeI; ii++) {
+   for (int ii = 0; ii < 3; ii++) {
       deltaCrossP[0][ii] *= termA;
       deltaCrossP[2][ii] *= termC;
-      deltaCrossP[1][ii]  = oneM*(deltaCrossP[0][ii] + deltaCrossP[2][ii]);
+      deltaCrossP[1][ii]  = -(deltaCrossP[0][ii] + deltaCrossP[2][ii]);
    }   
 
    // accumulate forces
  
    for (int jj = 0; jj < LastAtomIndex; jj++) {
-      for (int ii = 0; ii < threeI; ii++) {
+      for (int ii = 0; ii < 3; ii++) {
          forces[atomIndices[jj]][ii] += deltaCrossP[jj][ii];
       }   
    }   

platforms/reference/src/SimTKReference/ReferenceBondForce.cpp

@@ -38,13 +38,6 @@ using namespace OpenMM;
    --------------------------------------------------------------------------------------- */
 
 ReferenceBondForce::ReferenceBondForce() {
-
-   // ---------------------------------------------------------------------------------------
-
-   // static const char* methodName = "\nReferenceBondForce::ReferenceBondForce";
-
-   // ---------------------------------------------------------------------------------------
-
 }
 
 /**---------------------------------------------------------------------------------------
@@ -54,13 +47,6 @@ ReferenceBondForce::ReferenceBondForce() {
    --------------------------------------------------------------------------------------- */
 
 ReferenceBondForce::~ReferenceBondForce() {
-
-   // ---------------------------------------------------------------------------------------
-
-   // static const char* methodName = "\nReferenceBondForce::~ReferenceBondForce";
-
-   // ---------------------------------------------------------------------------------------
-
 }
 
 /**---------------------------------------------------------------------------------------
@@ -79,19 +65,12 @@ ReferenceBondForce::~ReferenceBondForce() {
    --------------------------------------------------------------------------------------- */
 
 void ReferenceBondForce::calculateForce(int numberOfBonds, int** atomIndices,
-                                        vector<RealVec>& atomCoordinates,
-                                        RealOpenMM** parameters,
-                                        vector<RealVec>& forces, 
-                                        RealOpenMM *totalEnergy, 
+                                        vector<Vec3>& atomCoordinates,
+                                        double** parameters,
+                                        vector<Vec3>& forces, 
+                                        double *totalEnergy, 
                                         ReferenceBondIxn& referenceBondIxn) {
 
-
-   // ---------------------------------------------------------------------------------------
-
-   static const char* methodName = "\nReferenceBondForce::calculateForce";
-
-   // ---------------------------------------------------------------------------------------
-
    for (int ii = 0; ii < numberOfBonds; ii++) {
 
       // calculate bond ixn