Merge branch 'master' into maintenance/v1.13

Author: adrpo

3rdParty

@@ -394,8 +394,7 @@ uniontype Equation
     .DAE.Exp iter "the iterator variable";
     .DAE.Exp start "start of iteration";
     .DAE.Exp stop "end of iteration";
-    .DAE.Exp left;
-    .DAE.Exp right;
+    Equation body "iterated equation";
     .DAE.ElementSource source "origin of equation";
     EquationAttributes attr;
   end FOR_EQUATION;

Compiler/BackEnd/BackendDAE.mo

@@ -424,6 +424,13 @@ algorithm
         then
           ();
 
+      // for equation
+      case DAE.FOR_EQUATION()
+        algorithm
+          (outEqns, outREqns, outIEqns) := lowerEqn(el, inFunctions, outEqns, outREqns, outIEqns, false);
+        then
+          ();
+
       // initial array equations
       case DAE.INITIAL_ARRAY_EQUATION()
         algorithm
@@ -434,7 +441,7 @@ algorithm
       // when equations
       case DAE.WHEN_EQUATION(condition = e, equations = dae_elts)
         algorithm
-          if intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33) and Types.isClockOrSubTypeClock(Expression.typeof(e)) then
+          if Config.synchronousFeaturesAllowed() and Types.isClockOrSubTypeClock(Expression.typeof(e)) then
 
             (outEqns, outVars, eq_attrs) := createWhenClock(whenClkCnt, e, outEqns, outVars);
             whenClkCnt := whenClkCnt + 1;
@@ -692,6 +699,7 @@ algorithm
       DAE.ComponentRef cr;
       DAE.ElementSource src;
       DAE.Exp e1, e2;
+      DAE.Dimensions dims;
       BackendDAE.EquationAttributes attr;
       BackendDAE.Var var;
       list<BackendDAE.Equation> assert_eqs;
@@ -710,7 +718,12 @@ algorithm
         outVars := lowerDynamicVar(inElement, inFunctions) :: outVars;
         e1 := Expression.crefExp(cr);
         attr := BackendDAE.EQ_ATTR_DEFAULT_BINDING;
-        outEqns := BackendDAE.EQUATION(e1, e2, src, attr) :: outEqns;
+        (_, dims) := ComponentReference.crefTypeFull2(cr);
+        if listEmpty(dims) then
+          outEqns := BackendDAE.EQUATION(e1, e2, src, attr) :: outEqns;
+        else
+          outEqns := BackendDAE.ARRAY_EQUATION(Expression.dimensionsSizes(dims), e1, e2, src, attr) :: outEqns;
+        end if;
       then
         ();
 
@@ -1295,8 +1308,14 @@ algorithm
 
     case DAE.EQUEQUATION(cr1 = cr1, cr2 = cr2,source = source)
       equation
-        e1 = Expression.crefExp(cr1);
-        e2 = Expression.crefExp(cr2);
+        if Flags.isSet(Flags.NF_SCALARIZE) then
+          e1 = Expression.crefExp(cr1);
+          e2 = Expression.crefExp(cr2);
+        else
+          // consider array dimensions
+          e1 = Expression.crefToExp(cr1);
+          e2 = Expression.crefToExp(cr2);
+        end if;
         eqns = lowerExtendedRecordEqn(e1,e2,source,BackendDAE.EQ_ATTR_DEFAULT_DYNAMIC,functionTree,inEquations);
       then
        (eqns,inREquations,inIEquations);
@@ -1356,6 +1375,16 @@ algorithm
       then
         (inEquations,inREquations,eqns);
 
+    case DAE.FOR_EQUATION(iter = s, range = e1, equations = eqnslst, source = source)
+      equation
+        // create one backend for-equation for each equation element in the loop
+        (eqns, reqns, ieqns) = lowerEqns(eqnslst, functionTree, {}, {}, {}, inInitialization);
+        eqns = listAppend(List.map2(eqns, lowerForEquation, s, e1), inEquations);
+        reqns = listAppend(List.map2(reqns, lowerForEquation, s, e1), inREquations);
+        ieqns = listAppend(List.map2(ieqns, lowerForEquation, s, e1), inIEquations);
+      then
+        (eqns, reqns, ieqns);
+
    // if equation that cannot be translated to if expression but have initial() as condition
     case DAE.IF_EQUATION(condition1 = {DAE.CALL(path=Absyn.IDENT("initial"))},equations2={eqnslst},equations3={})
       equation
@@ -1425,6 +1454,25 @@ algorithm
   end match;
 end lowerEqn;
 
