Perform incomplete matching for over/underdet syst

This performs an incomplete matching after producing the message unbalanced
equation system, and instead of just a number differing OMC will try to
perform a sanity check to figure out if for example a variable is never
referenced in any equation or if two variables must be matched by the same
equation.

Author: sjoelund

Compiler/BackEnd/BackendDAECreate.mo

@@ -115,6 +115,7 @@ protected
   list<BackendDAE.TimeEvent> timeEvents;
   String neqStr, nvarStr;
   Integer varSize, eqnSize, numCheckpoints;
+  BackendDAE.EqSystem syst;
 algorithm
   numCheckpoints:=ErrorExt.getNumCheckpoints();
   try
@@ -148,7 +149,8 @@ algorithm
   ieqnarr := BackendEquation.listEquation(ieqns);
   einfo := BackendDAE.EVENT_INFO(timeEvents, ZeroCrossings.new(), DoubleEndedList.fromList({}), ZeroCrossings.new(), 0);
   symjacs := {(NONE(), ({}, {}, ({}, {}), -1), {}), (NONE(), ({}, {}, ({}, {}), -1), {}), (NONE(), ({}, {}, ({}, {}), -1), {}), (NONE(), ({}, {}, ({}, {}), -1), {})};
-  outBackendDAE := BackendDAE.DAE(BackendDAEUtil.createEqSystem(vars_1, eqnarr, {}, BackendDAE.UNKNOWN_PARTITION(), reqnarr)::{},
+  syst := BackendDAEUtil.createEqSystem(vars_1, eqnarr, {}, BackendDAE.UNKNOWN_PARTITION(), reqnarr);
+  outBackendDAE := BackendDAE.DAE(syst::{},
                                   BackendDAE.SHARED(globalKnownVars,
                                                     localKnownVars,
                                                     extVars,
@@ -167,17 +169,11 @@ algorithm
                                                     BackendDAEUtil.emptyPartitionsInfo()
                                                     ));
   BackendDAEUtil.checkBackendDAEWithErrorMsg(outBackendDAE);
-  varSize := BackendVariable.varsSize(vars_1);
-  eqnSize := BackendEquation.equationArraySize(eqnarr);
-  neqStr := intString(eqnSize);
-  nvarStr := intString(varSize);
-
-  if varSize <> eqnSize then
-    Error.addMessage(if varSize > eqnSize then Error.UNDERDET_EQN_SYSTEM else Error.OVERDET_EQN_SYSTEM, {neqStr, nvarStr});
-    fail();
-  end if;
+  BackendDAEUtil.checkIncidenceMatrixSolvability(syst, functionTree);
 
-  Error.assertionOrAddSourceMessage(not Flags.isSet(Flags.DUMP_BACKENDDAE_INFO),Error.BACKENDDAEINFO_LOWER,{neqStr,nvarStr},Absyn.dummyInfo);
+  if Flags.isSet(Flags.DUMP_BACKENDDAE_INFO) then
+    Error.addSourceMessage(Error.BACKENDDAEINFO_LOWER,{String(BackendEquation.equationArraySize(syst.orderedEqs)), String(BackendVariable.varsSize(syst.orderedVars))},Absyn.dummyInfo);
+  end if;
   execStat("Generate backend data structure");
   return;
   else

Compiler/BackEnd/BackendDAEOptimize.mo

@@ -1662,7 +1662,7 @@ algorithm
         b = i > 1;
         // bcall2(b,BackendDump.dumpBackendDAE,BackendDAE.DAE({syst},shared), "partitionIndependentBlocksHelper");
         // printPartition(b,ixs);
-        systs = if b then SynchronousFeatures.partitionIndependentBlocksSplitBlocks(i, syst, eqPartMap, rixs, mT, rmT, throwNoError) else {syst};
+        systs = if b then SynchronousFeatures.partitionIndependentBlocksSplitBlocks(i, syst, eqPartMap, rixs, mT, rmT, throwNoError, funcs) else {syst};
         // print("Number of partitioned systems: " + intString(listLength(systs)) + "\n");
         // List.map1_0(systs, BackendDump.dumpEqSystem, "System");
         GC.free(eqPartMap);

Compiler/BackEnd/BackendDAEUtil.mo

@@ -156,8 +156,10 @@ algorithm
       Boolean samesize;
       BackendDAE.Variables vars;
       BackendDAE.EquationArray orderedEqs;
+      BackendDAE.EqSystem syst;
+      DAE.FunctionTree functionTree;
 
-    case (BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars=vars, orderedEqs=orderedEqs)::{})) equation
+    case BackendDAE.DAE(eqs=(syst as BackendDAE.EQSYSTEM(orderedVars=vars, orderedEqs=orderedEqs))::{}, shared=BackendDAE.SHARED(functionTree=functionTree)) equation
       //true = Flags.isSet(Flags.CHECK_BACKEND_DAE);
       //Check for correct size
       nVars = BackendVariable.varsSize(vars);
