From c65a89ca47a92d5fa7ac5c1db0002810e310a965 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20Sj=C3=B6lund?= Date: Wed, 14 Sep 2011 15:52:55 +0000 Subject: [PATCH] - matching,index-reduction and past-opt modules now handle independent eq-systems git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@9819 f25d12d1-65f4-0310-ae8a-bbce733d8d8e --- Compiler/BackEnd/BackendDAECreate.mo | 31 +++- Compiler/BackEnd/BackendDAEOptimize.mo | 225 ++++++++++-------------- Compiler/BackEnd/BackendDAEUtil.mo | 230 ++++++++++++++++++------- Compiler/BackEnd/BackendDump.mo | 14 +- Compiler/BackEnd/SimCode.mo | 4 +- Compiler/Main/Main.mo | 14 +- Compiler/Script/CevalScript.mo | 2 +- 7 files changed, 287 insertions(+), 233 deletions(-) diff --git a/Compiler/BackEnd/BackendDAECreate.mo b/Compiler/BackEnd/BackendDAECreate.mo index 460de5abe86..ec83663b175 100644 --- a/Compiler/BackEnd/BackendDAECreate.mo +++ b/Compiler/BackEnd/BackendDAECreate.mo @@ -2568,7 +2568,7 @@ public function expandDerOperator input DAE.FunctionTree funcs; output BackendDAE.BackendDAE odae; algorithm - odae := BackendDAEUtil.mapPreOptModule(expandDerOperatorWork,dae,funcs); + odae := BackendDAEUtil.mapEqSystem1(dae,expandDerOperatorWork,funcs); end expandDerOperator; protected function expandDerOperatorWork @@ -2824,11 +2824,26 @@ public function findZeroCrossings "function: findZeroCrossings This function finds all zerocrossings in the list of equations and the list of when clauses. " - input BackendDAE.BackendDAE inDAE; - output BackendDAE.BackendDAE outDAE; + input BackendDAE.BackendDAE inDAE; + output BackendDAE.BackendDAE outDAE; +protected + list systs; + BackendDAE.Shared shared; +algorithm + outDAE := BackendDAEUtil.mapEqSystem(inDAE,findZeroCrossings1); +end findZeroCrossings; + +protected function findZeroCrossings1 "function: findZeroCrossings + + This function finds all zerocrossings in the list of equations and + the list of when clauses. +" + input BackendDAE.EqSystem syst; + input BackendDAE.Shared shared; + output BackendDAE.EqSystem osyst; + output BackendDAE.Shared oshared; algorithm - outDAE:= - match (inDAE) + (osyst,oshared) := match (syst,shared) local BackendDAE.Variables vars,knvars,exobj; BackendDAE.AliasVariables av; @@ -2846,7 +2861,7 @@ algorithm Option m,mT; BackendDAE.BackendDAEType btp; BackendDAE.Matching matching; - case (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns,m,mT,matching)::{},BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,arreqns,algorithms,einfo as BackendDAE.EVENT_INFO(whenClauseLst=whenclauses),eoc,btp))) + case (BackendDAE.EQSYSTEM(vars,eqns,m,mT,matching),BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,arreqns,algorithms,einfo as BackendDAE.EVENT_INFO(whenClauseLst=whenclauses),eoc,btp)) equation eqs_lst = BackendDAEUtil.equationList(eqns); arreqns_lst = arrayList(arreqns); @@ -2857,9 +2872,9 @@ algorithm algorithms1 = listArray(algs_lst1); einfo1 = BackendDAE.EVENT_INFO(whenclauses1,zero_crossings); then - (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns1,m,mT,matching)::{},BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,arreqns1,algorithms1,einfo1,eoc,btp))); + (BackendDAE.EQSYSTEM(vars,eqns1,m,mT,matching),BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,arreqns1,algorithms1,einfo1,eoc,btp)); end match; -end findZeroCrossings; +end findZeroCrossings1; protected function findZeroCrossings2 "function: findZeroCrossings2 diff --git a/Compiler/BackEnd/BackendDAEOptimize.mo b/Compiler/BackEnd/BackendDAEOptimize.mo index bb1d94ba42d..f939f5b7c2e 100644 --- a/Compiler/BackEnd/BackendDAEOptimize.mo +++ b/Compiler/BackEnd/BackendDAEOptimize.mo @@ -84,24 +84,14 @@ public function inlineArrayEqnPast autor: Frenkel TUD 2011-3" input BackendDAE.BackendDAE inDAE; input DAE.FunctionTree inFunctionTree; - input array inAss1; - input array inAss2; - input BackendDAE.StrongComponents inComps; output BackendDAE.BackendDAE outDAE; - output array outAss1; - output array outAss2; - output BackendDAE.StrongComponents outComps; output Boolean outRunMatching; protected Option om,omT; BackendDAE.EqSystem syst; BackendDAE.Shared shared; algorithm - (outDAE as BackendDAE.DAE({syst},shared),outRunMatching) := inlineArrayEqn1(inDAE,inFunctionTree); - (syst,_,_) := BackendDAEUtil.getIncidenceMatrixfromOption(syst,shared); - outAss1 := inAss1; - outAss2 := inAss2; - outComps := inComps; + (outDAE,outRunMatching) := BackendDAEUtil.mapEqSystem1RetExtra(inDAE,inlineArrayEqn1,inFunctionTree,false); end inlineArrayEqnPast; public function inlineArrayEqn @@ -111,18 +101,19 @@ autor: Frenkel TUD 2011-3" input DAE.FunctionTree inFunctionTree; output BackendDAE.BackendDAE outDAE; algorithm - (outDAE,_):= inlineArrayEqn1(inDAE,inFunctionTree); + (outDAE,_):= BackendDAEUtil.mapEqSystem1RetExtra(inDAE,inlineArrayEqn1,inFunctionTree,false); end inlineArrayEqn; protected function inlineArrayEqn1 "function: inlineArrayEqn1 autor: Frenkel TUD 2011-5" - input BackendDAE.BackendDAE inDAE; + input BackendDAE.EqSystem syst; + input tuple sharedOptimized; input DAE.FunctionTree inFunctionTree; - output BackendDAE.BackendDAE outDAE; - output Boolean optimized; + output BackendDAE.EqSystem osyst; + output tuple osharedOptimized; algorithm - (outDAE,optimized) := match (inDAE,inFunctionTree) + (osyst,osharedOptimized) := match (syst,sharedOptimized,inFunctionTree) local DAE.FunctionTree funcs; BackendDAE.IncidenceMatrix m,mT,m1,mT1; @@ -137,21 +128,21 @@ algorithm array> arraylisteqns; list updateeqns; BackendDAE.BackendDAE dae,dae1; - Boolean b; - BackendDAE.EqSystem syst; + Boolean b1,b2,b; BackendDAE.Shared shared; - case (dae as BackendDAE.DAE({syst},shared as BackendDAE.SHARED(arrayEqs = arreqns)),funcs) + case (syst,(shared as BackendDAE.SHARED(arrayEqs = arreqns),b1),funcs) equation (syst,_,_) = BackendDAEUtil.getIncidenceMatrixfromOption(syst,shared); // get scalar array eqs list arraylisteqns = Util.arrayMap(arreqns,getScalarArrayEqns); // replace them - (syst,shared,updateeqns,b) = doReplaceScalarArrayEqns(arraylisteqns,syst,shared); + (syst,shared,updateeqns,b2) = doReplaceScalarArrayEqns(arraylisteqns,syst,shared); + b = b1 or b2; // update Incidence matrix syst = BackendDAEUtil.updateIncidenceMatrix(syst,shared,updateeqns); then - (BackendDAE.DAE({syst},shared),b); + (syst,(shared,b)); end match; end inlineArrayEqn1; @@ -302,19 +293,10 @@ public function lateInline "function lateInlineDAE" input BackendDAE.BackendDAE inDAE; input DAE.FunctionTree inFunctionTree; - input array inAss1; - input array inAss2; - input BackendDAE.StrongComponents inComps; output BackendDAE.BackendDAE outDAE; - output array outAss1; - output array outAss2; - output BackendDAE.StrongComponents outComps; output Boolean outRunMatching; algorithm outDAE := Inline.inlineCalls(SOME(inFunctionTree),{DAE.NORM_INLINE(),DAE.AFTER_INDEX_RED_INLINE()},inDAE); - outAss1 := inAss1; - outAss2 := inAss2; - outComps := inComps; outRunMatching := false; end lateInline; @@ -324,29 +306,18 @@ end lateInline; public function removeSimpleEquationsPast "function lateInlineDAE" - input BackendDAE.BackendDAE inDAE; - input DAE.FunctionTree inFunctionTree; - input array inAss1; - input array inAss2; - input BackendDAE.StrongComponents inComps; - output BackendDAE.BackendDAE outDAE; - output array outAss1; - output array outAss2; - output BackendDAE.StrongComponents outComps; - output Boolean outRunMatching; + input BackendDAE.BackendDAE inDAE; + input DAE.FunctionTree inFunctionTree; + output BackendDAE.BackendDAE outDAE; + output Boolean outRunMatching; protected Boolean b; BackendDAE.EqSystem syst; BackendDAE.Shared shared; algorithm - BackendDAE.DAE({syst},shared) := inDAE; - (syst,shared,b) := removeSimpleEquations1(syst,shared,inFunctionTree); - (syst,_,_) := BackendDAEUtil.getIncidenceMatrixfromOption(syst,shared); - outDAE := BackendDAE.DAE({syst},shared); - outAss1 := inAss1; - outAss2 := inAss2; - outComps := inComps; - outRunMatching := b; // until remove simple equations does not update assignments and comps + (outDAE,outRunMatching) := BackendDAEUtil.mapEqSystem1RetExtra(inDAE,removeSimpleEquations1,inFunctionTree,false); + outDAE := BackendDAEUtil.mapEqSystem(outDAE,BackendDAEUtil.getIncidenceMatrixfromOptionForMapEqSystem); + // until remove simple equations does not update assignments and comps end removeSimpleEquationsPast; public function removeSimpleEquations @@ -358,7 +329,7 @@ public function removeSimpleEquations input DAE.FunctionTree funcs; output BackendDAE.BackendDAE odae; algorithm - odae := BackendDAEUtil.mapPreOptModule(removeSimpleEquationsWork,dae,funcs); + odae := BackendDAEUtil.mapEqSystem1(dae,removeSimpleEquationsWork,funcs); end removeSimpleEquations; protected function removeSimpleEquationsWork @@ -372,7 +343,7 @@ protected function removeSimpleEquationsWork output BackendDAE.EqSystem osyst; output BackendDAE.Shared oshared; algorithm - (osyst,oshared,_) := removeSimpleEquations1(syst,shared,funcs); + (osyst,(oshared,_)) := removeSimpleEquations1(syst,(shared,false),funcs); end removeSimpleEquationsWork; protected function removeSimpleEquations1 @@ -381,14 +352,13 @@ protected function removeSimpleEquations1 This function moves simple equations on the form a=b and a=const and a=f(not time) in BackendDAE.BackendDAE to get speed up" input BackendDAE.EqSystem syst; - input BackendDAE.Shared shared; + input tuple sharedOptimized; input DAE.FunctionTree inFunctionTree; output BackendDAE.EqSystem osyst; - output BackendDAE.Shared oshared; - output Boolean optimized; + output tuple osharedOptimized; algorithm - (osyst,oshared,optimized):= - match (syst,shared,inFunctionTree) + (osyst,osharedOptimized):= + match (syst,sharedOptimized,inFunctionTree) local BackendDAE.BackendDAE dlow,dlow1,dlow2; DAE.FunctionTree funcs; @@ -399,8 +369,9 @@ algorithm BackendVarTransform.VariableReplacements repl,repl_1; BackendDAE.BinTree movedVars,movedAVars; list meqns; - Boolean b; - case (syst,shared,funcs) + Boolean b,b1,b2; + BackendDAE.Shared shared; + case (syst,(shared,b1),funcs) equation (syst,m,mT) = BackendDAEUtil.getIncidenceMatrixfromOption(syst,shared); repl = BackendVarTransform.emptyReplacements(); @@ -408,7 +379,7 @@ algorithm (m_1,(syst,shared,_,mT_1,repl_1,movedVars,movedAVars,meqns,b)) = traverseIncidenceMatrix(m,removeSimpleEquationsFinder,(syst,shared,funcs,mT,repl,BackendDAE.emptyBintree,BackendDAE.emptyBintree,{},false)); // replace vars in arrayeqns and algorithms, move vars to knvars and aliasvars, remove eqns (syst,shared) = removeSimpleEquations2(b,syst,shared,repl_1,movedVars,movedAVars,meqns); - then (syst,shared,b); + then (syst,(shared,b or b1)); end match; end removeSimpleEquations1; @@ -1977,7 +1948,7 @@ public function removeFinalParameters input DAE.FunctionTree funcs; output BackendDAE.BackendDAE odae; algorithm - odae := BackendDAEUtil.mapPreOptModule(removeFinalParametersWork,dae,funcs); + odae := BackendDAEUtil.mapEqSystem1(dae,removeFinalParametersWork,funcs); end removeFinalParameters; protected function removeFinalParametersWork @@ -2274,13 +2245,7 @@ public function removeEqualFunctionCallsPast "function removeEqualFunctionCallsPast" input BackendDAE.BackendDAE inDAE; input DAE.FunctionTree inFunctionTree; - input array inAss1; - input array inAss2; - input BackendDAE.StrongComponents inComps; output BackendDAE.BackendDAE outDAE; - output array outAss1; - output array outAss2; - output BackendDAE.StrongComponents outComps; output Boolean outRunMatching; protected Option om,omT; @@ -2291,9 +2256,6 @@ algorithm BackendDAE.DAE({syst},shared) := inDAE; (syst,shared,b) := removeEqualFunctionCalls1(syst,shared,inFunctionTree); (syst,_,_) := BackendDAEUtil.getIncidenceMatrixfromOption(syst,shared); - outAss1 := inAss1; - outAss2 := inAss2; - outComps := inComps; outRunMatching := b; // until does not update assignments and comps outDAE := BackendDAE.DAE({syst},shared); end removeEqualFunctionCallsPast; @@ -2307,7 +2269,7 @@ public function removeEqualFunctionCalls input DAE.FunctionTree funcs; output BackendDAE.BackendDAE odae; algorithm - odae := BackendDAEUtil.mapPreOptModule(removeEqualFunctionCallsWork,dae,funcs); + odae := BackendDAEUtil.mapEqSystem1(dae,removeEqualFunctionCallsWork,funcs); end removeEqualFunctionCalls; protected function removeEqualFunctionCallsWork @@ -2617,13 +2579,7 @@ public function removeUnusedParameterPast "function removeUnusedParameterPast" input BackendDAE.BackendDAE inDAE; input DAE.FunctionTree inFunctionTree; - input array inAss1; - input array inAss2; - input BackendDAE.StrongComponents inComps; output BackendDAE.BackendDAE outDAE; - output array outAss1; - output array outAss2; - output BackendDAE.StrongComponents outComps; output Boolean outRunMatching; protected Option om,omT; @@ -2632,9 +2588,6 @@ protected algorithm (outDAE as BackendDAE.DAE({syst},shared)) := removeUnusedParameter(inDAE,inFunctionTree); (syst,_,_) := BackendDAEUtil.getIncidenceMatrixfromOption(syst,shared); - outAss1 := inAss1; - outAss2 := inAss2; - outComps := inComps; outRunMatching := false; end removeUnusedParameterPast; @@ -2788,13 +2741,7 @@ public function removeUnusedVariablesPast "function removeUnusedVariablesPast" input BackendDAE.BackendDAE inDAE; input DAE.FunctionTree inFunctionTree; - input array inAss1; - input array inAss2; - input BackendDAE.StrongComponents inComps; output BackendDAE.BackendDAE outDAE; - output array outAss1; - output array outAss2; - output BackendDAE.StrongComponents outComps; output Boolean outRunMatching; protected BackendDAE.EqSystem syst; @@ -2802,9 +2749,6 @@ protected algorithm (outDAE as BackendDAE.DAE({syst},shared)) := removeUnusedVariables(inDAE,inFunctionTree); (syst,_,_) := BackendDAEUtil.getIncidenceMatrixfromOption(syst,shared); - outAss1 := inAss1; - outAss2 := inAss2; - outComps := inComps; outRunMatching := false; end removeUnusedVariablesPast; @@ -2937,17 +2881,22 @@ public function constantLinearSystem "function constantLinearSystem" input BackendDAE.BackendDAE inDAE; input DAE.FunctionTree inFunctionTree; - input array inAss1; - input array inAss2; - input BackendDAE.StrongComponents inComps; output BackendDAE.BackendDAE outDAE; - output array outAss1; - output array outAss2; - output BackendDAE.StrongComponents outComps; output Boolean outRunMatching; algorithm - (outDAE,outAss1,outAss2,outComps,outRunMatching):= - matchcontinue(inDAE,inFunctionTree,inAss1,inAss2,inComps) + (outDAE,outRunMatching) := BackendDAEUtil.mapEqSystem1RetExtra(inDAE,constantLinearSystem0,inFunctionTree,false); +end constantLinearSystem; + +protected function constantLinearSystem0 +"function constantLinearSystem" + input BackendDAE.EqSystem syst; + input tuple sharedChanged; + input DAE.FunctionTree inFunctionTree; + output BackendDAE.EqSystem osyst; + output tuple osharedChanged; +algorithm + (osyst,osharedChanged):= + matchcontinue(syst,sharedChanged,inFunctionTree) local BackendDAE.BackendDAE dae,dae1; DAE.FunctionTree funcs; @@ -2963,44 +2912,47 @@ algorithm BackendDAE.IncidenceMatrix mT; array ass1,ass2; BackendDAE.StrongComponents comps,comps1; - Boolean b; + Boolean b,b1,b2; list eqnlst; BackendDAE.BinTree movedVars; - BackendDAE.EqSystem syst; BackendDAE.Shared shared; - BackendDAE.BackendDAEType btp; + BackendDAE.BackendDAEType btp; + BackendDAE.Matching matching; - case (inDAE,inFunctionTree,inAss1,inAss2,inComps) + case (syst as BackendDAE.EQSYSTEM(matching=BackendDAE.MATCHING(comps=comps)),(shared,b1),inFunctionTree) equation - (dae as BackendDAE.DAE(BackendDAE.EQSYSTEM(orderedVars=vars,orderedEqs=eqns)::{},BackendDAE.SHARED(knvars,exobj,aliasVars,inieqns,remeqns,arreqns,algorithms,einfo,eoc,btp)),b,eqnlst,movedVars) = constantLinearSystem1(inDAE,inFunctionTree,inComps,{},BackendDAE.emptyBintree); + (BackendDAE.EQSYSTEM(orderedVars=vars,orderedEqs=eqns,matching=matching),BackendDAE.SHARED(knvars,exobj,aliasVars,inieqns,remeqns,arreqns,algorithms,einfo,eoc,btp),b2,eqnlst,movedVars) = constantLinearSystem1(syst,shared,inFunctionTree,comps,{},BackendDAE.emptyBintree); + b = b1 or b2; // move changed variables (vars1,knvars1) = BackendVariable.moveVariables(vars,knvars,movedVars); // remove changed eqns eqnlst = Util.listMap1(eqnlst,intSub,1); eqns1 = BackendEquation.equationDelete(eqns,eqnlst); - syst = BackendDAE.EQSYSTEM(vars1,eqns1,NONE(),NONE(),BackendDAE.MATCHING(inAss1,inAss2,inComps)); + syst = BackendDAE.EQSYSTEM(vars1,eqns1,NONE(),NONE(),matching); shared = BackendDAE.SHARED(knvars1,exobj,aliasVars,inieqns,remeqns,arreqns,algorithms,einfo,eoc,btp); (m,mT) = BackendDAEUtil.incidenceMatrix(syst, shared, BackendDAE.NORMAL()); - syst = BackendDAE.EQSYSTEM(vars1,eqns1,SOME(m),SOME(mT),BackendDAE.MATCHING(inAss1,inAss2,inComps)); + syst = BackendDAE.EQSYSTEM(vars1,eqns1,SOME(m),SOME(mT),matching); then - (BackendDAE.DAE({syst},shared),inAss1,inAss2,inComps,b); + (syst,(shared,b)); end matchcontinue; -end constantLinearSystem; +end constantLinearSystem0; protected function constantLinearSystem1 "function constantLinearSystem1" - input BackendDAE.BackendDAE inDAE; - input DAE.FunctionTree inFunctionTree; - input BackendDAE.StrongComponents inComps; - input list inEqnlst; - input BackendDAE.BinTree inMovedVars; - output BackendDAE.BackendDAE outDAE; - output Boolean outRunMatching; - output list outEqnlst; - output BackendDAE.BinTree movedVars; + input BackendDAE.EqSystem syst; + input BackendDAE.Shared shared; + input DAE.FunctionTree inFunctionTree; + input BackendDAE.StrongComponents inComps; + input list inEqnlst; + input BackendDAE.BinTree inMovedVars; + output BackendDAE.EqSystem osyst; + output BackendDAE.Shared oshared; + output Boolean outRunMatching; + output list outEqnlst; + output BackendDAE.BinTree movedVars; algorithm - (outDAE,outRunMatching,outEqnlst,movedVars):= - matchcontinue (inDAE,inFunctionTree,inComps,inEqnlst,inMovedVars) + (osyst,oshared,outRunMatching,outEqnlst,movedVars):= + matchcontinue (syst,shared,inFunctionTree,inComps,inEqnlst,inMovedVars) local BackendDAE.BackendDAE dae,dae1,dae2; DAE.FunctionTree funcs; @@ -3026,45 +2978,46 @@ algorithm Integer linInfo; list names; BackendDAE.BinTree movedVars,movedVars1; - case (dae,funcs,{},inEqnlst,inMovedVars) - then - (dae,false,inEqnlst,inMovedVars); - case (dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars=vars,orderedEqs=eqns)::{}),funcs,(comp as BackendDAE.EQUATIONSYSTEM(eqns=eindex,vars=vindx,jac=SOME(jac),jacType=BackendDAE.JAC_CONSTANT()))::comps,inEqnlst,inMovedVars) + case (syst,shared,funcs,{},inEqnlst,inMovedVars) + then (syst,shared,false,inEqnlst,inMovedVars); + case (syst as BackendDAE.EQSYSTEM(orderedVars=vars,orderedEqs=eqns),shared,funcs,(comp as BackendDAE.EQUATIONSYSTEM(eqns=eindex,vars=vindx,jac=SOME(jac),jacType=BackendDAE.JAC_CONSTANT()))::comps,inEqnlst,inMovedVars) equation eqn_lst = BackendEquation.getEqns(eindex,eqns); var_lst = Util.listMap1r(vindx, BackendVariable.getVarAt, vars); var_lst = listReverse(var_lst); - (dae,movedVars) = solveLinearSystem(dae,eqn_lst,var_lst,jac,inMovedVars); + (syst,shared,movedVars) = solveLinearSystem(syst,shared,eqn_lst,var_lst,jac,inMovedVars); remeqnlst = listAppend(eindex,inEqnlst); - (dae1,b,remeqnlst1,movedVars1) = constantLinearSystem1(dae,funcs,comps,remeqnlst,movedVars); + (syst,shared,b,remeqnlst1,movedVars1) = constantLinearSystem1(syst,shared,funcs,comps,remeqnlst,movedVars); then - (dae1,true,remeqnlst1,movedVars1); - case (dae,funcs,(comp as BackendDAE.MIXEDEQUATIONSYSTEM(condSystem=comp1))::comps,inEqnlst,inMovedVars) + (syst,shared,true,remeqnlst1,movedVars1); + case (syst,shared,funcs,(comp as BackendDAE.MIXEDEQUATIONSYSTEM(condSystem=comp1))::comps,inEqnlst,inMovedVars) equation - (dae1,b,remeqnlst,movedVars) = constantLinearSystem1(dae,funcs,{comp1},inEqnlst,inMovedVars); - (dae2,b1,remeqnlst1,movedVars1) = constantLinearSystem1(dae1,funcs,comps,remeqnlst,movedVars); + (syst,shared,b,remeqnlst,movedVars) = constantLinearSystem1(syst,shared,funcs,{comp1},inEqnlst,inMovedVars); + (syst,shared,b1,remeqnlst1,movedVars1) = constantLinearSystem1(syst,shared,funcs,comps,remeqnlst,movedVars); then - (dae2,b1 or b,remeqnlst1,movedVars1); - case (dae,funcs,comp::comps,inEqnlst,inMovedVars) + (syst,shared,b1 or b,remeqnlst1,movedVars1); + case (syst,shared,funcs,comp::comps,inEqnlst,inMovedVars) equation - (dae1,b,remeqnlst,movedVars) = constantLinearSystem1(dae,funcs,comps,inEqnlst,inMovedVars); + (syst,shared,b,remeqnlst,movedVars) = constantLinearSystem1(syst,shared,funcs,comps,inEqnlst,inMovedVars); then - (dae1,b,remeqnlst,movedVars); + (syst,shared,b,remeqnlst,movedVars); end matchcontinue; end constantLinearSystem1; protected function solveLinearSystem "function constantLinearSystem1" - input BackendDAE.BackendDAE inDAE; + input BackendDAE.EqSystem syst; + input BackendDAE.Shared shared; input list eqn_lst; input list var_lst; input list> jac; input BackendDAE.BinTree inMovedVars; - output BackendDAE.BackendDAE outDAE; + output BackendDAE.EqSystem osyst; + output BackendDAE.Shared oshared; output BackendDAE.BinTree outMovedVars; algorithm - (outDAE,outMovedVars):= - match (inDAE,eqn_lst,var_lst,jac,inMovedVars) + (osyst,oshared,outMovedVars):= + match (syst,shared,eqn_lst,var_lst,jac,inMovedVars) local BackendDAE.Variables vars,knvars,exobj,avars,vars1,knvars1; BackendDAE.AliasVariables aliasVars; @@ -3081,8 +3034,8 @@ algorithm Integer linInfo; list names; BackendDAE.BinTree movedVars; - BackendDAE.Shared shared; - case (BackendDAE.DAE(BackendDAE.EQSYSTEM(orderedVars=vars,orderedEqs=eqns)::{},shared as BackendDAE.SHARED(arrayEqs=arreqns)),eqn_lst,var_lst,jac,inMovedVars) + BackendDAE.Matching matching; + case (BackendDAE.EQSYSTEM(orderedVars=vars,orderedEqs=eqns,matching=matching),shared as BackendDAE.SHARED(arrayEqs=arreqns),eqn_lst,var_lst,jac,inMovedVars) equation eqns1 = BackendDAEUtil.listEquation(eqn_lst); ((_,_,_,beqs,sources)) = BackendEquation.traverseBackendDAEEqns(eqns1,BackendEquation.equationToExp,(vars,arreqns,{},{},{})); @@ -3096,7 +3049,7 @@ algorithm vars1 = changeconstantLinearSystemVars(var_lst,solvedVals,sources,vars); movedVars = BackendDAEUtil.treeAddList(inMovedVars, names); then - (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars1,eqns,NONE(),NONE(),BackendDAE.NO_MATCHING())::{},shared),movedVars); + (BackendDAE.EQSYSTEM(vars1,eqns,NONE(),NONE(),matching),shared,movedVars); end match; end solveLinearSystem; diff --git a/Compiler/BackEnd/BackendDAEUtil.mo b/Compiler/BackEnd/BackendDAEUtil.mo index 2b90579fab3..47031213d38 100644 --- a/Compiler/BackEnd/BackendDAEUtil.mo +++ b/Compiler/BackEnd/BackendDAEUtil.mo @@ -868,8 +868,17 @@ public function translateDae "function: translateDae input Option dummy; output BackendDAE.BackendDAE outBackendDAE; algorithm - outBackendDAE:= - match (inBackendDAE,dummy) + outBackendDAE := mapEqSystem1(inBackendDAE,translateDae1,dummy); +end translateDae; + +protected function translateDae1 + input BackendDAE.EqSystem syst; + input BackendDAE.Shared shared; + input Option dummy; + output BackendDAE.EqSystem osyst; + output BackendDAE.Shared oshared; +algorithm + (osyst,oshared) := match (syst,shared,dummy) local list varlst,knvarlst,extvarlst; array ae; @@ -884,7 +893,7 @@ algorithm Option m,mT; BackendDAE.BackendDAEType btp; BackendDAE.Matching matching; - case (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns,m,mT,matching)::{},BackendDAE.SHARED(knvars,extVars,av,ieqns,seqns,ae,al,BackendDAE.EVENT_INFO(whenClauseLst = wc,zeroCrossingLst = zc),extObjCls,btp)),_) + case (BackendDAE.EQSYSTEM(vars,eqns,m,mT,matching),BackendDAE.SHARED(knvars,extVars,av,ieqns,seqns,ae,al,BackendDAE.EVENT_INFO(whenClauseLst = wc,zeroCrossingLst = zc),extObjCls,btp),_) equation varlst = varList(vars); knvarlst = varList(knvars); @@ -896,12 +905,10 @@ algorithm vars = BackendVariable.addVars(varlst, vars); knvars = BackendVariable.addVars(knvarlst, knvars); extVars = BackendVariable.addVars(extvarlst, extVars); - trans_dae = BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns,m,mT,matching)::{},BackendDAE.SHARED(knvars,extVars,av,ieqns,seqns,ae,al, - BackendDAE.EVENT_INFO(wc,zc),extObjCls,btp)); then - trans_dae; + (BackendDAE.EQSYSTEM(vars,eqns,m,mT,matching),BackendDAE.SHARED(knvars,extVars,av,ieqns,seqns,ae,al,BackendDAE.EVENT_INFO(wc,zc),extObjCls,btp)); end match; -end translateDae; +end translateDae1; public function calculateSizes "function: calculateSizes author: PA @@ -4587,6 +4594,16 @@ algorithm end matchcontinue; end addValuetoMatrix; +public function getIncidenceMatrixfromOptionForMapEqSystem "function getIncidenceMatrixfromOption" + input BackendDAE.EqSystem syst; + input BackendDAE.Shared shared; + output BackendDAE.EqSystem osyst; + output BackendDAE.Shared oshared; +algorithm + (osyst,_,_) := getIncidenceMatrixfromOption(syst,shared); + oshared := shared; +end getIncidenceMatrixfromOptionForMapEqSystem; + public function getIncidenceMatrixfromOption "function getIncidenceMatrixfromOption" input BackendDAE.EqSystem syst; input BackendDAE.Shared shared; @@ -5821,13 +5838,7 @@ partial function pastoptimiseDAEModule This is the interface for past optimisation modules." input BackendDAE.BackendDAE inDAE; input DAE.FunctionTree inFunctionTree; - input array inAss1; - input array inAss2; - input BackendDAE.StrongComponents inComps; output BackendDAE.BackendDAE outDAE; - output array outAss1; - output array outAss2; - output BackendDAE.StrongComponents outComps; output Boolean outRunMatching; end pastoptimiseDAEModule; @@ -5863,9 +5874,6 @@ public function getSolvedSystem input Option strdaeHandler; input Option> strPastOptModules; output BackendDAE.BackendDAE outSODE; - output array outAss1; - output array outAss2; - output BackendDAE.StrongComponents outComps; protected BackendDAE.BackendDAE dae,optdae,sode,sode1,optsode,indexed_dlow; Option om,omT; @@ -5889,12 +5897,11 @@ algorithm (optdae,Util.SUCCESS()) := preoptimiseDAE(inDAE,functionTree,preOptModules); // transformation phase (matching and sorting using a index reduction method - (sode as BackendDAE.DAE(eqs={BackendDAE.EQSYSTEM(matching=BackendDAE.MATCHING(v1,v2,comps))})) := transformDAE(optdae,functionTree,NONE(),daeHandler); + sode := transformDAE(optdae,functionTree,NONE(),daeHandler); Debug.fcall("bltdump", BackendDump.bltdump, ("bltdump",sode)); // past optimisation phase - (sode,outAss1,outAss2,outComps,Util.SUCCESS()) := pastoptimiseDAE(sode,functionTree,pastOptModules,v1,v2,comps,daeHandler); - + (sode,Util.SUCCESS()) := pastoptimiseDAE(sode,functionTree,pastOptModules,daeHandler); sode1 := BackendDAECreate.findZeroCrossings(sode); Debug.execStat("findZeroCrossings",BackendDAE.RT_CLOCK_EXECSTAT_BACKEND_MODULES); indexed_dlow := translateDae(sode1,NONE()); @@ -5981,8 +5988,30 @@ protected function transformDAE input Option inMatchingOptions; input tuple daeHandler; output BackendDAE.BackendDAE outDAE; +protected + list systs; + BackendDAE.Shared shared; algorithm - outDAE := matchcontinue (inDAE,functionTree,inMatchingOptions,daeHandler) + BackendDAE.DAE(systs,shared) := inDAE; + (systs,shared) := mapTransformDAE(systs,shared,functionTree,inMatchingOptions,daeHandler,{}); + outDAE := BackendDAE.DAE(systs,shared); +end transformDAE; + +protected function mapTransformDAE +"function transformDAE + Run the matching Algorithm and the sorting algorithm. + In case of an DAE an DAE-Handler is used to reduce + the index of the dae." + input list systs; + input BackendDAE.Shared shared; + input DAE.FunctionTree functionTree; + input Option inMatchingOptions; + input tuple daeHandler; + input list acc; + output list osysts; + output BackendDAE.Shared oshared; +algorithm + (osysts,oshared) := matchcontinue (systs,shared,functionTree,inMatchingOptions,daeHandler,acc) local BackendDAE.BackendDAE dae,ode,ode2; DAE.FunctionTree funcs; @@ -5994,8 +6023,40 @@ algorithm BackendDAE.MatchingOptions match_opts; daeHandlerFunc daeHandlerfunc; BackendDAE.EqSystem syst; - BackendDAE.Shared shared; - case (dae as BackendDAE.DAE({syst},shared),funcs,inMatchingOptions,(daeHandlerfunc,methodstr)) + case ({},shared,funcs,inMatchingOptions,daeHandler,acc) then (listReverse(acc),shared); + case (syst::systs,shared,funcs,inMatchingOptions,daeHandler,acc) + equation + (syst,shared) = transformDAEWork(syst,shared,funcs,inMatchingOptions,daeHandler); + (systs,shared) = mapTransformDAE(systs,shared,funcs,inMatchingOptions,daeHandler,syst::acc); + then (systs,shared); + end matchcontinue; +end mapTransformDAE; + +protected function transformDAEWork +"function transformDAE + Run the matching Algorithm and the sorting algorithm. + In case of an DAE an DAE-Handler is used to reduce + the index of the dae." + input BackendDAE.EqSystem syst; + input BackendDAE.Shared shared; + input DAE.FunctionTree functionTree; + input Option inMatchingOptions; + input tuple daeHandler; + output BackendDAE.EqSystem osyst; + output BackendDAE.Shared oshared; +algorithm + (osyst,oshared) := matchcontinue (syst,shared,functionTree,inMatchingOptions,daeHandler) + local + BackendDAE.BackendDAE dae,ode,ode2; + DAE.FunctionTree funcs; + String str,methodstr; + Option om,omT; + BackendDAE.IncidenceMatrix m,mT,m1,mT1; + array v1,v2; + BackendDAE.StrongComponents comps; + BackendDAE.MatchingOptions match_opts; + daeHandlerFunc daeHandlerfunc; + case (syst,shared,funcs,inMatchingOptions,(daeHandlerfunc,methodstr)) equation (syst,m,mT) = getIncidenceMatrixfromOption(syst,shared); match_opts = Util.getOptionOrDefault(inMatchingOptions,(BackendDAE.INDEX_REDUCTION(), BackendDAE.EXACT())); @@ -6008,10 +6069,9 @@ algorithm // restart the matching true = checkCompsMatching(comps,arrayList(v1)); Debug.execStat("transformDAE -> sort components",BackendDAE.RT_CLOCK_EXECSTAT_BACKEND_MODULES); - then - BackendDAE.DAE({syst},shared); + then (syst,shared); - case (BackendDAE.DAE({syst},shared),funcs,inMatchingOptions,(daeHandlerfunc,methodstr)) + case (syst,shared,funcs,inMatchingOptions,(daeHandlerfunc,methodstr)) equation (syst,m,mT) = getIncidenceMatrixfromOption(syst,shared); match_opts = Util.getOptionOrDefault(inMatchingOptions,(BackendDAE.INDEX_REDUCTION(), BackendDAE.EXACT())); @@ -6027,16 +6087,14 @@ algorithm // sorting algorithm (syst,_) = BackendDAETransform.strongComponents(syst,shared); Debug.execStat("transformDAE -> sort components",BackendDAE.RT_CLOCK_EXECSTAT_BACKEND_MODULES); - then - BackendDAE.DAE({syst},shared); - else - equation - //str = "Transformation Module failed!"; - //Error.addMessage(Error.INTERNAL_ERROR, {str}); - then - fail(); + then (syst,shared); + else + equation + str = "Transformation Module failed!"; + Error.addMessage(Error.INTERNAL_ERROR, {str}); + then fail(); end matchcontinue; -end transformDAE; +end transformDAEWork; protected function pastoptimiseDAE "function optimiseDAE @@ -6044,18 +6102,12 @@ protected function pastoptimiseDAE input BackendDAE.BackendDAE inDAE; input DAE.FunctionTree functionTree; input list> optModules; - input array inAss1; - input array inAss2; - input BackendDAE.StrongComponents inComps; input tuple daeHandler; output BackendDAE.BackendDAE outDAE; - output array outAss1; - output array outAss2; - output BackendDAE.StrongComponents outComps; output Util.Status status; algorithm - (outDAE,outAss1,outAss2,outComps,status):= - matchcontinue (inDAE,functionTree,optModules,inAss1,inAss2,inComps,daeHandler) + (outDAE,status):= + matchcontinue (inDAE,functionTree,optModules,daeHandler) local BackendDAE.BackendDAE dae,dae1,dae2; DAE.FunctionTree funcs; @@ -6066,25 +6118,25 @@ algorithm array v1,v2,v1_1,v2_1,v1_2,v2_2; BackendDAE.StrongComponents comps,comps1,comps2; Boolean runMatching,b; - case (dae,funcs,{},v1,v2,comps,_) then (dae,v1,v2,comps,Util.SUCCESS()); - case (dae,funcs,(optModule,moduleStr,_)::rest,v1,v2,comps,daeHandler) + case (dae,funcs,{},_) then (dae,Util.SUCCESS()); + case (dae,funcs,(optModule,moduleStr,_)::rest,daeHandler) equation - (dae1,v1_1,v2_1,comps1,runMatching) = optModule(dae,funcs,v1,v2,comps); + (dae1,runMatching) = optModule(dae,funcs); Debug.execStat("pastOpt " +& moduleStr,BackendDAE.RT_CLOCK_EXECSTAT_BACKEND_MODULES); Debug.fcall("optdaedump", print, stringAppendList({"\nOptimisation Module ",moduleStr,":\n\n"})); Debug.fcall("optdaedump", BackendDump.dump, dae1); - (dae1 as BackendDAE.DAE(eqs={BackendDAE.EQSYSTEM(matching=BackendDAE.MATCHING(v1_1,v2_1,comps1))})) = checktransformDAE(runMatching,dae1,funcs,v1_1,v2_1,comps1,daeHandler); - (dae2,v1_2,v2_2,comps2,status) = pastoptimiseDAE(dae1,funcs,rest,v1_1,v2_1,comps1,daeHandler); + dae1 = checktransformDAE(runMatching,dae1,funcs,daeHandler); + (dae2,status) = pastoptimiseDAE(dae1,funcs,rest,daeHandler); then - (dae2,v1_2,v2_2,comps2,status); - case (dae,funcs,(optModule,moduleStr,b)::rest,v1,v2,comps,daeHandler) + (dae2,status); + case (dae,funcs,(optModule,moduleStr,b)::rest,daeHandler) equation Debug.execStat("pastOpt " +& moduleStr,BackendDAE.RT_CLOCK_EXECSTAT_BACKEND_MODULES); str = stringAppendList({"Optimisation Module ",moduleStr," failed."}); Debug.bcall2(not b,Error.addMessage, Error.INTERNAL_ERROR, {str}); - (dae1,v1_1,v2_1,comps1,status) = pastoptimiseDAE(dae,funcs,rest,v1,v2,comps,daeHandler); + (dae1,status) = pastoptimiseDAE(dae,funcs,rest,daeHandler); then - (dae1,v1_1,v2_1,comps1,Util.if_(b,Util.FAILURE(),status)); + (dae1,Util.if_(b,Util.FAILURE(),status)); end matchcontinue; end pastoptimiseDAE; @@ -6094,14 +6146,11 @@ protected function checktransformDAE input Boolean inRunMatching; input BackendDAE.BackendDAE inDAE; input DAE.FunctionTree functionTree; - input array inAss1; - input array inAss2; - input BackendDAE.StrongComponents inComps; input tuple daeHandler; output BackendDAE.BackendDAE outDAE; algorithm outDAE := - match (inRunMatching,inDAE,functionTree,inAss1,inAss2,inComps,daeHandler) + match (inRunMatching,inDAE,functionTree,daeHandler) local BackendDAE.BackendDAE dae,sode; DAE.FunctionTree funcs; @@ -6109,12 +6158,12 @@ algorithm array v1,v2; BackendDAE.StrongComponents comps; Boolean runMatching; - case (true,dae,funcs,_,_,_,daeHandler) + case (true,dae,funcs,daeHandler) equation sode = transformDAE(dae,funcs,NONE(),daeHandler); Debug.fcall("bltdump", BackendDump.bltdump, ("bltdump",sode)); then sode; - case (false,dae,funcs,v1,v2,comps,_) + case (false,dae,funcs,_) then dae; end match; end checktransformDAE; @@ -6418,29 +6467,80 @@ algorithm setGlobalRoot(6, realAdd(getGlobalRoot(6),t)); end profilerstop2; -public function mapPreOptModule +public function mapEqSystem1 "Helper to map a preopt module over each equation system" - input PreOptModule module; input BackendDAE.BackendDAE dae; - input DAE.FunctionTree funcs; + input Function func; + input A a; + output BackendDAE.BackendDAE odae; + partial function Function + input BackendDAE.EqSystem syst; + input BackendDAE.Shared shared; + input A a; + output BackendDAE.EqSystem osyst; + output BackendDAE.Shared oshared; + end Function; + replaceable type A subtypeof Any; +protected + list systs; + BackendDAE.Shared shared; +algorithm + BackendDAE.DAE(systs,shared) := dae; + (systs,shared) := Util.listMapAndFold1(systs,func,shared,a); + // Filter out empty systems + systs := Util.listSelect(systs,nonEmptySystem); + odae := BackendDAE.DAE(systs,shared); +end mapEqSystem1; + +public function mapEqSystem1RetExtra + "Helper to map a preopt module over each equation system" + input BackendDAE.BackendDAE dae; + input Function func; + input A a; + input B initialExtra; + output BackendDAE.BackendDAE odae; + output B extra; + partial function Function + input BackendDAE.EqSystem syst; + input tuple sharedChanged; + input A a; + output BackendDAE.EqSystem osyst; + output tuple osharedChanged; + end Function; + replaceable type A subtypeof Any; + replaceable type B subtypeof Any; +protected + list systs; + BackendDAE.Shared shared; +algorithm + BackendDAE.DAE(systs,shared) := dae; + (systs,(shared,extra)) := Util.listMapAndFold1(systs,func,(shared,initialExtra),a); + // Filter out empty systems + systs := Util.listSelect(systs,nonEmptySystem); + odae := BackendDAE.DAE(systs,shared); +end mapEqSystem1RetExtra; + +public function mapEqSystem + "Helper to map a preopt module over each equation system" + input BackendDAE.BackendDAE dae; + input Function func; output BackendDAE.BackendDAE odae; - partial function PreOptModule + partial function Function input BackendDAE.EqSystem syst; input BackendDAE.Shared shared; - input DAE.FunctionTree funcs; output BackendDAE.EqSystem osyst; output BackendDAE.Shared oshared; - end PreOptModule; + end Function; protected list systs; BackendDAE.Shared shared; algorithm BackendDAE.DAE(systs,shared) := dae; - (systs,shared) := Util.listMapAndFold1(systs,module,shared,funcs); + (systs,shared) := Util.listMapAndFold(systs,func,shared); // Filter out empty systems systs := Util.listSelect(systs,nonEmptySystem); odae := BackendDAE.DAE(systs,shared); -end mapPreOptModule; +end mapEqSystem; protected function nonEmptySystem input BackendDAE.EqSystem syst; diff --git a/Compiler/BackEnd/BackendDump.mo b/Compiler/BackEnd/BackendDump.mo index add327ca5bc..f2cb68408a0 100644 --- a/Compiler/BackEnd/BackendDump.mo +++ b/Compiler/BackEnd/BackendDump.mo @@ -1501,13 +1501,7 @@ public function dumpComponentsGraphStr components to format suitable for Mathematica" input BackendDAE.BackendDAE inDAE; input DAE.FunctionTree inFunctionTree; - input array inAss1; - input array inAss2; - input BackendDAE.StrongComponents inComps; output BackendDAE.BackendDAE outDAE; - output array outAss1; - output array outAss2; - output BackendDAE.StrongComponents outComps; output Boolean outRunMatching; protected Integer n; @@ -1516,17 +1510,15 @@ protected BackendDAE.EqSystem syst; BackendDAE.IncidenceMatrix m; BackendDAE.IncidenceMatrix mT; + array ass1,ass2; algorithm - BackendDAE.DAE(eqs={syst as BackendDAE.EQSYSTEM(m=SOME(m),mT=SOME(mT))}) := inDAE; + BackendDAE.DAE(eqs={syst as BackendDAE.EQSYSTEM(m=SOME(m),mT=SOME(mT),matching=BackendDAE.MATCHING(ass1,ass2,_))}) := inDAE; n := BackendDAEUtil.systemSize(syst); - lst := dumpComponentsGraphStr2(1,n,m,mT,inAss1,inAss2); + lst := dumpComponentsGraphStr2(1,n,m,mT,ass1,ass2); s := Util.stringDelimitList(lst,","); s := stringAppendList({"{",s,"}"}); print(s); outDAE := inDAE; - outAss1 := inAss1; - outAss2 := inAss2; - outComps := inComps; outRunMatching := false; end dumpComponentsGraphStr; diff --git a/Compiler/BackEnd/SimCode.mo b/Compiler/BackEnd/SimCode.mo index 5adf8727193..7455a001f7c 100644 --- a/Compiler/BackEnd/SimCode.mo +++ b/Compiler/BackEnd/SimCode.mo @@ -1027,7 +1027,7 @@ algorithm dae = DAEUtil.transformationsBeforeBackend(cache,dae); funcs = Env.getFunctionTree(cache); dlow = BackendDAECreate.lower(dae,funcs,true); - (dlow_1,ass1,ass2,comps) = BackendDAEUtil.getSolvedSystem(cache, env, dlow, funcs, + (dlow_1 as BackendDAE.DAE(eqs={BackendDAE.EQSYSTEM(matching=BackendDAE.MATCHING(ass1,ass2,comps))})) = BackendDAEUtil.getSolvedSystem(cache, env, dlow, funcs, NONE(), NONE(), NONE()); Debug.fprintln("dynload", "translateModel: Generating simulation code and functions."); (indexed_dlow_1,libs,file_dir,timeBackend,timeSimCode,timeTemplates) = @@ -1213,7 +1213,7 @@ algorithm dae = DAEUtil.transformationsBeforeBackend(cache,dae); funcs = Env.getFunctionTree(cache); dlow = BackendDAECreate.lower(dae,funcs,true); - (dlow_1,ass1,ass2,comps) = BackendDAEUtil.getSolvedSystem(cache, env, dlow, funcs, + (dlow_1 as BackendDAE.DAE(eqs={BackendDAE.EQSYSTEM(matching=BackendDAE.MATCHING(ass1,ass2,comps))})) = BackendDAEUtil.getSolvedSystem(cache, env, dlow, funcs, NONE(), NONE(), NONE()); (indexed_dlow_1,libs,file_dir,timeBackend,timeSimCode,timeTemplates) = generateModelCode(dlow_1,funcs,p, dae, className, filenameprefix, inSimSettingsOpt,ass1,ass2,comps); diff --git a/Compiler/Main/Main.mo b/Compiler/Main/Main.mo index 948ee47dbe4..5f160ab8669 100644 --- a/Compiler/Main/Main.mo +++ b/Compiler/Main/Main.mo @@ -764,22 +764,16 @@ algorithm true = runBackendQ(); funcs = Env.getFunctionTree(cache); dlow = BackendDAECreate.lower(dae,funcs,true); - (dlow_1,v1,v2,comps) = BackendDAEUtil.getSolvedSystem(cache,env,dlow,funcs,NONE(),NONE(),NONE()); + (dlow_1 as BackendDAE.DAE(eqs={BackendDAE.EQSYSTEM(matching=BackendDAE.MATCHING(v1,v2,comps))})) = BackendDAEUtil.getSolvedSystem(cache,env,dlow,funcs,NONE(),NONE(),NONE()); modpar(dlow_1,comps); Debug.execStat("Lowering Done",CevalScript.RT_CLOCK_EXECSTAT_MAIN); simcodegen(dlow_1,funcs,classname,ap,daeimpl,v1,v2,comps); then (); - case (_,_,_,_,_,_,_) - equation - true = runBackendQ() "so main can print error messages" ; - then - fail(); - case (_,_,_,_,_,_,_) /* If not running backend. */ + else equation - false = runBackendQ(); - then - (); + false = runBackendQ() "so main can print error messages" ; + then (); end matchcontinue; end optimizeDae; diff --git a/Compiler/Script/CevalScript.mo b/Compiler/Script/CevalScript.mo index 2ec2c1f37b0..775d1ea7e83 100644 --- a/Compiler/Script/CevalScript.mo +++ b/Compiler/Script/CevalScript.mo @@ -3444,7 +3444,7 @@ algorithm dae = DAEUtil.transformationsBeforeBackend(cache,dae_1); funcs = Env.getFunctionTree(cache); dlow = BackendDAECreate.lower(dae, funcs, true); - (indexed_dlow,_,_,_) = BackendDAEUtil.getSolvedSystem(cache, env, dlow, funcs, NONE(), NONE(), NONE()); + indexed_dlow = BackendDAEUtil.getSolvedSystem(cache, env, dlow, funcs, NONE(), NONE(), NONE()); xml_filename = stringAppendList({filenameprefix,".xml"}); funcelems = DAEUtil.getFunctionList(funcs); Print.clearBuf();