From 2001c11b57d04882895cd66fdcdf451c767c4b8e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20Sj=C3=B6lund?= Date: Wed, 14 Sep 2011 09:21:41 +0000 Subject: [PATCH] - Minor refactoring, adding field for storing matching information in each eqsystem git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@9809 f25d12d1-65f4-0310-ae8a-bbce733d8d8e --- Compiler/BackEnd/BackendDAE.mo | 10 ++ Compiler/BackEnd/BackendDAECreate.mo | 12 +- Compiler/BackEnd/BackendDAEOptimize.mo | 154 ++++++++++++------------ Compiler/BackEnd/BackendDAETransform.mo | 64 +++++----- Compiler/BackEnd/BackendDAEUtil.mo | 30 +++-- Compiler/BackEnd/BackendDump.mo | 2 +- Compiler/BackEnd/BackendEquation.mo | 9 +- Compiler/BackEnd/BackendVariable.mo | 5 +- Compiler/BackEnd/PartFn.mo | 5 +- Compiler/BackEnd/SimCode.mo | 23 ++-- Compiler/BackEnd/XMLDump.mo | 2 +- Compiler/FrontEnd/Inline.mo | 5 +- 12 files changed, 179 insertions(+), 142 deletions(-) diff --git a/Compiler/BackEnd/BackendDAE.mo b/Compiler/BackEnd/BackendDAE.mo index ea98a07eb1a..444dcf267df 100644 --- a/Compiler/BackEnd/BackendDAE.mo +++ b/Compiler/BackEnd/BackendDAE.mo @@ -271,9 +271,19 @@ uniontype EqSystem "An independent system of equations (and their corresponding EquationArray orderedEqs "orderedEqs ; ordered Equations" ; Option m; Option mT; + Matching matching; end EQSYSTEM; end EqSystem; +uniontype Matching + record NO_MATCHING "matching has not yet been performed" end NO_MATCHING; + record MATCHING "not yet used" + array ass1; + array ass2; + StrongComponents comps; + end MATCHING; +end Matching; + type ExternalObjectClasses = list "classes of external objects stored in list"; uniontype ExternalObjectClass "class of external objects" diff --git a/Compiler/BackEnd/BackendDAECreate.mo b/Compiler/BackEnd/BackendDAECreate.mo index deaa12ab42f..460de5abe86 100644 --- a/Compiler/BackEnd/BackendDAECreate.mo +++ b/Compiler/BackEnd/BackendDAECreate.mo @@ -136,7 +136,7 @@ algorithm algarr := listArray(algs); einfo := Inline.inlineEventInfo(BackendDAE.EVENT_INFO(whenclauses_1,{}),(SOME(functionTree),{DAE.NORM_INLINE()})); aliasVars := BackendDAEUtil.emptyAliasVariables(); - outBackendDAE := BackendDAE.DAE(BackendDAE.EQSYSTEM(vars_1,eqnarr,NONE(),NONE())::{},BackendDAE.SHARED(knvars,extVars,aliasVars,ieqnarr,reqnarr,arr_md_eqns,algarr,einfo,extObjCls,BackendDAE.SIMULATION())); + outBackendDAE := BackendDAE.DAE(BackendDAE.EQSYSTEM(vars_1,eqnarr,NONE(),NONE(),BackendDAE.NO_MATCHING())::{},BackendDAE.SHARED(knvars,extVars,aliasVars,ieqnarr,reqnarr,arr_md_eqns,algarr,einfo,extObjCls,BackendDAE.SIMULATION())); BackendDAEUtil.checkBackendDAEWithErrorMsg(outBackendDAE); end lower; @@ -2593,14 +2593,15 @@ algorithm BackendDAE.EventInfo einfo; BackendDAE.ExternalObjectClasses eoc; BackendDAE.BackendDAEType btp; - case (BackendDAE.EQSYSTEM(vars,eqns,m,mT),shared as BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,arreqns,algorithms,einfo,eoc,btp),funcs) + BackendDAE.Matching matching; + case (BackendDAE.EQSYSTEM(vars,eqns,m,mT,matching),shared as BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,arreqns,algorithms,einfo,eoc,btp),funcs) equation (eqns1,(vars1,_,_)) = BackendEquation.traverseBackendDAEEqnsWithUpdate(eqns,traverserexpandDerEquation,(vars,shared,funcs)); (inieqns1,(vars2,_,_)) = BackendEquation.traverseBackendDAEEqnsWithUpdate(inieqns,traverserexpandDerEquation,(vars1,shared,funcs)); (arreqns1,(vars3,_,_,_)) = BackendDAEUtil.traverseBackendDAEArrayNoCopyWithUpdate(arreqns,traverserexpandDerExp,BackendEquation.traverseBackendDAEExpsArrayEqnWithUpdate,1,arrayLength(arreqns),(vars2,shared,{},funcs)); (algorithms1,(vars4,_,_,_)) = BackendDAEUtil.traverseBackendDAEArrayNoCopyWithUpdate(algorithms,traverserexpandDerExp,BackendEquation.traverseBackendDAEExpsAlgortihmWithUpdate,1,arrayLength(algorithms),(vars3,shared,{},funcs)); then - (BackendDAE.EQSYSTEM(vars4,eqns1,m,mT),BackendDAE.SHARED(knvars,exobj,av,inieqns1,remeqns,arreqns1,algorithms1,einfo,eoc,btp)); + (BackendDAE.EQSYSTEM(vars4,eqns1,m,mT,matching),BackendDAE.SHARED(knvars,exobj,av,inieqns1,remeqns,arreqns1,algorithms1,einfo,eoc,btp)); end match; end expandDerOperatorWork; @@ -2844,7 +2845,8 @@ algorithm BackendDAE.EqSystems eqs; Option m,mT; BackendDAE.BackendDAEType btp; - case (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns,m,mT)::{},BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,arreqns,algorithms,einfo as BackendDAE.EVENT_INFO(whenClauseLst=whenclauses),eoc,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))) equation eqs_lst = BackendDAEUtil.equationList(eqns); arreqns_lst = arrayList(arreqns); @@ -2855,7 +2857,7 @@ algorithm algorithms1 = listArray(algs_lst1); einfo1 = BackendDAE.EVENT_INFO(whenclauses1,zero_crossings); then - (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns1,m,mT)::{},BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,arreqns1,algorithms1,einfo1,eoc,btp))); + (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns1,m,mT,matching)::{},BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,arreqns1,algorithms1,einfo1,eoc,btp))); end match; end findZeroCrossings; diff --git a/Compiler/BackEnd/BackendDAEOptimize.mo b/Compiler/BackEnd/BackendDAEOptimize.mo index bc47250dd9d..5002b420047 100644 --- a/Compiler/BackEnd/BackendDAEOptimize.mo +++ b/Compiler/BackEnd/BackendDAEOptimize.mo @@ -183,7 +183,8 @@ algorithm BackendDAE.BackendDAE dae; Option m,mT; BackendDAE.BackendDAEType btp; - case (arraylisteqns,BackendDAE.EQSYSTEM(vars,eqns,m,mT),BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,arreqns,algorithms,einfo,eoc,btp)) + BackendDAE.Matching matching; + case (arraylisteqns,BackendDAE.EQSYSTEM(vars,eqns,m,mT,matching),BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,arreqns,algorithms,einfo,eoc,btp)) equation len = arrayLength(arraylisteqns); true = intGt(len,0); @@ -191,7 +192,7 @@ algorithm (eqns1,(arraylisteqns,_,updateeqns)) = BackendEquation.traverseBackendDAEEqnsWithUpdate(eqns,replaceScalarArrayEqns,(arraylisteqns,1,{})); (remeqns1,(arraylisteqns,_,_)) = BackendEquation.traverseBackendDAEEqnsWithUpdate(remeqns,replaceScalarArrayEqns,(arraylisteqns,1,{})); (inieqns1,(_,_,_)) = BackendEquation.traverseBackendDAEEqnsWithUpdate(inieqns,replaceScalarArrayEqns,(arraylisteqns,1,{})); - syst = BackendDAE.EQSYSTEM(vars,eqns1,m,mT); + syst = BackendDAE.EQSYSTEM(vars,eqns1,m,mT,matching); shared = BackendDAE.SHARED(knvars,exobj,av,inieqns1,remeqns1,arreqns,algorithms,einfo,eoc,btp); then (syst,shared,updateeqns,true); @@ -442,7 +443,7 @@ algorithm Boolean b; BackendDAE.BackendDAEType btp; case (false,syst,shared,_,_,_,_) then (syst,shared); - case (true,BackendDAE.EQSYSTEM(ordvars,eqns,_,_),BackendDAE.SHARED(knvars,exobj,aliasVars,inieqns,remeqns,arreqns,algorithms,BackendDAE.EVENT_INFO(whenClauseLst,zeroCrossingLst),eoc,btp),repl,movedVars,movedAVars,meqns) + case (true,BackendDAE.EQSYSTEM(orderedVars=ordvars,orderedEqs=eqns),BackendDAE.SHARED(knvars,exobj,aliasVars,inieqns,remeqns,arreqns,algorithms,BackendDAE.EVENT_INFO(whenClauseLst,zeroCrossingLst),eoc,btp),repl,movedVars,movedAVars,meqns) equation Debug.fcall("dumprepl", BackendVarTransform.dumpReplacements, repl); // delete alias variables from orderedVars @@ -464,7 +465,7 @@ algorithm (remeqns1,(_,_,_)) = BackendEquation.traverseBackendDAEEqnsWithUpdate(remeqns,replaceEquationTraverser,(repl,crefOrDerCrefarray,inouttplarray)); (whenClauseLst1,_) = BackendDAETransform.traverseBackendDAEExpsWhenClauseLst(whenClauseLst,replaceWhenClauseTraverser,repl); // update array eqn wrapper - then (BackendDAE.EQSYSTEM(ordvars3,eqns2,NONE(),NONE()),BackendDAE.SHARED(knvars2,exobj,aliasVars,inieqns1,remeqns1,arreqns1,algorithms1,BackendDAE.EVENT_INFO(whenClauseLst1,zeroCrossingLst),eoc,btp)); + then (BackendDAE.EQSYSTEM(ordvars3,eqns2,NONE(),NONE(),BackendDAE.NO_MATCHING()),BackendDAE.SHARED(knvars2,exobj,aliasVars,inieqns1,remeqns1,arreqns1,algorithms1,BackendDAE.EVENT_INFO(whenClauseLst1,zeroCrossingLst),eoc,btp)); end match; end removeSimpleEquations2; @@ -719,7 +720,7 @@ algorithm BackendVarTransform.VariableReplacements repl_1; BackendDAE.Var v; BackendDAE.BackendDAEType btp; - case (0,cr,i,exp,pos,repl,BackendDAE.EQSYSTEM(ordvars,eqns,_,_),BackendDAE.SHARED(knvars,exobj,aliasVars,inieqns,remeqns,arreqns,algorithms,einfo,eoc,btp),m,mT,meqns,inFuncs) + case (0,cr,i,exp,pos,repl,BackendDAE.EQSYSTEM(orderedVars=ordvars,orderedEqs=eqns),BackendDAE.SHARED(knvars,exobj,aliasVars,inieqns,remeqns,arreqns,algorithms,einfo,eoc,btp),m,mT,meqns,inFuncs) equation // equations of var vareqns = mT[i]; @@ -728,12 +729,12 @@ algorithm (ordvars1,v) = BackendVariable.removeVar(i,ordvars); knvars1 = BackendVariable.addVar(v,knvars); // update IncidenceMatrix - syst = BackendDAE.EQSYSTEM(ordvars1,eqns,SOME(m),SOME(mT)); + syst = BackendDAE.EQSYSTEM(ordvars1,eqns,SOME(m),SOME(mT),BackendDAE.NO_MATCHING()); shared = BackendDAE.SHARED(knvars1,exobj,aliasVars,inieqns,remeqns,arreqns,algorithms,einfo,eoc,btp); (syst as BackendDAE.EQSYSTEM(m=SOME(m),mT=SOME(mT))) = BackendDAEUtil.updateIncidenceMatrix(syst,shared,vareqns); pos_1 = pos - 1; then (vareqns1,syst,shared,m,mT,repl,pos_1::meqns); - case (1,cr,i,exp,pos,repl,BackendDAE.EQSYSTEM(ordvars,eqns,_,_),shared,m,mT,meqns,inFuncs) + case (1,cr,i,exp,pos,repl,BackendDAE.EQSYSTEM(orderedVars=ordvars,orderedEqs=eqns),shared,m,mT,meqns,inFuncs) equation // equations of var vareqns = mT[i]; @@ -746,10 +747,10 @@ algorithm pos_1 = pos-1; eqns2 = BackendEquation.equationSetnth(eqns1,pos_1,BackendDAE.EQUATION(DAE.RCONST(0.0),DAE.RCONST(0.0),DAE.emptyElementSource)); // update IncidenceMatrix - syst = BackendDAE.EQSYSTEM(ordvars,eqns2,SOME(m),SOME(mT)); + syst = BackendDAE.EQSYSTEM(ordvars,eqns2,SOME(m),SOME(mT),BackendDAE.NO_MATCHING()); (syst as BackendDAE.EQSYSTEM(m=SOME(m),mT=SOME(mT))) = BackendDAEUtil.updateIncidenceMatrix(syst,shared,vareqns); then (vareqns1,syst,shared,m,mT,repl_1,pos_1::meqns); - case (2,cr,i,exp,pos,repl,BackendDAE.EQSYSTEM(ordvars,eqns,_,_),BackendDAE.SHARED(knvars,exobj,aliasVars,inieqns,remeqns,arreqns,algorithms,einfo,eoc,btp),m,mT,meqns,inFuncs) + case (2,cr,i,exp,pos,repl,BackendDAE.EQSYSTEM(orderedVars=ordvars,orderedEqs=eqns),BackendDAE.SHARED(knvars,exobj,aliasVars,inieqns,remeqns,arreqns,algorithms,einfo,eoc,btp),m,mT,meqns,inFuncs) equation // equations of var vareqns = mT[i]; @@ -758,7 +759,7 @@ algorithm // replace der(a)=b in vareqns (eqns1,arreqns1,algorithms1,einfo1) = replacementsInEqns2(vareqns2,exp,cr,eqns,arreqns,algorithms,einfo); // update IncidenceMatrix - syst = BackendDAE.EQSYSTEM(ordvars,eqns1,SOME(m),SOME(mT)); + syst = BackendDAE.EQSYSTEM(ordvars,eqns1,SOME(m),SOME(mT),BackendDAE.NO_MATCHING()); shared = BackendDAE.SHARED(knvars,exobj,aliasVars,inieqns,remeqns,arreqns1,algorithms1,einfo1,eoc,btp); (syst as BackendDAE.EQSYSTEM(m=SOME(m),mT=SOME(mT))) = BackendDAEUtil.updateIncidenceMatrix(syst,shared,vareqns); then (vareqns2,syst,shared,m,mT,repl,meqns); @@ -2004,7 +2005,8 @@ algorithm list lstarreqns,lstarreqns1; list algs,algs_1; BackendDAE.BackendDAEType btp; - case (BackendDAE.EQSYSTEM(vars,eqns,m,mT),BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,arreqns,algorithms,einfo,eoc,btp),funcs) + BackendDAE.Matching matching; + case (BackendDAE.EQSYSTEM(vars,eqns,m,mT,matching),BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,arreqns,algorithms,einfo,eoc,btp),funcs) equation repl = BackendVarTransform.emptyReplacements(); lsteqns = BackendDAEUtil.equationList(eqns); @@ -2020,7 +2022,7 @@ algorithm arreqns1 = listArray(lstarreqns1); algorithms1 = listArray(algs_1); then - (BackendDAE.EQSYSTEM(vars,eqns1,NONE(),NONE()),BackendDAE.SHARED(knvars1,exobj,av,inieqns,remeqns,arreqns1,algorithms1,einfo,eoc,btp)); + (BackendDAE.EQSYSTEM(vars,eqns1,NONE(),NONE(),matching),BackendDAE.SHARED(knvars1,exobj,av,inieqns,remeqns,arreqns1,algorithms1,einfo,eoc,btp)); end match; end removeFinalParametersWork; @@ -2136,7 +2138,8 @@ algorithm list lstarreqns,lstarreqns1; list algs,algs_1; BackendDAE.BackendDAEType btp; - case (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns,m,mT)::{},BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,arreqns,algorithms,einfo,eoc,btp)),funcs) + BackendDAE.Matching matching; + case (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns,m,mT,matching)::{},BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,arreqns,algorithms,einfo,eoc,btp)),funcs) equation repl = BackendVarTransform.emptyReplacements(); lsteqns = BackendDAEUtil.equationList(eqns); @@ -2152,7 +2155,7 @@ algorithm arreqns1 = listArray(lstarreqns1); algorithms1 = listArray(algs_1); then - (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns1,NONE(),NONE())::{},BackendDAE.SHARED(knvars1,exobj,av,inieqns,remeqns,arreqns1,algorithms1,einfo,eoc,btp))); + (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns1,NONE(),NONE(),matching)::{},BackendDAE.SHARED(knvars1,exobj,av,inieqns,remeqns,arreqns1,algorithms1,einfo,eoc,btp))); end match; end removeParameters; @@ -2213,7 +2216,8 @@ algorithm list lstarreqns,lstarreqns1; list algs,algs_1; BackendDAE.BackendDAEType btp; - case (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns,m,mT)::{},BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,arreqns,algorithms,einfo,eoc,btp)),funcs) + BackendDAE.Matching matching; + case (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns,m,mT,matching)::{},BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,arreqns,algorithms,einfo,eoc,btp)),funcs) equation repl = BackendVarTransform.emptyReplacements(); lsteqns = BackendDAEUtil.equationList(eqns); @@ -2228,7 +2232,7 @@ algorithm arreqns1 = listArray(lstarreqns1); algorithms1 = listArray(algs_1); then - (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns1,NONE(),NONE())::{},BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,arreqns1,algorithms1,einfo,eoc,btp))); + (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns1,NONE(),NONE(),matching)::{},BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,arreqns1,algorithms1,einfo,eoc,btp))); end match; end removeProtectedParameters; @@ -2345,14 +2349,14 @@ algorithm BackendDAE.EventInfo einfo,einfo1; list changed; Boolean b; - case (syst as BackendDAE.EQSYSTEM(vars,eqns,_,_),shared as BackendDAE.SHARED(arrayEqs=arreqns,algorithms=algorithms,eventInfo=einfo),funcs) + case (syst as BackendDAE.EQSYSTEM(orderedVars=vars,orderedEqs=eqns),shared as BackendDAE.SHARED(arrayEqs=arreqns,algorithms=algorithms,eventInfo=einfo),funcs) equation (syst,m,mT) = BackendDAEUtil.getIncidenceMatrixfromOption(syst,shared); // check equations (m_1,(mT_1,_,eqns1,arreqns1,algorithms1,einfo1,changed)) = traverseIncidenceMatrix(m,removeEqualFunctionCallFinder,(mT,vars,eqns,arreqns,algorithms,einfo,{})); b = intGt(listLength(changed),0); // update arrayeqns and algorithms, collect info for wrappers - syst = BackendDAE.EQSYSTEM(vars,eqns,SOME(m_1),SOME(mT_1)); + syst = BackendDAE.EQSYSTEM(vars,eqns,SOME(m_1),SOME(mT_1),BackendDAE.NO_MATCHING()); (syst,shared) = removeEqualFunctionCalls2(b,syst,shared,eqns1,arreqns1,algorithms1,einfo1); syst = BackendDAEUtil.updateIncidenceMatrix(syst,shared,changed); then (syst,shared,b); @@ -2389,7 +2393,7 @@ algorithm Option m,mT; BackendDAE.BackendDAEType btp; case (false,syst,shared,_,_,_,_) then (syst,shared); - case (true,BackendDAE.EQSYSTEM(vars,_,m,mT),BackendDAE.SHARED(knvars,exobj,aliasVars,inieqns,remeqns,_,_,_,eoc,btp),eqns,arreqns,algorithms,einfo) + case (true,BackendDAE.EQSYSTEM(vars,_,m,mT,_),BackendDAE.SHARED(knvars,exobj,aliasVars,inieqns,remeqns,_,_,_,eoc,btp),eqns,arreqns,algorithms,einfo) equation repl = BackendVarTransform.emptyReplacements(); // update arrayeqns and algorithms, collect info for wrappers @@ -2398,7 +2402,7 @@ algorithm (_,(_,_,inouttpllst)) = Util.arrayMapNoCopy_1(algorithms,replaceAlgorithmTraverser,(repl,vars,{})); inouttplarray = listArray(listReverse(inouttpllst)); (eqns1,(_,_,_)) = BackendEquation.traverseBackendDAEEqnsWithUpdate(eqns,replaceEquationTraverser,(repl,crefOrDerCrefarray,inouttplarray)); - then (BackendDAE.EQSYSTEM(vars,eqns1,m,mT),BackendDAE.SHARED(knvars,exobj,aliasVars,inieqns,remeqns,arreqns,algorithms,einfo,eoc,btp)); + then (BackendDAE.EQSYSTEM(vars,eqns1,m,mT,BackendDAE.NO_MATCHING()),BackendDAE.SHARED(knvars,exobj,aliasVars,inieqns,remeqns,arreqns,algorithms,einfo,eoc,btp)); end match; end removeEqualFunctionCalls2; @@ -2658,7 +2662,7 @@ algorithm BackendDAE.ExternalObjectClasses eoc; BackendDAE.EqSystems eqs; BackendDAE.BackendDAEType btp; - case (dae as BackendDAE.DAE(eqs as BackendDAE.EQSYSTEM(vars,eqns,_,_)::{},BackendDAE.SHARED(knvars,exobj,aliasVars as BackendDAE.ALIASVARS(aliasVars=avars),inieqns,remeqns,arreqns,algorithms,einfo as BackendDAE.EVENT_INFO(whenClauseLst=whenClauseLst),eoc,btp)),funcs) + case (dae as BackendDAE.DAE(eqs as BackendDAE.EQSYSTEM(orderedVars=vars,orderedEqs=eqns)::{},BackendDAE.SHARED(knvars,exobj,aliasVars as BackendDAE.ALIASVARS(aliasVars=avars),inieqns,remeqns,arreqns,algorithms,einfo as BackendDAE.EVENT_INFO(whenClauseLst=whenClauseLst),eoc,btp)),funcs) equation knvars1 = BackendDAEUtil.emptyVars(); ((knvars,knvars1)) = BackendVariable.traverseBackendDAEVars(knvars,copyNonParamVariables,(knvars,knvars1)); @@ -2829,7 +2833,7 @@ algorithm BackendDAE.EqSystems eqs; BackendDAE.BackendDAEType btp; - case (dae as BackendDAE.DAE(eqs as BackendDAE.EQSYSTEM(vars,eqns,_,_)::{},BackendDAE.SHARED(knvars,exobj,aliasVars as BackendDAE.ALIASVARS(aliasVars=avars),inieqns,remeqns,arreqns,algorithms,einfo as BackendDAE.EVENT_INFO(whenClauseLst=whenClauseLst),eoc,btp)),funcs) + case (dae as BackendDAE.DAE(eqs as BackendDAE.EQSYSTEM(orderedVars=vars,orderedEqs=eqns)::{},BackendDAE.SHARED(knvars,exobj,aliasVars as BackendDAE.ALIASVARS(aliasVars=avars),inieqns,remeqns,arreqns,algorithms,einfo as BackendDAE.EVENT_INFO(whenClauseLst=whenClauseLst),eoc,btp)),funcs) equation knvars1 = BackendDAEUtil.emptyVars(); ((_,knvars1)) = BackendDAEUtil.traverseBackendDAEExpsVars(vars,checkUnusedVariables,(knvars,knvars1)); @@ -2968,16 +2972,16 @@ algorithm case (inDAE,inFunctionTree,inAss1,inAss2,inComps) equation - (dae as BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns,_,_)::{},BackendDAE.SHARED(knvars,exobj,aliasVars,inieqns,remeqns,arreqns,algorithms,einfo,eoc,btp)),b,eqnlst,movedVars) = constantLinearSystem1(inDAE,inFunctionTree,inComps,{},BackendDAE.emptyBintree); + (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); // 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()); + syst = BackendDAE.EQSYSTEM(vars1,eqns1,NONE(),NONE(),BackendDAE.NO_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)); + syst = BackendDAE.EQSYSTEM(vars1,eqns1,SOME(m),SOME(mT),BackendDAE.NO_MATCHING()); then (BackendDAE.DAE({syst},shared),inAss1,inAss2,inComps,b); end matchcontinue; @@ -3078,7 +3082,7 @@ algorithm list names; BackendDAE.BinTree movedVars; BackendDAE.Shared shared; - case (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns,_,_)::{},shared as BackendDAE.SHARED(arrayEqs=arreqns)),eqn_lst,var_lst,jac,inMovedVars) + case (BackendDAE.DAE(BackendDAE.EQSYSTEM(orderedVars=vars,orderedEqs=eqns)::{},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,{},{},{})); @@ -3092,7 +3096,7 @@ algorithm vars1 = changeconstantLinearSystemVars(var_lst,solvedVals,sources,vars); movedVars = BackendDAEUtil.treeAddList(inMovedVars, names); then - (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars1,eqns,NONE(),NONE())::{},shared),movedVars); + (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars1,eqns,NONE(),NONE(),BackendDAE.NO_MATCHING())::{},shared),movedVars); end match; end solveLinearSystem; @@ -3303,7 +3307,8 @@ algorithm array> varOptArr,varOptArr1; BackendDAE.Shared shared; Option m,mT; - case (BackendDAE.DAE(BackendDAE.EQSYSTEM(ordvars,eqns,m,mT)::{},shared)) + BackendDAE.Matching matching; + case (BackendDAE.DAE(BackendDAE.EQSYSTEM(ordvars,eqns,m,mT,matching)::{},shared)) equation BackendDAE.VARIABLES(crefIdxLstArr,varArr,bucketSize,numberOfVars) = ordvars; BackendDAE.VARIABLE_ARRAY(n1,size1,varOptArr) = varArr; @@ -3317,7 +3322,7 @@ algorithm arr_1 = Util.arrayCopy(arr, arr_1); eqns1 = BackendDAE.EQUATION_ARRAY(n,size,arr_1); then - BackendDAE.DAE(BackendDAE.EQSYSTEM(ordvars1,eqns1,m,mT)::{},shared); + BackendDAE.DAE(BackendDAE.EQSYSTEM(ordvars1,eqns1,m,mT,matching)::{},shared); end match; end copyDaeLowforTearing; @@ -3611,9 +3616,9 @@ algorithm Debug.fcall("tearingdump", print, str2); // copy dlow dlowc = copyDaeLowforTearing(dlow); - BackendDAE.DAE(BackendDAE.EQSYSTEM(ordvars as BackendDAE.VARIABLES(varArr=varr),eqns,_,_)::{},shared) = dlowc; + BackendDAE.DAE(BackendDAE.EQSYSTEM(ordvars as BackendDAE.VARIABLES(varArr=varr),eqns,_,_,_)::{},shared) = dlowc; dlowc1 = copyDaeLowforTearing(dlow1); - BackendDAE.DAE(eqs = BackendDAE.EQSYSTEM(ordvars1,eqns1,_,_)::{}) = dlowc1; + BackendDAE.DAE(eqs = BackendDAE.EQSYSTEM(ordvars1,eqns1,_,_,_)::{}) = dlowc1; // add Tearing Var var = BackendVariable.vararrayNth(varr, tearingvar-1); cr = BackendVariable.varCref(var); @@ -3639,8 +3644,8 @@ algorithm expCref, DAE.emptyElementSource),eqns_1); tearingeqnid = BackendDAEUtil.equationSize(eqns_2); - dlow_1 = BackendDAE.DAE(BackendDAE.EQSYSTEM(vars_1,eqns_2,NONE(),NONE())::{},shared); - dlow1_1 = BackendDAE.DAE(BackendDAE.EQSYSTEM(ordvars1,eqns1_1,NONE(),NONE())::{},shared); + dlow_1 = BackendDAE.DAE(BackendDAE.EQSYSTEM(vars_1,eqns_2,NONE(),NONE(),BackendDAE.NO_MATCHING())::{},shared); + dlow1_1 = BackendDAE.DAE(BackendDAE.EQSYSTEM(ordvars1,eqns1_1,NONE(),NONE(),BackendDAE.NO_MATCHING())::{},shared); // try causalisation (dlow_2 as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(m=SOME(m_2),mT=SOME(mT_2))::{}),v1_1,v2_1,comps) = BackendDAEUtil.transformBackendDAE(dlow_1,DAEUtil.avlTreeNew(),SOME((BackendDAE.NO_INDEX_REDUCTION(), BackendDAE.EXACT())),NONE()); comps_1 = Util.listMap(comps,getEqnIndxFromComp); @@ -4047,56 +4052,57 @@ algorithm String str; BackendDAE.EqSystem syst; BackendDAE.Shared shared; + BackendDAE.Matching matching; - case(dlow as BackendDAE.DAE(BackendDAE.EQSYSTEM(v,e,om,omT)::{},shared),_,{},_,_,_) + case (dlow as BackendDAE.DAE(BackendDAE.EQSYSTEM(v,e,om,omT,matching)::{},shared),_,{},_,_,_) equation v = BackendDAEUtil.listVar({}); - then (BackendDAE.DAE(BackendDAE.EQSYSTEM(v,e,om,omT)::{},shared),listArray({}),listArray({}),{}); - case(dlow as BackendDAE.DAE(BackendDAE.EQSYSTEM(v,e,om,omT)::{},shared),_,_,{},_,_) + then (BackendDAE.DAE(BackendDAE.EQSYSTEM(v,e,om,omT,matching)::{},shared),listArray({}),listArray({}),{}); + case (dlow as BackendDAE.DAE(BackendDAE.EQSYSTEM(v,e,om,omT,matching)::{},shared),_,_,{},_,_) equation v = BackendDAEUtil.listVar({}); - then (BackendDAE.DAE(BackendDAE.EQSYSTEM(v,e,om,omT)::{},shared),listArray({}),listArray({}),{}); - case(dlow as BackendDAE.DAE(BackendDAE.EQSYSTEM(v,e,_,_)::{},shared),functionTree,eqvars,diffvars,varlst,inNoColumn) + then (BackendDAE.DAE(BackendDAE.EQSYSTEM(v,e,om,omT,matching)::{},shared),listArray({}),listArray({}),{}); + case (dlow,functionTree,eqvars,diffvars,varlst,inNoColumn) equation - true = RTOpts.debugFlag("linearization"); + true = RTOpts.debugFlag("linearization"); - // Remove simple Equtaion and Parameters - dlow = removeFinalParameters(dlow,functionTree); - dlow = removeProtectedParameters(dlow,functionTree); - dlow = removeParameters(dlow,functionTree); - dlow = removeSimpleEquations(dlow,functionTree); - - Debug.fcall("execStat",print, "*** analytical Jacobians -> removed simply equations: " +& realString(clock()) +& "\n" ); - // figure out new matching and the strong components - (dlow,v1,v2,comps1) = BackendDAEUtil.transformBackendDAE(dlow,functionTree,SOME((BackendDAE.NO_INDEX_REDUCTION(), BackendDAE.EXACT())),NONE()); - Debug.fcall("jacdump2", BackendDump.bltdump, ("jacdump2",dlow,v1,v2,comps1)); - Debug.fcall("execStat",print, "*** analytical Jacobians -> performed matching and sorting: " +& realString(clock()) +& "\n" ); + // Remove simple Equtaion and Parameters + dlow = removeFinalParameters(dlow,functionTree); + dlow = removeProtectedParameters(dlow,functionTree); + dlow = removeParameters(dlow,functionTree); + dlow = removeSimpleEquations(dlow,functionTree); + + Debug.fcall("execStat",print, "*** analytical Jacobians -> removed simply equations: " +& realString(clock()) +& "\n" ); + // figure out new matching and the strong components + (dlow,v1,v2,comps1) = BackendDAEUtil.transformBackendDAE(dlow,functionTree,SOME((BackendDAE.NO_INDEX_REDUCTION(), BackendDAE.EXACT())),NONE()); + Debug.fcall("jacdump2", BackendDump.bltdump, ("jacdump2",dlow,v1,v2,comps1)); + Debug.fcall("execStat",print, "*** analytical Jacobians -> performed matching and sorting: " +& realString(clock()) +& "\n" ); - Debug.fcall("jacdump2", BackendDump.dumpComponents, comps1); - //Debug.fcall("execStat",print, "*** analytical Jacobians -> performed splitig the system: " +& realString(clock()) +& "\n" ); + Debug.fcall("jacdump2", BackendDump.dumpComponents, comps1); + //Debug.fcall("execStat",print, "*** analytical Jacobians -> performed splitig the system: " +& realString(clock()) +& "\n" ); then (dlow,v1,v2,comps1); - case(dlow as BackendDAE.DAE(BackendDAE.EQSYSTEM(v,e,_,_)::{},shared),functionTree,eqvars,diffvars,varlst,inNoColumn) + case (dlow,functionTree,eqvars,diffvars,varlst,inNoColumn) equation - true = RTOpts.debugFlag("jacobian"); + true = RTOpts.debugFlag("jacobian"); - // Remove simple Equtaion and Parameters - dlow = removeFinalParameters(dlow,functionTree); - dlow = removeProtectedParameters(dlow,functionTree); - dlow = removeParameters(dlow,functionTree); - dlow = removeSimpleEquations(dlow,functionTree); - - Debug.fcall("execStat",print, "*** analytical Jacobians -> removed simply equations: " +& realString(clock()) +& "\n" ); - // figure out new matching and the strong components - (dlow,v1,v2,comps1) = BackendDAEUtil.transformBackendDAE(dlow,functionTree,SOME((BackendDAE.NO_INDEX_REDUCTION(), BackendDAE.EXACT())),NONE()); - Debug.fcall("jacdump2", BackendDump.bltdump, ("jacdump2",dlow,v1,v2,comps1)); - Debug.fcall("execStat",print, "*** analytical Jacobians -> performed matching and sorting: " +& realString(clock()) +& "\n" ); + // Remove simple Equtaion and Parameters + dlow = removeFinalParameters(dlow,functionTree); + dlow = removeProtectedParameters(dlow,functionTree); + dlow = removeParameters(dlow,functionTree); + dlow = removeSimpleEquations(dlow,functionTree); + + Debug.fcall("execStat",print, "*** analytical Jacobians -> removed simply equations: " +& realString(clock()) +& "\n" ); + // figure out new matching and the strong components + (dlow,v1,v2,comps1) = BackendDAEUtil.transformBackendDAE(dlow,functionTree,SOME((BackendDAE.NO_INDEX_REDUCTION(), BackendDAE.EXACT())),NONE()); + Debug.fcall("jacdump2", BackendDump.bltdump, ("jacdump2",dlow,v1,v2,comps1)); + Debug.fcall("execStat",print, "*** analytical Jacobians -> performed matching and sorting: " +& realString(clock()) +& "\n" ); then (dlow,v1,v2,comps1); else equation - Error.addMessage(Error.INTERNAL_ERROR, {"Linearization.generateLinearMatrix failed"}); - then fail(); + Error.addMessage(Error.INTERNAL_ERROR, {"Linearization.generateLinearMatrix failed"}); + then fail(); end matchcontinue; end generateLinearMatrix; @@ -4158,7 +4164,7 @@ algorithm jacEventInfo = BackendDAE.EVENT_INFO({},{}); jacExtObjClasses = {}; - jacobian = BackendDAE.DAE(BackendDAE.EQSYSTEM(jacOrderedVars, jacOrderedEqs, NONE(), NONE())::{}, BackendDAE.SHARED(jacKnownVars, jacExternalObjects, jacAliasVars, jacInitialEqs, jacRemovedEqs, jacArrayEqs, jacAlgorithms, jacEventInfo, jacExtObjClasses,BackendDAE.JACOBIAN())); + jacobian = BackendDAE.DAE(BackendDAE.EQSYSTEM(jacOrderedVars, jacOrderedEqs, NONE(), NONE(), BackendDAE.NO_MATCHING())::{}, BackendDAE.SHARED(jacKnownVars, jacExternalObjects, jacAliasVars, jacInitialEqs, jacRemovedEqs, jacArrayEqs, jacAlgorithms, jacEventInfo, jacExtObjClasses,BackendDAE.JACOBIAN())); then jacobian; case(bDAE as BackendDAE.DAE(BackendDAE.EQSYSTEM(orderedVars=orderedVars,orderedEqs=orderedEqs)::{}, BackendDAE.SHARED(knownVars=knownVars, removedEqs=removedEqs, algorithms=algorithms)), functions, vars, stateVars, inputVars, paramVars) equation @@ -4188,7 +4194,7 @@ algorithm jacEventInfo = BackendDAE.EVENT_INFO({},{}); jacExtObjClasses = {}; - jacobian = BackendDAE.DAE(BackendDAE.EQSYSTEM(jacOrderedVars, jacOrderedEqs, NONE(), NONE())::{}, BackendDAE.SHARED(jacKnownVars, jacExternalObjects, jacAliasVars, jacInitialEqs, jacRemovedEqs, jacArrayEqs, jacAlgorithms, jacEventInfo, jacExtObjClasses,BackendDAE.JACOBIAN())); + jacobian = BackendDAE.DAE(BackendDAE.EQSYSTEM(jacOrderedVars, jacOrderedEqs, NONE(), NONE(), BackendDAE.NO_MATCHING())::{}, BackendDAE.SHARED(jacKnownVars, jacExternalObjects, jacAliasVars, jacInitialEqs, jacRemovedEqs, jacArrayEqs, jacAlgorithms, jacEventInfo, jacExtObjClasses,BackendDAE.JACOBIAN())); Debug.fcall("jacdump", print, "\n+++++++++++++++++++++ daeLow-dump: jacobian +++++++++++++++++++++\n"); Debug.fcall("jacdump", BackendDump.dump, jacobian); @@ -5780,11 +5786,11 @@ protected BackendDAE.Variables vars,vars1,vars2; BackendDAE.EquationArray eqs,eqs1,eqs2; algorithm - BackendDAE.EQSYSTEM(vars1,eqs1,_,_) := syst1; - BackendDAE.EQSYSTEM(vars2,eqs2,_,_) := syst2; + BackendDAE.EQSYSTEM(orderedVars=vars1,orderedEqs=eqs1) := syst1; + BackendDAE.EQSYSTEM(orderedVars=vars2,orderedEqs=eqs2) := syst2; vars := BackendVariable.addVars(BackendDAEUtil.varList(vars2),vars1); eqs := BackendEquation.addEquations(BackendDAEUtil.equationList(eqs2),eqs1); - syst := BackendDAE.EQSYSTEM(vars,eqs,NONE(),NONE()); + syst := BackendDAE.EQSYSTEM(vars,eqs,NONE(),NONE(),BackendDAE.NO_MATCHING()); end mergeIndependentBlocks; public function partitionIndependentBlocks @@ -5869,7 +5875,7 @@ algorithm list> vl; Integer i1,i2; String s1,s2; - case (n,syst as BackendDAE.EQSYSTEM(vars,arr,_,_),ixs,mT) + case (n,syst as BackendDAE.EQSYSTEM(orderedVars=vars,orderedEqs=arr),ixs,mT) equation ea = arrayCreate(n,{}); va = arrayCreate(n,{}); @@ -5909,7 +5915,7 @@ algorithm s4 := Debug.bcallret1(i1<>i2,BackendDump.dumpEqnsStr,el,""); // Can this even be triggered? We check that all variables are defined somewhere, so everything should be balanced already? Error.assertionOrAddSourceMessage(i1==i2,Error.IMBALANCED_EQUATIONS,{s1,s2,s3,s4},Absyn.dummyInfo); - syst := BackendDAE.EQSYSTEM(vars,arr,NONE(),NONE()); + syst := BackendDAE.EQSYSTEM(vars,arr,NONE(),NONE(),BackendDAE.NO_MATCHING()); end createEqSystem; protected function partitionEquations diff --git a/Compiler/BackEnd/BackendDAETransform.mo b/Compiler/BackEnd/BackendDAETransform.mo index 498d0be149d..62edee468d4 100644 --- a/Compiler/BackEnd/BackendDAETransform.mo +++ b/Compiler/BackEnd/BackendDAETransform.mo @@ -978,7 +978,7 @@ algorithm av = BackendDAEUtil.emptyAliasVariables(); eeqns = BackendDAEUtil.listEquation({}); evars = BackendDAEUtil.listVar({}); - syst = BackendDAE.EQSYSTEM(vars_1,eqns_1,NONE(),NONE()); + syst = BackendDAE.EQSYSTEM(vars_1,eqns_1,NONE(),NONE(),BackendDAE.NO_MATCHING()); shared = BackendDAE.SHARED(evars,evars,av,eeqns,eeqns,ae1,al,BackendDAE.EVENT_INFO({},{}),{},BackendDAE.ALGEQSYSTEM()); (m,mt) = BackendDAEUtil.incidenceMatrix(syst, shared, BackendDAE.ABSOLUTE()); subsystem_dae = BackendDAE.DAE({syst},shared); @@ -2111,14 +2111,15 @@ algorithm list zc; Option om,omT; BackendDAE.BackendDAEType btp; + BackendDAE.Matching matching; case ({},dae,inStateOrd) then (dae); - case ((e :: es),(dae as BackendDAE.DAE(BackendDAE.EQSYSTEM(v,eqns,om,omT)::{},BackendDAE.SHARED(kv,ev,av,ie,seqns,ae,al,BackendDAE.EVENT_INFO(wclst,zc),eoc,btp))),inStateOrd) + case ((e :: es),(dae as BackendDAE.DAE(BackendDAE.EQSYSTEM(v,eqns,om,omT,matching)::{},BackendDAE.SHARED(kv,ev,av,ie,seqns,ae,al,BackendDAE.EVENT_INFO(wclst,zc),eoc,btp))),inStateOrd) equation e_1 = e - 1; eqn = BackendDAEUtil.equationNth(eqns, e_1); (eqn_1,al1,ae1,wclst1,_) = traverseBackendDAEExpsEqn(eqn, al, ae, wclst, replaceStateOrderExp,(inStateOrd,v)); eqns_1 = BackendEquation.equationSetnth(eqns,e_1,eqn_1); - dae = replaceStateOrder(es,BackendDAE.DAE(BackendDAE.EQSYSTEM(v,eqns_1,om,omT)::{},BackendDAE.SHARED(kv,ev,av,ie,seqns,ae1,al1,BackendDAE.EVENT_INFO(wclst1,zc),eoc,btp)),inStateOrd); + dae = replaceStateOrder(es,BackendDAE.DAE(BackendDAE.EQSYSTEM(v,eqns_1,om,omT,matching)::{},BackendDAE.SHARED(kv,ev,av,ie,seqns,ae1,al1,BackendDAE.EVENT_INFO(wclst1,zc),eoc,btp)),inStateOrd); then (dae); else @@ -2494,8 +2495,9 @@ algorithm BackendDAE.EqSystem syst; BackendDAE.Shared shared; BackendDAE.BackendDAEType btp; + BackendDAE.Matching matching; case (syst,shared,{},_,inDerivedAlgs,inDerivedMultiEqn,inStateOrd,inOrgEqnsLst) then (syst,shared,inDerivedAlgs,inDerivedMultiEqn,inStateOrd,inOrgEqnsLst); - case (syst as BackendDAE.EQSYSTEM(v,eqns,SOME(m),SOME(mt)),shared as BackendDAE.SHARED(kv,ev,av,ie,seqns,ae,al,BackendDAE.EVENT_INFO(wclst,zc),eoc,btp),(e :: es),inFunctions,inDerivedAlgs,inDerivedMultiEqn,inStateOrd,inOrgEqnsLst) + case (syst as BackendDAE.EQSYSTEM(v,eqns,SOME(m),SOME(mt),matching),shared as BackendDAE.SHARED(kv,ev,av,ie,seqns,ae,al,BackendDAE.EVENT_INFO(wclst,zc),eoc,btp),(e :: es),inFunctions,inDerivedAlgs,inDerivedMultiEqn,inStateOrd,inOrgEqnsLst) equation e_1 = e - 1; eqn = BackendDAEUtil.equationNth(eqns, e_1); @@ -2511,7 +2513,7 @@ algorithm Debug.fcall("bltdump", print, "Update Incidence Matrix: "); Debug.fcall("bltdump", BackendDump.debuglst,(eqnslst1,intString)); Debug.fcall("bltdump", print, "\n"); - syst = BackendDAE.EQSYSTEM(v1,eqns_1,SOME(m),SOME(mt)); + syst = BackendDAE.EQSYSTEM(v1,eqns_1,SOME(m),SOME(mt),matching); shared = BackendDAE.SHARED(kv,ev,av,ie,seqns,ae1,al1,BackendDAE.EVENT_INFO(wclst1,zc),eoc,btp); syst = BackendDAEUtil.updateIncidenceMatrix(syst, shared, eqnslst1); orgEqnsLst = addOrgEqn(inOrgEqnsLst,e,eqn,false); @@ -2760,15 +2762,16 @@ algorithm list zc; BackendDAE.ExternalObjectClasses eoc; BackendDAE.BackendDAEType btp; + BackendDAE.Matching matching; case ({},syst,shared,_,_,_) then (syst,shared,{}); - case ((orgeqn,false)::rest,syst as BackendDAE.EQSYSTEM(v,eqnsarr,SOME(m),SOME(mt)),shared as BackendDAE.SHARED(kv,ev,av,ie,seqns,ae,al,BackendDAE.EVENT_INFO(wclst,zc),eoc,btp),so,inFunctions,e) + case ((orgeqn,false)::rest,syst as BackendDAE.EQSYSTEM(v,eqnsarr,SOME(m),SOME(mt),matching),shared as BackendDAE.SHARED(kv,ev,av,ie,seqns,ae,al,BackendDAE.EVENT_INFO(wclst,zc),eoc,btp),so,inFunctions,e) equation (orgeqn,al,ae,wclst,(so,_)) = traverseBackendDAEExpsEqn(orgeqn, al, ae, wclst, replaceStateOrderExp,(so,v)); // add the equations (eqnsarr,ae) = addOrgEqntoDAE2(orgeqn,eqnsarr,ae,inFunctions); ep = arrayLength(m)+1; - syst = BackendDAE.EQSYSTEM(v,eqnsarr,SOME(m),SOME(mt)); + syst = BackendDAE.EQSYSTEM(v,eqnsarr,SOME(m),SOME(mt),matching); shared = BackendDAE.SHARED(kv,ev,av,ie,seqns,ae,al,BackendDAE.EVENT_INFO(wclst,zc),eoc,btp); syst = BackendDAEUtil.updateIncidenceMatrix(syst, shared, {ep}); states = BackendEquation.equationsStates({orgeqn},v); @@ -3481,9 +3484,10 @@ algorithm DAE.ElementSource source; BackendDAE.Shared shared; Option om,omT; + BackendDAE.Matching matching; case ({},_,syst,shared) then (syst,shared,{}); - case ((ep,l,b)::rest,repl,BackendDAE.EQSYSTEM(v,eqnsarr,om,omT),shared as BackendDAE.SHARED(arrayEqs=ae)) + case ((ep,l,b)::rest,repl,BackendDAE.EQSYSTEM(v,eqnsarr,om,omT,matching),shared as BackendDAE.SHARED(arrayEqs=ae)) equation e_1 = ep - 1; (orgeqn as BackendDAE.ARRAY_EQUATION(index=i)) = BackendDAEUtil.equationNth(eqnsarr, e_1); @@ -3494,7 +3498,7 @@ algorithm {orgeqn} = BackendVarTransform.replaceEquations({orgeqn},repl); eqnsarr = BackendEquation.equationSetnth(eqnsarr,e_1,orgeqn); // next - syst = BackendDAE.EQSYSTEM(v,eqnsarr,om,omT); + syst = BackendDAE.EQSYSTEM(v,eqnsarr,om,omT,matching); (syst,shared,orgEqnslst) = replaceDummyStateInOrgEqns1(rest,repl,syst,shared); then (syst,shared,(ep,l,b)::orgEqnslst); @@ -3551,9 +3555,10 @@ algorithm DAE.ElementSource source; BackendDAE.Shared shared; Option om,omT; + BackendDAE.Matching matching; case ({},_,syst,shared) then (syst,shared,{}); - case ((e,ep,l)::rest,repl,BackendDAE.EQSYSTEM(v,eqnsarr,om,omT),shared as BackendDAE.SHARED(arrayEqs=ae,eventInfo=BackendDAE.EVENT_INFO(wclst,zc))) + case ((e,ep,l)::rest,repl,BackendDAE.EQSYSTEM(v,eqnsarr,om,omT,matching),shared as BackendDAE.SHARED(arrayEqs=ae,eventInfo=BackendDAE.EVENT_INFO(wclst,zc))) equation e_1 = ep - 1; (orgeqn as BackendDAE.ARRAY_EQUATION(index=i)) = BackendDAEUtil.equationNth(eqnsarr, e_1); @@ -3564,7 +3569,7 @@ algorithm {orgeqn} = BackendVarTransform.replaceEquations({orgeqn},repl); eqnsarr = BackendEquation.equationSetnth(eqnsarr,e_1,orgeqn); // next - syst = BackendDAE.EQSYSTEM(v,eqnsarr,om,omT); + syst = BackendDAE.EQSYSTEM(v,eqnsarr,om,omT,matching); (syst,shared,orgEqnslst) = replaceDummyStateInOrgEqns2(rest,repl,syst,shared); then (syst,shared,(e,ep,l)::orgEqnslst); @@ -4800,15 +4805,16 @@ algorithm BackendDAE.ExternalObjectClasses eoc; BackendDAE.Shared shared; Option om,omT; + BackendDAE.Matching matching; - case (BackendDAE.EQSYSTEM(vars,e,om,omT),cr) + case (BackendDAE.EQSYSTEM(vars,e,om,omT,matching),cr) equation ((BackendDAE.VAR(cr,kind,d,t,b,value,dim,idx,source,dae_var_attr,comment,flowPrefix,streamPrefix) :: _),indx) = BackendVariable.getVar(cr, vars); vars_1 = BackendVariable.addVar(BackendDAE.VAR(cr,BackendDAE.DUMMY_STATE(),d,t,b,value,dim,idx,source,dae_var_attr,comment,flowPrefix,streamPrefix), vars); then - BackendDAE.EQSYSTEM(vars_1,e,om,omT); + BackendDAE.EQSYSTEM(vars_1,e,om,omT,matching); - case (_,_) + else equation Error.addMessage(Error.INTERNAL_ERROR, {"- BackendDAETransform.makeAlgebraic failed!"}); then @@ -4857,9 +4863,10 @@ algorithm BackendDAE.EventInfo ei; BackendDAE.ExternalObjectClasses eoc; Option om,omT; + BackendDAE.Matching matching; /* eqns dummy state */ - case (BackendDAE.EQSYSTEM(vars,e,om,omT),eqns,dummy,dummy_no) + case (BackendDAE.EQSYSTEM(vars,e,om,omT,matching),eqns,dummy,dummy_no) equation eqns_lst = BackendEquation.getEqns(eqns,e); crefs = BackendEquation.equationsCrefs(eqns_lst); @@ -4871,10 +4878,10 @@ algorithm v_2 = BackendVariable.setVarFixed(v_1, dummy_fixed); vars_1 = BackendVariable.addVar(v_2, vars); then - BackendDAE.EQSYSTEM(vars_1,e,om,omT); + BackendDAE.EQSYSTEM(vars_1,e,om,omT,matching); // Never propagate fixed=true - case (syst as BackendDAE.EQSYSTEM(vars,e,om,omT),eqns,dummy,dummy_no) + case (syst as BackendDAE.EQSYSTEM(vars,e,om,omT,matching),eqns,dummy,dummy_no) equation eqns_lst = BackendEquation.getEqns(eqns,e); crefs = BackendEquation.equationsCrefs(eqns_lst); @@ -4964,14 +4971,15 @@ algorithm BackendDAE.ExternalObjectClasses eoc; DAE.Exp stateexpcall,dummyderexp; BackendDAE.BackendDAEType btp; - case (stateexpcall,dummyderexp,BackendDAE.EQSYSTEM(v,eqns,SOME(m),SOME(mt)),BackendDAE.SHARED(kv,ev,av as BackendDAE.ALIASVARS(aliasVars = aliasVars),ie,seqns,ae,al,BackendDAE.EVENT_INFO(wclst,zeroCrossingLst),eoc,btp),{}) + BackendDAE.Matching matching; + case (stateexpcall,dummyderexp,BackendDAE.EQSYSTEM(v,eqns,SOME(m),SOME(mt),matching),BackendDAE.SHARED(kv,ev,av as BackendDAE.ALIASVARS(aliasVars = aliasVars),ie,seqns,ae,al,BackendDAE.EVENT_INFO(wclst,zeroCrossingLst),eoc,btp),{}) equation ((_, _, av)) = BackendVariable.traverseBackendDAEVars(aliasVars,traverseReplaceAliasVarsBindExp,(stateexpcall, dummyderexp, av)); (ie1,(al1,ae1,wclst1,_,_)) = BackendEquation.traverseBackendDAEEqnsWithUpdate(ie,traversereplaceDummyDer,(al, ae, wclst, replaceDummyDer2Exp,(stateexpcall,dummyderexp))); (seqns1,(al2,ae2,wclst2,_,_)) = BackendEquation.traverseBackendDAEEqnsWithUpdate(seqns,traversereplaceDummyDer,(al1, ae1, wclst1, replaceDummyDer2Exp,(stateexpcall,dummyderexp))); - then (BackendDAE.EQSYSTEM(v,eqns,SOME(m),SOME(mt)),BackendDAE.SHARED(kv,ev,av,ie1,seqns1,ae2,al2,BackendDAE.EVENT_INFO(wclst2,zeroCrossingLst),eoc,btp)); + then (BackendDAE.EQSYSTEM(v,eqns,SOME(m),SOME(mt),matching),BackendDAE.SHARED(kv,ev,av,ie1,seqns1,ae2,al2,BackendDAE.EVENT_INFO(wclst2,zeroCrossingLst),eoc,btp)); - case (stateexpcall,dummyderexp,BackendDAE.EQSYSTEM(v,eqns,SOME(m),SOME(mt)),BackendDAE.SHARED(kv,ev,av,ie,seqns,ae,al,BackendDAE.EVENT_INFO(wclst,zeroCrossingLst),eoc,btp),(e :: rest)) + case (stateexpcall,dummyderexp,BackendDAE.EQSYSTEM(v,eqns,SOME(m),SOME(mt),matching),BackendDAE.SHARED(kv,ev,av,ie,seqns,ae,al,BackendDAE.EVENT_INFO(wclst,zeroCrossingLst),eoc,btp),(e :: rest)) equation e_1 = e - 1; eqn = BackendDAEUtil.equationNth(eqns, e_1); @@ -4981,7 +4989,7 @@ algorithm "incidence_row(v\'\',eqn\') => row\' & Util.list_replaceat(row\',e\',m) => m\' & transpose_matrix(m\') => mt\' &" ; - (syst,shared) = replaceDummyDer(stateexpcall, dummyderexp, BackendDAE.EQSYSTEM(v_1,eqns_1,SOME(m),SOME(mt)),BackendDAE.SHARED(kv,ev,av,ie,seqns,ae2,al2,BackendDAE.EVENT_INFO(wclst2,zeroCrossingLst),eoc,btp), rest); + (syst,shared) = replaceDummyDer(stateexpcall, dummyderexp, BackendDAE.EQSYSTEM(v_1,eqns_1,SOME(m),SOME(mt),matching),BackendDAE.SHARED(kv,ev,av,ie,seqns,ae2,al2,BackendDAE.EVENT_INFO(wclst2,zeroCrossingLst),eoc,btp), rest); then (syst,shared); @@ -5543,8 +5551,9 @@ algorithm BackendDAE.Var dummyvar; BackendDAE.Shared shared; Option om,omT; + BackendDAE.Matching matching; - case (var,BackendDAE.EQSYSTEM(vars,eqns,om,omT),op) + case (var,BackendDAE.EQSYSTEM(vars,eqns,om,omT,matching),op) equation ((BackendDAE.VAR(name,kind,dir,tp,bind,value,dim,idx,source,dae_var_attr,comment,flowPrefix,streamPrefix) :: _),_) = BackendVariable.getVar(var, vars); dummyvar_cr = ComponentReference.crefPrefixDer(name); @@ -5555,7 +5564,7 @@ algorithm dummyvar = BackendVariable.setVarFixed(dummyvar,false); vars_1 = BackendVariable.addVar(dummyvar, vars); then - (dummyvar_cr,BackendDAE.EQSYSTEM(vars_1,eqns,om,omT)); + (dummyvar_cr,BackendDAE.EQSYSTEM(vars_1,eqns,om,omT,matching)); else equation @@ -6171,9 +6180,10 @@ algorithm list> derivedAlgs,derivedAlgs1; list> derivedMultiEqn,derivedMultiEqn1; BackendDAE.BackendDAEType btp; + BackendDAE.Matching matching; case (syst,shared,{},_,inDerivedAlgs,inDerivedMultiEqn) then (syst,shared,{},inDerivedAlgs,inDerivedMultiEqn); - case (BackendDAE.EQSYSTEM(v,eqns,SOME(m),SOME(mt)),shared as BackendDAE.SHARED(kv,ev,av,ie,seqns,ae,al,wc,eoc,btp),(e :: es),inFunctions,inDerivedAlgs,inDerivedMultiEqn) + case (BackendDAE.EQSYSTEM(v,eqns,SOME(m),SOME(mt),matching),shared as BackendDAE.SHARED(kv,ev,av,ie,seqns,ae,al,wc,eoc,btp),(e :: es),inFunctions,inDerivedAlgs,inDerivedMultiEqn) equation e_1 = e - 1; eqn = BackendDAEUtil.equationNth(eqns, e_1); @@ -6190,10 +6200,10 @@ algorithm eqns_1 = BackendEquation.equationAdd(eqn_1,eqns); leneqns = BackendDAEUtil.equationSize(eqns_1); BackendDAEEXT.markDifferentiated(e) "length gives index of new equation Mark equation as differentiated so it won\'t be differentiated again" ; - (syst,shared,reqns,derivedAlgs1,derivedMultiEqn1) = differentiateEqns(BackendDAE.EQSYSTEM(v,eqns_1,SOME(m),SOME(mt)),BackendDAE.SHARED(kv,ev,av,ie,seqns,ae1,al1,wc,eoc,btp), es, inFunctions,derivedAlgs,derivedMultiEqn); + (syst,shared,reqns,derivedAlgs1,derivedMultiEqn1) = differentiateEqns(BackendDAE.EQSYSTEM(v,eqns_1,SOME(m),SOME(mt),matching),BackendDAE.SHARED(kv,ev,av,ie,seqns,ae1,al1,wc,eoc,btp), es, inFunctions,derivedAlgs,derivedMultiEqn); then (syst,shared,(leneqns :: (e :: reqns)),derivedAlgs1,derivedMultiEqn1); - case (BackendDAE.EQSYSTEM(v,eqns,SOME(m),SOME(mt)),shared as BackendDAE.SHARED(kv,ev,av,ie,seqns,ae,al,wc,eoc,btp),(e :: es),inFunctions,inDerivedAlgs,inDerivedMultiEqn) + case (BackendDAE.EQSYSTEM(v,eqns,SOME(m),SOME(mt),matching),shared as BackendDAE.SHARED(kv,ev,av,ie,seqns,ae,al,wc,eoc,btp),(e :: es),inFunctions,inDerivedAlgs,inDerivedMultiEqn) equation e_1 = e - 1; eqn = BackendDAEUtil.equationNth(eqns, e_1); @@ -6208,7 +6218,7 @@ algorithm // print("\n"); Debug.fcall("bltdump", debugdifferentiateEqns,(eqn,eqn_1)); BackendDAEEXT.markDifferentiated(e) "length gives index of new equation Mark equation as differentiated so it won\'t be differentiated again" ; - (syst,shared,reqns,derivedAlgs1,derivedMultiEqn1) = differentiateEqns(BackendDAE.EQSYSTEM(v,eqns,SOME(m),SOME(mt)),BackendDAE.SHARED(kv,ev,av,ie,seqns,ae1,al1,wc,eoc,btp), es, inFunctions,derivedAlgs,derivedMultiEqn); + (syst,shared,reqns,derivedAlgs1,derivedMultiEqn1) = differentiateEqns(BackendDAE.EQSYSTEM(v,eqns,SOME(m),SOME(mt),matching),BackendDAE.SHARED(kv,ev,av,ie,seqns,ae1,al1,wc,eoc,btp), es, inFunctions,derivedAlgs,derivedMultiEqn); then (syst,shared,(e :: reqns),derivedAlgs1,derivedMultiEqn1); else diff --git a/Compiler/BackEnd/BackendDAEUtil.mo b/Compiler/BackEnd/BackendDAEUtil.mo index 87981a86e21..97da1d6297e 100644 --- a/Compiler/BackEnd/BackendDAEUtil.mo +++ b/Compiler/BackEnd/BackendDAEUtil.mo @@ -492,6 +492,7 @@ algorithm BackendDAE.BackendDAE dae1; Option om,omT; BackendDAE.BackendDAEType btp; + BackendDAE.Matching matching; // unfixed equal equations case (inUnfixed,inInitialEqns,inDAE,_,_,_,_,_) @@ -508,7 +509,7 @@ algorithm inDAE; // unfixed greater than equations - case (inUnfixed,inInitialEqns,inDAE as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(vars,orderedEqs,om,omT)::{},shared=BackendDAE.SHARED(knownVars=knvars,initialEqs=initialEqs,externalObjects=exObj,aliasVars=alisvars,removedEqs=removedEqs, + case (inUnfixed,inInitialEqns,inDAE as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(vars,orderedEqs,om,omT,matching)::{},shared=BackendDAE.SHARED(knownVars=knvars,initialEqs=initialEqs,externalObjects=exObj,aliasVars=alisvars,removedEqs=removedEqs, arrayEqs=arrayEqs,algorithms=algs,eventInfo=eventInfo,extObjClasses=extObjClasses,backendDAEType=btp)),funcs,inVars,inVarsWS,inStates,inStatesWS) equation true = RTOpts.debugFlag("dumpInit"); @@ -518,18 +519,18 @@ algorithm true = intGt(inUnfixed,inInitialEqns); // change fixed to true until equal equations (vars1,knvars1) = fixInitalVars(inUnfixed,inInitialEqns,vars,knvars,inVars,inVarsWS,inStates,inStatesWS); - dae1 = BackendDAE.DAE(BackendDAE.EQSYSTEM(vars1,orderedEqs,om,omT)::{},BackendDAE.SHARED(knvars1,exObj,alisvars,initialEqs,removedEqs,arrayEqs,algs,eventInfo,extObjClasses,btp)); + dae1 = BackendDAE.DAE(BackendDAE.EQSYSTEM(vars1,orderedEqs,om,omT,matching)::{},BackendDAE.SHARED(knvars1,exObj,alisvars,initialEqs,removedEqs,arrayEqs,algs,eventInfo,extObjClasses,btp)); then dae1; // unfixed greater than equations - case (inUnfixed,inInitialEqns,inDAE as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(vars,orderedEqs,om,omT)::{},shared=BackendDAE.SHARED(knownVars=knvars,externalObjects=exObj,aliasVars=alisvars,initialEqs=initialEqs,removedEqs=removedEqs, + case (inUnfixed,inInitialEqns,inDAE as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(vars,orderedEqs,om,omT,matching)::{},shared=BackendDAE.SHARED(knownVars=knvars,externalObjects=exObj,aliasVars=alisvars,initialEqs=initialEqs,removedEqs=removedEqs, arrayEqs=arrayEqs,algorithms=algs,eventInfo=eventInfo,extObjClasses=extObjClasses,backendDAEType=btp)),funcs,inVars,inVarsWS,inStates,inStatesWS) equation true = intGt(inUnfixed,inInitialEqns); // change fixed to true until equal equations (vars1,knvars1) = fixInitalVars(inUnfixed,inInitialEqns,vars,knvars,inVars,inVarsWS,inStates,inStatesWS); - dae1 = BackendDAE.DAE(BackendDAE.EQSYSTEM(vars1,orderedEqs,om,omT)::{},BackendDAE.SHARED(knvars1,exObj,alisvars,initialEqs,removedEqs,arrayEqs,algs,eventInfo,extObjClasses,btp)); + dae1 = BackendDAE.DAE(BackendDAE.EQSYSTEM(vars1,orderedEqs,om,omT,matching)::{},BackendDAE.SHARED(knvars1,exObj,alisvars,initialEqs,removedEqs,arrayEqs,algs,eventInfo,extObjClasses,btp)); then dae1; @@ -882,7 +883,8 @@ algorithm BackendDAE.ExternalObjectClasses extObjCls; Option m,mT; BackendDAE.BackendDAEType btp; - case (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns,m,mT)::{},BackendDAE.SHARED(knvars,extVars,av,ieqns,seqns,ae,al,BackendDAE.EVENT_INFO(whenClauseLst = wc,zeroCrossingLst = zc),extObjCls,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)),_) equation varlst = varList(vars); knvarlst = varList(knvars); @@ -894,7 +896,7 @@ 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)::{},BackendDAE.SHARED(knvars,extVars,av,ieqns,seqns,ae,al, + 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; @@ -4430,12 +4432,13 @@ algorithm BackendDAE.Variables vars,knvars; BackendDAE.EquationArray daeeqns,daeseqns,inieq; list wc; + BackendDAE.Matching matching; - case (BackendDAE.EQSYSTEM(vars,daeeqns,SOME(m),SOME(mt)),BackendDAE.SHARED(eventInfo = BackendDAE.EVENT_INFO(whenClauseLst = wc)),eqns) + case (BackendDAE.EQSYSTEM(vars,daeeqns,SOME(m),SOME(mt),matching),BackendDAE.SHARED(eventInfo = BackendDAE.EVENT_INFO(whenClauseLst = wc)),eqns) equation (m,mt) = updateIncidenceMatrix1(vars,daeeqns,wc,m,mt,eqns); then - BackendDAE.EQSYSTEM(vars,daeeqns,SOME(m),SOME(mt)); + BackendDAE.EQSYSTEM(vars,daeeqns,SOME(m),SOME(mt),matching); else equation @@ -4600,17 +4603,18 @@ algorithm BackendDAE.IncidenceMatrix m,mT; BackendDAE.Variables v; BackendDAE.EquationArray eq,ieq; - case(syst as BackendDAE.EQSYSTEM(v,eq,NONE(),_),shared) + BackendDAE.Matching matching; + case(syst as BackendDAE.EQSYSTEM(v,eq,NONE(),_,matching),shared) equation (m,mT) = incidenceMatrix(syst, shared, BackendDAE.NORMAL()); then - (BackendDAE.EQSYSTEM(v,eq,SOME(m),SOME(mT)),m,mT); - case(BackendDAE.EQSYSTEM(v,eq,SOME(m),NONE()),_) + (BackendDAE.EQSYSTEM(v,eq,SOME(m),SOME(mT),matching),m,mT); + case(BackendDAE.EQSYSTEM(v,eq,SOME(m),NONE(),matching),_) equation mT = transposeMatrix(m); then - (BackendDAE.EQSYSTEM(v,eq,SOME(m),SOME(mT)),m,mT); - case(syst as BackendDAE.EQSYSTEM(v,eq,SOME(m),SOME(mT)),_) + (BackendDAE.EQSYSTEM(v,eq,SOME(m),SOME(mT),matching),m,mT); + case(syst as BackendDAE.EQSYSTEM(v,eq,SOME(m),SOME(mT),matching),_) then (syst,m,mT); end matchcontinue; diff --git a/Compiler/BackEnd/BackendDump.mo b/Compiler/BackEnd/BackendDump.mo index 0cbdbb3aa06..08fd92ada4c 100644 --- a/Compiler/BackEnd/BackendDump.mo +++ b/Compiler/BackEnd/BackendDump.mo @@ -630,7 +630,7 @@ algorithm list wc; BackendDAE.ExternalObjectClasses extObjCls; BackendDAE.BackendDAEType btp; - case (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars1,eqns,_,_)::{},BackendDAE.SHARED(vars2,vars3,av,ieqns,reqns,ae,algs,BackendDAE.EVENT_INFO(zeroCrossingLst = zc,whenClauseLst=wc),extObjCls,btp))) + case (BackendDAE.DAE(BackendDAE.EQSYSTEM(orderedVars=vars1,orderedEqs=eqns)::{},BackendDAE.SHARED(vars2,vars3,av,ieqns,reqns,ae,algs,BackendDAE.EVENT_INFO(zeroCrossingLst = zc,whenClauseLst=wc),extObjCls,btp))) equation print("Variables ("); vars = BackendDAEUtil.varList(vars1); diff --git a/Compiler/BackEnd/BackendEquation.mo b/Compiler/BackEnd/BackendEquation.mo index 8fd280a6810..5470f21474d 100644 --- a/Compiler/BackEnd/BackendEquation.mo +++ b/Compiler/BackEnd/BackendEquation.mo @@ -999,10 +999,10 @@ algorithm BackendDAE.EventInfo einfo; BackendDAE.ExternalObjectClasses eoc; BackendDAE.Shared shared; - case (inEquation,BackendDAE.EQSYSTEM(ordvars,eqns,_,_)) + case (inEquation,BackendDAE.EQSYSTEM(orderedVars=ordvars,orderedEqs=eqns)) equation eqns1 = equationAdd(inEquation,eqns); - then BackendDAE.EQSYSTEM(ordvars,eqns1,NONE(),NONE()); + then BackendDAE.EQSYSTEM(ordvars,eqns1,NONE(),NONE(),BackendDAE.NO_MATCHING()); end match; end equationAddDAE; @@ -1025,10 +1025,11 @@ algorithm BackendDAE.ExternalObjectClasses eoc; BackendDAE.Shared shared; Option m,mT; - case (inInteger,inEquation,BackendDAE.EQSYSTEM(ordvars,eqns,m,mT)) + BackendDAE.Matching matching; + case (inInteger,inEquation,BackendDAE.EQSYSTEM(ordvars,eqns,m,mT,matching)) equation eqns1 = equationSetnth(eqns,inInteger,inEquation); - then BackendDAE.EQSYSTEM(ordvars,eqns1,m,mT); + then BackendDAE.EQSYSTEM(ordvars,eqns1,m,mT,matching); end match; end equationSetnthDAE; diff --git a/Compiler/BackEnd/BackendVariable.mo b/Compiler/BackEnd/BackendVariable.mo index eb96572b196..78254162b40 100644 --- a/Compiler/BackEnd/BackendVariable.mo +++ b/Compiler/BackEnd/BackendVariable.mo @@ -3206,10 +3206,11 @@ algorithm BackendDAE.ExternalObjectClasses eoc; BackendDAE.Shared shared; Option m,mT; - case (var,BackendDAE.EQSYSTEM(ordvars,eqns,m,mT)) + BackendDAE.Matching matching; + case (var,BackendDAE.EQSYSTEM(ordvars,eqns,m,mT,matching)) equation ordvars1 = addVar(var,ordvars); - then BackendDAE.EQSYSTEM(ordvars1,eqns,m,mT); + then BackendDAE.EQSYSTEM(ordvars1,eqns,m,mT,matching); end match; end addVarDAE; diff --git a/Compiler/BackEnd/PartFn.mo b/Compiler/BackEnd/PartFn.mo index 7d74a2961ad..5a189395949 100644 --- a/Compiler/BackEnd/PartFn.mo +++ b/Compiler/BackEnd/PartFn.mo @@ -80,12 +80,13 @@ algorithm BackendDAE.ExternalObjectClasses extObjClasses; Option m,mT; BackendDAE.BackendDAEType btp; + BackendDAE.Matching matching; /*case(dae,dlow) equation false = RTOpts.debugFlag("fnptr") or RTOpts.acceptMetaModelicaGrammar(); then (dae,dlow);*/ - case(dae,BackendDAE.DAE(BackendDAE.EQSYSTEM(orderedVars,orderedEqs,m,mT)::{},BackendDAE.SHARED(knownVars,externalObjects,aliasVars,initialEqs,removedEqs,arrayEqs,algorithms,eventInfo,extObjClasses,btp))) + case(dae,BackendDAE.DAE(BackendDAE.EQSYSTEM(orderedVars,orderedEqs,m,mT,matching)::{},BackendDAE.SHARED(knownVars,externalObjects,aliasVars,initialEqs,removedEqs,arrayEqs,algorithms,eventInfo,extObjClasses,btp))) equation (orderedVars,dae) = partEvalVars(orderedVars,dae); (knownVars,dae) = partEvalVars(knownVars,dae); @@ -96,7 +97,7 @@ algorithm (arrayEqs,dae) = partEvalArrEqs(arrayList(arrayEqs),dae); (algorithms,dae) = partEvalAlgs(algorithms,dae); then - (dae,BackendDAE.DAE(BackendDAE.EQSYSTEM(orderedVars,orderedEqs,m,mT)::{},BackendDAE.SHARED(knownVars,externalObjects,aliasVars,initialEqs,removedEqs,arrayEqs,algorithms,eventInfo,extObjClasses,btp))); + (dae,BackendDAE.DAE(BackendDAE.EQSYSTEM(orderedVars,orderedEqs,m,mT,matching)::{},BackendDAE.SHARED(knownVars,externalObjects,aliasVars,initialEqs,removedEqs,arrayEqs,algorithms,eventInfo,extObjClasses,btp))); else equation Debug.fprintln("failtrace","- PartFn.partEvalBackendDAE failed"); diff --git a/Compiler/BackEnd/SimCode.mo b/Compiler/BackEnd/SimCode.mo index d57123bf11e..bc7c1d5b957 100644 --- a/Compiler/BackEnd/SimCode.mo +++ b/Compiler/BackEnd/SimCode.mo @@ -2423,7 +2423,7 @@ algorithm newEqns = BackendDAEUtil.listEquation({}); newVars = BackendDAEUtil.emptyVars(); (newEqns, newVars) = splitoutEquationAndVars(blt_states,e,v,newEqns,newVars); - dlow = BackendDAE.DAE(BackendDAE.EQSYSTEM(newVars,newEqns,NONE(),NONE())::{},shared); + dlow = BackendDAE.DAE(BackendDAE.EQSYSTEM(newVars,newEqns,NONE(),NONE(),BackendDAE.NO_MATCHING())::{},shared); // Prepare all needed variables varlst_tmp = BackendDAEUtil.varList(v); @@ -2735,12 +2735,13 @@ algorithm list sampleEquations; BackendDAE.Shared shared; Option m,mT; - case (helpvars,BackendDAE.DAE(BackendDAE.EQSYSTEM(orderedVars,orderedEqs,m,mT)::{},shared)) + BackendDAE.Matching matching; + case (helpvars,BackendDAE.DAE(BackendDAE.EQSYSTEM(orderedVars,orderedEqs,m,mT,matching)::{},shared)) equation eqnsList = BackendDAEUtil.equationList(orderedEqs); (eqnsList,sampleEquations,(_,helpvars)) = BackendEquation.traverseBackendDAEExpsEqnListOutEqn(eqnsList, {}, sampleFinder, (listLength(helpvars)-1,helpvars)); orderedEqs = BackendDAEUtil.listEquation(eqnsList); - then (helpvars,BackendDAE.DAE(BackendDAE.EQSYSTEM(orderedVars,orderedEqs,m,mT)::{},shared),sampleEquations); + then (helpvars,BackendDAE.DAE(BackendDAE.EQSYSTEM(orderedVars,orderedEqs,m,mT,matching)::{},shared),sampleEquations); case (_,_) equation Error.addMessage(Error.INTERNAL_ERROR, @@ -4386,7 +4387,7 @@ algorithm ave = BackendDAEUtil.emptyAliasVariables(); eeqns = BackendDAEUtil.listEquation({}); knvars_1 = BackendEquation.equationsVars(eqns_1,knvars); - syst = BackendDAE.EQSYSTEM(vars_1,eqns_1,NONE(),NONE()); + syst = BackendDAE.EQSYSTEM(vars_1,eqns_1,NONE(),NONE(),BackendDAE.NO_MATCHING()); shared = BackendDAE.SHARED(knvars_1,exvars,ave,eeqns,eeqns,ae1,al,ev,eoc,BackendDAE.ALGEQSYSTEM()); (m,mt) = BackendDAEUtil.incidenceMatrix(syst, shared, BackendDAE.ABSOLUTE()); subsystem_dae = BackendDAE.DAE({syst},shared); @@ -4446,10 +4447,10 @@ algorithm ave = BackendDAEUtil.emptyAliasVariables(); eeqns = BackendDAEUtil.listEquation({}); knvars_1 = BackendEquation.equationsVars(eqns_1,knvars); - syst = BackendDAE.EQSYSTEM(vars_1,eqns_1,NONE(),NONE()); + syst = BackendDAE.EQSYSTEM(vars_1,eqns_1,NONE(),NONE(),BackendDAE.NO_MATCHING()); shared = BackendDAE.SHARED(knvars_1,exvars,ave,eeqns,eeqns,ae1,al,ev,eoc,BackendDAE.ALGEQSYSTEM()); (m,mt) = BackendDAEUtil.incidenceMatrix(syst, shared, BackendDAE.ABSOLUTE()); - syst = BackendDAE.EQSYSTEM(vars_1,eqns_1,SOME(m),SOME(mt)); + syst = BackendDAE.EQSYSTEM(vars_1,eqns_1,SOME(m),SOME(mt),BackendDAE.NO_MATCHING()); subsystem_dae = BackendDAE.DAE({syst},shared); (subsystem_dae_1,v1,v2,comps) = BackendDAEUtil.transformBackendDAE(subsystem_dae,DAEUtil.avlTreeNew(),SOME((BackendDAE.NO_INDEX_REDUCTION(), BackendDAE.EXACT())),NONE()); (subsystem_dae_2 as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(m=SOME(m_3),mT=SOME(mT_3))::{}),v1_1,v2_1,comps_1,r,t) = BackendDAEOptimize.tearingSystem(subsystem_dae_1,v1,v2,comps); @@ -4554,7 +4555,7 @@ algorithm // replace tearing variables in other equations with x_loc[..] eqn_lst2 = generateTearingSystem1(eqn_lst,repl); eqn1 = BackendDAEUtil.listEquation(eqn_lst2); - daelow1=BackendDAE.DAE(BackendDAE.EQSYSTEM(v,eqn1,NONE(),NONE())::{},shared); + daelow1=BackendDAE.DAE(BackendDAE.EQSYSTEM(v,eqn1,NONE(),NONE(),BackendDAE.NO_MATCHING())::{},shared); // generade code for other equations simeqnsystemlst = Util.listMap3(block_1,generateTearingOtherEqns,daelow1, ass2, helpVarInfo); simeqnsystem = Util.listFlatten(simeqnsystemlst); @@ -4759,7 +4760,7 @@ algorithm ave = BackendDAEUtil.emptyAliasVariables(); evars = BackendDAEUtil.emptyVars(); eeqns = BackendDAEUtil.listEquation({}); - subsystem_dae = BackendDAE.DAE(BackendDAE.EQSYSTEM(v,eqn,NONE(),NONE())::{},BackendDAE.SHARED(evars,evars,ave,eeqns,eeqns,ae,algorithms,BackendDAE.EVENT_INFO({},{}),{},BackendDAE.ALGEQSYSTEM() )); + subsystem_dae = BackendDAE.DAE(BackendDAE.EQSYSTEM(v,eqn,NONE(),NONE(),BackendDAE.NO_MATCHING())::{},BackendDAE.SHARED(evars,evars,ave,eeqns,eeqns,ae,algorithms,BackendDAE.EVENT_INFO({},{}),{},BackendDAE.ALGEQSYSTEM() )); (subsystem_dae_1,v1,v2,comps) = BackendDAEUtil.transformBackendDAE(subsystem_dae,DAEUtil.avlTreeNew(),SOME((BackendDAE.NO_INDEX_REDUCTION(), BackendDAE.EXACT())),NONE()); (subsystem_dae_2,v1_1,v2_1,comps_1,r,t) = BackendDAEOptimize.tearingSystem(subsystem_dae_1,v1,v2,comps); true = listLength(r) > 0; @@ -5038,7 +5039,7 @@ algorithm block_2 = Util.listIntRange(size); ass1_1 = listArray(block_2); ass2_1 = listArray(block_2); - daelow1=BackendDAE.DAE(BackendDAE.EQSYSTEM(v1,eqn1,NONE(),NONE())::{},shared); + daelow1=BackendDAE.DAE(BackendDAE.EQSYSTEM(v1,eqn1,NONE(),NONE(),BackendDAE.NO_MATCHING())::{},shared); // generate code for relaxation equations reqns = generateRelaxedResidualEqns(block_2,mixedEvent,daelow1, ass1_1, ass2_1, helpVarInfo); alleqns = listAppend(reqns,eqns); @@ -5366,7 +5367,7 @@ algorithm evars = BackendDAEUtil.listVar({}); al = listArray({}); ae1 = listArray({}); - syst = BackendDAE.EQSYSTEM(vars,eqns_1,NONE(),NONE()); + syst = BackendDAE.EQSYSTEM(vars,eqns_1,NONE(),NONE(),BackendDAE.NO_MATCHING()); shared = BackendDAE.SHARED(evars,evars,av,eeqns,eeqns,ae1,al,BackendDAE.EVENT_INFO({},{}),{},BackendDAE.ARRAYSYSTEM()); subsystem_dae = BackendDAE.DAE({syst},shared); (subsystem_dae,v1,v2,comps) = BackendDAEUtil.transformBackendDAE(subsystem_dae,DAEUtil.avlTreeNew(),SOME((BackendDAE.NO_INDEX_REDUCTION(), BackendDAE.ALLOW_UNDERCONSTRAINED())),NONE()); @@ -5808,7 +5809,7 @@ algorithm alisvars = BackendDAEUtil.emptyAliasVariables(); v = BackendDAEUtil.listVar(lv); kn = BackendDAEUtil.listVar(lkn); - syst = BackendDAE.EQSYSTEM(v,pe,NONE(),NONE()); + syst = BackendDAE.EQSYSTEM(v,pe,NONE(),NONE(),BackendDAE.NO_MATCHING()); shared = BackendDAE.SHARED(kn,extobj,alisvars,emptyeqns,emptyeqns,arrayEqs,algs,BackendDAE.EVENT_INFO({},{}),extObjClasses,BackendDAE.PARAMETERSYSTEM()); (syst,m,mT) = BackendDAEUtil.getIncidenceMatrixfromOption(syst,shared); paramdlow = BackendDAE.DAE({syst},shared); diff --git a/Compiler/BackEnd/XMLDump.mo b/Compiler/BackEnd/XMLDump.mo index f34f364551e..d4bb1f839c6 100644 --- a/Compiler/BackEnd/XMLDump.mo +++ b/Compiler/BackEnd/XMLDump.mo @@ -1089,7 +1089,7 @@ algorithm Boolean addOrInMatrix,addSolInfo,addMML,dumpRes; BackendDAE.BackendDAEType btp; - case (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars_orderedVars as BackendDAE.VARIABLES(crefIdxLstArr=crefIdxLstArr_orderedVars,varArr=varArr_orderedVars,bucketSize=bucketSize_orderedVars,numberOfVars=numberOfVars_orderedVars),eqns,_,_)::{}, + case (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars_orderedVars as BackendDAE.VARIABLES(crefIdxLstArr=crefIdxLstArr_orderedVars,varArr=varArr_orderedVars,bucketSize=bucketSize_orderedVars,numberOfVars=numberOfVars_orderedVars),eqns,_,_,_)::{}, BackendDAE.SHARED(vars_knownVars as BackendDAE.VARIABLES(crefIdxLstArr=crefIdxLstArr_knownVars,varArr=varArr_knownVars,bucketSize=bucketSize_knownVars,numberOfVars=numberOfVars_knownVars), vars_externalObject as BackendDAE.VARIABLES(crefIdxLstArr=crefIdxLstArr_externalObject,varArr=varArr_externalObject,bucketSize=bucketSize_externalObject,numberOfVars=numberOfVars_externalObject), _,ieqns,reqns,ae,algs,BackendDAE.EVENT_INFO(zeroCrossingLst = zc),extObjCls,btp)),inFunctions,addOrInMatrix,addSolInfo,addMML,dumpRes) diff --git a/Compiler/FrontEnd/Inline.mo b/Compiler/FrontEnd/Inline.mo index 3d50202dc68..2462f1a2b96 100644 --- a/Compiler/FrontEnd/Inline.mo +++ b/Compiler/FrontEnd/Inline.mo @@ -123,12 +123,13 @@ algorithm BackendDAE.EquationArray orderedEqs; BackendDAE.EquationArray initialEqs; Option m,mT; - case (BackendDAE.EQSYSTEM(orderedVars,orderedEqs,m,mT),tpl) + BackendDAE.Matching matching; + case (BackendDAE.EQSYSTEM(orderedVars,orderedEqs,m,mT,matching),tpl) equation orderedVars = inlineVariables(orderedVars,tpl); orderedEqs = inlineEquationArray(orderedEqs,tpl); // TODO: Incidencematrix may change, but it's not updated here?! - then BackendDAE.EQSYSTEM(orderedVars,orderedEqs,m,mT); + then BackendDAE.EQSYSTEM(orderedVars,orderedEqs,m,mT,matching); end match; end inlineEquationSystem;