- new debug-flag: +d=iterationVars

- this flag generates a list with all iteration vars for both simulation system and initialization system git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@20834 f25d12d1-65f4-0310-ae8a-bbce733d8d8e
OpenModelica · May 26, 2014 · f8032de · f8032de
1 parent ffd0ca1
commit f8032de
Show file tree

Hide file tree

Showing 5 changed files with 156 additions and 10 deletions.
diff --git a/Compiler/BackEnd/BackendDAEOptimize.mo b/Compiler/BackEnd/BackendDAEOptimize.mo
@@ -7694,4 +7694,136 @@ algorithm
   outDAE := BackendDAE.DAE(systs, BackendDAE.SHARED(knvars, exobj, aliasVars, inieqns, remeqns, constrs, clsAttrs, cache, env, funcTree, eventInfo, eoc, btp, symjacs, ei));
 end applyRewriteRulesBackendShared;
 
+// =============================================================================
+// generates a list with all iteration variables
+//
+// =============================================================================
+
+public function listAllIterationVariables "author: lochel"
+  input BackendDAE.BackendDAE inBackendDAE;
+protected
+  list<BackendDAE.EqSystem> eqs;
+  BackendDAE.BackendDAEType backendDAEType;
+algorithm
+  BackendDAE.DAE(eqs=eqs, shared=BackendDAE.SHARED(backendDAEType=backendDAEType)) := inBackendDAE;
+  Error.addCompilerNotification("\nList of all iteration variable (DAE kind: " +& BackendDump.printBackendDAEType2String(backendDAEType) +& ")\n########################################\n\n");
+  listAllIterationVariables0(eqs);
+end listAllIterationVariables;
+
+protected function listAllIterationVariables0 "author: lochel"
+  input list<BackendDAE.EqSystem> inEqs;
+algorithm
+  _ := match(inEqs)
+    local
+      BackendDAE.EqSystem eq;
+      list<BackendDAE.EqSystem> eqs;
+
+    case ({})
+    then ();
+
+    case (eq::eqs) equation
+      listAllIterationVariables1(eq);
+      listAllIterationVariables0(eqs);
+    then ();
+  end match;
+end listAllIterationVariables0;
+
+protected function listAllIterationVariables1 "author: lochel"
+  input BackendDAE.EqSystem inEqSystem;
+protected
+  BackendDAE.Variables vars;
+  BackendDAE.StrongComponents comps;
+algorithm
+  BackendDAE.EQSYSTEM(orderedVars=vars,
+                      matching=BackendDAE.MATCHING(comps=comps)) := inEqSystem;
+  listAllIterationVariables2(comps, vars);
+end listAllIterationVariables1;
+
+protected function listAllIterationVariables2 "author: lochel"
+  input BackendDAE.StrongComponents inComps;
+  input BackendDAE.Variables inVars;
+algorithm
+  _ := matchcontinue(inComps, inVars)
+    local
+      BackendDAE.StrongComponents rest;
+      list<BackendDAE.Var> varlst;
+      list<Integer> vlst;
+      Boolean linear;
+      String str;
+
+    case ({}, _)
+    then ();
+
+    case (BackendDAE.MIXEDEQUATIONSYSTEM(disc_vars=vlst)::rest, _) equation
+      varlst = List.map1r(vlst, BackendVariable.getVarAt, inVars);
+      false = List.isEmpty(varlst);
+
+      Error.addCompilerNotification("Iteration variables of mixed equation system:\n" +& warnAboutVars(varlst));
+      listAllIterationVariables2(rest, inVars);
+    then ();
+
+    case (BackendDAE.EQUATIONSYSTEM(vars=vlst, jacType=BackendDAE.JAC_NONLINEAR())::rest, _) equation
+      varlst = List.map1r(vlst, BackendVariable.getVarAt, inVars);
+      false = List.isEmpty(varlst);
+
+      Error.addCompilerNotification("Iteration variables of nonlinear equation system:\n" +& warnAboutVars(varlst));
+      listAllIterationVariables2(rest, inVars);
+    then ();
+
+     case (BackendDAE.EQUATIONSYSTEM(vars=vlst, jacType=BackendDAE.JAC_GENERIC())::rest, _) equation
+      varlst = List.map1r(vlst, BackendVariable.getVarAt, inVars);
+      false = List.isEmpty(varlst);
+
+      Error.addCompilerNotification("Iteration variables of equation system w/o analytic Jacobian:\n" +& warnAboutVars(varlst));
+      listAllIterationVariables2(rest, inVars);
+    then ();
+
+    case (BackendDAE.EQUATIONSYSTEM(vars=vlst, jacType=BackendDAE.JAC_NO_ANALYTIC())::rest, _) equation
+      varlst = List.map1r(vlst, BackendVariable.getVarAt, inVars);
+      false = List.isEmpty(varlst);
+
+      Error.addCompilerNotification("Iteration variables of equation system w/o analytic Jacobian:\n" +& warnAboutVars(varlst));
+      listAllIterationVariables2(rest, inVars);
+    then ();
+
+    case (BackendDAE.TORNSYSTEM(tearingvars=vlst, linear=linear)::rest, _) equation
+      varlst = List.map1r(vlst, BackendVariable.getVarAt, inVars);
+      false = List.isEmpty(varlst);
+
+      str = Util.if_(linear, "linear", "nonlinear");
+      Error.addCompilerNotification("Iteration variables of torn " +& str +& "equation system:\n" +& warnAboutVars(varlst));
+      listAllIterationVariables2(rest, inVars);
+    then ();
+
+    case (_::rest, _) equation
+      listAllIterationVariables2(rest, inVars);
+    then ();
+  end matchcontinue;
+end listAllIterationVariables2;
+
+protected function warnAboutVars "author: lochel"
+  input list<BackendDAE.Var> inVars;
+  output String outString;
+algorithm
+  outString := match(inVars)
+    local
+      BackendDAE.Var v;
+      list<BackendDAE.Var> vars;
+      String crStr;
+      String str;
+
+    case ({})
+    then "";
+
+    case (v::{}) equation
+      crStr = "  " +& BackendDump.varString(v);
+    then crStr;
+
+    case (v::vars) equation
+      crStr = BackendDump.varString(v);
+      str = "  " +& crStr +& "\n" +& warnAboutVars(vars);
+    then str;
+  end match;
+end warnAboutVars;
+
 end BackendDAEOptimize;
