fix daeMode for records fucntions

Author: Willi Braun

Compiler/SimCode/SimCodeUtil.mo

@@ -448,7 +448,7 @@ algorithm
 
     // add residuals vars from DAE creation
     if Flags.getConfigEnum(Flags.DAE_MODE)>1 then
-      daeModeSP := createDaeModeSparsePattern(bdaeModeVars, bdaeModeEqns, shared, crefToSimVarHT);
+      daeModeSP := createDaeModeSparsePattern(bdaeModeVars, bdaeModeEqns, residualVars, shared, crefToSimVarHT);
 
       residualVars := rewriteIndex(residualVars, 0);
       crefToSimVarHT:= List.fold(residualVars,addSimVarToHashTable,crefToSimVarHT);
@@ -1815,7 +1815,7 @@ algorithm
         if debug then
           print("DAE Mode debug output for one system:\n");
           print("DAE Mode equations:\n");
-          print(Tpl.tplString3(TaskSystemDump.dumpEqs, daeEquations1, 0, false));
+          dumpSimEqSystemLst(daeEquations1,"\n");
           print("DAE Mode residual variables:\n");
           print(Tpl.tplString(SimCodeDump.dumpVarsShort, resVars1));
           print("DAE Mode algebraic variables:\n");
@@ -1897,7 +1897,7 @@ protected
   list<SimCodeVar.SimVar> resVarsTmp = {};
   list<SimCodeVar.SimVar> algVarsTmp = {};
 
-  list<BackendDAE.Equation> eqnlst, alglst;
+  list<BackendDAE.Equation> eqnlst, orgeqnLst, alglst;
   list<BackendDAE.Var> varlst, algVarlst, tmpVarsLst;
   BackendDAE.Var dummyVar;
 
@@ -1908,17 +1908,17 @@ algorithm
     (stateeqnsmark, syst, shared) := inArg;
     (daeEquations, resVars, algVars, uniqueEqIndex, varIndex, tempvars, bdaeVars, bdaeEqns) := inFold;
     emptyVars := BackendVariable.emptyVars();
-    (varlst,varNums,eqnlst,eqnNums) := BackendDAEUtil.getStrongComponentVarsAndEquations(comp, syst.orderedVars, syst.orderedEqs);
+    (varlst,varNums,orgeqnLst,eqnNums) := BackendDAEUtil.getStrongComponentVarsAndEquations(comp, syst.orderedVars, syst.orderedEqs);
     skip := false;
 
     if debug then
       print("Proceed component: " + BackendDump.strongComponentString(comp) + "\n");
-      BackendDump.dumpEquationList(eqnlst,"Equations:");
+      BackendDump.dumpEquationList(orgeqnLst,"Equations:");
       BackendDump.dumpVarList(varlst,"Variables:");
     end if;
 
     // skip is when equations
-    skip := Util.boolAndList(List.map(eqnlst, BackendEquation.isWhenEquation));
+    skip := Util.boolAndList(List.map(orgeqnLst, BackendEquation.isWhenEquation));
     // skip is discrete
     skip := Util.boolAndList(List.map(varlst, BackendVariable.isVarDiscrete)) or skip;
     // skip algebraic equation if dynamic option is selected
@@ -1927,13 +1927,14 @@ algorithm
     // convert only dynamic block here
     if skipEquations and not skip then
 
-      // try as is should fallback case is a hack for complex record equations
+      // try as it is
       try
         // make residual equations => 0 = f(x,xd,y)
-        eqnlst := List.flattenReverse(List.map(eqnlst, BackendEquation.equationToScalarResidualForm));
+        eqnlst := List.flattenReverse(List.map(orgeqnLst, BackendEquation.equationToScalarResidualForm));
         tmpEqns := {};
+      // this fallback case is a hack for complex record equations
       else
