ParsedExpression CustomHbondForceImpl::prepareExpression(const CustomHbondForce& force, const map<string, CustomFunction*>& customFunctions, map<string, vector<int> >& distances,
map<string, vector<int> >& angles, map<string, vector<int> >& dihedrals) {
CustomHbondForceImpl::FunctionPlaceholder custom(1);
CustomHbondForceImpl::FunctionPlaceholder distance(2);
CustomHbondForceImpl::FunctionPlaceholder angle(3);
CustomHbondForceImpl::FunctionPlaceholder dihedral(4);
map<string, CustomFunction*> functions = customFunctions;
functions["distance"] = &distance;
functions["angle"] = ∠
functions["dihedral"] = &dihedral;
ParsedExpression expression = Lepton::Parser::parse(force.getEnergyFunction(), functions);
map<string, int> atoms;
atoms["a1"] = 0;
atoms["a2"] = 1;
atoms["a3"] = 2;
atoms["d1"] = 3;
atoms["d2"] = 4;
atoms["d3"] = 5;
set<string> variables;
for (int i = 0; i < force.getNumPerDonorParameters(); i++)
variables.insert(force.getPerDonorParameterName(i));
for (int i = 0; i < force.getNumPerAcceptorParameters(); i++)
variables.insert(force.getPerAcceptorParameterName(i));
for (int i = 0; i < force.getNumGlobalParameters(); i++)
variables.insert(force.getGlobalParameterName(i));
return ParsedExpression(replaceFunctions(expression.getRootNode(), atoms, distances, angles, dihedrals, variables)).optimize();
}
CompiledExpression::CompiledExpression(const ParsedExpression& expression) : jitCode(NULL) {
ParsedExpression expr = expression.optimize(); // Just in case it wasn't already optimized.
vector<pair<ExpressionTreeNode, int> > temps;
compileExpression(expr.getRootNode(), temps);
int maxArguments = 1;
for (int i = 0; i < (int) operation.size(); i++)
if (operation[i]->getNumArguments() > maxArguments)
maxArguments = operation[i]->getNumArguments();
argValues.resize(maxArguments);
#ifdef LEPTON_USE_JIT
generateJitCode();
#endif
}
void VectorExpression::analyzeExpression(const ParsedExpression& expression) {
parsed = expression.optimize();
program = parsed.createProgram();
stack.resize(program.getStackSize()+1);
for (int i = 0; i < program.getNumOperations(); i++) {
const Operation& op = program.getOperation(i);
if (op.getId() == Operation::VARIABLE)
operations.push_back(new Variable(op.getName()));
else if (op.getId() == Operation::CONSTANT)
operations.push_back(new Constant(dynamic_cast<const Operation::Constant&>(op).getValue()));
else if (op.getName() == "dot")
operations.push_back(new Dot());
else if (op.getName() == "cross")
operations.push_back(new Cross());
else if (op.getName() == "_x")
operations.push_back(new Component(0));
else if (op.getName() == "_y")
operations.push_back(new Component(1));
else if (op.getName() == "_z")
operations.push_back(new Component(2));
else if (op.getName() == "vector")
operations.push_back(new Vector());
else if (op.getNumArguments() == 1)
operations.push_back(new OpWrapper1(op));
else if (op.getNumArguments() == 2)
operations.push_back(new OpWrapper2(op));
else if (op.getNumArguments() == 3)
operations.push_back(new OpWrapper3(op));
else
throw OpenMMException("Unsupported operator in vector expression: "+op.getName());
}
}
ExpressionProgram::ExpressionProgram(const ParsedExpression& expression) : maxArgs(0), stackSize(0) {
buildProgram(expression.getRootNode());
int currentStackSize = 0;
for (int i = 0; i < (int) operations.size(); i++) {
int args = operations[i]->getNumArguments();
if (args > maxArgs)
maxArgs = args;
currentStackSize += 1-args;
if (currentStackSize > stackSize)
stackSize = currentStackSize;
}
}
void verifyEvaluation(const string& expression, double expectedValue) {
map<string, CustomFunction*> customFunctions;
ParsedExpression parsed = Parser::parse(expression, customFunctions);
double value = parsed.evaluate();
ASSERT_EQUAL_TOL(expectedValue, value, 1e-10);
// Try optimizing it and make sure the result is still correct.
value = parsed.optimize().evaluate();
ASSERT_EQUAL_TOL(expectedValue, value, 1e-10);
// Create an ExpressionProgram and see if that also gives the same result.
ExpressionProgram program = parsed.createProgram();
value = program.evaluate();
ASSERT_EQUAL_TOL(expectedValue, value, 1e-10);
// Create a CompiledExpression and see if that also gives the same result.
CompiledExpression compiled = parsed.createCompiledExpression();
value = compiled.evaluate();
ASSERT_EQUAL_TOL(expectedValue, value, 1e-10);
}
void verifySameValue(const ParsedExpression& exp1, const ParsedExpression& exp2, double x, double y) {
map<string, double> variables;
variables["x"] = x;
variables["y"] = y;
double val1 = exp1.evaluate(variables);
double val2 = exp2.evaluate(variables);
assertNumbersEqual(val1, val2);
// Now create CompiledExpressions from them and see if those also match.
CompiledExpression compiled1 = exp1.createCompiledExpression();
CompiledExpression compiled2 = exp2.createCompiledExpression();
if (compiled1.getVariables().find("x") != compiled1.getVariables().end())
compiled1.getVariableReference("x") = x;
if (compiled1.getVariables().find("y") != compiled1.getVariables().end())
compiled1.getVariableReference("y") = y;
if (compiled2.getVariables().find("x") != compiled2.getVariables().end())
compiled2.getVariableReference("x") = x;
if (compiled2.getVariables().find("y") != compiled2.getVariables().end())
compiled2.getVariableReference("y") = y;
assertNumbersEqual(val1, compiled1.evaluate());
assertNumbersEqual(val2, compiled2.evaluate());
}
void verifyEvaluation(const string& expression, double x, double y, double expectedValue) {
map<string, double> variables;
variables["x"] = x;
variables["y"] = y;
ParsedExpression parsed = Parser::parse(expression);
double value = parsed.evaluate(variables);
ASSERT_EQUAL_TOL(expectedValue, value, 1e-10);
// Try optimizing it and make sure the result is still correct.
value = parsed.optimize().evaluate(variables);
ASSERT_EQUAL_TOL(expectedValue, value, 1e-10);
// Try optimizing with predefined values for the variables.
value = parsed.optimize(variables).evaluate();
ASSERT_EQUAL_TOL(expectedValue, value, 1e-10);
// Create an ExpressionProgram and see if that also gives the same result.
ExpressionProgram program = parsed.createProgram();
value = program.evaluate(variables);
ASSERT_EQUAL_TOL(expectedValue, value, 1e-10);
// Create a CompiledExpression and see if that also gives the same result.
CompiledExpression compiled = parsed.createCompiledExpression();
if (compiled.getVariables().find("x") != compiled.getVariables().end())
compiled.getVariableReference("x") = x;
if (compiled.getVariables().find("y") != compiled.getVariables().end())
compiled.getVariableReference("y") = y;
value = compiled.evaluate();
ASSERT_EQUAL_TOL(expectedValue, value, 1e-10);
// Make sure that variable renaming works.
variables.clear();
variables["w"] = x;
variables["y"] = y;
map<string, string> replacements;
replacements["x"] = "w";
value = parsed.renameVariables(replacements).evaluate(variables);
ASSERT_EQUAL_TOL(expectedValue, value, 1e-10);
}
CompiledExpression::CompiledExpression(const ParsedExpression& expression) {
ParsedExpression expr = expression.optimize(); // Just in case it wasn't already optimized.
vector<pair<ExpressionTreeNode, int> > temps;
compileExpression(expr.getRootNode(), temps);
}
