ExpressionSolve: improved handling of modelica functions

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

Author: Vitalij Ruge

Compiler/BackEnd/BackendDAEUtil.mo

@@ -4958,7 +4958,7 @@ algorithm
         cr1 = ComponentReference.crefPrefixDer(cr);
         e = Expression.crefExp(cr);
         ((e,_)) = Expression.replaceExp(Expression.expSub(e1,e2), DAE.CALL(Absyn.IDENT("der"),{e},DAE.callAttrBuiltinReal), Expression.crefExp(cr1));
-        de = Differentiate.differentiateExpSolve(e, cr1);
+        de = Differentiate.differentiateExpSolve(e, cr1, NONE());
         (de,_) = ExpressionSimplify.simplify(de);
         (_,crlst) = Expression.traverseExp(de, Expression.traversingComponentRefFinder, {});
         solvab = adjacencyRowEnhanced2(cr1,de,crlst,vars,kvars);
@@ -4972,7 +4972,7 @@ algorithm
         // de/dvar
         BackendDAE.VAR(varName=cr) = BackendVariable.getVarAt(vars, rabs);
         e = Expression.expSub(e1,e2);
-        de = Differentiate.differentiateExpSolve(e, cr);
+        de = Differentiate.differentiateExpSolve(e, cr, NONE());
         (de,_) = ExpressionSimplify.simplify(de);
         (_,crlst) = Expression.traverseExpTopDown(de, Expression.traversingComponentRefFinderNoPreDer, {});
         solvab = adjacencyRowEnhanced2(cr,de,crlst,vars,kvars);

Compiler/BackEnd/Differentiate.mo

@@ -160,27 +160,34 @@ public function differentiateExpSolve
   Differentiates an equation with respect to the cref variable."
   input DAE.Exp inExp;
   input DAE.ComponentRef inCref;
+  input Option<DAE.FunctionTree> functions;
   output DAE.Exp outExp;
 algorithm
   outExp := matchcontinue(inExp, inCref)
     local
       String msg;
-      DAE.Exp dexp, zero;
+      DAE.Exp dexp;
       BackendDAE.DifferentiateInputData diffData;
-      DAE.Type tp;
+      DAE.FunctionTree fun;
 
-    case (_, _)
+    case (_,_)
       equation
+        fun = match(functions)
+              local DAE.FunctionTree fun_;
+              case(SOME(fun_)) then fun_; 
+              else DAE.emptyFuncTree;
+              end match;
         diffData = BackendDAE.DIFFINPUTDATA(NONE(), NONE(), NONE(), NONE(), SOME({}), NONE(), NONE());
-        (dexp, _) = differentiateExp(inExp, inCref, diffData, BackendDAE.SIMPLE_DIFFERENTIATION(), DAE.emptyFuncTree);
+        (dexp, _) = differentiateExp(inExp, inCref, diffData, BackendDAE.SIMPLE_DIFFERENTIATION(), fun);
         (dexp,_) = ExpressionSimplify.simplify(dexp);
       then dexp;
 
     else
       equation
-        true = Flags.isSet(Flags.FAILTRACE);
-        msg = "\nDifferentiate.differentiateExpSolve failed for " + ExpressionDump.printExpStr(inExp) + "\n\n";
-        Error.addMessage(Error.NON_EXISTING_DERIVATIVE, {msg});
+        if Flags.isSet(Flags.FAILTRACE) then
+          msg = "\nDifferentiate.differentiateExpSolve failed for " + ExpressionDump.printExpStr(inExp) + "\n\n";
+          Error.addMessage(Error.NON_EXISTING_DERIVATIVE, {msg});
+        end if;
       then fail();
 
   end matchcontinue;

Compiler/BackEnd/ExpressionSolve.mo

@@ -352,7 +352,7 @@ algorithm
  (outExp, outAsserts, eqnForNewVars1, newVarsCrefs1, depth) := matchcontinue(e1, e2, inExp3)
                           case(DAE.IFEXP(),_,_) then  solveIfExp(e1, e2, inExp3, functions, uniqueEqIndex, depth);
                           case(_,_,_) then  solveSimple(e1, e2, inExp3, depth);
-                          case(_,_,_) then  solveLinearSystem(e1, e2, inExp3, depth);
+                          case(_,_,_) then  solveLinearSystem(e1, e2, inExp3, functions, depth);
                           else fail();
                          end matchcontinue;
 
@@ -659,6 +659,13 @@ preprocessing for solve1,
        inlineFun := false;
      end if;
 
+     if con and collect then
+       (lhsX, lhsY) := preprocessingSolve5(x, inExp3, true);
+       (rhsX, rhsY) := preprocessingSolve5(y, inExp3, false);
+       x := Expression.expSub(lhsX, rhsX);
+       y := Expression.expSub(rhsY, lhsY);
+     end if;
+
      iter := iter + 1;
      //print("\nx ");print(ExpressionDump.printExpStr(x));print("\ny ");print(ExpressionDump.printExpStr(y));
    end while;
@@ -1240,7 +1247,8 @@ algorithm
                   case(_,_)
                   equation
                     (funX,_) = Expression.traverseExpTopDown(inExp1, inlineCallX, (inExp3, functions));
-                  then (funX, not Expression.expEqual(funX, inExp1));
+                    b = not Expression.expEqual(funX, inExp1);
+                  then (funX, b);
                   else (inExp1, false);
                   end matchcontinue;
 end solveFunCalls;
@@ -1857,6 +1865,7 @@ protected function solveLinearSystem
   input DAE.Exp inExp1;
   input DAE.Exp inExp2;
   input DAE.Exp inExp3;
+  input Option<DAE.FunctionTree> functions;
   input Integer idepth;
   output DAE.Exp outExp;
   output list<DAE.Statement> outAsserts;
@@ -1880,7 +1889,9 @@ algorithm
         e = Expression.makeDiff(inExp1,inExp2);
         (e,_) = ExpressionSimplify.simplify1(e);
         ({},_) = List.split1OnTrue(Expression.factors(e),isCrefInIFEXP,cr); // check: differentiateExpSolve is allowed
-        dere = Differentiate.differentiateExpSolve(e, cr);
+        //print("\n\ne: ");print(ExpressionDump.printExpStr(e));
+        dere = Differentiate.differentiateExpSolve(e, cr, functions);
+        //print("\nder(e): ");print(ExpressionDump.printExpStr(dere));
         (dere,_) = ExpressionSimplify.simplify(dere);
         false = Expression.isZero(dere);
         false = Expression.expHasCrefNoPreOrStart(dere, cr);

Compiler/BackEnd/OnRelaxation.mo

@@ -3708,7 +3708,7 @@ algorithm
         cr = BackendVariable.varCref(v);
         (_,i::_) = BackendVariable.getVar(cr,vars);
         false = intGt(vec1[i],0);
-        e1 = Differentiate.differentiateExpSolve(e, cr);
+        e1 = Differentiate.differentiateExpSolve(e, cr,NONE());
         (e2,_) = ExpressionSimplify.simplify(e1);
         true = Expression.isConstOne(e2) or Expression.isConstMinusOne(e2);
       then