Fixing bug in VarTransform.replaceExpRepeated

git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@18798 f25d12d1-65f4-0310-ae8a-bbce733d8d8e

Author: Leonardo Laguna

Compiler/BackEnd/BackendDAEUtil.mo

@@ -52,6 +52,7 @@ public import BackendDAE;
 public import BackendDAEFunc;
 public import DAE;
 public import Env;
+public import SCode;
 public import Util;
 public import HpcOmEqSystems;
 
@@ -89,7 +90,6 @@ protected import List;
 protected import Matching;
 protected import OnRelaxation;
 protected import RemoveSimpleEquations;
-protected import SCode;
 protected import System;
 protected import Tearing;
 protected import Types;
@@ -1302,6 +1302,64 @@ algorithm
   end matchcontinue;
 end addAliasVariables;
 
+public function isApproximatedEquation
+  input BackendDAE.Equation eqn;
+  output Boolean out;
+algorithm
+  out:= match(eqn)
+    local
+      list<SCode.Comment> comment;
+      Boolean ret;
+    case(BackendDAE.EQUATION(source=DAE.SOURCE(comment=comment)))
+      equation
+        ret = isApproximatedEquation2(comment);
+      then
+        ret;
+    case(_)
+      then
+        false;
+  end match;
+end isApproximatedEquation;
+
+public function isApproximatedEquation2
+  input list<SCode.Comment> commentIn;
+  output Boolean out;
+ algorithm
+  out:= matchcontinue(commentIn)
+    local
+      SCode.Comment h;
+      list<SCode.Comment> t;
+      Boolean ret;
+      list<SCode.SubMod> subModLst;
+    case({})
+      equation
+        then false;
+    case(SCode.COMMENT(annotation_=SOME(SCode.ANNOTATION(SCode.MOD(subModLst=subModLst))))::t)
+      equation
+        ret = (List.exist(subModLst,isApproximatedEquation3)) or isApproximatedEquation2(t);
+      then
+        ret;
+    case(h::t)
+      equation
+        ret = isApproximatedEquation2(t);
+      then
+        ret;
+  end matchcontinue;
+end isApproximatedEquation2;
+
+protected function isApproximatedEquation3
+  input SCode.SubMod m;
+  output Boolean out;
+algorithm
+out:= match(m)
+  case(SCode.NAMEMOD("__OpenModelica_ApproximatedEquation",SCode.MOD(binding = SOME((Absyn.BOOL(true),_)))))
+    equation
+     then true;
+  case(_) equation
+     then false;
+   end match;
+end isApproximatedEquation3;
+
 public function isDiscreteEquation
   input BackendDAE.Equation eqn;
   input BackendDAE.Variables vars;

Compiler/BackEnd/RemoveSimpleEquations.mo

@@ -601,40 +601,46 @@ algorithm
       Integer index;
       array<list<Integer>> mT;
       Boolean b, differentiated;
-    case (BackendDAE.EQUATION(exp=e1, scalar=e2, source=source, differentiated=differentiated), _)
+      BackendDAE.Equation e;
+    case (e as BackendDAE.EQUATION(exp=e1, scalar=e2, source=source, differentiated=differentiated), _)
       equation
+        //false = BackendDAEUtil.isApproximatedEquation(e);
         Debug.fcall(Flags.DEBUG_ALIAS, BackendDump.debugStrExpStrExpStr, ("Found Equation ", e1, " = ", e2, " to handle.\n"));
-      then 
+      then
         simpleEquationAcausal(e1, e2, (source, differentiated), false, inTpl);
-    
-    case (BackendDAE.ARRAY_EQUATION(left=e1, right=e2, source=source, differentiated=differentiated), _)
+
+    case (e as BackendDAE.ARRAY_EQUATION(left=e1, right=e2, source=source, differentiated=differentiated), _)
       equation
