- add BackendDAEOptimize.optimizeInitialSystem

- move linearize/test_01 back to failing tests git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@12652 f25d12d1-65f4-0310-ae8a-bbce733d8d8e
OpenModelica · Aug 23, 2012 · e80f444 · e80f444
1 parent 6517df6
commit e80f444
Show file tree

Hide file tree

Showing 3 changed files with 195 additions and 5 deletions.
diff --git a/Compiler/BackEnd/BackendDAEOptimize.mo b/Compiler/BackEnd/BackendDAEOptimize.mo
@@ -12053,4 +12053,188 @@ algorithm
   end match;
 end makeEquationsFromResiduals;
 
+
+/*
+ * optimize inital system
+ *
+ */
+
+public function optimizeInitialSystem
+"function: optimizeInitialSystem
+  autor Frenkel TUD 2012-08"
+  input BackendDAE.BackendDAE inDAE;
+  output BackendDAE.BackendDAE outDAE;
+algorithm
+  outDAE := match (inDAE)
+    local
+      BackendDAE.EqSystems systs;
+      BackendDAE.Variables knvars;
+      BackendDAE.EquationArray inieqns;
+      HashTable2.HashTable initalAliases;
+      list<BackendDAE.Equation> eqnlst;
+      Boolean optimizationfound;
+    case (BackendDAE.DAE(systs,BackendDAE.SHARED(knownVars=knvars,initialEqs=inieqns)))
+      equation
+        // search 
+        initalAliases = HashTable2.emptyHashTable();
+        eqnlst = BackendDAEUtil.equationList(inieqns);
+        (eqnlst,initalAliases,optimizationfound) = optimizeInitialSystem1(eqnlst,knvars,initalAliases,{},false);
+      then
+        // do optimization
+        optimizeInitialSystemWork(optimizationfound,inDAE,eqnlst,initalAliases);
+  end match;
+end optimizeInitialSystem;
+
+protected function optimizeInitialSystemWork
+"function: optimizeInitialSystemWork
+  autor Frenkel TUD 2012-08"
+  input Boolean optimizationfound;
+  input BackendDAE.BackendDAE inDAE;
+  input list<BackendDAE.Equation> eqnlst;
+  input HashTable2.HashTable initalAliases;
+  output BackendDAE.BackendDAE outDAE;
+algorithm
+  outDAE := match (optimizationfound,inDAE,eqnlst,initalAliases)
+    local
+      BackendDAE.EqSystems systs;
+      BackendDAE.Variables knvars,knvars1,exobj,av;
+      BackendDAE.EquationArray remeqns,inieqns;
+      array<DAE.Constraint> constrs;
+      array<DAE.ClassAttributes> clsAttrs;
+      Env.Cache cache;
+      Env.Env env;      
+      DAE.FunctionTree funcs;
+      BackendDAE.EventInfo einfo;
+      BackendDAE.ExternalObjectClasses eoc;
+      BackendDAE.SymbolicJacobians symjacs;
+      BackendDAE.BackendDAEType btp;
+    case (true,BackendDAE.DAE(systs,BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,constrs,clsAttrs,cache,env,funcs,einfo,eoc,btp,symjacs)),_,_)
+      equation
+        (knvars1,(_,_)) = BackendVariable.traverseBackendDAEVarsWithUpdate(knvars,optimizeInitialAliasesFinder,(initalAliases,false));
+        inieqns = BackendDAEUtil.listEquation(eqnlst);
+        systs= List.map1(systs,optimizeInitialAliases,initalAliases);
+      then
+        BackendDAE.DAE(systs,BackendDAE.SHARED(knvars1,exobj,av,inieqns,remeqns,constrs,clsAttrs,cache,env,funcs,einfo,eoc,btp,symjacs));
+    case(false,_,_,_) 
+      then inDAE;
+  end match;
+end optimizeInitialSystemWork;
+
+protected function optimizeInitialSystem1"
+  author: Frenkel TUD 2012-06"
+  input list<BackendDAE.Equation> iEqns;
+  input BackendDAE.Variables knvars;
+  input HashTable2.HashTable iInitalAliases;
+  input list<BackendDAE.Equation> iAcc;
+  input Boolean iOptimizationfound;
+  output list<BackendDAE.Equation> outEqsLst;
+  output HashTable2.HashTable oInitalAliases;
+  output Boolean oOptimizationfound;
+algorithm
+  (outEqsLst,oInitalAliases,oOptimizationfound) := matchcontinue (iEqns,knvars,iInitalAliases,iAcc,iOptimizationfound)
+    local
+      list<BackendDAE.Equation> eqnslst,eqnslst1;
+      BackendDAE.Equation eqn;
+      HashTable2.HashTable initalAliases;
+      Boolean optimizationfound,negate;
+      DAE.ComponentRef cr1,cr2;
+      DAE.Exp e1,e2,e1_1,e2_1;
+      list<DAE.Exp> ea1,ea2;
+
+    case ({},_,_,_,_) then (listReverse(iAcc),iInitalAliases,iOptimizationfound);
+    case ((eqn as BackendDAE.EQUATION(exp=e1,scalar=e2))::eqnslst,_,_,_,_)
+      equation
+        (cr1,cr2,e1,e2,negate) = BackendEquation.aliasEquation(eqn);
+        initalAliases = addInitialAlias(cr1,cr2,e1,e2,negate,knvars,iInitalAliases);
+        (eqnslst1,initalAliases,optimizationfound) = optimizeInitialSystem1(eqnslst,knvars,initalAliases,iAcc,true);
+       then
+         (eqnslst1,initalAliases,optimizationfound);
+    case (eqn::eqnslst,_,_,_,_)
+      equation
+        (eqnslst1,initalAliases,optimizationfound) = optimizeInitialSystem1(eqnslst,knvars,iInitalAliases,eqn::iAcc,iOptimizationfound);
+       then
+         (eqnslst1,initalAliases,optimizationfound);
+  end matchcontinue;
+end optimizeInitialSystem1;
+
+protected function addInitialAlias
+  input DAE.ComponentRef cr1;
+  input DAE.ComponentRef cr2;
+  input DAE.Exp e1;
+  input DAE.Exp e2;
+  input Boolean negate;
+  input BackendDAE.Variables knvars;
+  input HashTable2.HashTable iInitalAliases;
+  output HashTable2.HashTable oInitalAliases;
+algorithm
+  oInitalAliases := matchcontinue(cr1,cr2,e1,e2,negate,knvars,iInitalAliases)
+    local
+      HashTable2.HashTable initalAliases;
+      DAE.Exp e;  
+    case(_,_,_,_,_,_,_)
+      equation
+        (_::_,_) = BackendVariable.getVar(cr2, knvars);
+        e = Debug.bcallret1(negate, Expression.negate, e2, e2);
+        initalAliases = BaseHashTable.add((cr1,e),iInitalAliases);
+        Debug.fcall(Flags.DUMPOPTINIT,BackendDump.debugStrCrefStrExpStr,("Found initial Alias ",cr1," = ",e,"\n"));
+      then
+        initalAliases;
+    case(_,_,_,_,_,_,_)
+      equation
+        (_::_,_) = BackendVariable.getVar(cr1, knvars);
+        e = Debug.bcallret1(negate, Expression.negate, e1, e1);
+        initalAliases = BaseHashTable.add((cr2,e),iInitalAliases);
+        Debug.fcall(Flags.DUMPOPTINIT,BackendDump.debugStrCrefStrExpStr,("Found initial Alias ",cr2," = ",e,"\n"));
+      then
+        initalAliases;
+  end matchcontinue;
+end addInitialAlias;
+
+protected function optimizeInitialAliases
+"function: optimizeInitialAliases
+  autor Frenkel TUD 2012-08"
+  input BackendDAE.EqSystem isyst;
+  input HashTable2.HashTable initalAliases;
+  output BackendDAE.EqSystem osyst;
+algorithm
+  osyst := match (isyst,initalAliases)
+    local
+      Option<BackendDAE.IncidenceMatrix> m,mT;
+      BackendDAE.Variables vars;
+      BackendDAE.EquationArray eqns;
+      BackendDAE.Matching matching;
+      Boolean b;
+      BackendDAE.EqSystem syst;
+    case (BackendDAE.EQSYSTEM(vars,eqns,m,mT,matching),_)
+      equation
+        (vars,(_,b)) = BackendVariable.traverseBackendDAEVarsWithUpdate(vars,optimizeInitialAliasesFinder,(initalAliases,false));
+        syst = Util.if_(b,BackendDAE.EQSYSTEM(vars,eqns,m,mT,matching),isyst);
+      then
+        syst;
+  end match;
+end optimizeInitialAliases;
+
+protected function optimizeInitialAliasesFinder
+"autor: Frenkel TUD 2011-03"
+ input tuple<BackendDAE.Var, tuple<HashTable2.HashTable,Boolean>> inTpl;
+ output tuple<BackendDAE.Var, tuple<HashTable2.HashTable,Boolean>> outTpl;
+algorithm
+  outTpl:=
+  matchcontinue (inTpl)
+    local
+      BackendDAE.Var v;
+      HashTable2.HashTable initalAliases;
+      DAE.ComponentRef varName;
+      DAE.Exp exp;
+    case ((v as BackendDAE.VAR(varName=varName),(initalAliases,_)))
+      equation
+        exp = BaseHashTable.get(varName,initalAliases);
+        v = BackendVariable.setVarStartValue(v, exp);
+        v = BackendVariable.setVarFixed(v, true);
+        Debug.fcall(Flags.DUMPOPTINIT,BackendDump.debugStrCrefStrExpStr,("Set Var ",varName," (start= ",exp,", fixed=true)\n"));
+      then ((v,(initalAliases,true)));
+    case inTpl then inTpl;
+  end matchcontinue;
+end optimizeInitialAliasesFinder;
+
 end BackendDAEOptimize;