@@ -271,7 +273,7 @@ algorithm
       equation
         allvars = BackendVariable.mergeVariables(syst.orderedVars, shared.globalKnownVars);
         ((_, expcrefs)) = traverseBackendDAEExpsVars(syst.orderedVars, checkBackendDAEExp, (allvars, {}));
-       ((_, expcrefs)) = traverseBackendDAEExpsEqns(shared.removedEqs, checkBackendDAEExp, (allvars, expcrefs));
+        ((_, expcrefs)) = traverseBackendDAEExpsEqns(shared.removedEqs, checkBackendDAEExp, (allvars, expcrefs));
         ((_, expcrefs)) = traverseBackendDAEExpsVars(shared.globalKnownVars, checkBackendDAEExp, (allvars, expcrefs));
         ((_, expcrefs)) = traverseBackendDAEExpsEqns(syst.orderedEqs, checkBackendDAEExp, (allvars, expcrefs));
         ((_, expcrefs)) = traverseBackendDAEExpsEqns(syst.removedEqs, checkBackendDAEExp, (allvars, expcrefs));
@@ -9060,5 +9062,178 @@ algorithm
   end for;
 end getNoDerivativeInputPosition;
 
+public function checkIncidenceMatrixSolvability "Performs a limited matching algorithm to sometimes figure out which equations are superflours or which variables are never solved for."
+  input BackendDAE.EqSystem syst;
+  input DAE.FunctionTree functionTree;
+protected
+  Integer varSize, eqnSize, v, eq, count;
+  BackendDAE.IncidenceMatrix m, mT, mOrig, mTOrig;
+  list<Integer> vars, eqs, varsInOrig, eqsInOrig;
+  array<Integer> solvedVars;
+  array<list<tuple<DAE.ComponentRef,Integer>>> solvedEqs;
+  list<SourceInfo> infos;
+  list<tuple<DAE.ComponentRef,Integer>> names;
+  Integer errors = 0, numSolved = 0, eqSize, lenInfos, lenVars;
+  Boolean cont = true;
+  BackendDAE.Variables varsArray;
+  BackendDAE.Var var;
+  BackendDAE.EquationArray eqsArray;
+  BackendDAE.Equation _equation;
+  constant Boolean debug=false;
+  constant Boolean alwaysCheck=false;
+  SourceInfo info;
+algorithm
+  varsArray := syst.orderedVars;
+  eqsArray := syst.orderedEqs;
+  varSize := BackendVariable.varsSize(varsArray);
+  eqnSize := BackendEquation.equationArraySize(eqsArray);
+  if varSize <> eqnSize then
+    Error.addMessage(if varSize > eqnSize then Error.UNDERDET_EQN_SYSTEM else Error.OVERDET_EQN_SYSTEM, {String(eqnSize), String(varSize)});
+  elseif not alwaysCheck then
+    return;
+  end if;
+  (_, mOrig, mTOrig) := BackendDAEUtil.getIncidenceMatrixfromOption(syst, BackendDAE.ABSOLUTE(), SOME(functionTree));
+
+  m := arrayCopy(mOrig);
+  mT := arrayCopy(mTOrig);
+
+  solvedVars := arrayCreate(arrayLength(mT), 0);
+  solvedEqs := arrayCreate(arrayLength(m), {});
+
+  if debug then
+    print("Got adjacency matrix "+String(varSize)+" "+String(arrayLength(m))+" "+String(eqnSize)+" "+String(arrayLength(mT))+"...\n");
+  end if;
+  count := 0;
+  while cont and count < 1000 loop
+    cont := false;
+    count := count+1;
+    for i in 1:arrayLength(m) /* Not eqnSize; that is the size including arrays */ loop
+      if not listEmpty(arrayGet(solvedEqs, i)) then
+        continue;
+      end if;
+      _equation := BackendEquation.get(eqsArray, i);
+      info := BackendEquation.equationInfo(_equation);
+      eqSize := BackendEquation.equationSize(_equation);
+      vars := arrayGet(m, i);
+      lenVars := listLength(vars);
+      if eqSize == 0 then
+        arrayUpdate(solvedEqs, i, {(DAE.emptyCref,0)});
+        continue;
+      end if;
+      if lenVars <= eqSize then
+        if lenVars < eqSize then
+          variableDoesNotFitInEquation(i, vars, mOrig, eqsArray, varsArray, solvedVars);
+          errors := errors+1;
+          if lenVars == 0 then
+            arrayUpdate(solvedEqs, i, (DAE.emptyCref,0)::arrayGet(solvedEqs,i));
+          end if;
+        end if;
+        for v in vars loop
+          var := BackendVariable.getVarAt(varsArray, v);
+          arrayUpdate(solvedEqs, i, (var.varName,v)::arrayGet(solvedEqs,i));
+          arrayUpdate(solvedVars, v, i);
+          eqs := arrayGet(mT, v);
+          for eq in eqs loop
+            // Remove references to the variable in other equations since we can't solve it there
+            arrayUpdate(m, eq, List.setDifference(arrayGet(m, eq), vars));
+          end for;
+          numSolved := numSolved+1;
+        end for;
+        cont := true;
+      end if;
+    end for;
+
+    if debug then
+      print("Number of equations solved: " + String(numSolved-errors) + "\n");
+      print("Number of errors: " + String(errors) + "\n");
+    end if;
+
+    for i in 1:arrayLength(mT) /* = varSize */ loop
+      if 0 <> arrayGet(solvedVars, i) then
+        continue;
+      end if;
+      eqs := arrayGet(mT, i);
+      var := BackendVariable.getVarAt(varsArray, i);
+      info := var.source.info;
+      if listLength(eqs) == 0 then
+        Error.addSourceMessage(Error.VAR_NO_REMAINING_EQN, {
+          ComponentReference.printComponentRefStr(var.varName),
+          stringAppendList(list("\n  Equation " + String(eq) + ": " + BackendDump.equationString(BackendEquation.get(eqsArray, eq)) + ", which needs to solve for " + stringDelimitList(list(ComponentReference.printComponentRefStr(Util.tuple21(tpl)) for tpl in arrayGet(solvedEqs, eq)), ", ") for eq in arrayGet(mTOrig, i)))
+          }, info);
+        arrayUpdate(solvedVars, i, -1);
+      elseif listLength(eqs) == 1 then
+        {eq} := eqs;
+        eqSize := BackendEquation.equationSize(BackendEquation.get(eqsArray, eq));
+        names := arrayGet(solvedEqs, eq);
+        lenInfos := listLength(names);
+        arrayUpdate(solvedVars, i, eq);
+        arrayUpdate(solvedEqs, eq, (var.varName,i)::names);
+        if lenInfos >= eqSize then
+          variableDoesNotFitInEquation(eq, {i}, mOrig, eqsArray, varsArray, solvedVars);
+          errors := errors+1;
+        end if;
+        vars := arrayGet(m, eq);
+        if lenInfos+1 >= eqSize then // TODO: FIXME
+          for v in vars loop
+            // Remove references to the equation in other variables since we can't solve it there
+            arrayUpdate(mT, v, List.setDifference(arrayGet(mT, v), eqs));
+          end for;
+        end if;
+        numSolved := numSolved+1;
+        cont := true;
+      end if;
+    end for;
+
+    if debug then
+      print("Number of equations solved: " + String(numSolved-errors) + "\n");
+      print("Number of errors: " + String(errors) + "\n");
+    end if;
+  end while;
+  true := 0 == errors;
+  if alwaysCheck and varSize == eqnSize then
+    return;
+  end if;
+  fail();
+end checkIncidenceMatrixSolvability;
+
+protected function variableDoesNotFitInEquation
+  input Integer eq;
+  input list<Integer> vars;
+  input BackendDAE.IncidenceMatrix m;
+  input BackendDAE.EquationArray eqsArray;
+  input BackendDAE.Variables varsArray;
+  input array<Integer> solvedVars;
+protected
+  BackendDAE.Equation _equation;
+  list<Integer> varsInOrig, eqsInOrig;
+  String eqsString;
+  SourceInfo info;
+  Integer eqSize;
+algorithm
+  _equation := BackendEquation.get(eqsArray, eq);
+  info := BackendEquation.equationInfo(_equation);
+  eqSize := BackendEquation.equationSize(_equation);
+
+  varsInOrig := List.setDifference(arrayGet(m, eq), vars);
+  eqsInOrig := List.sortedUnique(List.sort(list(arrayGet(solvedVars,myVar) for myVar guard arrayGet(solvedVars,myVar)>0 in varsInOrig), intGt), intEq);
+  eqsString := stringAppendList(list("\n    Equation " + String(eqNum) + " (size: "+String(BackendEquation.equationSize(BackendEquation.get(eqsArray, eqNum)))+"): " + BackendDump.equationString(BackendEquation.get(eqsArray, eqNum)) for eqNum in eqsInOrig));
+  Error.addSourceMessage(Error.EQN_NO_SPACE_TO_SOLVE, {
+    String(eq),
+    String(eqSize),
+    BackendDump.equationString(_equation),
+    getVariableNamesForErrorMessage(varsArray, vars),
+    getVariableNamesForErrorMessage(varsArray, varsInOrig),
+    eqsString
+    }, info);
+end variableDoesNotFitInEquation;
+
+protected function getVariableNamesForErrorMessage
+  input BackendDAE.Variables varsArray;
+  input list<Integer> vars;
+  output String names;
+algorithm
+  names := stringDelimitList(list(ComponentReference.printComponentRefStr(BackendVariable.varCref(BackendVariable.getVarAt(varsArray, v))) for v in vars), ", ");
+end getVariableNamesForErrorMessage;
+
 annotation(__OpenModelica_Interface="backend");
 end BackendDAEUtil;