+        //false = BackendDAEUtil.isApproximatedEquation(e);
         Debug.fcall(Flags.DEBUG_ALIAS, BackendDump.debugStrExpStrExpStr, ("Found Array Equation ", e1, " = ", e2, " to handle.\n"));
-      then 
+      then
         simpleEquationAcausal(e1, e2, (source, differentiated), false, inTpl);
-    
-    case (BackendDAE.SOLVED_EQUATION(componentRef=cr, exp=e2, source=source, differentiated=differentiated), _)
+
+    case (e as BackendDAE.SOLVED_EQUATION(componentRef=cr, exp=e2, source=source, differentiated=differentiated), _)
       equation
+        //false = BackendDAEUtil.isApproximatedEquation(e);
         e1 = Expression.crefExp(cr);
         Debug.fcall(Flags.DEBUG_ALIAS, BackendDump.debugStrExpStrExpStr, ("Found Solved Equation ", e1, " = ", e2, " to handle.\n"));
-      then 
+      then
         simpleEquationAcausal(e1, e2, (source, differentiated), false, inTpl);
-    
-    case (BackendDAE.RESIDUAL_EQUATION(exp=e1, source=source, differentiated=differentiated), _)
+
+    case (e as BackendDAE.RESIDUAL_EQUATION(exp=e1, source=source, differentiated=differentiated), _)
       equation
+        //false = BackendDAEUtil.isApproximatedEquation(e);
         Debug.fcall(Flags.DEBUG_ALIAS, BackendDump.debugStrExpStr, ("Found Residual Equation ", e1, " to handle.\n"));
-      then 
+      then
         simpleExpressionAcausal(e1, (source, differentiated), false, inTpl);
-    
-    case (BackendDAE.COMPLEX_EQUATION(left=e1, right=e2, source=source, differentiated=differentiated), _)
+
+    case (e as BackendDAE.COMPLEX_EQUATION(left=e1, right=e2, source=source, differentiated=differentiated), _)
       equation
+        //false = BackendDAEUtil.isApproximatedEquation(e);
         Debug.fcall(Flags.DEBUG_ALIAS, BackendDump.debugStrExpStrExpStr, ("Found Complex Equation ", e1, " = ", e2, " to handle.\n"));
-      then 
+      then
         simpleEquationAcausal(e1, e2, (source, differentiated), false, inTpl);
-    
+
     case (_, (v, s, eqns, seqns, index, mT, b))
       then ((v, s, eqn::eqns, seqns, index, mT, b));
-   
+
    end matchcontinue;
 end simpleEquationsFinder;
 

Compiler/BackEnd/Uncertainties.mo

@@ -162,6 +162,7 @@ algorithm
         approximatedEquations_one = getEquationsWithApproximatedAnnotation(dlow_1);
         approximatedEquations = List.flatten(List.map1r(approximatedEquations_one,listGet,arrayList(mapEqnIncRow)));
 
+//////////////////////////////
         mExt=removeEquations(mExt,approximatedEquations);
 
               printSep(getMathematicaText("Approximated equations to be removed"));
@@ -170,6 +171,9 @@ algorithm
               printSep(getMathematicaText("After eliminating approximated equations"));
               printSep(equationsToMathematicaGrid(getEquationsNumber(mExt),allEqs,allVars,sharedVars,mapIncRowEqn));
 
+//////////////////////
+
+
         // get the variable indices after the elimination
         variables = List.intRange(BackendVariable.varsSize(allVars));
         (knowns,distributions) = getUncertainRefineVariableIndexes(allVars,variables);
@@ -205,7 +209,9 @@ algorithm
 
               printSep(getMathematicaText("Remaining equations"));
               printSep(equationsToMathematicaGrid(remainingEquations,allEqs,allVars,sharedVars,mapIncRowEqn));
+///////////////////
 
