Skip to content

Commit

Permalink
- rewrite DynamicOptimization parts in BackEnd
Browse files Browse the repository at this point in the history 
 - create DynamicOptimization.mo
 - mv some parts inside DynamicOptimization.mo
- added annotation marker for DynamicOptimization
- update tests for DynamicOptimization



git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@22056 f25d12d1-65f4-0310-ae8a-bbce733d8d8e
  • Loading branch information
Vitalij Ruge committed Aug 31, 2014
1 parent 38a8d7f commit 7a145f4
Show file tree
Hide file tree
Showing 9 changed files with 461 additions and 144 deletions.
99 changes: 2 additions & 97 deletions Compiler/BackEnd/BackendDAECreate.mo
View file
Expand Up @@ -56,6 +56,7 @@ protected import ClassInf;
protected import DAEDump;
protected import DAEUtil;
protected import Debug;
protected import DynamicOptimization;
protected import Error;
protected import Expression;
protected import ExpressionDump;
Expand Down Expand Up @@ -121,7 +122,7 @@ algorithm
// handle alias equations
(vars, knvars, extVars, aliasVars, eqns, reqns, ieqns, whenclauses_1) := handleAliasEquations(aliaseqns, vars, knvars, extVars, aliasVars, eqns, reqns, ieqns, whenclauses_1);
vars_1 := detectImplicitDiscrete(vars, knvars, eqns);
(vars_1, eqns) := addOptimizationVarsEqns(vars_1, eqns, Config.acceptOptimicaGrammar(), clsAttrs, constrs);
(vars_1, eqns, clsAttrs) := DynamicOptimization.addOptimizationVarsEqns(vars_1, eqns, Config.acceptOptimicaGrammar(), clsAttrs, constrs, knvars);
eqnarr := BackendEquation.listEquation(eqns);
reqnarr := BackendEquation.listEquation(reqns);
ieqnarr := BackendEquation.listEquation(ieqns);
Expand Down Expand Up @@ -3260,101 +3261,5 @@ algorithm
end match;
end expInt;

protected function addOptimizationVarsEqns
"add objective function to DAE. Neeed for derivatives"
input BackendDAE.Variables inVars;
input list<BackendDAE.Equation> inEqns;
input Boolean inOptimicaFlag;
input list< .DAE.ClassAttributes> inClassAttr;
input list< .DAE.Constraint> inConstraint;
output BackendDAE.Variables outVars;
output list<BackendDAE.Equation> outEqns;
algorithm
(outVars, outEqns) := match(inVars, inEqns, inOptimicaFlag, inClassAttr, inConstraint)
local
DAE.ComponentRef leftcref;
list<BackendDAE.Equation> objectEqn;
BackendDAE.Var dummyVar;
Boolean b;
BackendDAE.Variables v, knownVars;
list<BackendDAE.Equation> e;
Option<DAE.Exp> mayer, lagrange;
list< .DAE.Exp> constraintLst;

case (v, e, true, {DAE.OPTIMIZATION_ATTRS(objetiveE=mayer, objectiveIntegrandE=lagrange)}, _)
equation
leftcref = ComponentReference.makeCrefIdent("$TMP_mayerTerm", DAE.T_REAL_DEFAULT, {});
dummyVar = BackendDAE.VAR(leftcref, BackendDAE.VARIABLE(), DAE.OUTPUT(), DAE.NON_PARALLEL(), DAE.T_REAL_DEFAULT, NONE(), NONE(), {}, DAE.emptyElementSource, NONE(), NONE(), DAE.NON_CONNECTOR());
objectEqn = BackendEquation.generateSolvedEqnsfromOption(leftcref, mayer, DAE.emptyElementSource, BackendDAE.UNKNOWN_EQUATION_KIND());
b = not List.isEmpty(objectEqn);

v = Util.if_(b, BackendVariable.addNewVar(dummyVar, v), v);
e = Util.if_(b, listAppend(e, objectEqn), e);

