Changeset d316ab2 in OpenModelica

Timestamp:

2017-01-06T20:35:49+01:00 (7 years ago)

Author:

hudson <openmodelica@…>

Branches:

Added-citation-metadata, maintenance/v1.14, maintenance/v1.15, maintenance/v1.16, maintenance/v1.17, maintenance/v1.18, maintenance/v1.19, maintenance/v1.20, maintenance/v1.21, maintenance/v1.22, maintenance/v1.23, master, omlib-staging

Children:

e7c76f7

Parents:

c2a8668f

git-author:

Rüdiger Franke <rdgfranke@…> (01/06/17 20:35:49)

git-committer:

hudson <openmodelica@…> (01/06/17 20:35:49)

Message:

Add synchronous solver method ExplicitEuler, besides ImplicitEuler

File:

• Compiler/BackEnd/SynchronousFeatures.mo (modified) (4 diffs)

Compiler/BackEnd/SynchronousFeatures.mo

@@ -189 +189 @@
           subPartition := shared.partitionsInfo.subPartitions[idx];
           solverMethod := BackendDump.optionString(subPartition.clock.solver);
+          if stringLength(solverMethod) > 7 and substring(solverMethod, 1, 8) == "Explicit" then
+            if solverMethod <> "ExplicitEuler" then
+              Error.addCompilerWarning("Solving clocked continuous equations with " +
+                                       "ExplicitEuler instead of specified " + solverMethod + ". "
+                                       + "Supporting ExplicitEuler and ImplicitEuler.");
+            end if;
+            for i in 1:BackendDAEUtil.equationArraySize(eqs) loop
+              eq := BackendEquation.equationNth1(eqs, i);
+              (_, derVars) := BackendEquation.traverseExpsOfEquation(eq, getDerVars1, derVars);
+            end for;
+            for i in 1:BackendDAEUtil.equationArraySize(eqs) loop
+              eq := BackendEquation.equationNth1(eqs, i);
+              (eq, _) := BackendEquation.traverseExpsOfEquation(eq, shiftDerVars1, derVars);
+              eqs := BackendEquation.setAtIndex(eqs, i, eq);
+            end for;
+          elseif stringLength(solverMethod) > 0 and solverMethod <> "ImplicitEuler" then
+            Error.addCompilerWarning("Solving clocked continuous equations with " +
+                                     "ImplicitEuler instead of specified " + solverMethod + ". "
+                                     + "Supporting ExplicitEuler and ImplicitEuler.");
+          end if;
           lstEqs := {};
+          derVars := {};
           for i in 1:BackendDAEUtil.equationArraySize(eqs) loop
             eq := BackendEquation.equationNth1(eqs, i);
-            (eq, (solverMethod, derVars)) := BackendEquation.traverseExpsOfEquation(eq, applySolverMethod1, (solverMethod, derVars));
+            (eq, derVars) := BackendEquation.traverseExpsOfEquation(eq, applyEulerMethod1, derVars);
             lstEqs := eq::lstEqs;
           end for;
@@ -204 +225 @@
 end treatClockedStates;
 
-protected function applySolverMethod1 "helper to applySolverMethod"
-  input DAE.Exp inExp;
-  input tuple<String, list<DAE.ComponentRef>> inTpl;
+protected function getDerVars1 "helper to getDerVars"
+  input DAE.Exp inExp;
+  input list<DAE.ComponentRef> inDerVars;
   output DAE.Exp outExp;
-  output tuple<String, list<DAE.ComponentRef>> outTpl;
-algorithm
-  (outExp, outTpl) := Expression.traverseExpBottomUp(inExp, applySolverMethod, inTpl);
-end applySolverMethod1;
-
-protected function applySolverMethod
-"Apply given solverMethod to convert continous-time to clocked expression.
- So far ImplicitEuler, replacing der(x) -> (x - previous(x))/interval().
+  output list<DAE.ComponentRef> outDerVars;
+algorithm
+  (outExp, outDerVars) := Expression.traverseExpBottomUp(inExp, getDerVars, inDerVars);
+end getDerVars1;
+
+protected function getDerVars
+"Get all crefs that appear in a der() operator.
  author: rfranke"
   input DAE.Exp inExp;
-  input tuple<String, list<DAE.ComponentRef>> inTpl;
+  input list<DAE.ComponentRef> inDerVars;
+  output DAE.Exp outExp = inExp;
+  output list<DAE.ComponentRef> outDerVars;
+algorithm
+  outDerVars := match inExp
+    local
+      DAE.ComponentRef x;
+    case DAE.CALL(path = Absyn.IDENT(name = "der"),
+                  expLst = {DAE.CREF(componentRef = x)})
+      then x :: inDerVars;
+    else inDerVars;
+  end match;
+end getDerVars;
+
+protected function shiftDerVars1 "helper to shiftDerVars"
+  input DAE.Exp inExp;
+  input list<DAE.ComponentRef> inDerVars;
   output DAE.Exp outExp;
