Use CompiledExpressionSet for reference CustomGBForce

platforms/reference/include/ReferenceCustomGBIxn.h

@@ -26,7 +26,7 @@
 #define __ReferenceCustomGBIxn_H__
 
 #include "ReferenceNeighborList.h"
-#include "lepton/ExpressionProgram.h"
+#include "openmm/internal/CompiledExpressionSet.h"
 #include "openmm/CustomGBForce.h"
 #include <map>
 #include <set>
@@ -43,18 +43,20 @@ class ReferenceCustomGBIxn {
       const OpenMM::NeighborList* neighborList;
       OpenMM::RealVec periodicBoxVectors[3];
       RealOpenMM cutoffDistance;
-      std::vector<Lepton::ExpressionProgram> valueExpressions;
-      std::vector<std::vector<Lepton::ExpressionProgram> > valueDerivExpressions;
-      std::vector<std::vector<Lepton::ExpressionProgram> > valueGradientExpressions;
-      std::vector<std::string> valueNames;
+      CompiledExpressionSet expressionSet;
+      std::vector<Lepton::CompiledExpression> valueExpressions;
+      std::vector<std::vector<Lepton::CompiledExpression> > valueDerivExpressions;
+      std::vector<std::vector<Lepton::CompiledExpression> > valueGradientExpressions;
       std::vector<OpenMM::CustomGBForce::ComputationType> valueTypes;
-      std::vector<Lepton::ExpressionProgram> energyExpressions;
-      std::vector<std::vector<Lepton::ExpressionProgram> > energyDerivExpressions;
-      std::vector<std::vector<Lepton::ExpressionProgram> > energyGradientExpressions;
-      std::vector<std::string> paramNames;
+      std::vector<Lepton::CompiledExpression> energyExpressions;
+      std::vector<std::vector<Lepton::CompiledExpression> > energyDerivExpressions;
+      std::vector<std::vector<Lepton::CompiledExpression> > energyGradientExpressions;
       std::vector<OpenMM::CustomGBForce::ComputationType> energyTypes;
-      std::vector<std::string> particleParamNames;
-      std::vector<std::string> particleValueNames;
+      std::vector<int> paramIndex;
+      std::vector<int> valueIndex;
+      std::vector<int> particleParamIndex;
+      std::vector<int> particleValueIndex;
+      int rIndex, xIndex, yIndex, zIndex;
 
       /**---------------------------------------------------------------------------------------
 
@@ -64,13 +66,12 @@ class ReferenceCustomGBIxn {
          @param numAtoms         number of atoms
          @param atomCoordinates  atom coordinates
          @param values           the vector to store computed values into
-         @param globalParameters the values of global parameters
          @param atomParameters   atomParameters[atomIndex][paramterIndex]
 
          --------------------------------------------------------------------------------------- */
 
       void calculateSingleParticleValue(int index, int numAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, std::vector<std::vector<RealOpenMM> >& values,
-                                        const std::map<std::string, double>& globalParameters, RealOpenMM** atomParameters) const;
+                                        RealOpenMM** atomParameters);
 
       /**---------------------------------------------------------------------------------------
 
@@ -81,7 +82,6 @@ class ReferenceCustomGBIxn {
          @param atomCoordinates  atom coordinates
          @param atomParameters   atomParameters[atomIndex][paramterIndex]
          @param values           the vector to store computed values into
-         @param globalParameters the values of global parameters
          @param exclusions       exclusions[i] is the set of excluded indices for atom i
          @param useExclusions    specifies whether to use exclusions
 
@@ -89,8 +89,7 @@ class ReferenceCustomGBIxn {
 
       void calculateParticlePairValue(int index, int numAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, RealOpenMM** atomParameters,
                                       std::vector<std::vector<RealOpenMM> >& values,
-                                      const std::map<std::string, double>& globalParameters,
-                                      const std::vector<std::set<int> >& exclusions, bool useExclusions) const;
+                                      const std::vector<std::set<int> >& exclusions, bool useExclusions);
 
       /**---------------------------------------------------------------------------------------
 
@@ -101,14 +100,12 @@ class ReferenceCustomGBIxn {
          @param atom2            the index of the second atom in the pair
          @param atomCoordinates  atom coordinates
          @param atomParameters   atomParameters[atomIndex][paramterIndex]
-         @param globalParameters the values of global parameters
          @param values           the vector to store computed values into
 
          --------------------------------------------------------------------------------------- */
 
       void calculateOnePairValue(int index, int atom1, int atom2, std::vector<OpenMM::RealVec>& atomCoordinates, RealOpenMM** atomParameters,
-                                 const std::map<std::string, double>& globalParameters,
-                                 std::vector<std::vector<RealOpenMM> >& values) const;
+                                 std::vector<std::vector<RealOpenMM> >& values);
 
       /**---------------------------------------------------------------------------------------
 
@@ -118,7 +115,6 @@ class ReferenceCustomGBIxn {
          @param numAtoms         number of atoms
          @param atomCoordinates  atom coordinates
          @param values           the vector containing computed values
-         @param globalParameters the values of global parameters
          @param atomParameters   atomParameters[atomIndex][paramterIndex]
          @param forces           forces on atoms are added to this
          @param totalEnergy      the energy contribution is added to this
@@ -127,8 +123,8 @@ class ReferenceCustomGBIxn {
          --------------------------------------------------------------------------------------- */
 
       void calculateSingleParticleEnergyTerm(int index, int numAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, const std::vector<std::vector<RealOpenMM> >& values,
-                                        const std::map<std::string, double>& globalParameters, RealOpenMM** atomParameters, std::vector<OpenMM::RealVec>& forces,
-                                        RealOpenMM* totalEnergy, std::vector<std::vector<RealOpenMM> >& dEdV) const;
+                                        RealOpenMM** atomParameters, std::vector<OpenMM::RealVec>& forces,
+                                        RealOpenMM* totalEnergy, std::vector<std::vector<RealOpenMM> >& dEdV);
 
       /**---------------------------------------------------------------------------------------
 
@@ -139,7 +135,6 @@ class ReferenceCustomGBIxn {
          @param atomCoordinates  atom coordinates
          @param atomParameters   atomParameters[atomIndex][paramterIndex]
          @param values           the vector containing computed values
-         @param globalParameters the values of global parameters
          @param exclusions       exclusions[i] is the set of excluded indices for atom i
          @param useExclusions    specifies whether to use exclusions
          @param forces           forces on atoms are added to this
@@ -150,9 +145,8 @@ class ReferenceCustomGBIxn {
 
       void calculateParticlePairEnergyTerm(int index, int numAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, RealOpenMM** atomParameters,
                                       const std::vector<std::vector<RealOpenMM> >& values,
-                                      const std::map<std::string, double>& globalParameters,
                                       const std::vector<std::set<int> >& exclusions, bool useExclusions,
-                                      std::vector<OpenMM::RealVec>& forces, RealOpenMM* totalEnergy, std::vector<std::vector<RealOpenMM> >& dEdV) const;
+                                      std::vector<OpenMM::RealVec>& forces, RealOpenMM* totalEnergy, std::vector<std::vector<RealOpenMM> >& dEdV);
 
       /**---------------------------------------------------------------------------------------
 
@@ -163,7 +157,6 @@ class ReferenceCustomGBIxn {
          @param atom2            the index of the second atom in the pair
          @param atomCoordinates  atom coordinates
          @param atomParameters   atomParameters[atomIndex][paramterIndex]
-         @param globalParameters the values of global parameters
          @param values           the vector containing computed values
          @param forces           forces on atoms are added to this
          @param totalEnergy      the energy contribution is added to this
@@ -172,9 +165,8 @@ class ReferenceCustomGBIxn {
          --------------------------------------------------------------------------------------- */
 
       void calculateOnePairEnergyTerm(int index, int atom1, int atom2, std::vector<OpenMM::RealVec>& atomCoordinates, RealOpenMM** atomParameters,
-                                 const std::map<std::string, double>& globalParameters,
                                  const std::vector<std::vector<RealOpenMM> >& values,
-                                 std::vector<OpenMM::RealVec>& forces, RealOpenMM* totalEnergy, std::vector<std::vector<RealOpenMM> >& dEdV) const;
+                                 std::vector<OpenMM::RealVec>& forces, RealOpenMM* totalEnergy, std::vector<std::vector<RealOpenMM> >& dEdV);
 
       /**---------------------------------------------------------------------------------------
 
@@ -184,7 +176,6 @@ class ReferenceCustomGBIxn {
          @param atomCoordinates  atom coordinates
          @param atomParameters   atomParameters[atomIndex][paramterIndex]
          @param values           the vector containing computed values
-         @param globalParameters the values of global parameters
          @param exclusions       exclusions[i] is the set of excluded indices for atom i
          @param forces           forces on atoms are added to this
          @param dEdV             the derivative of energy with respect to computed values is stored in this
@@ -193,9 +184,8 @@ class ReferenceCustomGBIxn {
 
       void calculateChainRuleForces(int numAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, RealOpenMM** atomParameters,
                                       const std::vector<std::vector<RealOpenMM> >& values,
-                                      const std::map<std::string, double>& globalParameters,
                                       const std::vector<std::set<int> >& exclusions,
-                                      std::vector<OpenMM::RealVec>& forces, std::vector<std::vector<RealOpenMM> >& dEdV) const;
+                                      std::vector<OpenMM::RealVec>& forces, std::vector<std::vector<RealOpenMM> >& dEdV);
 
       /**---------------------------------------------------------------------------------------
 
@@ -205,7 +195,6 @@ class ReferenceCustomGBIxn {
          @param atom2            the index of the second atom in the pair
          @param atomCoordinates  atom coordinates
          @param atomParameters   atomParameters[atomIndex][paramterIndex]
-         @param globalParameters the values of global parameters
          @param values           the vector containing computed values
          @param forces           forces on atoms are added to this
          @param dEdV             the derivative of energy with respect to computed values is stored in this
@@ -214,10 +203,9 @@ class ReferenceCustomGBIxn {
          --------------------------------------------------------------------------------------- */
 
       void calculateOnePairChainRule(int atom1, int atom2, std::vector<OpenMM::RealVec>& atomCoordinates, RealOpenMM** atomParameters,
-                                 const std::map<std::string, double>& globalParameters,
                                  const std::vector<std::vector<RealOpenMM> >& values,
                                  std::vector<OpenMM::RealVec>& forces, std::vector<std::vector<RealOpenMM> >& dEdV,
-                                 bool isExcluded) const;
+                                 bool isExcluded);
 
    public:
 