leftcref = ComponentReference.makeCrefIdent("$TMP_lagrangeTerm", DAE.T_REAL_DEFAULT, {});
dummyVar = BackendDAE.VAR(leftcref, BackendDAE.VARIABLE(), DAE.OUTPUT(), DAE.NON_PARALLEL(), DAE.T_REAL_DEFAULT, NONE(), NONE(), {}, DAE.emptyElementSource, NONE(), NONE(), DAE.NON_CONNECTOR());
objectEqn = BackendEquation.generateSolvedEqnsfromOption(leftcref, lagrange, DAE.emptyElementSource, BackendDAE.UNKNOWN_EQUATION_KIND());
b = not List.isEmpty(objectEqn);

v = Util.if_(b, BackendVariable.addNewVar(dummyVar, v), v);
e = Util.if_(b, listAppend(e, objectEqn), e);

(v, e) = addOptimizationVarsEqns2(inConstraint, 1, v, e);

then (v, e);
else (inVars, inEqns);
end match;
end addOptimizationVarsEqns;

protected function addOptimizationVarsEqns1
input list<DAE.Exp> constraintLst;
input Integer inI;
input BackendDAE.Variables inVars;
input list<BackendDAE.Equation> inEqns;
output BackendDAE.Variables outVars;
output list<BackendDAE.Equation> outEqns;
algorithm
(outVars, outEqns) := match(constraintLst, inI, inVars, inEqns)
local
list<DAE.Exp> conLst;
DAE.Exp e;
DAE.ComponentRef leftcref;
BackendDAE.Var dummyVar;
list<BackendDAE.Equation> conEqn;
BackendDAE.Variables v;
list<BackendDAE.Equation> eqns;

case({}, _, _, _) then (inVars, inEqns);
case(e::conLst, _, _, _) equation
//print("con"+& intString(inI) +& " "+& ExpressionDump.printExpStr(e) +& "\n");
(conEqn, dummyVar) = BackendEquation.generateResidualfromRealtion(inI, e, DAE.emptyElementSource);
v = BackendVariable.addNewVar(dummyVar, inVars);
eqns = listAppend(conEqn, inEqns);
(v, eqns)= addOptimizationVarsEqns1(conLst, inI + 1, v, eqns);
then (v, eqns);
else (inVars, inEqns);
end match;
end addOptimizationVarsEqns1;

public function addOptimizationVarsEqns2
input list< .DAE.Constraint> inConstraint;
input Integer inI;
input BackendDAE.Variables inVars;
input list<BackendDAE.Equation> inEqns;
output BackendDAE.Variables outVars;
output list<BackendDAE.Equation> outEqns;
algorithm
(outVars, outEqns) := match(inConstraint, inI, inVars, inEqns)
local
list<BackendDAE.Equation> e;
BackendDAE.Variables v;
list< .DAE.Exp> constraintLst;
case({DAE.CONSTRAINT_EXPS(constraintLst = constraintLst)}, _, _, _) equation
(v, e) = addOptimizationVarsEqns1(constraintLst, inI, inVars, inEqns);
then (v, e);
else (inVars, inEqns);
end match;
end addOptimizationVarsEqns2;

end BackendDAECreate;

28 changes: 12 additions & 16 deletions Compiler/BackEnd/BackendDAEOptimize.mo
View file
Expand Up @@ -49,7 +49,6 @@ public import Env;
public import HashTable2;

protected import Algorithm;
protected import BackendDAECreate;
protected import BackendDAETransform;
protected import BackendDAEUtil;
protected import BackendDump;
Expand Down Expand Up @@ -2995,17 +2994,12 @@ algorithm
BackendDAE.SymbolicJacobians linearModelMatrixes;
DAE.FunctionTree funcs, functionTree;
list< .DAE.Constraint> constraints;
BackendDAE.Variables v;
list<BackendDAE.Equation> eqns;
case(_) equation
true = Flags.getConfigBool(Flags.GENERATE_SYMBOLIC_LINEARIZATION);
System.realtimeTick(GlobalScript.RT_CLOCK_EXECSTAT_JACOBIANS);
BackendDAE.DAE(eqs=eqs,shared=shared) = inBackendDAE;
BackendDAE.SHARED(constraints=constraints) = shared;
eqns = {};
v = BackendVariable.emptyVars();
(v,eqns) = BackendDAECreate.addOptimizationVarsEqns2(constraints,1,v,eqns);
(linearModelMatrixes, funcs) = createLinearModelMatrixes(inBackendDAE, Config.acceptOptimicaGrammar(),v);
(linearModelMatrixes, funcs) = createLinearModelMatrixes(inBackendDAE, Config.acceptOptimicaGrammar());
shared = BackendDAEUtil.addBackendDAESharedJacobians(linearModelMatrixes, shared);
functionTree = BackendDAEUtil.getFunctions(shared);
functionTree = DAEUtil.joinAvlTrees(functionTree, funcs);
Expand Down Expand Up @@ -3092,21 +3086,20 @@ protected function createLinearModelMatrixes
author: wbraun"
input BackendDAE.BackendDAE inBackendDAE;
input Boolean UseOtimica;
input BackendDAE.Variables conVars;
output BackendDAE.SymbolicJacobians outJacobianMatrixes;
output DAE.FunctionTree outFunctionTree;