+protected
+function lowerForEquation
+"Wrap one equation into a for-equation.
+ author: rfranke"
+  input BackendDAE.Equation eq;
+  input DAE.Ident iter;
+  input DAE.Exp range;
+  output BackendDAE.Equation forEq;
+protected
+  DAE.Exp iterExp, start, stop;
+  DAE.Type ty;
+algorithm
+  DAE.RANGE(ty=ty, start=start, stop=stop) := range;
+  iterExp := DAE.CREF(DAE.CREF_IDENT(iter, ty, {}), ty);
+  forEq := BackendDAE.FOR_EQUATION(iterExp, start, stop, eq,
+                                   BackendEquation.equationSource(eq),
+                                   BackendEquation.getEquationAttributes(eq));
+end lowerForEquation;
+
 protected function lowerIfEquation
   input list<DAE.Exp> conditions;
   input list<list<DAE.Element>> theneqns;

Compiler/BackEnd/BackendDAECreate.mo

@@ -116,7 +116,7 @@ end simplifyAllExpressions;
 // OM introduces $OMC$PosetiveMax which can simplified using min or max attribute
 // see Modelica spec for inStream
 // author: Vitalij Ruge
-// see. #3885, 4441
+// see. #3885, 4441, 5104
 // =============================================================================
 
 public function simplifyInStream
@@ -140,6 +140,14 @@ protected function simplifyInStreamWork
   output list<BackendDAE.Variables> outVars = inVars;
 algorithm
   outExp := Expression.traverseExpBottomUp(inExp, simplifyInStreamWork2, outVars);
+
+  // with #5104 we remove max(x, eps)
+  // so in case max(x,eps)*y/max(x,eps) => x*y/x
+  // now x can be equal 0, so we need simplify x*y/x = y
+  // it's seem no other models silplyfied it
+  if not Expression.expEqual(outExp, inExp) then
+    outExp := ExpressionSimplify.simplify(outExp);
+  end if;
 end simplifyInStreamWork;
 
 protected function simplifyInStreamWork2
@@ -152,44 +160,70 @@ algorithm
     local
       DAE.Type tp;
       DAE.ComponentRef cr;
-      DAE.Exp e, expr, a, b;
+      DAE.Exp e, expr, ret;
       Option<DAE.Exp> eMin, eMax;
-      Boolean isZero;
 
-    case DAE.CALL(path=Absyn.IDENT("$OMC$PositiveMax"),expLst={e as DAE.CREF(componentRef=cr), expr}) algorithm
+    // positiveMax(cref, eps) = 0 if variable(cref).max <= 0
+    // positiveMax(cref, eps) = cref if variable(cref).min >= 0
+    case DAE.CALL(path=Absyn.IDENT("$OMC$PositiveMax"),expLst={e as DAE.CREF(componentRef=cr), expr})
+    algorithm
       (eMin, eMax) := simplifyInStreamWorkExpresion(cr, outVars);
-      isZero := simplifyInStreamWorkSimplify(eMin, false);
-      tp := ComponentReference.crefTypeFull(cr);
-    then if isZero then Expression.createZeroExpression(tp) else Expression.makePureBuiltinCall("max", {e, expr}, tp);
+      if simplifyInStreamWorkSimplify(eMax, true) then  // var.max <= 0.0
+        tp := ComponentReference.crefTypeFull(cr);
+        ret := Expression.createZeroExpression(tp);
+      elseif simplifyInStreamWorkSimplify(eMin, false) then // var.min >= 0.0
+        ret := e;
+      else
+        tp := ComponentReference.crefTypeFull(cr);
+        ret := Expression.makePureBuiltinCall("max", {e, expr}, tp);
+      end if;
+    then
+       ret;
 
-    case DAE.CALL(path=Absyn.IDENT("$OMC$PositiveMax"),expLst={e as DAE.UNARY(DAE.UMINUS(tp), DAE.CREF(componentRef=cr)), expr}) algorithm
+    //positiveMax(-cref, eps) = 0 if variable(cref).min >= 0
+    //positiveMax(-cref, eps) = -cref if variable(cref).max <= 0
+    case DAE.CALL(path=Absyn.IDENT("$OMC$PositiveMax"),expLst={e as DAE.UNARY(DAE.UMINUS(tp), DAE.CREF(componentRef=cr)), expr})
+    algorithm
       (eMin, eMax) := simplifyInStreamWorkExpresion(cr, outVars);
-      isZero := simplifyInStreamWorkSimplify(eMax, true);
-    then if isZero then Expression.createZeroExpression(tp) else Expression.makePureBuiltinCall("max", {e, expr}, tp);
+      if simplifyInStreamWorkSimplify(eMin, false) then // var.min >= 0.0
+        ret := Expression.createZeroExpression(tp);
+      elseif simplifyInStreamWorkSimplify(eMax, true) then  // var.max <= 0.0
+        ret := e;
+      else
+        ret := Expression.makePureBuiltinCall("max", {e, expr}, tp);
+      end if;
+    then
+       ret;
 