diff --git a/Compiler/BackEnd/BackendDump.mo b/Compiler/BackEnd/BackendDump.mo
@@ -293,16 +293,23 @@ end printShared;
 public function printBackendDAEType "This is a helper for printShared."
   input BackendDAE.BackendDAEType btp;
 algorithm
-  _ := match(btp)
-    case (BackendDAE.SIMULATION()) equation print("simulation"); then ();
-    case (BackendDAE.JACOBIAN()) equation print("jacobian"); then ();
-    case (BackendDAE.ALGEQSYSTEM()) equation print("algebraic loop"); then ();
-    case (BackendDAE.ARRAYSYSTEM()) equation print("multidim equation arrays"); then ();
-    case (BackendDAE.PARAMETERSYSTEM()) equation print("parameter system"); then ();
-    case (BackendDAE.INITIALSYSTEM()) equation print("initial system"); then ();
-  end match;
+  print(printBackendDAEType2String(btp));
 end printBackendDAEType;
 
+public function printBackendDAEType2String "This is a helper for printShared."
+  input BackendDAE.BackendDAEType btp;
+  output String str;
+algorithm
+  str := match(btp)
+    case (BackendDAE.SIMULATION()) then "simulation";
+    case (BackendDAE.JACOBIAN()) then "jacobian";
+    case (BackendDAE.ALGEQSYSTEM()) then "algebraic loop";
+    case (BackendDAE.ARRAYSYSTEM()) then "multidim equation arrays";
+    case (BackendDAE.PARAMETERSYSTEM()) then "parameter system";
+    case (BackendDAE.INITIALSYSTEM()) then "initial system";
+  end match;
+end printBackendDAEType2String;
+
 public function printStateSets "author: Frenkel TUD"
   input BackendDAE.StateSets stateSets;
 algorithm

diff --git a/Compiler/BackEnd/Initialization.mo b/Compiler/BackEnd/Initialization.mo
@@ -203,6 +203,8 @@ algorithm
 
       b = Flags.isSet(Flags.DUMP_EQNINORDER) and Flags.isSet(Flags.DUMP_INITIAL_SYSTEM);
       Debug.bcall2(b, BackendDump.dumpEqnsSolved, initdae, "initial system: eqns in order");
+
+      Debug.fcall(Flags.ITERATION_VARS, BackendDAEOptimize.listAllIterationVariables, initdae);
     then (SOME(initdae), useHomotopy);
 
     else (NONE(), false);

diff --git a/Compiler/BackEnd/SimCodeUtil.mo b/Compiler/BackEnd/SimCodeUtil.mo
@@ -1499,6 +1499,8 @@ algorithm
 
       // generate initDAE before replacing pre(alias)!
       (initDAE, useHomotopy) = Initialization.solveInitialSystem(dlow);
+
+      Debug.fcall(Flags.ITERATION_VARS, BackendDAEOptimize.listAllIterationVariables, dlow);
 
       // replace pre(alias) in time-equations
       dlow = BackendDAEOptimize.simplifyTimeIndepFuncCalls(dlow);

diff --git a/Compiler/Util/Flags.mo b/Compiler/Util/Flags.mo
@@ -387,7 +387,9 @@ constant DebugFlag EVAL_FUNC_DUMP = DEBUG_FLAG(110, "evalFuncDump", false,
   Util.gettext("dumps debug information about the function evaluation"));
 constant DebugFlag PRINT_STRUCTURAL = DEBUG_FLAG(111, "printStructuralParameters", false,
   Util.gettext("Prints the structural parameters identified by the front-end"));
-
+constant DebugFlag ITERATION_VARS = DEBUG_FLAG(113, "iterationVars", false,
+  Util.gettext("Shows a list of all iteration variables."));
+
 // 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
 // initialization so that all flags are sorted by index (and thus have unique
@@ -503,7 +505,8 @@ constant list<DebugFlag> allDebugFlags = {
   STRICT_RML,
   IMPL_ODE,
   EVAL_FUNC_DUMP,
-  PRINT_STRUCTURAL
+  PRINT_STRUCTURAL,
+  ITERATION_VARS
 };
 
 // CONFIGURATION FLAGS