diff --git a/Compiler/BackEnd/BackendDAEUtil.mo b/Compiler/BackEnd/BackendDAEUtil.mo
@@ -8781,7 +8781,9 @@ algorithm
   (BackendDAEOptimize.generateSymbolicLinearizationPast,"generateSymbolicLinearization",false),
   (BackendDAEOptimize.collapseIndependentBlocks,"collapseIndependentBlocks",true),
   (BackendDAEOptimize.removeUnusedFunctions,"removeUnusedFunctions",false),
-  (BackendDAEOptimize.simplifyTimeIndepFuncCalls,"simplifyTimeIndepFuncCalls",false)};
+  (BackendDAEOptimize.simplifyTimeIndepFuncCalls,"simplifyTimeIndepFuncCalls",false),
+  (BackendDAEOptimize.optimizeInitialSystem,"optimizeInitialSystem",false)
+  };
   strPastOptModules := getPastOptModulesString();
   strPastOptModules := Util.getOptionOrDefault(ostrPastOptModules,strPastOptModules);
   pastOptModules := selectOptModules(strPastOptModules,allPastOptModules,{});

diff --git a/Compiler/Util/Flags.mo b/Compiler/Util/Flags.mo
@@ -357,7 +357,8 @@ constant DebugFlag SYMBOLIC_INITIALIZATION = DEBUG_FLAG(97, "symbolicInitializat
   Util.gettext("Enables using of symbolic matrices for initialization (ipopt only)"));
 constant DebugFlag TEARING_AND_RELAXATION = DEBUG_FLAG(98, "tearing_and_relaxation",
   Util.gettext("performes relaxation after tearing"));