-    case DAE.CALL(path=Absyn.IDENT("$OMC$PositiveMax"),expLst={e, expr}) guard Expression.isZero(e)
+    //positiveMax(cref, eps) = cref where cref >= 0
+    case DAE.CALL(path=Absyn.IDENT("$OMC$PositiveMax"),expLst={e, expr}) guard Expression.isPositiveOrZero(e)
     then e;
 
+    // e.g. positiveMax(cref, eps) = max(cref,eps) = eps where cref < 0
     case DAE.CALL(path=Absyn.IDENT("$OMC$PositiveMax"),expLst={e, expr})
       //print("\nsimplifyInStreamWork: ");
       //print(ExpressionDump.printExpStr(inExp));
       //print(" <-> ");
       //print(ExpressionDump.printExpStr(e));
-    then Expression.makePureBuiltinCall("max", {e, expr}, Expression.typeof(e));
+    then
+      Expression.makePureBuiltinCall("max", {e, expr}, Expression.typeof(e));
 
     case DAE.CALL(path=Absyn.IDENT("$OMC$inStreamDiv"),expLst={e, expr})
       algorithm
           e := ExpressionSimplify.simplify(e);
-          expr := match(e)
-                      case DAE.BINARY(a, DAE.DIV(), b)
-                        guard Expression.isZero(a) and Expression.isZero(b)
-                      then
-                        expr;
-                      else
-                        e;
+          ret := match(e)
+                  local
+                    DAE.Exp a,b;
+
+                  case DAE.BINARY(a, DAE.DIV(), b)
+                  guard Expression.isZero(a) and Expression.isZero(b)
+                  then expr;
+
+                  else e;
+
                  end match;
       then
-         expr;
+         ret;
 
     else inExp;
   end match;
@@ -207,7 +241,7 @@ algorithm
     try
       (v, _) := BackendVariable.getVarSingle(cr, vars);
       (outMin, outMax) := BackendVariable.getMinMaxAttribute(v);
-      return;
+      break;
     else
       // search
     end try;
@@ -5602,15 +5636,15 @@ algorithm
       varlst = List.map1r(vlst, BackendVariable.getVarAt, inVars);
       false = listEmpty(varlst);
 
-      warning = "Iteration variables of equation system w/o analytic Jacobian:\n" + warnAboutVars(varlst);
+      warning = "Iteration variables of equation system with analytic Jacobian:\n" + warnAboutVars(varlst);
       warningList = listAllIterationVariables2(rest, inVars);
     then warning::warningList;
 
     case (BackendDAE.EQUATIONSYSTEM(vars=vlst, jacType=BackendDAE.JAC_NO_ANALYTIC())::rest, _) equation
       varlst = List.map1r(vlst, BackendVariable.getVarAt, inVars);
       false = listEmpty(varlst);
 
-      warning = "Iteration variables of equation system w/o analytic Jacobian:\n" + warnAboutVars(varlst);
+      warning = "Iteration variables of equation system without analytic Jacobian:\n" + warnAboutVars(varlst);
       warningList = listAllIterationVariables2(rest, inVars);
     then warning::warningList;
 
@@ -5852,6 +5886,7 @@ algorithm
       tasks := List.sort(listAppend(predecessors,listAppend(outputTasks,stateTasks)),intGt);
         //print("predecessors of outputs and states "+stringDelimitList(List.map(tasks,intString),", ")+"\n");
       compsNew := List.map1(tasks,List.getIndexFirst,comps);
+      compsNew := List.unique(compsNew);
         print("There have been "+intString(listLength(comps))+" SCCs and now there are "+intString(listLength(compsNew))+" SCCs.\n");
 
       //get vars and equations from the new reduced set of comps and make a equationIdxMap

Compiler/BackEnd/BackendDAEOptimize.mo

@@ -565,10 +565,11 @@ algorithm
   (outEquation, outTypeA) := matchcontinue (inEquation)
     local
       DAE.Exp e1_1, e2_1, e1, e2, cond;
+      DAE.Exp iter, start, stop;
       DAE.ComponentRef cr, cr1;
       Integer size;
       list<DAE.Exp> expl;
-      BackendDAE.Equation res;
+      BackendDAE.Equation eqn;
       BackendDAE.WhenEquation elsepartRes;
       BackendDAE.WhenEquation elsepart;
       Option<BackendDAE.WhenEquation> oelsepart;