algorithm
(outJacobianMatrixes, outFunctionTree) :=
match (inBackendDAE,UseOtimica,conVars)
match (inBackendDAE,UseOtimica)
local
BackendDAE.BackendDAE backendDAE,backendDAE2;

list<BackendDAE.Var> varlst, knvarlst, states, inputvars, inputvars2, outputvars, paramvars, states_inputs;
list<BackendDAE.Var> varlst, knvarlst, states, inputvars, inputvars2, outputvars, paramvars, states_inputs, conVarsList;
list<DAE.ComponentRef> comref_states, comref_inputvars, comref_outputvars, comref_vars, comref_knvars;
DAE.ComponentRef leftcref;

BackendDAE.Variables v,kv,statesarr,inputvarsarr,paramvarsarr,outputvarsarr, object, optimizer_vars;
BackendDAE.Variables v,kv,statesarr,inputvarsarr,paramvarsarr,outputvarsarr, object, optimizer_vars, conVars;
BackendDAE.EquationArray e;

BackendDAE.SymbolicJacobians linearModelMatrices;
Expand All @@ -3118,7 +3111,7 @@ algorithm
DAE.FunctionTree funcs, functionTree;
list<DAE.Function> funcLst;

case (backendDAE, false,_)
case (backendDAE, false)
equation
backendDAE2 = BackendDAEUtil.copyBackendDAE(backendDAE);
backendDAE2 = collapseIndependentBlocks(backendDAE2);
Expand Down Expand Up @@ -3174,7 +3167,7 @@ algorithm
then
(linearModelMatrices, functionTree);

case (backendDAE, true,_) // created linear model (matrixes) for optimization
case (backendDAE, true) // created linear model (matrixes) for optimization
equation
// A := der(x)
// B := {der(x), con(x), L(x)}
Expand All @@ -3196,6 +3189,8 @@ algorithm
paramvars = List.select(knvarlst, BackendVariable.isParam);
inputvars2 = List.select(knvarlst,BackendVariable.isVarOnTopLevelAndInput);
outputvars = List.select(varlst, BackendVariable.isVarOnTopLevelAndOutput);
conVarsList = List.select(varlst, BackendVariable.isRealOptimizeConstraintsVars);

states_inputs = listAppend(states, inputvars2);
_ = List.map(states,BackendVariable.varCref);
_ = List.map(inputvars2,BackendVariable.varCref);
Expand All @@ -3205,7 +3200,8 @@ algorithm
inputvarsarr = BackendVariable.listVar1(inputvars);
paramvarsarr = BackendVariable.listVar1(paramvars);
outputvarsarr = BackendVariable.listVar1(outputvars);

conVars = BackendVariable.listVar1(conVarsList);

//BackendDump.printVariables(conVars);
//BackendDump.printVariables(object);
//print(intString(BackendVariable.numVariables(object)));
Expand All @@ -3221,7 +3217,7 @@ algorithm
// Differentiate the System w.r.t states&inputs for matrices B

