- fix bad handled failure of new initialization

git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@14105 f25d12d1-65f4-0310-ae8a-bbce733d8d8e
OpenModelica · Nov 28, 2012 · ca2d05d · ca2d05d
1 parent 10f4f2b
commit ca2d05d
Show file tree

Hide file tree

Showing 4 changed files with 145 additions and 163 deletions.
diff --git a/Compiler/BackEnd/BackendDAEOptimize.mo b/Compiler/BackEnd/BackendDAEOptimize.mo
@@ -7588,7 +7588,7 @@ algorithm
       DAE.Exp exp;
       DAE.ElementSource source "origin of equation";
 
-      String varName;
+      String varName, errorMessage;
       DAE.ComponentRef componentRef;
       BackendDAE.Equation currEquation;
       BackendDAE.Var currVariable;
@@ -7607,6 +7607,11 @@ algorithm
       (equationList, variableList) = convertInitialResidualsIntoInitialEquations2(restEquationList, index+1,currEquation::iEquationList,currVariable::iVariableList);
     then (equationList, variableList);
 
+    case(currEquation::_, _,_,_) equation
+      errorMessage = "./Compiler/BackEnd/BackendDAEOptimize.mo: function convertInitialResidualsIntoInitialEquations2 failed: " +& BackendDump.equationStr(currEquation);
+      Error.addMessage(Error.INTERNAL_ERROR, {errorMessage});
+    then fail();
+
     else equation
       Error.addMessage(Error.INTERNAL_ERROR, {"./Compiler/BackEnd/BackendDAEOptimize.mo: function convertInitialResidualsIntoInitialEquations2 failed"});
     then fail();
@@ -7677,9 +7682,11 @@ algorithm
 
     case(DAE) equation
       (initialEqs_lst, _, _) = collectInitialEquations(DAE);
+
+      //BackendDump.dumpBackendDAEEqnList(initialEqs_lst, "initial residuals 1", false);
       initialEqs_lst = BackendEquation.traverseBackendDAEEqns(BackendDAEUtil.listEquation(initialEqs_lst), BackendDAEUtil.traverseEquationToScalarResidualForm, {});  // ugly
+      //BackendDump.dumpBackendDAEEqnList(initialEqs_lst, "initial residuals 2", false);
 
-      //BackendDump.dumpBackendDAEEqnList(initialEqs_lst, "initial residuals", false);
       (initialEquationList, initialVariableList) = convertInitialResidualsIntoInitialEquations(initialEqs_lst);
       initialEqs = BackendDAEUtil.listEquation(initialEquationList);
       initialVars = BackendDAEUtil.listVar1(initialVariableList);
@@ -7763,9 +7770,11 @@ algorithm
 
     case(DAE) equation
       (initialEqs_lst, _, _) = collectInitialEquations(DAE);
+
+      //BackendDump.dumpBackendDAEEqnList(initialEqs_lst, "initial residuals 1", false);
       initialEqs_lst = BackendEquation.traverseBackendDAEEqns(BackendDAEUtil.listEquation(initialEqs_lst), BackendDAEUtil.traverseEquationToScalarResidualForm, {});  // ugly
+      //BackendDump.dumpBackendDAEEqnList(initialEqs_lst, "initial residuals 2", false);
 
-      //BackendDump.dumpBackendDAEEqnList(initialEqs_lst, "initial residuals", false);
       (initialEquationList, initialVariableList) = convertInitialResidualsIntoInitialEquations(initialEqs_lst);
       initialEqs = BackendDAEUtil.listEquation(initialEquationList);
       initialVars = BackendDAEUtil.listVar1(initialVariableList);

diff --git a/Compiler/BackEnd/BackendDAEUtil.mo b/Compiler/BackEnd/BackendDAEUtil.mo
@@ -6317,14 +6317,15 @@ public function traverseEquationToScalarResidualForm "function traverseEquationT
   input tuple<BackendDAE.Equation, list<BackendDAE.Equation>> inTpl;
   output tuple<BackendDAE.Equation, list<BackendDAE.Equation>> outTpl;
 algorithm
-  outTpl := matchcontinue (inTpl)
+  outTpl := matchcontinue(inTpl)
     local
       list<BackendDAE.Equation> eqns,reqn;
       BackendDAE.Equation eqn;
-    case ((eqn,eqns)) equation
+
+    case ((eqn, eqns)) equation
       reqn = BackendEquation.equationToScalarResidualForm(eqn);
       eqns = listAppend(reqn,eqns);
-    then ((eqn,eqns));
+    then ((eqn, eqns));
 
     case _
     then inTpl;
@@ -9069,7 +9070,7 @@ public function solveInitialSystem "public function solveInitialSystem
   This function generates a algebraic system of equations for the initialization and solves it."
   input BackendDAE.BackendDAE inDAE;
   output BackendDAE.BackendDAE outDAE;
-  output BackendDAE.BackendDAE outInitDAE;
+  output Option<BackendDAE.BackendDAE> outInitDAE;
 algorithm
   (outDAE, outInitDAE) := matchcontinue(inDAE)
     local
@@ -9138,11 +9139,10 @@ algorithm
 
       // now let's solve the system!
       initdae = solveInitialSystem1(vars, eqns, inDAE, initdae);
-    then(inDAE, initdae);
+    then (inDAE, SOME(initdae));
 
     case BackendDAE.DAE(systs, shared)
-      then
-        (inDAE,BackendDAE.DAE({}, shared));      
+    then (inDAE, NONE());
   end matchcontinue;
 end solveInitialSystem;
 