Compiler/BackEnd/Causalize.mo

@@ -100,6 +100,7 @@ algorithm
         esize_str = intString(neqns);
         vsize_str = intString(nvars);
         Error.addMessage(Error.UNDERDET_EQN_SYSTEM, {esize_str,vsize_str});
+        BackendDAEUtil.checkIncidenceMatrixSolvability(isyst, ishared.functionTree);
       then
         fail();
 
@@ -109,6 +110,7 @@ algorithm
         esize_str = intString(neqns) ;
         vsize_str = intString(nvars);
         Error.addMessage(Error.OVERDET_EQN_SYSTEM, {esize_str,vsize_str});
+        BackendDAEUtil.checkIncidenceMatrixSolvability(isyst, ishared.functionTree);
       then
         fail();
 

Compiler/BackEnd/SynchronousFeatures.mo

@@ -2600,7 +2600,7 @@ algorithm
   partitionCnt := partitionIndependentBlocks0(m, mT, rm, rmT, eqPartMap, varPartMap, reqsPartition, varsPartition, rvarsPartition);
 
   if partitionCnt > 1 then
-    (systs, outUnpartRemEqs) := partitionIndependentBlocksSplitBlocks(partitionCnt, syst, eqPartMap, reqsPartition, mT, rmT, false);
+    (systs, outUnpartRemEqs) := partitionIndependentBlocksSplitBlocks(partitionCnt, syst, eqPartMap, reqsPartition, mT, rmT, false, funcs);
   else
     (systs, outUnpartRemEqs) := ({syst}, {});
   end if;