optimizer_vars = BackendVariable.mergeVariables(statesarr, conVars);
object = checkObjectIsSet(outputvarsarr,"$TMP_lagrangeTerm");
object = checkObjectIsSet(outputvarsarr,"$OMC$objectLagrangeTerm");
optimizer_vars = BackendVariable.mergeVariables(optimizer_vars, object);
//BackendDump.printVariables(optimizer_vars);
(linearModelMatrix, sparsePattern, sparseColoring, funcs) = createJacobian(backendDAE2,states_inputs,statesarr,inputvarsarr,paramvarsarr,optimizer_vars,varlst,"B");
Expand All @@ -3231,7 +3227,7 @@ algorithm
Debug.fcall(Flags.JAC_DUMP2, print, "analytical Jacobians -> generated system for matrix B time: " +& realString(clock()) +& "\n");

// Differentiate the System w.r.t states for matrices C
object = checkObjectIsSet(outputvarsarr,"$TMP_mayerTerm");
object = checkObjectIsSet(outputvarsarr,"$OMC$objectMayerTerm");
optimizer_vars = BackendVariable.mergeVariables(optimizer_vars, object);
//BackendDump.printVariables(optimizer_vars);
(linearModelMatrix, sparsePattern, sparseColoring, funcs) = createJacobian(backendDAE2,states_inputs,statesarr,inputvarsarr,paramvarsarr,optimizer_vars,varlst,"C");
Expand Down
71 changes: 52 additions & 19 deletions Compiler/BackEnd/BackendEquation.mo
View file
Expand Up @@ -1969,44 +1969,77 @@ public function generateResidualfromRealtion "author: vitalij"
input Integer inI;
input DAE.Exp iRhs;
input DAE.ElementSource Source;
input BackendDAE.Variables inVars;
input BackendDAE.Variables knvars;
output list<BackendDAE.Equation> outEqn;
output BackendDAE.Var vout;
algorithm
(outEqn, vout) := match (inI, iRhs, Source)
(outEqn, vout) := match (inI, iRhs, Source, inVars, knvars)
local
DAE.Exp rhs, e1, e2;
DAE.ComponentRef lhs;
BackendDAE.Var dummyVar;
DAE.Exp rhs, e1, e2 , expNull, lowBound;
DAE.ComponentRef lhs, cr;
BackendDAE.Var dummyVar, v;
BackendDAE.Variables mergeVars;
BackendDAE.Equation eqn;

case (_, DAE.RELATION(e1, DAE.LESS(_), e2, _, _), _) equation
lhs = ComponentReference.makeCrefIdent("$TMP_ineq_con" +& intString(inI), DAE.T_REAL_DEFAULT, {});
case (_, DAE.RELATION(e1, DAE.LESS(_), e2, _, _), _,_,_) equation
lhs = ComponentReference.makeCrefIdent("$OMC$constarintTerm" +& intString(inI), DAE.T_REAL_DEFAULT, {});
dummyVar = BackendDAE.VAR(lhs, BackendDAE.OPT_CONSTR(), DAE.OUTPUT(), DAE.NON_PARALLEL(), DAE.T_REAL_DEFAULT, NONE(), NONE(), {}, DAE.emptyElementSource, NONE(), NONE(), DAE.NON_CONNECTOR());
(rhs, _) = ExpressionSimplify.simplify(DAE.BINARY(e1, DAE.SUB(DAE.T_REAL_DEFAULT), e2));
rhs = Expression.expSub(e1,e2);
(rhs, _) = ExpressionSimplify.simplify1(rhs);
expNull = DAE.RCONST(0.0);
lowBound = DAE.RCONST(-1e21);
dummyVar = BackendVariable.setVarMinMax(dummyVar, (SOME(lowBound), SOME(expNull)));
then ({BackendDAE.SOLVED_EQUATION(lhs, rhs, Source, BackendDAE.EQ_ATTR_DEFAULT_UNKNOWN)}, dummyVar);