-  output tuple<String, list<DAE.ComponentRef>> outTpl;
-algorithm
-  (outExp, outTpl) := match inExp
+  output list<DAE.ComponentRef> outDerVars;
+algorithm
+  (outExp, outDerVars) := Expression.traverseExpBottomUp(inExp, shiftDerVars, inDerVars);
+end shiftDerVars1;
+
+protected function shiftDerVars
+"Apply previous() operator to all inDerVars.
+ author: rfranke"
+  input DAE.Exp inExp;
+  input list<DAE.ComponentRef> inDerVars;
+  output DAE.Exp outExp;
+  output list<DAE.ComponentRef> outDerVars = inDerVars;
+algorithm
+  outExp := match inExp
     local
       List<DAE.Exp> expLst;
@@ -229 +276 @@
       DAE.Type ty;
       DAE.Exp exp;
-      String inSolverMethod, outSolverMethod;
-      list<DAE.ComponentRef> inDerVars;
+    // introduce previous()
+    case DAE.CREF(componentRef = x)
+      guard ComponentReference.crefInLst(x, inDerVars)
+      algorithm
+        exp := DAE.CALL(Absyn.IDENT(name = "previous"), {inExp}, DAE.callAttrBuiltinImpureReal);
+      then exp;
+    // check for possibly introduced der(previous())
+    case DAE.CALL(path = Absyn.IDENT(name = "der"),
+                  expLst = {DAE.CALL(path = Absyn.IDENT(name = "previous"), expLst = expLst)},
+                  attr = attr as DAE.CALL_ATTR(ty = ty))
+      algorithm
+        exp := DAE.CALL(Absyn.IDENT(name = "der"), expLst, attr);
+      then exp;
+    // check for possibly introduced previous(previous())
+    case DAE.CALL(path = Absyn.IDENT(name = "previous"),
+                  expLst = {DAE.CALL(path = Absyn.IDENT(name = "previous"), expLst = expLst)},
+                  attr = attr as DAE.CALL_ATTR(ty = ty))
+      algorithm
+        exp := DAE.CALL(Absyn.IDENT(name = "previous"), expLst, attr);
+      then exp;
+    // do nothing per default
+    else inExp;
+  end match;
+end shiftDerVars;
+
+protected function applyEulerMethod1 "helper to applyEulerMethod"
+  input DAE.Exp inExp;
+  input list<DAE.ComponentRef> inDerVars;
+  output DAE.Exp outExp;
+  output list<DAE.ComponentRef> outDerVars;
+algorithm
+  (outExp, outDerVars) := Expression.traverseExpBottomUp(inExp, applyEulerMethod, inDerVars);
+end applyEulerMethod1;
+
+protected function applyEulerMethod
+"Convert continous-time to clocked expression by replacing
+ der(x) -> (x - previous(x)) / interval().
+ author: rfranke"
+  input DAE.Exp inExp;
+  input list<DAE.ComponentRef> inDerVars;
+  output DAE.Exp outExp;
+  output list<DAE.ComponentRef> outDerVars;
+algorithm
+  (outExp, outDerVars) := match inExp
+    local
+      List<DAE.Exp> expLst;
+      DAE.CallAttributes attr;
+      DAE.ComponentRef x;
+      DAE.Type ty;
+      DAE.Exp exp;
     case DAE.CALL(path = Absyn.IDENT(name = "der"),
                   expLst = expLst as {DAE.CREF(componentRef = x)},
                   attr = attr as DAE.CALL_ATTR(ty = ty))
       algorithm
-        (inSolverMethod, inDerVars) := inTpl;
-        outSolverMethod := "ImplicitEuler";
         exp := DAE.CALL(Absyn.IDENT(name = "previous"), expLst, attr);
         exp := DAE.BINARY(DAE.CREF(x, ty), DAE.SUB(DAE.T_REAL_DEFAULT), exp);
@@ -242 +335 @@
                           DAE.CALL(Absyn.IDENT(name = "interval"), {},
                                    DAE.callAttrBuiltinImpureReal));
-        if outSolverMethod <> inSolverMethod then
-          Error.addCompilerWarning("Solved clocked continuous equations with " +
-                                   outSolverMethod + " instead of specified " +
-                                   inSolverMethod + ".");
-        end if;
-      then (exp, (outSolverMethod, x :: inDerVars));
-    else (inExp, inTpl);
-  end match;
-end applySolverMethod;
+      then (exp, x :: inDerVars);
+    else (inExp, inDerVars);
+  end match;
+end applyEulerMethod;
 
 protected function markClockedStates