@@ -3049,14 +3049,14 @@ public function partitionIndependentBlocksSplitBlocks
   input BackendDAE.IncidenceMatrix mT;
   input BackendDAE.IncidenceMatrix rmT;
   input Boolean throwNoError;
+  input DAE.FunctionTree funcs;
   output list<BackendDAE.EqSystem> systs = {};
   output list<BackendDAE.Equation> unpartRemovedEqs;
   output array<Integer> varPartMap;
 protected
   array<list<BackendDAE.Equation>> ea, rea;
   array<list<BackendDAE.Var>> va;
   Integer i1, i2;
-  String s1, s2;
   Boolean b, b1 = true;
   BackendDAE.EqSystem syst;
   array<Integer> varsPartition;
@@ -3070,10 +3070,8 @@ algorithm
   i2 := BackendVariable.varsSize(inSyst.orderedVars);
 
   if i1 <> i2 and not throwNoError then
-  s1 := intString(i1);
-  s2 := intString(i2);
-  Error.addSourceMessage(if i1 > i2 then Error.OVERDET_EQN_SYSTEM else Error.UNDERDET_EQN_SYSTEM,
-    {s1, s2}, Absyn.dummyInfo);
+    Error.addSourceMessage(if i1 > i2 then Error.OVERDET_EQN_SYSTEM else Error.UNDERDET_EQN_SYSTEM, {String(i1), String(i2)}, Absyn.dummyInfo);
+    BackendDAEUtil.checkIncidenceMatrixSolvability(inSyst, funcs);
     fail();
   end if;
 

Compiler/Util/Error.mo

@@ -879,6 +879,10 @@ public constant Message CLASS_EXTENDS_TARGET_NOT_FOUND = MESSAGE(579, TRANSLATIO
   Util.gettext("Base class targeted by class extends %s not found in the inherited classes."));
 public constant Message ASSIGN_PARAM_FIXED_ERROR = MESSAGE(580, TRANSLATION(), ERROR(),
   Util.gettext("Trying to assign to parameter component %s(fixed=true) in %s := %s"));
+public constant Message EQN_NO_SPACE_TO_SOLVE = MESSAGE(581, SYMBOLIC(), WARNING(),
+  Util.gettext("Equation %s (size: %s) %s is not big enough to solve for enough variables.\n  Remaining unsolved variables are: %s\n  Already solved: %s\n  Equations used to solve those variables:%s"));
+public constant Message VAR_NO_REMAINING_EQN = MESSAGE(582, SYMBOLIC(), WARNING(),
+  Util.gettext("Variable %s does not have any remaining equation to be solved in.\n  The original equations were:%s"));
 
 public constant Message MATCH_SHADOWING = MESSAGE(5001, TRANSLATION(), ERROR(),
   Util.gettext("Local variable '%s' shadows another variable."));