case (_, DAE.RELATION(e1, DAE.LESSEQ(_), e2, _, _), _) equation
lhs = ComponentReference.makeCrefIdent("$TMP_ineq_con" +& intString(inI), DAE.T_REAL_DEFAULT, {});
case (_, DAE.RELATION(e1, DAE.LESSEQ(_), e2, _, _), _,_,_) equation
lhs = ComponentReference.makeCrefIdent("$OMC$constarintTerm" +& intString(inI), DAE.T_REAL_DEFAULT, {});
dummyVar = BackendDAE.VAR(lhs, BackendDAE.OPT_CONSTR(), DAE.OUTPUT(), DAE.NON_PARALLEL(), DAE.T_REAL_DEFAULT, NONE(), NONE(), {}, DAE.emptyElementSource, NONE(), NONE(), DAE.NON_CONNECTOR());
(rhs, _) = ExpressionSimplify.simplify(DAE.BINARY(e1, DAE.SUB(DAE.T_REAL_DEFAULT), e2));
rhs = Expression.expSub(e1,e2);
(rhs, _) = ExpressionSimplify.simplify1(rhs);
expNull = DAE.RCONST(0.0);
lowBound = DAE.RCONST(-1e21);
dummyVar = BackendVariable.setVarMinMax(dummyVar, (SOME(lowBound), SOME(expNull)));
then ({BackendDAE.SOLVED_EQUATION(lhs, rhs, Source, BackendDAE.EQ_ATTR_DEFAULT_UNKNOWN)}, dummyVar);

case (_, DAE.RELATION(e1, DAE.GREATER(_), e2, _, _), _) equation
lhs = ComponentReference.makeCrefIdent("$TMP_ineq_con" +& intString(inI), DAE.T_REAL_DEFAULT, {});
case (_, DAE.RELATION(e1, DAE.GREATER(_), e2, _, _), _,_,_) equation
lhs = ComponentReference.makeCrefIdent("$OMC$constarintTerm" +& intString(inI), DAE.T_REAL_DEFAULT, {});
dummyVar = BackendDAE.VAR(lhs, BackendDAE.OPT_CONSTR(), DAE.OUTPUT(), DAE.NON_PARALLEL(), DAE.T_REAL_DEFAULT, NONE(), NONE(), {}, DAE.emptyElementSource, NONE(), NONE(), DAE.NON_CONNECTOR());
(rhs, _) = ExpressionSimplify.simplify(DAE.BINARY(e2, DAE.SUB(DAE.T_REAL_DEFAULT), e1));
rhs = Expression.expSub(e2,e1);
(rhs, _) = ExpressionSimplify.simplify1(rhs);
expNull = DAE.RCONST(0.0);
lowBound = DAE.RCONST(-1e21);
dummyVar = BackendVariable.setVarMinMax(dummyVar, (SOME(lowBound), SOME(expNull)));
then ({BackendDAE.SOLVED_EQUATION(lhs, rhs, Source, BackendDAE.EQ_ATTR_DEFAULT_UNKNOWN)}, dummyVar);

case (_, DAE.RELATION(e1, DAE.GREATEREQ(_), e2, _, _), _) equation
lhs = ComponentReference.makeCrefIdent("$TMP_ineq_con" +& intString(inI), DAE.T_REAL_DEFAULT, {});
case (_, DAE.RELATION(e1, DAE.GREATEREQ(_), e2, _, _), _,_,_) equation
lhs = ComponentReference.makeCrefIdent("$OMC$constarintTerm" +& intString(inI), DAE.T_REAL_DEFAULT, {});
dummyVar = BackendDAE.VAR(lhs, BackendDAE.OPT_CONSTR(), DAE.OUTPUT(), DAE.NON_PARALLEL(), DAE.T_REAL_DEFAULT, NONE(), NONE(), {}, DAE.emptyElementSource, NONE(), NONE(), DAE.NON_CONNECTOR());
(rhs, _) = ExpressionSimplify.simplify(DAE.BINARY(e2, DAE.SUB(DAE.T_REAL_DEFAULT), e1));
rhs = Expression.expSub(e2,e1);
(rhs, _) = ExpressionSimplify.simplify(rhs);
expNull = DAE.RCONST(0.0);
lowBound = DAE.RCONST(-1e21);
dummyVar = BackendVariable.setVarMinMax(dummyVar, (SOME(lowBound), SOME(expNull)));
then ({BackendDAE.SOLVED_EQUATION(lhs, rhs, Source, BackendDAE.EQ_ATTR_DEFAULT_UNKNOWN)}, dummyVar);

