Improve and fix minimal tearing. (#733)

  - Minimal tearing now handles algorithm equations.
  - It now uses a local subsystem to do the matching. This is
    not strictly needed but simplifies things.
  - It now uses the Enhanced Adjacency Matrix.
  - It does not scalarize the system anymore.

  TODO:
     - The inner equations of the torn system are NOT properly sorted right now.

Author: mahge

OMCompiler/Compiler/BackEnd/BackendDAEUtil.mo

@@ -2696,7 +2696,8 @@ algorithm
     case BackendDAE.ALGORITHM(size=size,alg=DAE.ALGORITHM_STMTS(statementLst = statementLst))
       algorithm
         res := traverseStmts(statementLst, function adjacencyRowAlgorithm(inVariables = vars,
-          functionTree = functionTree, inIndexType = inIndexType, isInitial = isInitial), iRow);
+            functionTree = functionTree, inIndexType = inIndexType, isInitial = isInitial), iRow);
+
         /*
           If looking for solvability add all discrete output variables, even if they don't occur in the algorithm.
           Discrete output variables that do not occur get computed by pre().
@@ -4371,266 +4372,6 @@ algorithm
   res := listArray(lst_1);
 end adjacencyMatrixToSparsePattern;
 
-/******************************************************************
-  Functions to calculate the solvability for minimal tearing
-******************************************************************/
-function findSolvabelVarInEquation
-"Checks if equation is solvable for variable.
- Returns true if input equation is solvable for input variable."
-  input Integer inVariable;
-  input Integer inEquation;
-  input array<Boolean> varArray;
-  input BackendDAE.EqSystem isyst;
-  input BackendDAE.Shared ishared;
-  output Boolean solvability;
-protected
-  BackendDAE.Var v;
-  BackendDAE.Variables vars, globalKnownVars;
-  BackendDAE.EquationArray eqns;
-  BackendDAE.Equation eq;
-  BackendDAE.VarKind varKind;
-  DAE.ComponentRef cr;
-  constant Boolean debug = false;
-algorithm
-  // Get equation and variable from integer index
-  try
-    BackendDAE.EQSYSTEM(orderedVars=vars, orderedEqs=eqns) := isyst;
-    BackendDAE.SHARED(globalKnownVars=globalKnownVars) := ishared;
-  else
-    //Todo: Error
-  end try;
-  eq := BackendEquation.get(eqns, inEquation);
-  BackendDAE.VAR(varName = cr , varKind = varKind) := BackendVariable.getVarAt(vars, inVariable);
-  // Compute solvability
-  solvability := match(varKind)
-    // Case variable is a state
-    case(BackendDAE.STATE()) algorithm
-        v := BackendVariable.createAliasDerVar(cr);
-        cr := BackendVariable.varCref(v);
-      then testSolvabilityForEquation(cr, eq, varArray, vars, globalKnownVars);
-    else
-      then testSolvabilityForEquation(cr, eq, varArray, vars, globalKnownVars);
-  end match;
-
-  if debug then
-    print("\n solvability: " + boolString(solvability) + " \n");
-  end if;
-end findSolvabelVarInEquation;
-
-function testSolvabilityForEquation
-"Helper function for findSolvabelVarInEquation."
-  input DAE.ComponentRef inCref;
-  input BackendDAE.Equation inEq;
-  input array<Boolean> varArray;
-  input BackendDAE.Variables inVariables "Unknowns of system";
-  input BackendDAE.Variables globalKnownVars;
-  output Boolean solvability;
-protected
- DAE.Exp detmp;
- Boolean debug = false;
-algorithm
-
-  if debug then
-    detmp := Expression.crefExp(inCref);
-    print("\n Equation Check: " + BackendDump.equationString(inEq) + "\n");
-    print("\n The Cref: " + ExpressionDump.printExpStr(detmp)+"\n");
-  end if;
-
-  solvability := match (inEq)
-    local
-      Integer size;
-      list<Integer> lst,ds, lstall, varsSolvedInWhenEqns;
-      DAE.Exp e1,e2,e,expCref,cond;
-      list<DAE.Exp> expl;
-      BackendDAE.WhenEquation we,elsewe;
-      String eqnstr;
-      DAE.Algorithm alg;
-      BackendDAE.AdjacencyMatrixElementEnhanced row, row1;
-      list<list<BackendDAE.Equation>> eqnslst;
-      list<BackendDAE.Equation> eqnselse;
-      list<DAE.ComponentRef> algoutCrefs;
-      DAE.Expand crefExpand;
-      DAE.ComponentRef cr;
-      Boolean try_b;
-      DAE.ElementSource source;
-    // EQUATION
-    case (BackendDAE.EQUATION(exp = e1,scalar = e2)) algorithm
-       then minimalTearingRowEnhanced(e1, e2, inCref, varArray, inVariables, globalKnownVars);
-
-    // COMPLEX_EQUATION
-    case (BackendDAE.COMPLEX_EQUATION(left=e1,right=e2)) algorithm
-        then minimalTearingRowEnhanced(e1, e2, inCref, varArray, inVariables, globalKnownVars);
-
-    // ARRAY_EQUATION
-    case (BackendDAE.ARRAY_EQUATION(dimSize=ds,left=e1,right=e2)) algorithm
-        then minimalTearingRowEnhanced(e1, e2, inCref, varArray, inVariables, globalKnownVars);
-
-    // SOLVED_EQUATION
-    case (BackendDAE.SOLVED_EQUATION(componentRef = cr,exp = e)) algorithm
-        if ComponentReference.crefEqualNoStringCompare(cr, inCref) then
-          solvability := true;
-        else
-          expCref := Expression.crefExp(cr);
-          solvability := minimalTearingRowEnhanced(expCref, e, inCref, varArray, inVariables, globalKnownVars);
-        end if;
-      then solvability;
-
-    // RESIDUAL_EQUATION
-    case (BackendDAE.RESIDUAL_EQUATION(exp = e)) algorithm
-      then minimalTearingRowEnhanced(e, DAE.RCONST(0.0), inCref, varArray, inVariables, globalKnownVars);
-
-    // WHEN_EQUATION
-    case (BackendDAE.WHEN_EQUATION(whenEquation = elsewe)) algorithm
-        print("\nWHEN_EQUATION are not supported now!\n");
-        fail();
-        // Todo Add Waring / Error
-      then false;
-
-    // IF_EQUATION
-    // TODO : how to handle this?
-    // Proposal:
-    // 1. vars in conditions are unsolvable
-    // 2. vars occur in all branches: check how they are occur
-    // 3. vars occur not in all branches: then unsolvable
-    case(BackendDAE.IF_EQUATION(conditions=expl,eqnstrue=eqnslst,eqnsfalse=eqnselse)) algorithm
-      try
-        //check condition?
-        try_b := tryToFindSolvableEqInBranch(inCref, eqnselse, varArray, inVariables, globalKnownVars);
-        true := try_b;
-        for eqns in eqnslst loop
-          try_b := tryToFindSolvableEqInBranch(inCref, eqns, varArray, inVariables, globalKnownVars);
-          true := try_b;
-        end for;
-        solvability := true;
-      else
-        solvability := false;
-      end try;
-      then solvability;
-
-    else
-      algorithm
-        eqnstr := BackendDump.equationString(inEq);
-        eqnstr := stringAppendList({"BackendDAE.adjacencyRowEnhanced failed for eqn:\n",eqnstr,"\n"});
-        Error.addMessage(Error.INTERNAL_ERROR,{eqnstr});
-        fail();
-      then false;
-  end match;
-end testSolvabilityForEquation;
-
-
-protected function tryToFindSolvableEqInBranch
-  input DAE.ComponentRef inCref;
-  input list<BackendDAE.Equation> iEqns;
-  input array<Boolean> varArray;
-  input BackendDAE.Variables inVariables;
-  input BackendDAE.Variables globalKnownVars;
-  output Boolean solvability = false;
-protected
-  Boolean solvable;
-algorithm
-  for eq in iEqns loop
-    solvable := testSolvabilityForEquation(inCref, eq, varArray, inVariables, globalKnownVars);
-    if solvable then
-      // Found a solvable equation, return solvability=true
-      solvability := true;
-      break;
-    end if;
-  end for;
-end tryToFindSolvableEqInBranch;
-
-
-protected function minimalTearingRowEnhanced
-  input DAE.Exp e1;
-  input DAE.Exp e2;
-  input DAE.ComponentRef inCref;
-  input array<Boolean> varArray;
-  input BackendDAE.Variables inVariables;
-  input BackendDAE.Variables globalKnownVars;
-  output Boolean solvability;
-protected
-  Integer r,rabs;
-  list<Integer> rest;
-  DAE.Exp de,detmp, e, e_derAlias, e3, nominal;
-  DAE.ComponentRef cr,cr1,crarr;
-  BackendDAE.Solvability solvab;
-  list<DAE.ComponentRef> crlst;
-  Absyn.Path path,path1;
-  list<DAE.Exp> explst,crexplst, explst2;
-  Boolean b,solved,constOneorMOne, b1, b2, b_1;
-  BackendDAE.Constraints cons;
-  Boolean debug = false;
-algorithm
-  try
-     try
-       e := Expression.expSub(e1,e2);
-     else
-       solvability := true;
-       return;
-     end try;
-     e_derAlias := Expression.traverseExpDummy(e, replaceDerCall);
-     (de,constOneorMOne) := minimalTearingTestSolvability(e_derAlias, inCref, inVariables,NONE());
-     (de,_) := ExpressionSimplify.simplify(de);
-
-     if debug then
-       detmp := Expression.crefExp(inCref);
-       print("\n The Cref: " + ExpressionDump.printExpStr(detmp)+"\n" + " the expression: " + ExpressionDump.printExpStr(e_derAlias));
-       print("\n Expressin after derive: " + ExpressionDump.printExpStr(de) + "\n");
-     end if ;
-
-     if not constOneorMOne then
-       solvability := Expression.isConst(de);
-     else
-       solvability := true;
-     end if;
-   else
-     solvability := false;
-   end try;
-end minimalTearingRowEnhanced;
-
-function minimalTearingTestSolvability
-  input DAE.Exp e;
-  input DAE.ComponentRef cr "x";
-  input BackendDAE.Variables vars;
-  input Option<DAE.FunctionTree> functions;
-  output DAE.Exp derivedFunction;
-  output Boolean constOneorMOne;
-protected
-  DAE.Type tp = Expression.typeof(e);
-  Boolean trytosolve2 = stringEqual(Flags.getConfigString(Flags.TEARING_STRICTNESS), "casual");
-  Boolean localCon;
-  DAE.Exp one, tmpEqn, solvedExp, con;
-  list<BackendDAE.Equation> eqnForNewVars;
-  list<DAE.ComponentRef> newVarsCrefs;
-  DAE.ComponentRef tmpVar;
-  constant Boolean debug = false;
-algorithm
-  try
-    derivedFunction := Differentiate.differentiateExpSolve(e, cr, functions);
-    //print("\n Expressin after derive: " + ExpressionDump.printExpStr(derivedFunction) + "\n");
-    (derivedFunction,constOneorMOne) := match(derivedFunction)
-      /* der(f(x)) = c/y => c*x = y*lhs */
-      case DAE.BINARY(one,DAE.DIV(), DAE.CREF()) /*Note: 1/x => ln(x) => Expression.solve will solve it */
-            guard (Expression.isConst(one) and not Expression.isZero(one))
-        then (one,true);
-
-      else (derivedFunction,false);
-    end match;
-  else
-    derivedFunction := Expression.makeConstOne(tp);
-    constOneorMOne:=true;
-  end try;
-
-  if Expression.isZero(derivedFunction) then
-    // see https://trac.openmodelica.org/OpenModelica/ticket/3742#comment:12
-    // ExpressionSolve will fail for derivedFunction == 0 --> internal loops inside tearing
-    Error.addInternalError("Expression is zero.", sourceInfo());
-    fail();
-  end if;
-
-  if debug then
-    print("minimalTearingTestSolvability" + ExpressionDump.printExpStr(e) + " -> " +  ExpressionDump.printExpStr(derivedFunction) + " == " + ExpressionDump.printExpStr(Expression.crefExp(cr)) + "\n");
-  end if;
-end minimalTearingTestSolvability;
 
 /******************************************************************
  stuff to calculate enhanced Adjacency matrix