-
+constant DebugFlag DUMPOPTINIT = DEBUG_FLAG(99, "dumpoptinit",
+  Util.gettext("Enables dumping of the optimisationinformation when optimize the initial system"));
 
 // This is a list of all debug flags, to keep track of which flags are used. A
 // flag can not be used unless it's in this list, and the list is checked at
@@ -461,7 +462,8 @@ constant list<DebugFlag> allDebugFlags = {
   DUMP_DERREPL,
   DUMP_EQNINORDER,
   SYMBOLIC_INITIALIZATION,
-  TEARING_AND_RELAXATION
+  TEARING_AND_RELAXATION,
+  DUMPOPTINIT
 };
 
 // CONFIGURATION FLAGS
@@ -579,7 +581,8 @@ constant ConfigFlag POST_OPT_MODULES = CONFIG_FLAG(16, "postOptModules",
     "removeSimpleEquations",
 //    "countOperations",
     "removeUnusedFunctions",
-    "simplifyTimeIndepFuncCalls"
+    "simplifyTimeIndepFuncCalls",
+    "optimizeInitialSystem"
   }),
   SOME(STRING_DESC_OPTION({
     ("lateInlineFunction", Util.gettext("perform function inlining for function with annotation LateInline=true")),
@@ -599,7 +602,8 @@ constant ConfigFlag POST_OPT_MODULES = CONFIG_FLAG(16, "postOptModules",
     ("generateSymbolicLinearization", Util.gettext("Generates symbolic Linearization Matrixes A,B,C,D for Linear Model:\n\t\t\\dot x = Ax + Bu\n\t\ty = Cx +Du")),
     ("collapseIndependentBlocks", Util.gettext("Collapses all equation systems back into one big system again (undo partitionIndependentBlocks)")),
     ("removeUnusedFunctions", Util.gettext("removed all unused functions from functionTree")),
-    ("simplifyTimeIndepFuncCalls", Util.gettext("simplifies time independent built in function calls like pre(param) -> param, der(param) -> 0.0, change(param) -> false, edge(param) -> false"))
+    ("simplifyTimeIndepFuncCalls", Util.gettext("simplifies time independent built in function calls like pre(param) -> param, der(param) -> 0.0, change(param) -> false, edge(param) -> false")),
+    ("optimizeInitialSystem", Util.gettext("simplifies time initial system"))
     })),
   Util.gettext("Sets the post optimisation modules to use in the back end. See +help=optmodules for more info."));
 constant ConfigFlag SIMCODE_TARGET = CONFIG_FLAG(17, "simCodeTarget",