@@ -596,6 +597,10 @@ algorithm
       source = List.foldr(ops, ElementSource.addSymbolicTransformation, source);
     then (BackendDAE.ARRAY_EQUATION(dimSize, e1_1, e2_1, source, eqAttr), ext_arg_2);
 
+    case BackendDAE.FOR_EQUATION(iter = iter, start = start, stop = stop, body = eqn, source = source, attr = eqAttr) equation
+      (eqn, outTypeA) = traverseBackendDAEExpsEqnWithSymbolicOperation(eqn, func, inTypeA);
+    then (BackendDAE.FOR_EQUATION(iter, start, stop, eqn, source, eqAttr), outTypeA);
+
     case BackendDAE.SOLVED_EQUATION(componentRef = cr, exp = e2, source=source, attr=eqAttr) equation
       e1 = Expression.crefExp(cr);
       (DAE.CREF(cr1, _), (ops, ext_arg_1)) = func(e1, ({}, inTypeA));
@@ -626,8 +631,8 @@ algorithm
         oelsepart = NONE();
         ext_arg_3 = ext_arg_2;
       end if;
-      res = BackendDAE.WHEN_EQUATION(size, BackendDAE.WHEN_STMTS(cond, whenStmtLst, oelsepart), source, eqAttr);
-   then (res, ext_arg_3);
+      eqn = BackendDAE.WHEN_EQUATION(size, BackendDAE.WHEN_STMTS(cond, whenStmtLst, oelsepart), source, eqAttr);
+   then (eqn, ext_arg_3);
 
     case BackendDAE.COMPLEX_EQUATION(size=size, left = e1, right = e2, source = source, attr=eqAttr) equation
       (e1_1, (ops, ext_arg_1)) = func(e1, ({}, inTypeA));
@@ -842,6 +847,8 @@ protected
   list<Integer> ds;
   Integer len;
   list<DAE.Exp> exps;
+  DAE.Exp exp1;
+  Absyn.Ident call1, call2;
   DAE.ComponentRef cr1,cr2;
   list<DAE.Subscript> subs;
   Integer ndim;
@@ -859,7 +866,18 @@ algorithm
   ndim := listLength(ds);
   len := product(i for i in ds);
   true := len > 0;
-  (DAE.CREF(componentRef=cr1)::exps) := Expression.flattenArrayExpToList(e); // TODO: Use a better routine? We now get all expressions even if no expression is a cref...
+  //(DAE.CREF(componentRef=cr1)::exps) := Expression.flattenArrayExpToList(e); // TODO: Use a better routine? We now get all expressions even if no expression is a cref...
+  (exp1::exps) := Expression.flattenArrayExpToList(e);
+  (cr1, call1) := match exp1
+    case DAE.CREF(componentRef=cr1) then (cr1, "");
+    case DAE.CALL(path=Absyn.IDENT(name=call1), expLst={DAE.CREF(componentRef=cr1)}) then (cr1, call1);
+    else fail();
+  end match;
+  if call1 <> "" and Config.simCodeTarget() <> "Cpp" or call1 == "pre" then
+    // only Cpp runtime supports collapsed calls, except pre(array), see e.g.
+    // Modelica_Synchronous.Examples.Elementary.RealSignals.SampleWithADeffects
+    fail();
+  end if;
   // Check that the first element starts at index [1,...,1]
   subs := ComponentReference.crefLastSubs(cr1);
   true := ndim==listLength(subs);
@@ -870,14 +888,23 @@ algorithm
   // Same number of expressions as expected...
   true := (1+listLength(exps))==len;
   for exp in exps loop
-    DAE.CREF(componentRef=cr2) := exp;
+    //DAE.CREF(componentRef=cr2) := exp;
+    (cr2, call2) := match exp
+      case DAE.CREF(componentRef=cr2) then (cr2, "");
+      case DAE.CALL(path=Absyn.IDENT(name=call2), expLst={DAE.CREF(componentRef=cr2)}) then (cr2, call2);
+      else fail();
+    end match;
     true := ndim==listLength(ComponentReference.crefLastSubs(cr2));
     true := ComponentReference.crefEqualWithoutSubs(cr1,cr2);
     true := 1==ComponentReference.crefCompareIntSubscript(cr2,cr1); // cr2 > cr1
+    true := call1==call2;
     cr1 := cr2;
   end for;
   // All of the crefs are in ascending order; the first one starts at 1,1; the length is the full array... So it is the complete cref!
   e := Expression.makeCrefExp(ComponentReference.crefStripLastSubs(cr1), ty);
+  if call1 <> "" then
+    e := DAE.CALL(Absyn.IDENT(name = call1), {e}, DAE.callAttrBuiltinImpureReal);
+  end if;
 end collapseArrayCrefExpWork2;
 
 annotation(__OpenModelica_Interface="backend");