-        (eqnlst, tmpEqns, uniqueEqIndex, tempvars) := createDAEResidualComplexEquation(eqnlst, uniqueEqIndex, tempvars);
+        (eqnlst, tmpEqns, uniqueEqIndex, tempvars) := createDAEResidualComplexEquation(orgeqnLst, uniqueEqIndex, tempvars, shared.functionTree);
       end try;
 
       // add residual var => $DAEres = f(x,xd,y)
@@ -1954,12 +1955,14 @@ algorithm
 
       //collect also the BackendDAE versions for sparsity and jacobains
       bdaeVars := BackendVariable.addVars(varlst, bdaeVars);
-      bdaeEqns := BackendEquation.addEquations(eqnlst, bdaeEqns);
+      bdaeEqns := BackendEquation.addEquations(listReverse(orgeqnLst), bdaeEqns);
 
       // result --> resVarsTmp, algVarsTmp, daeEquationsTmp, bdaeVars, bdaeEqns
     end if;
 
     if debug then
+      print("Result residual equations\n");
+      dumpSimEqSystemLst(daeEquationsTmp,"\n");
       print("Result residual variables\n");
       print(Tpl.tplString(SimCodeDump.dumpVarsShort, resVarsTmp));
       print("Result algebraic variables\n");
@@ -1984,6 +1987,7 @@ protected function createDaeModeSparsePattern
    since no other dependencies are necessary "
   input BackendDAE.Variables inVars;
   input BackendDAE.EquationArray inEqns;
+  input list<SimCodeVar.SimVar> inResidualVarsLst;
   input BackendDAE.Shared inShared;
   input SimCode.HashTableCrefToSimVar crefToSimVarHT;
   output Option<SimCode.JacobianMatrix> outSimCodeJac;
@@ -1997,7 +2001,7 @@ protected
   list<list<DAE.ComponentRef>> translated;
   list<tuple<DAE.ComponentRef,list<DAE.ComponentRef>>> sparsetuple, sparsetupleT;
   array<DAE.ComponentRef> varCrefs;
-  list<DAE.ComponentRef> varCrefsList;
+  list<DAE.ComponentRef> varCrefsList, resVarCrefsList;
   array<list<Integer>> coloredArray;
   BackendDAE.SparseColoring coloring;
   SimCode.JacobianMatrix simCodeJac;
@@ -2009,21 +2013,23 @@ protected
   SimCodeVar.SimVar svar; BackendDAE.Var bvar;
 algorithm
   try
+    resVarCrefsList := List.map(inResidualVarsLst, getSimVarCompRef);
     // sort variables in SimCode order
     inVarsLst := BackendVariable.varList(inVars);
-    varCrefsList := listReverse(List.map(inVarsLst, BackendVariable.varCref));
-    inSimVars := getSimVars2Crefs(varCrefsList, crefToSimVarHT);
+    varCrefsList := List.map(inVarsLst, BackendVariable.varCref);
+    inSimVars := listReverse(getSimVars2Crefs(varCrefsList, crefToSimVarHT));
     tupleVars := List.threadTuple(inSimVars, inVarsLst);
     tupleVars := List.sort(tupleVars, compareSimVarTupleIndexGt);
     inVarsLst := List.unzipSecond(tupleVars);
-    sortedVars := BackendVariable.listVar(listReverse(inVarsLst));
     varCrefsList := List.map(inVarsLst, BackendVariable.varCref);
+    sortedVars := BackendVariable.listVar1(inVarsLst);
 
     // create adjacency matrix
     funcs := BackendDAEUtil.getFunctions(inShared);
     system := BackendDAEUtil.createEqSystem(sortedVars, inEqns);
     (system,_,_,_,_) := BackendDAEUtil.getIncidenceMatrixScalar(system, BackendDAE.SOLVABLE(), SOME(funcs));
     if debug then
+      dumpVarLst(inSimVars,"sortedVars ("+intString(listLength(inSimVars))+")");
       print("createDaeModeSparsePattern DAE-System:\n");
       BackendDump.printEqSystem(system);
     end if;