case (_, DAE.RELATION(e1, DAE.EQUAL(_), e2, _, _), _) equation
lhs = ComponentReference.makeCrefIdent("$TMP_eq_con" +& intString(inI), DAE.T_REAL_DEFAULT, {});
case (_, DAE.RELATION(e1, DAE.EQUAL(_), e2, _, _), _,_,_) equation
lhs = ComponentReference.makeCrefIdent("$OMC$constarintTerm" +& intString(inI), DAE.T_REAL_DEFAULT, {});
dummyVar = BackendDAE.VAR(lhs, BackendDAE.OPT_CONSTR(), DAE.OUTPUT(), DAE.NON_PARALLEL(), DAE.T_REAL_DEFAULT, NONE(), NONE(), {}, DAE.emptyElementSource, NONE(), NONE(), DAE.NON_CONNECTOR());
(rhs, _) = ExpressionSimplify.simplify(DAE.BINARY(e2, DAE.SUB(DAE.T_REAL_DEFAULT), e1));
rhs = Expression.expSub(e2,e1);
(rhs, _) = ExpressionSimplify.simplify(rhs);
expNull = DAE.RCONST(0.0);
dummyVar = BackendVariable.setVarMinMax(dummyVar, (SOME(expNull), SOME(expNull)));
then ({BackendDAE.SOLVED_EQUATION(lhs, rhs, Source, BackendDAE.EQ_ATTR_DEFAULT_UNKNOWN)}, dummyVar);

case(_,e1 as DAE.CREF(componentRef = cr),_,_,_) equation
mergeVars = BackendVariable.mergeVariables(inVars, knvars);
({v},_)= BackendVariable.getVar(cr,mergeVars);
lhs = ComponentReference.makeCrefIdent("$OMC$constarintTerm" +& intString(inI), DAE.T_REAL_DEFAULT, {});
dummyVar = BackendDAE.VAR(lhs, BackendDAE.OPT_CONSTR(), DAE.OUTPUT(), DAE.NON_PARALLEL(), DAE.T_REAL_DEFAULT, NONE(), NONE(), {}, DAE.emptyElementSource, NONE(), NONE(), DAE.NON_CONNECTOR());
dummyVar = BackendVariable.mergeAliasVars(dummyVar, v, false, knvars);
eqn = BackendDAE.SOLVED_EQUATION(lhs, e1, Source, BackendDAE.EQ_ATTR_DEFAULT_UNKNOWN);
then ({eqn}, dummyVar);
else fail();
end match;
end generateResidualfromRealtion;

Expand Down
46 changes: 46 additions & 0 deletions Compiler/BackEnd/BackendVariable.mo
View file
Expand Up @@ -1655,6 +1655,52 @@ algorithm
end match;
end isRealOptimizeConstraintsVars;

public function hasMayerTermAnno
"author: Vitalij Ruge
Return true if variable has isMayer=true annotation"
input BackendDAE.Var inVar;
output Boolean outBoolean;
algorithm
outBoolean := match (inVar)
local SCode.Comment comm;

case (BackendDAE.VAR(comment= SOME(comm) ))
then SCode.commentHasBooleanNamedAnnotation(comm, "isMayer");
else then false;
end match;
end hasMayerTermAnno;

public function hasLagrangeTermAnno
"author: Vitalij Ruge
Return true if variable has isLagrange=true annotation"
input BackendDAE.Var inVar;
output Boolean outBoolean;
algorithm
outBoolean := match (inVar)
local SCode.Comment comm;

case (BackendDAE.VAR(comment= SOME(comm) ))
then SCode.commentHasBooleanNamedAnnotation(comm, "isLagrange");
else then false;
end match;
end hasLagrangeTermAnno;

public function hasConTermAnno
"author: Vitalij Ruge
Return true if variable has isConstraint=true annotation"
input BackendDAE.Var inVar;
output Boolean outBoolean;
algorithm
outBoolean := match (inVar)
local SCode.Comment comm;

case (BackendDAE.VAR(comment= SOME(comm) ))
then SCode.commentHasBooleanNamedAnnotation(comm, "isConstraint");
else then false;
end match;
end hasConTermAnno;


public function isNonRealParam
"Return true if variable is NOT a parameter of real-type"
input BackendDAE.Var inVar;
Expand Down

0 comments on commit 7a145f4

Please sign in to comment.