+/////////////////////////////////////////////////////////////
         (setC,removed_equations_squared)=getEquationsForKnownsSystem(mExt,knowns,unknowns,setS,allEqs,allVars,sharedVars,mapIncRowEqn);
 
         print(Util.if_(List.isNotEmpty(removed_equations_squared),"Warning: the system is ill-posed. One or more equations have been removed from squared system of knowns.\n",""));
@@ -532,7 +538,7 @@ algorithm
             {};
         case(h::t,i)
           equation
-            true=isApproximatedEquation(h);
+            true=BackendDAEUtil.isApproximatedEquation(h);
             inner_ret = getEquationsWithApproximatedAnnotation2(t,i+1);
           then
             i::inner_ret;
@@ -544,64 +550,6 @@ algorithm
       end matchcontinue;
 end getEquationsWithApproximatedAnnotation2;
 
-protected function isApproximatedEquation
-  input BackendDAE.Equation eqn;
-  output Boolean out;
-algorithm
-  out:= match(eqn)
-    local
-      list<SCode.Comment> comment;
-      Boolean ret;
-    case(BackendDAE.EQUATION(source=DAE.SOURCE(comment=comment)))
-      equation
-        ret = isApproximatedEquation2(comment);
-      then
-        ret;
-    case(_)
-      then
-        false;
-  end match;
-end isApproximatedEquation;
-
-protected function isApproximatedEquation2
-  input list<SCode.Comment> commentIn;
-  output Boolean out;
- algorithm
-  out:= matchcontinue(commentIn)
-    local
-      SCode.Comment h;
-      list<SCode.Comment> t;
-      Boolean ret;
-      list<SCode.SubMod> subModLst;
-    case({})
-      equation
-        then false;
-    case(SCode.COMMENT(annotation_=SOME(SCode.ANNOTATION(SCode.MOD(subModLst=subModLst))))::t)
-      equation
-        ret = (List.exist(subModLst,isApproximatedEquation3)) or isApproximatedEquation2(t);
-      then
-        ret;
-    case(h::t)
-      equation
-        ret = isApproximatedEquation2(t);
-      then
-        ret;
-  end matchcontinue;
-end isApproximatedEquation2;
-
-protected function isApproximatedEquation3
-  input SCode.SubMod m;
-  output Boolean out;
-algorithm
-out:= match(m)
-  case(SCode.NAMEMOD("__OpenModelica_ApproximatedEquation",SCode.MOD(binding = SOME((Absyn.BOOL(true),_)))))
-     then true;
-  case(_)
-     then false;
-   end match;
-end isApproximatedEquation3;
-
-
 protected function flattenModel
   input Absyn.Path className;
   input Absyn.Program p;
@@ -2912,7 +2860,7 @@ protected function getSourceIfApproximated "Returns SOME(source) if the equation
     protected DAE.ElementSource temp;
 algorithm
     temp:=BackendEquation.equationSource(eqn);
-    source:=Util.if_(isApproximatedEquation(eqn),SOME(temp),NONE());
+    source:=Util.if_(BackendDAEUtil.isApproximatedEquation(eqn),SOME(temp),NONE());
 end getSourceIfApproximated;
 
 /*     Set handling functions    */
@@ -3175,7 +3123,7 @@ algorithm
   then ();
   case(SOME(DAE.SOURCE(comment=comment)))
   equation
-    str = Util.if_(isApproximatedEquation2(comment),"true","false");    
+    str = Util.if_(BackendDAEUtil.isApproximatedEquation2(comment),"true","false");    
     print(" *Approximated = "+&str);
   then ();
   end match;

Compiler/Util/VarTransform.mo

@@ -1392,7 +1392,7 @@ algorithm
         true = i > maxIter;
       then e;
     case (_,_,_,_,_,true) then e;
-    case (_,_,_,_,_,true)
+    case (_,_,_,_,_,_)
       equation
         (e1,b) = replaceExp(e,repl,func);
         res = replaceExpRepeated2(e1,repl,func,maxIter,i+1,not b /*Expression.expEqual(e,e1)*/);