@@ -2053,6 +2059,10 @@ algorithm
     // build sparse pattern
     bdaeSP :=(sparsetuple, sparsetupleT, (varCrefsList, varCrefsList), nonZeroElements);
 
+    if debug then
+      BackendDump.dumpSparsityPattern(bdaeSP, "DAE mode sparsity pattern");
+    end if;
+
     // get coloring
     coloredArray := SymbolicJacobian.createColoring(intsp, intspT, listLength(varCrefsList), listLength(varCrefsList));
     coloring := list(list(arrayGet(varCrefs, i) for i in lst) for lst in coloredArray);
@@ -2100,24 +2110,25 @@ protected function createDAEResidualComplexEquation
   input list<BackendDAE.Equation> inEquation;
   input Integer iuniqueEqIndex;
   input list<SimCodeVar.SimVar> itempvars;
+  input DAE.FunctionTree funcsIn;
   output list<BackendDAE.Equation> outResEqn;
   output list<SimCode.SimEqSystem> equations_;
   output Integer ouniqueEqIndex;
   output list<SimCodeVar.SimVar> otempvars;
 protected
-  DAE.Exp inExp, inExp1;
+  DAE.Exp right, left;
   DAE.ElementSource source;
   BackendDAE.EquationAttributes inEqAttr;
   BackendDAE.Equation eqn;
 algorithm
   eqn::{} := inEquation;
-  BackendDAE.COMPLEX_EQUATION(left = inExp, right = inExp1, source=source, attr=inEqAttr) := eqn;
-  (equations_, ouniqueEqIndex, otempvars) := matchcontinue (inExp, inExp1)
+  BackendDAE.COMPLEX_EQUATION(left = left, right = right, source=source, attr=inEqAttr) := eqn;
+  (equations_, ouniqueEqIndex, otempvars) := matchcontinue (left, right)
     local
       DAE.ComponentRef cr, crtmp;
       list<DAE.ComponentRef> crlst;
       list<list<DAE.ComponentRef>> crlstlst;
-      DAE.Exp e1, e2, e1_1, e2_1, etmp;
+      DAE.Exp etmp, crefExp, recordExp, callExp;
       DAE.Statement stms;
       DAE.Type tp;
       list<DAE.Type> tplst;
@@ -2132,39 +2143,28 @@ algorithm
       String ident, s, s1, s2;
       list<SimCodeVar.SimVar> tempvars;
 
-    /* a = f() */
-    case (DAE.CREF(componentRef=cr), _) equation
-      // ((e1_1, _)) = Expression.extendArrExp((inExp, false));
-      (e2_1, _) = Expression.extendArrExp(inExp1, false);
-      // true = ComponentReference.crefEqualNoStringCompare(cr, cr2);
-      (tp as DAE.T_COMPLEX(varLst=varLst, complexClassType=ClassInf.RECORD(path)))  = Expression.typeof(inExp);
-      // tmp
-      ident = Absyn.pathStringUnquoteReplaceDot(path, "_");
-      crtmp = ComponentReference.makeCrefIdent("$TMP_" + ident + intString(iuniqueEqIndex), tp, {});
-      tempvars = createTempVars(varLst, crtmp, itempvars);
-      // 0 = a - tmp
-      e1lst = List.map1(varLst, Expression.generateCrefsExpFromExpVar, cr);
-      e2lst = List.map1(varLst, Expression.generateCrefsExpFromExpVar, crtmp);
-      exptl = List.threadTuple(e1lst, e2lst);
-      outResEqn = List.map2(exptl, BackendEquation.generateRESIDUAL_EQUATION1, source, inEqAttr);
-      uniqueEqIndex = iuniqueEqIndex;
+    /* a = f()  or f() = a */
+    case (_, _) guard (Expression.isCref(left) or Expression.isCref(right))
+      equation
+      if Expression.isCref(left) then
+        crefExp = left;
+        callExp = right;
+      else
+        crefExp = right;
+        callExp = left;
+      end if;
 