@@ -227,14 +215,14 @@ class ReferenceCustomGBIxn {
 
          --------------------------------------------------------------------------------------- */
 
-       ReferenceCustomGBIxn(const std::vector<Lepton::ExpressionProgram>& valueExpressions,
-                            const std::vector<std::vector<Lepton::ExpressionProgram> > valueDerivExpressions,
-                            const std::vector<std::vector<Lepton::ExpressionProgram> > valueGradientExpressions,
+       ReferenceCustomGBIxn(const std::vector<Lepton::CompiledExpression>& valueExpressions,
+                            const std::vector<std::vector<Lepton::CompiledExpression> > valueDerivExpressions,
+                            const std::vector<std::vector<Lepton::CompiledExpression> > valueGradientExpressions,
                             const std::vector<std::string>& valueNames,
                             const std::vector<OpenMM::CustomGBForce::ComputationType>& valueTypes,
-                            const std::vector<Lepton::ExpressionProgram>& energyExpressions,
-                            const std::vector<std::vector<Lepton::ExpressionProgram> > energyDerivExpressions,
-                            const std::vector<std::vector<Lepton::ExpressionProgram> > energyGradientExpressions,
+                            const std::vector<Lepton::CompiledExpression>& energyExpressions,
+                            const std::vector<std::vector<Lepton::CompiledExpression> > energyDerivExpressions,
+                            const std::vector<std::vector<Lepton::CompiledExpression> > energyGradientExpressions,
                             const std::vector<OpenMM::CustomGBForce::ComputationType>& energyTypes,
                             const std::vector<std::string>& parameterNames);
 
@@ -284,7 +272,7 @@ class ReferenceCustomGBIxn {
          --------------------------------------------------------------------------------------- */
 
       void calculateIxn(int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, RealOpenMM** atomParameters, const std::vector<std::set<int> >& exclusions,
-                       std::map<std::string, double>& globalParameters, std::vector<OpenMM::RealVec>& forces, RealOpenMM* totalEnergy) const;
+                       std::map<std::string, double>& globalParameters, std::vector<OpenMM::RealVec>& forces, RealOpenMM* totalEnergy);
 
 // ---------------------------------------------------------------------------------------
 

platforms/reference/include/ReferenceKernels.h

@@ -38,7 +38,6 @@
 #include "ReferenceNeighborList.h"
 #include "lepton/CompiledExpression.h"
 #include "lepton/CustomFunction.h"
-#include "lepton/ExpressionProgram.h"
 
 namespace OpenMM {
 
@@ -739,13 +738,13 @@ private:
     RealOpenMM nonbondedCutoff;
     std::vector<std::set<int> > exclusions;
     std::vector<std::string> particleParameterNames, globalParameterNames, valueNames;
-    std::vector<Lepton::ExpressionProgram> valueExpressions;
-    std::vector<std::vector<Lepton::ExpressionProgram> > valueDerivExpressions;
-    std::vector<std::vector<Lepton::ExpressionProgram> > valueGradientExpressions;
+    std::vector<Lepton::CompiledExpression> valueExpressions;
+    std::vector<std::vector<Lepton::CompiledExpression> > valueDerivExpressions;
+    std::vector<std::vector<Lepton::CompiledExpression> > valueGradientExpressions;
     std::vector<OpenMM::CustomGBForce::ComputationType> valueTypes;
-    std::vector<Lepton::ExpressionProgram> energyExpressions;
-    std::vector<std::vector<Lepton::ExpressionProgram> > energyDerivExpressions;
-    std::vector<std::vector<Lepton::ExpressionProgram> > energyGradientExpressions;
+    std::vector<Lepton::CompiledExpression> energyExpressions;
+    std::vector<std::vector<Lepton::CompiledExpression> > energyDerivExpressions;
+    std::vector<std::vector<Lepton::CompiledExpression> > energyGradientExpressions;
     std::vector<OpenMM::CustomGBForce::ComputationType> energyTypes;
     NonbondedMethod nonbondedMethod;
     NeighborList* neighborList;

platforms/reference/src/ReferenceKernels.cpp

@@ -1376,19 +1376,19 @@ void ReferenceCalcCustomGBForceKernel::initialize(const System& system, const Cu
         CustomGBForce::ComputationType type;
         force.getComputedValueParameters(i, name, expression, type);
         Lepton::ParsedExpression ex = Lepton::Parser::parse(expression, functions).optimize();
-        valueExpressions.push_back(ex.createProgram());
+        valueExpressions.push_back(ex.createCompiledExpression());
         valueTypes.push_back(type);
         valueNames.push_back(name);
         if (i == 0) {
-            valueDerivExpressions[i].push_back(ex.differentiate("r").optimize().createProgram());
+            valueDerivExpressions[i].push_back(ex.differentiate("r").optimize().createCompiledExpression());
             validateVariables(ex.getRootNode(), pairVariables);
         }
         else {
-            valueGradientExpressions[i].push_back(ex.differentiate("x").optimize().createProgram());
-            valueGradientExpressions[i].push_back(ex.differentiate("y").optimize().createProgram());
-            valueGradientExpressions[i].push_back(ex.differentiate("z").optimize().createProgram());
+            valueGradientExpressions[i].push_back(ex.differentiate("x").optimize().createCompiledExpression());
+            valueGradientExpressions[i].push_back(ex.differentiate("y").optimize().createCompiledExpression());
+            valueGradientExpressions[i].push_back(ex.differentiate("z").optimize().createCompiledExpression());
             for (int j = 0; j < i; j++)
-                valueDerivExpressions[i].push_back(ex.differentiate(valueNames[j]).optimize().createProgram());
+                valueDerivExpressions[i].push_back(ex.differentiate(valueNames[j]).optimize().createCompiledExpression());
             validateVariables(ex.getRootNode(), particleVariables);
         }
         particleVariables.insert(name);
@@ -1405,21 +1405,21 @@ void ReferenceCalcCustomGBForceKernel::initialize(const System& system, const Cu
         CustomGBForce::ComputationType type;
         force.getEnergyTermParameters(i, expression, type);
         Lepton::ParsedExpression ex = Lepton::Parser::parse(expression, functions).optimize();
-        energyExpressions.push_back(ex.createProgram());
+        energyExpressions.push_back(ex.createCompiledExpression());
         energyTypes.push_back(type);
         if (type != CustomGBForce::SingleParticle)
-            energyDerivExpressions[i].push_back(ex.differentiate("r").optimize().createProgram());
+            energyDerivExpressions[i].push_back(ex.differentiate("r").optimize().createCompiledExpression());
         for (int j = 0; j < force.getNumComputedValues(); j++) {
             if (type == CustomGBForce::SingleParticle) {
-                energyDerivExpressions[i].push_back(ex.differentiate(valueNames[j]).optimize().createProgram());
-                energyGradientExpressions[i].push_back(ex.differentiate("x").optimize().createProgram());
-                energyGradientExpressions[i].push_back(ex.differentiate("y").optimize().createProgram());
-                energyGradientExpressions[i].push_back(ex.differentiate("z").optimize().createProgram());
+                energyDerivExpressions[i].push_back(ex.differentiate(valueNames[j]).optimize().createCompiledExpression());
+                energyGradientExpressions[i].push_back(ex.differentiate("x").optimize().createCompiledExpression());
+                energyGradientExpressions[i].push_back(ex.differentiate("y").optimize().createCompiledExpression());
+                energyGradientExpressions[i].push_back(ex.differentiate("z").optimize().createCompiledExpression());
                 validateVariables(ex.getRootNode(), particleVariables);
             }
             else {
-                energyDerivExpressions[i].push_back(ex.differentiate(valueNames[j]+"1").optimize().createProgram());
-                energyDerivExpressions[i].push_back(ex.differentiate(valueNames[j]+"2").optimize().createProgram());
+                energyDerivExpressions[i].push_back(ex.differentiate(valueNames[j]+"1").optimize().createCompiledExpression());
+                energyDerivExpressions[i].push_back(ex.differentiate(valueNames[j]+"2").optimize().createCompiledExpression());
                 validateVariables(ex.getRootNode(), pairVariables);
             }
         }