diff --git a/Compiler/BackEnd/BackendEquation.mo b/Compiler/BackEnd/BackendEquation.mo
@@ -1569,52 +1569,41 @@ algorithm
       list<DAE.Exp> explst;
       list<BackendDAE.Equation> eqns;
       list<list<DAE.Subscript>> subslst;
+      String errorMessage;
 
-    case (BackendDAE.EQUATION(exp = DAE.TUPLE(explst),scalar = e2,source = source))
-      equation
-        ((_,eqns)) = List.fold2(explst,equationTupleToScalarResidualForm,e2,source,(1,{}));
-      then eqns;
+    case (BackendDAE.EQUATION(exp=DAE.TUPLE(explst), scalar=e2, source=source)) equation
+      ((_, eqns)) = List.fold2(explst, equationTupleToScalarResidualForm, e2, source, (1, {}));
+    then eqns;
 
-    case (BackendDAE.EQUATION(exp = e1,scalar = e2,source = source))
-      equation
-        //ExpressionDump.dumpExpWithTitle("equationToResidualForm 1\n",e2);
-        exp = Expression.expSub(e1,e2);
-        (e,_) = ExpressionSimplify.simplify(exp);
-      then
-        {BackendDAE.RESIDUAL_EQUATION(e,source)};
+    case (BackendDAE.EQUATION(exp=e1, scalar=e2, source=source)) equation
+      exp = Expression.expSub(e1, e2);
+      (e, _) = ExpressionSimplify.simplify(exp);
+    then {BackendDAE.RESIDUAL_EQUATION(e, source)};
 
-    case (BackendDAE.SOLVED_EQUATION(componentRef = cr,exp = e2,source = source))
-      equation
-        e1 = Expression.crefExp(cr);
-        exp = Expression.expSub(e1,e2);
-        (e,_) = ExpressionSimplify.simplify(exp);
-      then
-        {BackendDAE.RESIDUAL_EQUATION(e,source)};
+    case (BackendDAE.SOLVED_EQUATION(componentRef=cr, exp=e2, source=source)) equation
+      e1 = Expression.crefExp(cr);
+      exp = Expression.expSub(e1, e2);
+      (e, _) = ExpressionSimplify.simplify(exp);
+    then {BackendDAE.RESIDUAL_EQUATION(e, source)};
 
-    case (BackendDAE.ARRAY_EQUATION(dimSize=ds,left=e1, right=e2,source=source))
-      equation
-        exp = Expression.expSub(e1,e2);
-        ad = List.map(ds,Util.makeOption);
-        subslst = BackendDAEUtil.arrayDimensionsToRange(ad);
-        subslst = BackendDAEUtil.rangesToSubscripts(subslst);
-        explst = List.map1r(subslst,Expression.applyExpSubscripts,exp);
-        explst = ExpressionSimplify.simplifyList(explst, {});
-        eqns = List.map1(explst,generateRESIDUAL_EQUATION,source);
-      then eqns;          
+    case (BackendDAE.ARRAY_EQUATION(dimSize=ds, left=e1, right=e2, source=source)) equation
+      exp = Expression.expSub(e1, e2);
+      ad = List.map(ds, Util.makeOption);
+      subslst = BackendDAEUtil.arrayDimensionsToRange(ad);
+      subslst = BackendDAEUtil.rangesToSubscripts(subslst);
+      explst = List.map1r(subslst, Expression.applyExpSubscripts, exp);
+      explst = ExpressionSimplify.simplifyList(explst, {});
+      eqns = List.map1(explst, generateRESIDUAL_EQUATION, source);
+    then eqns;
 
-    case (backendEq as BackendDAE.COMPLEX_EQUATION(source = source)) then {backendEq};
-
-    case (backendEq as BackendDAE.RESIDUAL_EQUATION(exp = _,source = source)) then {backendEq};
-
-    case (backendEq as BackendDAE.ALGORITHM(alg = _)) then {backendEq};
+    case (backendEq as BackendDAE.COMPLEX_EQUATION(source=source))  then {backendEq};
+    case (backendEq as BackendDAE.RESIDUAL_EQUATION(source=source)) then {backendEq};
+    case (backendEq as BackendDAE.ALGORITHM(alg=_))                 then {backendEq};
+    case (backendEq as BackendDAE.WHEN_EQUATION(whenEquation=_))    then {backendEq};
 
-    case (backendEq as BackendDAE.WHEN_EQUATION(whenEquation = _)) then {backendEq};
-
-    case (backendEq)
-      equation
-        Debug.fprintln(Flags.FAILTRACE, "- BackendDAE.equationToScalarResidualForm failed");
-      then
-        fail();
+    case (backendEq) equation
+      Debug.fprintln(Flags.FAILTRACE, "- BackendDAE.equationToScalarResidualForm failed");
+    then fail();
   end matchcontinue;
 end equationToScalarResidualForm;
 
@@ -1889,12 +1878,12 @@ algorithm
 end generateEQUATION;
 
 public function generateRESIDUAL_EQUATION "
-Author: Frenkel TUD 2010-05"
+  author: Frenkel TUD 2010-05"
   input DAE.Exp inExp;
   input DAE.ElementSource Source;
   output BackendDAE.Equation outEqn;
 algorithm 
-  outEqn := BackendDAE.RESIDUAL_EQUATION(inExp,Source);
+  outEqn := BackendDAE.RESIDUAL_EQUATION(inExp, Source);
 end generateRESIDUAL_EQUATION;
 
 public function daeEqns