-      // tmp = f(x, y)
-      etmp = Expression.crefExp(crtmp);
-      stms = DAE.STMT_ASSIGN(tp, etmp, e2_1, source);
-      eqSystlst = {SimCode.SES_ALGORITHM(uniqueEqIndex, {stms})};
-    then (eqSystlst, uniqueEqIndex+1, tempvars);
+      //get cref from crefExp before expand
+      cr = Expression.getCrefFromCrefOrAsub(crefExp);
 
-    // f() = a
-    case (_, DAE.CREF(componentRef=cr)) equation
-      // true = ComponentReference.crefEqualNoStringCompare(cr, cr2);
-      (e1_1, _) = Expression.extendArrExp(inExp, false);
-      // ((e2_1, _)) = Expression.extendArrExp((inExp1, false));
-      (tp as DAE.T_COMPLEX(varLst=varLst, complexClassType=ClassInf.RECORD(path)))  = Expression.typeof(inExp1);
-      // tmp
+      (crefExp, _) = Expression.extendArrExp(crefExp, false);
+      (tp as DAE.T_COMPLEX(varLst=varLst, complexClassType=ClassInf.RECORD(path))) = Expression.typeof(callExp);
+
+      // create tmp vars
       ident = Absyn.pathStringUnquoteReplaceDot(path, "_");
       crtmp = ComponentReference.makeCrefIdent("$TMP_" + ident + intString(iuniqueEqIndex), tp, {});
       tempvars = createTempVars(varLst, crtmp, itempvars);
+
       // 0 = a - tmp
       e1lst = List.map1(varLst, Expression.generateCrefsExpFromExpVar, cr);
       e2lst = List.map1(varLst, Expression.generateCrefsExpFromExpVar, crtmp);
@@ -2174,66 +2174,47 @@ algorithm
 
       // tmp = f(x, y)
       etmp = Expression.crefExp(crtmp);
-      stms = DAE.STMT_ASSIGN(tp, etmp, e1_1, source);
+      stms = DAE.STMT_ASSIGN(tp, etmp, callExp, source);
       eqSystlst = {SimCode.SES_ALGORITHM(uniqueEqIndex, {stms})};
     then (eqSystlst, uniqueEqIndex+1, tempvars);
 
-    // Record() = f()
-    case (DAE.CALL(path=path, expLst=e2lst, attr=DAE.CALL_ATTR(ty= tp as DAE.T_COMPLEX(varLst=varLst, complexClassType=ClassInf.RECORD(rpath)))), _) equation
-      true = Absyn.pathEqual(path, rpath);
-      (e2_1, _) = Expression.extendArrExp(inExp1, false);
-      // true = ComponentReference.crefEqualNoStringCompare(cr, cr2);
+    case (_, _) guard (Expression.isRecordCall(left, funcsIn) or Expression.isRecordCall(right, funcsIn))
+      equation
+      if Expression.isRecordCall(left, funcsIn) then
+        recordExp = left;
+        callExp = right;
+      else
+        recordExp = right;
+        callExp = left;
+      end if;
+
+      DAE.CALL(expLst=expl, attr=DAE.CALL_ATTR(ty= tp as DAE.T_COMPLEX(varLst=varLst, complexClassType=ClassInf.RECORD(path)))) = recordExp;
+
       // tmp = f()
       ident = Absyn.pathStringUnquoteReplaceDot(path, "_");
-      cr = ComponentReference.makeCrefIdent("$TMP_" + ident + intString(iuniqueEqIndex), tp, {});
-      e1_1 = Expression.crefToExp(cr);
-      stms = DAE.STMT_ASSIGN(tp, e1_1, e2_1, source);
+      crtmp = ComponentReference.makeCrefIdent("$TMP_" + ident + intString(iuniqueEqIndex), tp, {});
+      tempvars = createTempVars(varLst, crtmp, itempvars);
+      etmp = Expression.crefToExp(crtmp);
+      stms = DAE.STMT_ASSIGN(tp, etmp, callExp, source);
       simeqn = SimCode.SES_ALGORITHM(iuniqueEqIndex, {stms});
       uniqueEqIndex = iuniqueEqIndex + 1;
+      eqSystlst = {simeqn};
 
-      // Record()-tmp = 0
-      // Expand the tmp record and any arrays
-      e1lst = Expression.expandExpression(e1_1);
+      // 0 = tmp - Record()
+      // Expand the record for any arrays
+      e1lst = List.mapFlat(expl, Expression.expandExpression);
       // Expand the varLst. Each var might be an array or record.
-      e2lst = List.mapFlat(e2lst, Expression.expandExpression);
+      e2lst = List.map1(varLst, Expression.generateCrefsExpFromExpVar, crtmp);
       // pair each of the expanded expressions to coressponding one
       exptl = List.threadTuple(e1lst, e2lst);
       // Create residual equations for each pair
       outResEqn = List.map2(exptl, BackendEquation.generateRESIDUAL_EQUATION1, source, inEqAttr);
-      uniqueEqIndex = iuniqueEqIndex;
-
-      eqSystlst = {simeqn};
-
-      tempvars = createTempVars(varLst, cr, itempvars);
-    then (eqSystlst, uniqueEqIndex, tempvars);
-
-    // f() = Record()
-    case (_, DAE.CALL(path=path, expLst=e2lst, attr=DAE.CALL_ATTR(ty=tp as DAE.T_COMPLEX(varLst=varLst, complexClassType=ClassInf.RECORD(rpath))))) equation
-      true = Absyn.pathEqual(path, rpath);
-      (e1_1, _) = Expression.extendArrExp(inExp1, false);
-      // true = ComponentReference.crefEqualNoStringCompare(cr, cr2);
-      // tmp = f()
-      ident = Absyn.pathStringUnquoteReplaceDot(path, "_");
-      cr = ComponentReference.makeCrefIdent("$TMP_" + ident + intString(iuniqueEqIndex), tp, {});
-      e2_1 = Expression.crefExp(cr);
-      stms = DAE.STMT_ASSIGN(tp, e2_1, e1_1, source);
-      simeqn = SimCode.SES_ALGORITHM(iuniqueEqIndex, {stms});
-      uniqueEqIndex = iuniqueEqIndex + 1;
-      // Record()-tmp = 0
-      e1lst = List.map1(varLst, Expression.generateCrefsExpFromExpVar, cr);
-      exptl = List.threadTuple(e1lst, e2lst);
-      outResEqn = List.map2(exptl, BackendEquation.generateRESIDUAL_EQUATION1, source, inEqAttr);
-      uniqueEqIndex = iuniqueEqIndex;
-
-      eqSystlst = {simeqn};
-
-      tempvars = createTempVars(varLst, cr, itempvars);
     then (eqSystlst, uniqueEqIndex, tempvars);
 
     // failure
     else equation
-      s1 = ExpressionDump.printExpStr(inExp);
-      s2 = ExpressionDump.printExpStr(inExp1);
+      s1 = ExpressionDump.printExpStr(left);
+      s2 = ExpressionDump.printExpStr(right);
       s = stringAppendList({"function createDAEResidualComplexEquation failed for: ", s1, " = " , s2 });
       Error.addInternalError(s, sourceInfo());
     then fail();
@@ -9636,9 +9617,9 @@ algorithm
   result := index1 > index2;
 end compareVarIndexGt;
 
-public function compareSimVarTupleIndexGt
-  input tuple<SimCodeVar.SimVar, BackendDAE.Var> var1;
-  input tuple<SimCodeVar.SimVar, BackendDAE.Var> var2;
+public function compareSimVarTupleIndexGt<anyT>
+  input tuple<SimCodeVar.SimVar, anyT> var1;
+  input tuple<SimCodeVar.SimVar, anyT> var2;
   output Boolean result;
 protected
   Integer index1, index2;